Comment configurer l'authentification pour le SDK Alibaba Cloud pour 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'identification pour un développement sécurisé.

Prérequis

La version du package aliyun-java-sdk-core doit être la 4.7.3 ou une version 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 divulgation d'un AccessKey de compte Alibaba Cloud compromet toutes les ressources associées à ce compte. Utilisez plutôt l'AccessKey d'un utilisateur Resource Access Management (RAM). Créer un 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 les variables d'environnement sous Linux, macOS et Windows.

Initialisez le client en configurant un AccessKey à l'aide de 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 un AccessKey à l'aide de 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 : Jeton STS

Initialisez le client avec un identifiant d'accès temporaire (jeton 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 du service Security Token Service (STS) pour obtenir un jeton 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 à partir d'un rôle RAM d'instance attaché à une instance Elastic Compute Service (ECS) ou Elastic Container Instance (ECI), éliminant ainsi le besoin d'AccessKeys statiques. Le SDK détecte automatiquement le rôle RAM attaché et obtient un jeton STS depuis le serveur de métadonnées.

L'outil Credentials utilise IMDSv2 (mode de sécurité renforcée) par défaut. Si IMDSv2 échoue, le paramètre disableIMDSv1 contrôle le comportement de secours :

false (par défaut) : bascule vers le mode normal (IMDSv1) pour récupérer les identifiants.
true : lève une exception au lieu de basculer vers IMDSv1.

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

Remarque

Important

Assurez-vous que l'instance ECS est configurée avec un rôle RAM.

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 différent et utilise des identifiants temporaires pour accéder aux ressources Alibaba Cloud, éliminant ainsi les AccessKeys à long terme.

ACK monte un fichier de jeton 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 jeton OIDC contre un jeton STS. Isoler les autorisations 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 : Chaîne de fournisseurs d'identifiants par défaut

Si aucun identifiant n'est fourni explicitement, 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 utilise 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 jeton OIDC.

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

4. Fichier de configuration

Si aucun identifiant n'a été trouvé, 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 le fichier.

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

Pour configurer un identifiant de cette manière, vous pouvez utiliser l'Alibaba Cloud CLI ou créer manuellement un fichier config.json dans le 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 d'identifiant correspondante. Le nom de l'identifiant correspond à la valeur du paramètre name dans profiles. Par défaut, le système donne la priorité au nom de l'identifiant spécifié par la variable d'environnement ALIBABA_CLOUD_PROFILE . Si cette variable d'environnement n'est pas configurée, le système utilise le nom de l'identifiant spécifié par current.

profiles

Contient une collection de configurations d'identifiants. Le paramètre mode spécifie le type d'identifiant :

AK : utilise l'AccessKey d'un utilisateur RAM comme identifiant.
StsToken : utilise un jeton STS comme identifiant.
RamRoleArn : endosse un rôle RAM en utilisant les identifiants d'un utilisateur RAM pour obtenir un identifiant temporaire.
EcsRamRole : obtient un identifiant à partir des métadonnées de l'instance.
OIDC : obtient un identifiant en utilisant un ARN de fournisseur OIDC, un jeton OIDC et un ARN de rôle RAM.
ChainableRamRoleArn : utilise le chaînage de rôles pour obtenir un nouvel identifiant, en utilisant un identifiant initial issu de profiles qui est spécifié par le paramètre source_profile.

5. Rôle RAM d'instance ECS

Le SDK vérifie la présence de la variable d'environnement ALIBABA_CLOUD_ECS_METADATA, qui spécifie un nom de rôle RAM d'instance. Si elle est définie, le SDK récupère un jeton STS depuis le serveur de métadonnées ECS.

6. URI des identifiants

Le SDK vérifie la présence de la variable d'environnement ALIBABA_CLOUD_CREDENTIALS_URI. Si elle est définie, le SDK demande un identifiant temporaire à l'URI spécifié.