How to configure authentication for the Alibaba Cloud SDK for Java V1.0 - Alibaba Cloud SDK

Le SDK Alibaba Cloud pour Java V1.0 nécessite un identifiant d'accès valide pour appeler les opérations OpenAPI. Le SDK prend en charge plusieurs méthodes d'authentification afin de garantir la sécurité du développement.

Prérequis

La version du package aliyun-java-sdk-core doit être 4.7.3 ou ultérieure.

<dependency>
    <groupId>com.aliyun</groupId>
    <artifactId>aliyun-java-sdk-core</artifactId>
    <version>4.7.3</version>
</dependency>

Méthode 1 : AccessKey

Important

La fuite d'une AccessKey associée à un compte Alibaba Cloud compromet toutes les ressources de ce compte. Utilisez plutôt l'AccessKey d'un utilisateur Resource Access Management (RAM). Créer une AccessKey.
Définissez les variables d'environnement ALIBABA_CLOUD_ACCESS_KEY_ID et ALIBABA_CLOUD_ACCESS_KEY_SECRET dans votre environnement d'exécution. Configurer des variables d'environnement sur Linux, macOS et Windows.

Initialisez le client en configurant une AccessKey via DefaultProfile.

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.profile.DefaultProfile;

public class Sample {
    public static void main(String[] args) {
        DefaultProfile profile = DefaultProfile.getProfile(
                "<REGION_ID>",
                // Retrieve the AccessKey ID of the RAM user from an environment variable.
                System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"),
                // Retrieve the AccessKey secret of the RAM user from an environment variable.
                System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET"));
        IAcsClient client = new DefaultAcsClient(profile);
        // The API call logic is omitted.
    }
}

Initialisez le client en configurant une AccessKey via BasicCredentials.

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.auth.BasicCredentials;
import com.aliyuncs.profile.DefaultProfile;

public class Sample {
    public static void main(String[] args) {
        BasicCredentials basicCredentials = new BasicCredentials(
                // Retrieve the AccessKey ID of the RAM user from an environment variable.
                System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"),
                // Retrieve the AccessKey secret of the RAM user from an environment variable.
                System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")
        );
        DefaultProfile profile = DefaultProfile.getProfile("<REGION_ID>");
        IAcsClient client = new DefaultAcsClient(profile, basicCredentials);
        // The API call logic is omitted.
    }
}

Méthode 2 : Token STS

Initialisez le client avec un identifiant d'accès temporaire (token STS).

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.profile.DefaultProfile;

public class Test {
    public static void main(String[] args) {
        DefaultProfile profile = DefaultProfile.getProfile(
                "<REGION_ID>",
                // Retrieve the AccessKey ID of the RAM user from an environment variable.
                System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"),
                // Retrieve the AccessKey secret of the RAM user from an environment variable.
                System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET"),
                // The STS token.
                System.getenv("ALIBABA_CLOUD_SECURITY_TOKEN"));
        IAcsClient client = new DefaultAcsClient(profile);
        // The API call logic is omitted.
    }
}

Méthode 3 : ARN de rôle RAM

Appelez l'opération AssumeRole de Security Token Service (STS) pour obtenir un token STS.

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.auth.STSAssumeRoleSessionCredentialsProvider;
import com.aliyuncs.profile.DefaultProfile;

public class Sample {
    public static void main(String[] args) {
        DefaultProfile profile = DefaultProfile.getProfile("<REGION_ID>");
        // Use a RAM role ARN.
        STSAssumeRoleSessionCredentialsProvider stsProvider = STSAssumeRoleSessionCredentialsProvider
                .builder()
                // Required. Retrieve the AccessKey ID of the RAM user from an environment variable.
                .accessKeyId(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"))
                // Required. Retrieve the AccessKey secret of the RAM user from an environment variable.
                .accessKeySecret(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET"))
                // The Alibaba Cloud Resource Name (ARN) of the RAM role. Required unless the ALIBABA_CLOUD_ROLE_ARN environment variable is set.
                .roleArn("<ROLE_ARN>")
                // A custom session name. Optional. Can also be set by using the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
                .roleSessionName("<ROLE_SESSION_NAME>")
                // A custom policy. Optional. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
                .policy("<POLICY>")
                // An external ID to prevent the confused deputy problem. Optional.
                .externalId("<<EXTERNAL_ID>>")
                // The duration of the access credential in seconds. Optional. Defaults to 3600 and must not exceed 43200 (12 hours).
                .durationSeconds(3600)
                // The region ID for the AssumeRole API call. Optional.
                .stsRegionId("<STS_REGION_ID>") 
                .build();
        DefaultAcsClient client = new DefaultAcsClient(profile, stsProvider);
        // The API call logic is omitted.
    }
}

Méthode 4 : Rôle RAM d'instance

Le SDK peut récupérer les identifiants depuis un rôle RAM d'instance attaché à une instance Elastic Compute Service (ECS) ou Elastic Container Instance (ECI), ce qui évite le recours aux AccessKey statiques. Le SDK détecte automatiquement le rôle RAM attaché et obtient un token STS auprès du serveur de métadonnées.

L'outil Credentials utilise IMDSv2 (mode de renforcement de la sécurité) par défaut. En cas d'échec d'IMDSv2, le paramètre disableIMDSv1 contrôle le comportement de repli :

false (par défaut) : retour au mode normal (IMDSv1) pour récupérer les identifiants.
true : déclenche une exception au lieu de revenir à IMDSv1.

La prise en charge d'IMDSv2 dépend de la configuration de votre instance.

Remarque

Important

Assurez-vous qu'un rôle RAM est bien configuré sur l'instance ECS.

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.auth.InstanceProfileCredentialsProvider;
import com.aliyuncs.profile.DefaultProfile;

public class Sample {
    public static void main(String[] args) {
        DefaultProfile profile = DefaultProfile.getProfile("<REGION_ID>");
        // Use an instance RAM role.
        InstanceProfileCredentialsProvider provider = InstanceProfileCredentialsProvider
                .builder()
                // The name of the RAM role attached to the instance.
                .roleName("<ROLE_NAME>")
                //.disableIMDSv1(false)
                .build();
        DefaultAcsClient client = new DefaultAcsClient(profile, provider);
        // The API call logic is omitted.
    }
}

Méthode 5 : Rôle RAM OIDC

Dans Container Service for Kubernetes (ACK), la fonctionnalité RAM Roles for Service Accounts (RRSA) associe des rôles RAM à des pods individuels. Chaque application endosse un rôle RAM distinct et utilise des identifiants temporaires pour accéder aux ressources Alibaba Cloud, supprimant ainsi le besoin d'AccessKey permanentes.

ACK monte un fichier de token OIDC pour chaque pod et injecte la configuration sous forme de variables d'environnement. Le SDK appelle l'opération AssumeRoleWithOIDC de STS pour échanger le token OIDC contre un token STS. Isoler les permissions des pods à l'aide de RRSA.

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.auth.OIDCCredentialsProvider;
import com.aliyuncs.profile.DefaultProfile;

public class Sample {
    public static void main(String[] args) {
        // Use an OIDC-based RAM role.
        OIDCCredentialsProvider provider = OIDCCredentialsProvider
                .builder()
                // The ARN of the OIDC provider. Required unless the ALIBABA_CLOUD_OIDC_PROVIDER_ARN environment variable is set.
                .oidcProviderArn(System.getenv("ALIBABA_CLOUD_OIDC_PROVIDER_ARN"))
                // The path of the OIDC token file. Required unless the ALIBABA_CLOUD_OIDC_TOKEN_FILE environment variable is set.
                .oidcTokenFilePath(System.getenv("ALIBABA_CLOUD_OIDC_TOKEN_FILE"))
                // The ARN of the RAM role. Required unless the ALIBABA_CLOUD_ROLE_ARN environment variable is set.
                .roleArn(System.getenv("ALIBABA_CLOUD_ROLE_ARN"))
                // A custom session name. Optional.
                .roleSessionName("<ROLE_SESSION_NAME>")
                // A custom policy. Optional. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
                .policy("<POLICY>")
                // The duration of the access credential in seconds. Optional. Defaults to 3600 and must not exceed 43200 (12 hours).
                .durationSeconds(3600)
                // The region ID of STS. Optional.
                .stsRegionId("<REGION_ID>")
                .build();
        DefaultProfile profile = DefaultProfile.getProfile(
                // Specify the region ID of the client.
                "<REGION_ID>");
        IAcsClient client = new DefaultAcsClient(profile, provider);
        // The API call logic is omitted.
    }
}

Méthode 6 : Token Bearer

Remarque

Cette méthode est uniquement prise en charge par Cloud Call Center (CCC).

import com.aliyuncs.auth.BearerTokenCredentials;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.DefaultAcsClient;

public class BearerToken {
    public static void main(String[] args) {
        DefaultProfile profile = DefaultProfile.getProfile("<REGION_ID>");
        // Set the access credential by using BearerTokenCredentials.
        BearerTokenCredentials bearerTokenCredential = new BearerTokenCredentials("<BEARER_TOKEN>");
        DefaultAcsClient client = new DefaultAcsClient(profile, bearerTokenCredential);
        // The API call logic is omitted.
    }
}

Méthode 7 : Chaîne de fournisseurs d'identifiants par défaut

Si aucun identifiant n'est explicitement fourni, le SDK utilise la chaîne de fournisseurs d'identifiants par défaut.

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.IAcsClient;
import com.aliyuncs.exceptions.ClientException;

public class Test {
    public static void main(String[] args) throws ClientException {
        // Use the default credential provider chain.
        IAcsClient client = new DefaultAcsClient("<REGION_ID>");
        // The API call logic is omitted.
    }
}

La chaîne de fournisseurs d'identifiants par défaut recherche les identifiants disponibles dans l'ordre suivant :

1. Propriétés système

Si les propriétés système alibabacloud.accessKeyId et alibabacloud.accessKeyIdSecret sont définies et non vides, le SDK les utilise pour créer les identifiants par défaut.

2. Variables d'environnement

Si les variables d'environnement ALIBABA_CLOUD_ACCESS_KEY_ID et ALIBABA_CLOUD_ACCESS_KEY_SECRET sont définies et non vides, le SDK les emploie comme identifiants par défaut.

3. Rôle RAM OIDC

Le SDK vérifie la présence des variables d'environnement suivantes :

ALIBABA_CLOUD_ROLE_ARN : L'ARN du rôle RAM.

ALIBABA_CLOUD_OIDC_PROVIDER_ARN : L'ARN du fournisseur OIDC.

ALIBABA_CLOUD_OIDC_TOKEN_FILE : Le chemin du fichier de token OIDC.

Lorsque ces trois variables d'environnement sont définies, le SDK appelle l'opération AssumeRoleWithOIDC de STS pour obtenir un token STS, utilisé ensuite comme identifiant par défaut.

4. Fichier de configuration

À défaut d'identifiant trouvé précédemment, la chaîne de fournisseurs tente de charger le fichier d'identifiants partagés, config.json, depuis son emplacement par défaut et utilise l'identifiant spécifié dans ce fichier.

Linux/macOS : ~/.aliyun/config.json
Windows : C:\Users\USER_NAME\.aliyun\config.json

Pour configurer un identifiant de cette manière, utilisez l'Alibaba Cloud CLI ou créez manuellement un fichier config.json au chemin approprié. L'exemple suivant illustre le format du contenu :

{
  "current": "<PROFILE_NAME>",
  "profiles": [
    {
      "name": "<PROFILE_NAME>",
      "mode": "AK",
      "access_key_id": "<ALIBABA_CLOUD_ACCESS_KEY_ID>",
      "access_key_secret": "<ALIBABA_CLOUD_ACCESS_KEY_SECRET>"
    },
    {
      "name": "<PROFILE_NAME1>",
      "mode": "StsToken",
      "access_key_id": "<ALIBABA_CLOUD_ACCESS_KEY_ID>",
      "access_key_secret": "<ALIBABA_CLOUD_ACCESS_KEY_SECRET>",
      "sts_token": "<SECURITY_TOKEN>"
    },
    {
      "name":"<PROFILE_NAME2>",
      "mode":"RamRoleArn",
      "access_key_id":"<ALIBABA_CLOUD_ACCESS_KEY_ID>",
      "access_key_secret":"<ALIBABA_CLOUD_ACCESS_KEY_SECRET>",
      "ram_role_arn":"<ROLE_ARN>",
      "ram_session_name":"<ROLE_SESSION_NAME>",
      "expired_seconds":3600
    },
    {
      "name":"<PROFILE_NAME3>",
      "mode":"EcsRamRole",
      "ram_role_name":"<RAM_ROLE_ARN>"
    },
    {
      "name":"<PROFILE_NAME4>",
      "mode":"OIDC",
      "oidc_provider_arn":"<OIDC_PROVIDER_ARN>",
      "oidc_token_file":"<OIDC_TOKEN_FILE>",
      "ram_role_arn":"<ROLE_ARN>",
      "ram_session_name":"<ROLE_SESSION_NAME>",
      "expired_seconds":3600
    },
    {
      "name":"<PROFILE_NAME5>",
      "mode":"ChainableRamRoleArn",
      "source_profile":"<PROFILE_NAME>",
      "ram_role_arn":"<ROLE_ARN>",
      "ram_session_name":"<ROLE_SESSION_NAME>",
      "expired_seconds":3600
    }
  ]
}

Paramètre

Description

current

Spécifiez le nom de l'identifiant pour récupérer la configuration correspondante. Ce nom correspond à la valeur du paramètre name dans profiles. Par défaut, le système privilégie le nom d'identifiant défini par la variable d'environnement ALIBABA_CLOUD_PROFILE. Si cette variable n'est pas configurée, le système utilise le nom indiqué par current.

profiles

Contient un ensemble de configurations d'identifiants. Le paramètre mode détermine le type d'identifiant :

AK : Utilise l'AccessKey d'un utilisateur RAM comme identifiant.
StsToken : Emploie un token STS comme identifiant.
RamRoleArn : Endosse un rôle RAM en utilisant les identifiants d'un utilisateur RAM pour obtenir un identifiant temporaire.
EcsRamRole : Récupère un identifiant depuis les métadonnées de l'instance.
OIDC : Obtient un identifiant à partir d'un ARN de fournisseur OIDC, d'un token OIDC et d'un ARN de rôle RAM.
ChainableRamRoleArn : Recourt au chaînage de rôles pour obtenir un nouvel identifiant, en s'appuyant sur un identifiant initial issu de profiles et désigné par le paramètre source_profile.

5. Rôle RAM d'instance ECS

Le SDK vérifie la variable d'environnement ALIBABA_CLOUD_ECS_METADATA, qui indique un nom de rôle RAM d'instance. Si elle est définie, le SDK récupère un token STS auprès du serveur de métadonnées ECS.

6. URI des identifiants

Le SDK examine la variable d'environnement ALIBABA_CLOUD_CREDENTIALS_URI. Lorsqu'elle est présente, le SDK demande un identifiant temporaire à l'URI spécifiée.