:Comment configurer les identifiants d'accès à l'aide du SDK OSS pour Node.js

Le tableau suivant compare les différentes méthodes de configuration des identifiants afin de vous aider à choisir la plus adaptée.

Méthode 1 : Utiliser une paire AccessKey

L'utilisation d'une paire AccessKey à long terme est simple, mais moins sécurisée. Elle convient aux applications évoluant dans des environnements hautement sécurisés. Pour une meilleure sécurité, utilisez toujours la paire AccessKey d'un utilisateur RAM disposant des autorisations minimales requises, et non celle de votre compte Alibaba Cloud. Pour savoir comment obtenir une paire AccessKey, consultez la rubrique CreateAccessKey.

1. Configurez les variables d'environnement.

   Mac OS X/Linux/Unix

   export ALIBABA_CLOUD_ACCESS_KEY_ID=<ALIBABA_CLOUD_ACCESS_KEY_ID>
   export ALIBABA_CLOUD_ACCESS_KEY_SECRET=<ALIBABA_CLOUD_ACCESS_KEY_SECRET>

   Windows

   set ALIBABA_CLOUD_ACCESS_KEY_ID=<ALIBABA_CLOUD_ACCESS_KEY_ID>
   set ALIBABA_CLOUD_ACCESS_KEY_SECRET=<ALIBABA_CLOUD_ACCESS_KEY_SECRET>

2. Utilisez la paire AccessKey pour initialiser le client.

   const OSS = require("ali-oss");
   
   // Initialize the OSSClient instance.
   const client = new OSS({
     // Obtain the AccessKey ID from the environment variable.
     accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID,
     // Obtain the AccessKey secret from the environment variable.
     accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET
   });
   
   // listBuckets
   const buckets = await client.listBuckets();
   console.log(buckets);
   

Méthode 2 : Utiliser un jeton de sécurité

Appelez l'opération AssumeRole de STS en tant qu'utilisateur RAM et spécifiez la durée de validité maximale du jeton de sécurité. Vous obtenez ainsi un jeton de sécurité.

1. Configurez les variables d'environnement.

   Mac OS X/Linux/Unix

   export ALIBABA_CLOUD_ACCESS_KEY_ID=<ALIBABA_CLOUD_ACCESS_KEY_ID>
   export ALIBABA_CLOUD_ACCESS_KEY_SECRET=<ALIBABA_CLOUD_ACCESS_KEY_SECRET>
   export ALIBABA_CLOUD_SECURITY_TOKEN=<ALIBABA_CLOUD_SECURITY_TOKEN>

   Windows

   set ALIBABA_CLOUD_ACCESS_KEY_ID=<ALIBABA_CLOUD_ACCESS_KEY_ID>
   set ALIBABA_CLOUD_ACCESS_KEY_SECRET=<ALIBABA_CLOUD_ACCESS_KEY_SECRET>
   set ALIBABA_CLOUD_SECURITY_TOKEN=<ALIBABA_CLOUD_SECURITY_TOKEN>

2. Utilisez les identifiants d'accès temporaires pour initialiser l'instance OSSClient.

   const OSS = require("ali-oss");
   
   // Initialize the OSSClient instance.
   const client = new OSS({
     // Obtain the AccessKey ID from the environment variable.
     accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID,
     // Obtain the AccessKey secret from the environment variable.
     accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET,
     // Obtain the security token from the environment variable.
     stsToken: process.env.ALIBABA_CLOUD_SECURITY_TOKEN
   });
   
   // listBuckets
   const buckets = await client.listBuckets();
   console.log(buckets);

Méthode 3 : Utiliser RAMRoleARN

La logique sous-jacente de cette méthode consiste à utiliser un jeton de sécurité obtenu auprès de STS pour configurer les identifiants d'accès. Après avoir spécifié le nom de ressource Alibaba Cloud (ARN) d'un rôle RAM, l'outil Credentials obtient le jeton de sécurité depuis STS. Vous pouvez également utiliser le paramètre policy pour limiter les autorisations du rôle RAM.

Utilisez la paire AccessKey et RAMRoleARN pour initialiser l'instance OSSClient.

const Credential = require("@alicloud/credentials");
const OSS = require("ali-oss");

// Use the ARN of your RAM role to initialize the Credentials client. 
const credentialsConfig = new Credential.Config({
  // Specify the credential type. 
  type: "ram_role_arn",
  // Obtain the AccessKey ID from the environment variable.
  accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID,
  // Obtain the AccessKey secret from the environment variable.
  accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET,
  // Specify the ARN of the RAM role that you want your application to assume by specifying the ALIBABA_CLOUD_ROLE_ARN environment variable. Example: acs:ram::123456789012****:role/adminrole.
  roleArn: '<RoleArn>',
  // Specify the role session name by specifying the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
  roleSessionName: '<RoleSessionName>',
  // Optional. Specify limited permissions for the RAM role. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}.
  // policy: '<Policy>',
  roleSessionExpiration: 3600
});
const credentialClient = new Credential.default(credentialsConfig);
const credential = await credentialClient.getCredential();

// Initialize the OSSClient instance.
const client = new OSS({
  accessKeyId:credential.accessKeyId,
  accessKeySecret: credential.accessKeySecret,
  stsToken: credential.securityToken,
  refreshSTSTokenInterval: 0, // Specify that Credential manages the update of the AccessKey ID, AccessKey secret, and security token.
  refreshSTSToken: async () => {
    const { accessKeyId, accessKeySecret, securityToken } = await credentialClient.getCredential();
    return {
      accessKeyId,
      accessKeySecret,
      stsToken: securityToken,
    };
  }
});

// listBuckets
const buckets = await client.listBuckets();
console.log( buckets);

Méthode 4 : Utiliser le rôle RAM obtenu via le mode de renforcement de la sécurité des métadonnées de l'instance ECS

La logique sous-jacente de cette méthode consiste à utiliser un jeton de sécurité obtenu auprès de STS pour configurer les identifiants d'accès. L'outil Credentials obtient automatiquement le rôle RAM attaché à une instance ECS et récupère le jeton de sécurité du rôle attaché via le serveur de métadonnées de l'instance ECS. Ce jeton de sécurité est utilisé pour initialiser un client Credentials. Utilisez l'outil Credentials pour lire le jeton de sécurité et initialiser le client Credentials.

const Credential = require("@alicloud/credentials");
const OSS = require("ali-oss");

// Use the ARN of your RAM role to initialize the Credentials client. 
const credentialsConfig = new Credential.Config({
  // Specify the credential type. 
  type: "ecs_ram_role",
  // Optional. Specify the name of the RAM role attached to an ECS instance by specifying the ALIBABA_CLOUD_ECS_METADATA environment variable. If you do not specify this parameter, the name of the RAM role attached to an ECS instance is automatically obtained. We recommend that you specify this parameter to reduce the number of requests.
  roleName: '<RoleName>'
});
const credentialClient = new Credential.default(credentialsConfig);

const { accessKeyId, accessKeySecret, securityToken } = await credentialClient.getCredential();

// Initialize the OSSClient instance.
const client = new OSS({
  accessKeyId,
  accessKeySecret,
  stsToken: securityToken,
  refreshSTSTokenInterval: 0, // Specify that Credential manages the update of the AccessKey ID, AccessKey secret, and security token.
  refreshSTSToken: async () => {
    const { accessKeyId, accessKeySecret, securityToken } = await credentialClient.getCredential();
    
    return {
      accessKeyId,
      accessKeySecret,
      stsToken: securityToken,
    };
  }
});

// listBuckets
const buckets = await client.listBuckets();
console.log(buckets);

Méthode 5 : Utiliser OIDCRoleARN

Une fois qu'un rôle RAM est configuré sur le nœud de travail ACK, les applications s'exécutant dans les pods de ce nœud peuvent obtenir le jeton de sécurité du rôle via le serveur de métadonnées, à l'instar des applications sur les instances ECS. Toutefois, pour les applications non fiables, telles que le code soumis par les clients, il peut être nécessaire de restreindre l'accès au jeton de sécurité du rôle RAM. Afin de sécuriser les ressources cloud tout en permettant aux applications non fiables d'obtenir les jetons nécessaires et de minimiser les autorisations, utilisez la fonctionnalité Rôles RAM pour les comptes de service. ACK crée et monte des fichiers de jetons OpenID Connect pour différents pods d'application, en transmettant les informations de configuration aux variables d'environnement. L'outil Credentials récupère ces configurations et appelle l'opération AssumeRoleWithOIDC de STS pour obtenir le jeton de sécurité du rôle attaché. Pour plus d'informations, consultez la rubrique Utiliser RRSA pour le contrôle d'accès au niveau des pods.

Configurez OIDCRoleARN comme identifiant d'accès pour initialiser le client.

const OSS = require("ali-oss");
const Credential = require("@alicloud/credentials");

const credentialsConfig = new Credential.Config({
  // Specify the credential type. 
  type: "oidc_role_arn",
  // Specify the ARN of the RAM role by specifying the ALIBABA_CLOUD_ROLE_ARN environment variable.
  roleArn: '<RoleArn>',
  // Specify the ARN of the OIDC IdP by specifying the ALIBABA_CLOUD_OIDC_PROVIDER_ARN environment variable.
  oidcProviderArn: '<OidcProviderArn>',
  // Specify the path of the OIDC token file by specifying the ALIBABA_CLOUD_OIDC_TOKEN_FILE environment variable.
  oidcTokenFilePath: '<OidcTokenFilePath>',
  // Specify the role session name by specifying the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
  roleSessionName: '<RoleSessionName>',
  // Optional. Specify limited permissions for the RAM role. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}.
  // policy: "<Policy>",
  // Specify the validity period of the session.
  roleSessionExpiration: 3600
});
const credentialClient = new Credential.default(credentialsConfig);
const { accessKeyId, accessKeySecret, securityToken } = await credentialClient.getCredential();
const client = new OSS({
  accessKeyId,
  accessKeySecret,
  stsToken: securityToken,
  refreshSTSTokenInterval: 0, // Specify that Credential manages the update of the AccessKey ID, AccessKey secret, and security token.
  refreshSTSToken: async () => {
    const { accessKeyId, accessKeySecret, securityToken } = await credentialClient.getCredential();
    
    return {
      accessKeyId,
      accessKeySecret,
      stsToken: securityToken,
    };
  }
});
const buckets = await client.listBuckets();

console.log(buckets);

Méthode 6 : Utiliser CredentialsURI

Si votre application doit obtenir des identifiants Alibaba Cloud auprès d'un système externe pour une gestion flexible et un accès sans clé, utilisez CredentialsURI pour initialiser un fournisseur d'identifiants. Cette méthode utilise un jeton de sécurité de STS pour configurer les identifiants d'accès. L'outil Credentials récupère le jeton à l'aide de l'URI spécifié pour initialiser une instance OSSClient sur le client. Cette approche minimise les risques associés à la gestion manuelle des paires AccessKey ou des jetons de sécurité. Notez que le service backend fournissant la réponse CredentialsURI doit actualiser automatiquement le jeton de sécurité afin de garantir que votre application dispose toujours d'identifiants valides.

1. Pour permettre à l'outil Credentials d'analyser et d'utiliser correctement un jeton de sécurité, l'URI doit respecter le protocole de réponse suivant :

   • Code d'état de la réponse : 200

   • Structure du corps de la réponse :

     {
       "Code": "Success",
       "AccessKeySecret": "AccessKeySecret",
       "AccessKeyId": "AccessKeyId",
       "Expiration": "2021-09-26T03:46:38Z",
       "SecurityToken": "SecurityToken"
     }

2. Configurez CredentialsURI comme identifiant d'accès pour initialiser le client.

   const OSS = require("ali-oss");
   const Credential = require("@alicloud/credentials");
   
   // Use the URI of the credential to initialize the Credentials client. 
   const credentialsConfig = new Credential.Config({
     // Specify the credential type. 
     type: "credentials_uri",
     // Specify the URI of the credential in the http://local_or_remote_uri/ format by specifying the ALIBABA_CLOUD_CREDENTIALS_URI environment variable.
     credentialsURI: '<CredentialsUri>'
   });
   const credentialClient = new Credential.default(credentialsConfig);
   const credential = await credentialClient.getCredential();
   
   // Initialize the OSSClient instance.
   const client = new OSS({
     accessKeyId: credential.accessKeyId,
     accessKeySecret: credential.accessKeySecret,
     stsToken: credential.securityToken,
     refreshSTSTokenInterval: 0, // Specify that Credential manages the update of the AccessKey ID, AccessKey secret, and security token.
     refreshSTSToken: async () => {
       const { accessKeyId, accessKeySecret, securityToken } = await credentialClient.getCredential();
   
       return {
         accessKeyId,
         accessKeySecret,
         stsToken: securityToken,
       };
     }
   });
   
   // listBuckets
   const buckets = await client.listBuckets();
   console.log(buckets);