Le SDK Alibaba Cloud utilise l'outil Credentials pour gérer centralisée les identifiants, tels que votre AccessKey et votre jeton STS. Cette rubrique décrit les types d'identifiants pris en charge et leurs méthodes de configuration.
Contexte
Les identifiants vérifient l'identité d'un utilisateur lors de l'accès aux services Alibaba Cloud. Les types d'identifiants courants sont les suivants :
Une paire d'AccessKey fournit des identifiants permanents pour un compte Alibaba Cloud ou un utilisateur RAM. Elle se compose d'un AccessKey ID et d'un AccessKey Secret.
Un jeton STS fournit des identifiants temporaires pour un rôle RAM, avec une période de validité et une portée d'autorisation configurables. Qu'est-ce que STS.
Un jeton bearer sert à l'authentification et à l'autorisation.
Prérequis
Node.js 8.5.0 ou version ultérieure est installé.
Le SDK Alibaba Cloud V2.0 est configuré. Utiliser le SDK Alibaba Cloud pour Node.js avec un IDE.
Installer l'outil Credentials
Exécutez la commande npm suivante pour installer le package.
npm install @alicloud/credentials
Utilisez la dernière version pour garantir la prise en charge de tous les types d'identifiants. Releases · aliyun/credentials-nodejs · GitHub.
Paramètres des identifiants
Configurez les identifiants via le constructeur Config du module @alicloud/credentials. Le paramètre type est obligatoire et détermine les autres paramètres applicables. Le tableau suivant liste les valeurs valides pour type et leurs paramètres associés. √ = obligatoire, - = facultatif, × = non pris en charge.
Seuls les types d'identifiants et les paramètres listés ci-dessous sont pris en charge.
|
type |
access_key |
sts |
ram_role_arn |
ecs_ram_role |
oidc_role_arn |
credentials_uri |
bearer |
|
accessKeyId : L'AccessKey ID. |
√ |
√ |
√ |
× |
× |
× |
× |
|
accessKeySecret : L'AccessKey secret. |
√ |
√ |
√ |
× |
× |
× |
× |
|
securityToken : Le jeton Security Token Service (STS). |
× |
√ |
- |
× |
× |
× |
× |
|
roleArn : L'Alibaba Cloud Resource Name (ARN) du rôle RAM. |
× |
× |
√ |
× |
√ |
× |
× |
|
roleSessionName : Un nom personnalisé pour la session. Le format par défaut est |
× |
× |
- |
× |
- |
× |
× |
|
roleName : Le nom du rôle RAM. |
× |
× |
× |
- |
× |
× |
× |
|
disableIMDSv1 : Indique s'il faut imposer le mode de renforcement de la sécurité (IMDSv2). Valeur par défaut : |
× |
× |
× |
- |
× |
× |
× |
|
bearerToken : Le jeton bearer. |
× |
× |
× |
× |
× |
× |
√ |
|
policy : Une politique personnalisée. |
× |
× |
- |
× |
- |
× |
× |
|
roleSessionExpiration : La durée d'expiration de la session, en secondes. Valeur par défaut : 3600. |
× |
× |
- |
× |
- |
× |
× |
|
oidcProviderArn : L'ARN du fournisseur d'identité OpenID Connect (OIDC). |
× |
× |
× |
× |
√ |
× |
× |
|
oidcTokenFilePath : Le chemin vers le fichier de jeton OpenID Connect (OIDC). |
× |
× |
× |
× |
√ |
× |
× |
|
externalId : Un ID externe pour atténuer le problème du « confused deputy ». Utiliser un ID externe pour prévenir le problème du confused deputy. |
× |
× |
- |
× |
× |
× |
× |
|
credentialsURI : L'URI des identifiants. |
× |
× |
× |
× |
× |
√ |
× |
|
L'endpoint STS. Prend en charge les endpoints VPC et publics. Endpoints disponibles : Endpoints. Par défaut : |
× |
× |
- |
× |
- |
× |
× |
|
timeout : Le délai d'attente de lecture pour les requêtes HTTP, en millisecondes. La valeur par défaut est 5000. |
× |
× |
- |
- |
- |
- |
× |
|
connectTimeout : Le délai d'attente de connexion pour les requêtes HTTP, en millisecondes. La valeur par défaut est 10000. |
× |
× |
- |
- |
- |
- |
× |
Initialiser un client d'identifiants
La section précédente décrit les types d'identifiants et les paramètres de configuration pris en charge par l'outil Credentials. Les sections suivantes fournissent des exemples de code illustrant l'utilisation de cet outil. Choisissez la méthode la plus adaptée à votre scénario.
Ne stockez jamais d'
AccessKeyen texte brut dans le code de votre projet. Une clé exposée compromet toutes les ressources du compte. Stockez-la plutôt dans des variables d'environnement ou des fichiers de configuration.Implémentez le
singleton patternpour l'outil credentials. Cela active lecache d'identifiantsintégré, évitant ainsi lalimitation de débitdue à un nombre excessif d'appels API. Mécanisme de rafraîchissement automatique des identifiants de session.
Méthode 1 : Chaîne de fournisseurs d'identifiants par défaut
L'initialisation d'un client d'identifiants sans paramètres active la Chaîne de fournisseurs d'identifiants par défaut.
const Credential = require('@alicloud/credentials');
// Use the default credential provider chain
const credentialClient = new Credential.default();
const credential = credentialClient.getCredential();
credential.then(credential => {
console.log(credential);
});
import Credential from '@alicloud/credentials';
const credential = new Credential();
credential.getCredential().then(credential => {
console.log(credential);
});Appel API
Méthode 2 : Utiliser un AccessKey
L'outil Credentials utilise l'AccessKey fourni comme identifiant d'accès.
Un compte Alibaba Cloud (compte racine) dispose de toutes les autorisations sur l'ensemble de ses ressources. Par conséquent, un AK exposé représente un risque de sécurité majeur. N'utilisez pas l'AK d'un compte racine.
Utilisez l'AK d'un utilisateur RAM disposant du principe du moindre privilège.
const Credential = require('@alicloud/credentials');
const credentialsConfig = new Credential.Config({
// The credential type.
type: 'access_key',
// Your AccessKey ID, retrieved from an environment variable.
accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID,
// Your AccessKey Secret, retrieved from an environment variable.
accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET,
});
const credentialClient = new Credential.default(credentialsConfig);
import Credential, { Config } from '@alicloud/credentials';
const credentialsConfig = new Config({
// The credential type.
type: 'access_key',
// Your AccessKey ID, retrieved from an environment variable.
accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID,
// Your AccessKey Secret, retrieved from an environment variable.
accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET,
});
const credentialClient = new Credential(credentialsConfig);Appel API
Méthode 3 : Utiliser un jeton STS
L'outil Credentials utilise le jeton STS statique fourni comme identifiant d'accès.
const Credential = require('@alicloud/credentials');
const credentialsConfig = new Credential.Config({
type: 'sts',
// Your AccessKey ID, retrieved from an environment variable.
accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID,
// Your AccessKey Secret, retrieved from an environment variable.
accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET,
// Your security token, retrieved from an environment variable.
securityToken: process.env.ALIBABA_CLOUD_SECURITY_TOKEN,
});
const cred = new Credential.default(credentialsConfig);import Credential, { Config } from '@alicloud/credentials';
const credentialsConfig = new Config({
// The credential type.
type: 'access_key',
// Your AccessKey ID, retrieved from an environment variable.
accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID,
// Your AccessKey Secret, retrieved from an environment variable.
accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET,
// Your security token, retrieved from an environment variable.
securityToken: process.env.ALIBABA_CLOUD_SECURITY_TOKEN,
});
const credentialClient = new Credential(credentialsConfig);
Appel API
Méthode 4 : AccessKey et ARN de rôle RAM
Cette méthode utilise STS en interne. Lorsque vous spécifiez un ARN de rôle RAM, l'outil Credentials obtient un jeton STS auprès de STS. Vous pouvez utiliser le paramètre policy pour restreindre davantage les autorisations du rôle.
const Credential = require('@alicloud/credentials');
const credentialsConfig = new Credential.Config({
type: 'ram_role_arn',
accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID,
accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET,
// The RAM role ARN to assume. Example: acs:ram::123456789012****:role/adminrole. This can also be set using the `ALIBABA_CLOUD_ROLE_ARN` environment variable.
roleArn: '<RoleArn>',
// A custom role session name. This can also be set using the `ALIBABA_CLOUD_ROLE_SESSION_NAME` environment variable.
roleSessionName: '<RoleSessionName>',
// Optional. An inline policy to limit the permissions of the RAM role. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
policy: '<Policy>',
roleSessionExpiration: 3600,
});
const cred = new Credential.default(credentialsConfig);import Credential, { Config } from '@alicloud/credentials';
const credentialsConfig = new Config({
type: 'ram_role_arn',
accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID,
accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET,
// The RAM role ARN to assume. Example: acs:ram::123456789012****:role/adminrole. This can also be set using the `ALIBABA_CLOUD_ROLE_ARN` environment variable.
roleArn: '<RoleArn>',
// A custom role session name. This can also be set using the `ALIBABA_CLOUD_ROLE_SESSION_NAME` environment variable.
roleSessionName: '<RoleSessionName>',
// Optional. An inline policy to limit the permissions of the RAM role. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
policy: '<Policy>',
roleSessionExpiration: 3600,
});
const credentialClient = new Credential(credentialsConfig);Méthode d'appel API
Méthode 5 : Rôle RAM d'instance ECS
Attachez un rôle RAM d'instance à une instance ECS ou à une instance de conteneur élastique. Les applications présentes sur l'instance peuvent alors utiliser l'outil Credentials pour obtenir automatiquement un jeton STS pour ce rôle.
Par défaut, l'outil Credentials accède au serveur de métadonnées ECS en mode de renforcement de la sécurité (IMDSv2). En cas d'erreur, il revient au mode normal. Contrôlez ce comportement avec le paramètre disableIMDSv1 ou la variable d'environnement ALIBABA_CLOUD_IMDSV1_DISABLE :
false(par défaut) : Revient au mode normal en cas d'échec.true: Utilise uniquement le mode de renforcement de la sécurité et lève une exception en cas d'échec.
La prise en charge d'IMDSv2 dépend de la configuration de votre serveur.
Vous pouvez également désactiver l'accès aux identifiants via les métadonnées ECS en définissant la variable d'environnement ALIBABA_CLOUD_ECS_METADATA_DISABLED=true.
Le mode de renforcement de la sécurité nécessite la version 2.3.1 ou ultérieure de la bibliothèque d'identifiants.
Présentation des métadonnées d'instance ECS : Métadonnées d'instance.
Pour attribuer un rôle RAM à une instance ECS ou de conteneur élastique : Étape 1 : Créer un rôle RAM et Attribuer un rôle RAM d'instance à une instance ECI.
const Credential = require('@alicloud/credentials');
const credentialsConfig = new Credential.Config({
type: 'ecs_ram_role',
// Optional. The name of the ECS RAM role. If unspecified, the system retrieves it automatically. Specifying a name is recommended to reduce requests. This can also be set via the ALIBABA_CLOUD_ECS_METADATA environment variable.
roleName: '<RoleName>',
// Optional. Default: false. If true, enforces security hardening mode. If false, the system tries security hardening mode first, falling back to normal mode (IMDSv1) on failure.
// disableIMDSv1: true,
});
const cred = new Credential.default(credentialsConfig);
import Credential, { Config } from '@alicloud/credentials';
const credentialsConfig = new Config({
type: 'ecs_ram_role',
// Optional. The name of the ECS RAM role. If unspecified, the system retrieves it automatically. Specifying a name is recommended to reduce requests. This can also be set via the ALIBABA_CLOUD_ECS_METADATA environment variable.
roleName: '<RoleName>',
// Optional. Default: false. If true, enforces security hardening mode. If false, the system tries security hardening mode first, falling back to normal mode (IMDSv1) on failure.
// disableIMDSv1: true,
});
const credentialClient = new Credential(credentialsConfig);Appel API
Méthode 6 : Utiliser OIDCRoleArn
Si vous utilisez OIDC et avez créé un rôle RAM pour un fournisseur OIDC, transmettez un ARN de fournisseur OIDC, un jeton OIDC et un ARN de rôle RAM au SDK Credentials. Le SDK appelle l'opération AssumeRoleWithOIDC pour obtenir un jeton STS. Ces identifiants prennent en charge le rafraîchissement automatique. Mécanisme de rafraîchissement automatique des identifiants de session. Par exemple, dans un cluster ACK avec RRSA activé, le SDK lit la configuration OIDC depuis les variables d'environnement du Pod et obtient un jeton STS pour accéder aux services Alibaba Cloud.
const Credential = require('@alicloud/credentials');
const credentialsConfig = new Credential.Config({
type: 'oidc_role_arn',
// The RAM role ARN to assume. You can also set this using the ALIBABA_CLOUD_ROLE_ARN environment variable.
roleArn: '<RoleArn>',
// The OIDC IdP ARN. You can also set this using the ALIBABA_CLOUD_OIDC_PROVIDER_ARN environment variable.
oidcProviderArn: '<OidcProviderArn>',
// The OIDC token file path. You can also set this using the ALIBABA_CLOUD_OIDC_TOKEN_FILE environment variable.
oidcTokenFilePath: '<OidcTokenFilePath>',
// A custom role session name. You can also set this using the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
roleSessionName: '<RoleSessionName>',
// Optional. A policy to scope down the permissions for the session. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
policy: '<Policy>',
// The session duration in seconds.
roleSessionExpiration: 3600,
});
const credentialClient = new Credential.default(credentialsConfig);import Credential, { Config } from '@alicloud/credentials';
const credentialsConfig = new Config({
type: 'oidc_role_arn',
// The RAM role ARN to assume. You can also set this using the ALIBABA_CLOUD_ROLE_ARN environment variable.
roleArn: '<RoleArn>',
// The OIDC IdP ARN. You can also set this using the ALIBABA_CLOUD_OIDC_PROVIDER_ARN environment variable.
oidcProviderArn: '<OidcProviderArn>',
// The OIDC token file path. You can also set this using the ALIBABA_CLOUD_OIDC_TOKEN_FILE environment variable.
oidcTokenFilePath: '<OidcTokenFilePath>',
// A custom role session name. You can also set this using the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
roleSessionName: '<RoleSessionName>',
// Optional. A policy to scope down the permissions for the session. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
policy: '<Policy>',
// The session duration in seconds.
roleSessionExpiration: 3600,
});
const credentialClient = new Credential(credentialsConfig);Appel API
Méthode 7 : Identifiant URI
Exposez le service STS via une URI afin que les services externes puissent obtenir un jeton STS sans gérer directement les paires d'AccessKey. L'outil Credentials récupère un jeton STS à partir de l'URI spécifiée et l'utilise comme identifiant d'accès, avec prise en charge du rafraîchissement automatique. Mécanisme de rafraîchissement automatique pour les identifiants de type session.
const Credential = require('@alicloud/credentials');
const config = new Credential.Config({
type: 'credentials_uri',
// The endpoint to retrieve credentials, for example, http://local_or_remote_uri/. This can also be set with the ALIBABA_CLOUD_CREDENTIALS_URI environment variable.
credentialsURI: '<CredentialsUri>',
});
const credentialClient = new Credential(config);import Credential, { Config } from '@alicloud/credentials';
const credentialsConfig = new Config({
type: 'credentials_uri',
// The endpoint to retrieve credentials, for example, http://local_or_remote_uri/. This can also be set with the ALIBABA_CLOUD_CREDENTIALS_URI environment variable.
credentialsURI: '<CredentialsUri>',
});
const credentialClient = new Credential(credentialsConfig);La réponse de l'URI doit respecter les exigences suivantes :
Le code de statut est 200.
-
Format du corps de la réponse :
{ "Code": "Success", "AccessKeySecret": "AccessKeySecret", "AccessKeyId": "AccessKeyId", "Expiration": "2021-09-26T03:46:38Z", "SecurityToken": "SecurityToken" }
Appel API
Méthode 8 : Utiliser un jeton bearer
Actuellement, seul Alibaba Cloud Call Center (CCC) prend en charge l'authentification par jeton bearer.
const Credential = require('@alicloud/credentials');
const config = new Credential.Config({
type: 'bearer',
// Replace with your bearer token.
bearerToken: '<BearerToken>',
});
const credentialClient = new Credential(config);import Credential, { Config } from '@alicloud/credentials';
const credentialsConfig = new Config({
type: 'bearer',
// Replace with your bearer token.
bearerToken: '<BearerToken>',
});
const credentialClient = new Credential(credentialsConfig);Appel API
Chaîne de fournisseurs d'identifiants par défaut
La chaîne de fournisseurs d'identifiants par défaut permet d'utiliser le même code dans différents environnements et de contrôler la récupération des identifiants via une configuration externe. Lors de l'appel à new Credential() sans paramètres, le SDK recherche les identifiants dans l'ordre suivant.
1. Utilisation des variables d'environnement
Si aucun identifiant n'est trouvé dans les propriétés système, la chaîne de fournisseurs vérifie ensuite les variables d'environnement.
Si ALIBABA_CLOUD_ACCESS_KEY_ID et ALIBABA_CLOUD_ACCESS_KEY_SECRET sont présents et non vides, la chaîne de fournisseurs les utilise comme identifiant par défaut.
Si ALIBABA_CLOUD_ACCESS_KEY_ID, ALIBABA_CLOUD_ACCESS_KEY_SECRET et ALIBABA_CLOUD_SECURITY_TOKEN sont également définis, la chaîne de fournisseurs utilise un jeton STS comme identifiant par défaut.
2. Rôles RAM OIDC
Si aucun identifiant n'a été trouvé, la chaîne de fournisseurs vérifie les variables d'environnement suivantes liées à un rôle RAM OIDC :
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 présentes et non vides, la chaîne de fournisseurs utilise ces valeurs pour appeler l'API AssumeRoleWithOIDC du Security Token Service (STS) afin d'obtenir un jeton STS.
3. Config.json
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 ce fichier.
Linux/macOS :
~/.aliyun/config.jsonWindows :
C:\Users\USER_NAME\.aliyun\config.json
Pour configurer un identifiant de cette manière, utilisez l'CLI Alibaba Cloud ou créez manuellement un fichier config.json au chemin approprié. L'exemple suivant montre 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 |
|
profiles |
Contient une collection de configurations d'identifiants. Le paramètre
|
4. Rôle RAM d'instance ECS
Si aucun identifiant de priorité supérieure n'est trouvé, le SDK récupère les identifiants du rôle RAM de l'instance ECS. Il accède au service de métadonnées de l'instance en mode renforcé (IMDSv2) pour obtenir un jeton STS. Cela nécessite deux requêtes : une pour le nom du rôle, une autre pour les identifiants. Pour réduire cela à une seule requête, définissez le nom du rôle dans la variable d'environnement ALIBABA_CLOUD_ECS_METADATA. Si le mode renforcé échoue, le processus revient au mode normal. Contrôlez ce comportement avec ALIBABA_CLOUD_IMDSV1_DISABLE :
false: Revient au mode normal en cas d'échec.true: Utilise uniquement le mode renforcé et lève une exception en cas d'échec.
La prise en charge d'IMDSv2 dépend de la configuration du service de métadonnées de votre instance.
Pour désactiver la récupération des identifiants depuis les métadonnées de l'instance ECS, définissez ALIBABA_CLOUD_ECS_METADATA_DISABLED=true.
Présentation des métadonnées d'instance ECS : Métadonnées d'instance.
Pour attribuer un rôle RAM à une instance ECS ou ECI : Étape 1 : Créer un rôle RAM et Attribuer un rôle RAM d'instance à une instance ECI.
5. URI des identifiants
Si aucun identifiant n'a été trouvé, la chaîne de fournisseurs vérifie la variable d'environnement ALIBABA_CLOUD_CREDENTIALS_URI. Si cette variable est définie et pointe vers une URI valide, la chaîne accède à cette URI pour récupérer un jeton STS.
Rafraîchissement automatique des identifiants de session
Les identifiants de session (ram_role_arn, ecs_ram_role, oidc_role_arn et credentials_uri) incluent un mécanisme de rafraîchissement automatique intégré. Lors de la première récupération, l'outil Credentials met l'identifiant en cache. Les requêtes suivantes renvoient la valeur mise en cache jusqu'à son expiration, moment auquel un nouvel identifiant est automatiquement récupéré.
Pour les identifiants ecs_ram_role, l'outil Credentials les rafraîchit de manière proactive 15 minutes avant leur expiration.
L'exemple suivant utilise le modèle singleton pour créer un client d'identifiants, vérifiant le rafraîchissement automatique en récupérant les identifiants à différents intervalles et en confirmant leur validité via un appel OpenAPI.
const Credential = require('@alicloud/credentials');
const Ecs20140526 = require('@alicloud/ecs20140526');
const { Config } = require('@alicloud/openapi-client');
const { RuntimeOptions } = require('@alicloud/tea-util');
// Obtain environment variables.
const accessKeyId = process.env.ALIBABA_CLOUD_ACCESS_KEY_ID;
const accessKeySecret = process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET;
const roleArn = process.env.ALIBABA_CLOUD_ROLE_ARN;
/**
* The Credential singleton class manages Alibaba Cloud credential instances.
*/
class CredentialClient {
constructor() {
if (!CredentialClient.instance) {
var credentialsConfig = new Credential.Config({
type: 'ram_role_arn',
accessKeyId: accessKeyId,
accessKeySecret: accessKeySecret,
roleArn: roleArn,
roleSessionName: 'RoleSessionNameTest',
roleSessionExpiration: 3600,
});
this.credentialsClient = new Credential.default(credentialsConfig);
CredentialClient.instance = this;
}
return CredentialClient.instance;
}
static getInstance() {
return new CredentialClient().credentialsClient;
}
}
/**
* The ECS Client singleton class manages ECS client instances.
*/
class EcsClient {
constructor(credentialClient) {
if (!EcsClient.instance) {
const config = new Config({
endpoint: 'ecs.cn-hangzhou.aliyuncs.com',
credential: credentialClient
});
this.ecsClient = new Ecs20140526.default(config);
EcsClient.instance = this;
}
return EcsClient.instance;
}
static getInstance(credentialClient) {
return new EcsClient(credentialClient).ecsClient;
}
}
/**
* Execute the task logic.
*/
async function executeTask() {
try {
const credentialClient = CredentialClient.getInstance();
const credential = await credentialClient.getCredential();
console.log(new Date());
console.log(`AK ID: ${credential.accessKeyId}`);
console.log(`AK Secret: ${credential.accessKeySecret}`);
console.log(`STS Token: ${credential.securityToken}`);
// This example calls an ECS API operation to verify the credential's validity. Modify this as needed.
const ecsClient = EcsClient.getInstance(credentialClient);
const request = new Ecs20140526.DescribeRegionsRequest();
const runtime = new RuntimeOptions({});
const response = await ecsClient.describeRegionsWithOptions(request, runtime);
console.log(`Invoke result: ${response.statusCode}`);
} catch (error) {
throw new Error(`ECS client execution failed: ${error.message}`, { cause: error });
}
}
/**
* Schedule task execution by using a timer.
*/
function scheduleTasks() {
// Immediately run the task once.
executeTask();
// Set a delay for subsequent tasks.
setTimeout(executeTask, 600 * 1000); // Second run: after 600 seconds.
setTimeout(executeTask, 4200 * 1000); // Third run: after 4,200 seconds.
setTimeout(executeTask, 4300 * 1000); // Fourth run: after 4,300 seconds.
}
// Start task scheduling.
scheduleTasks();
import Credential, { Config as CredentialsConfig } from '@alicloud/credentials';
import Ecs20140526, * as $Ecs20140526 from '@alicloud/ecs20140526';
import { Config } from '@alicloud/openapi-client';
import { RuntimeOptions } from '@alicloud/tea-util';
// Obtain environment variables.
const accessKeyId: string | undefined = process.env.ALIBABA_CLOUD_ACCESS_KEY_ID;
const accessKeySecret: string | undefined = process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET;
const roleArn: string | undefined = process.env.ALIBABA_CLOUD_ROLE_ARN;
if (!accessKeyId || !accessKeySecret || !roleArn) {
throw new Error('Missing required environment variables.');
}
/**
* The Credential singleton class manages Alibaba Cloud credential instances.
*/
class CredentialClient {
private static instance: CredentialClient;
private readonly credentialsClient: InstanceType<typeof Credential>;
private constructor() {
const credentialsConfig = new CredentialsConfig({
type: 'ram_role_arn',
accessKeyId,
accessKeySecret,
roleArn,
roleSessionName: 'RoleSessionNameTest',
roleSessionExpiration: 3600,
});
this.credentialsClient = new Credential(credentialsConfig);
}
static getInstance(): InstanceType<typeof Credential> {
if (!CredentialClient.instance) {
CredentialClient.instance = new CredentialClient();
}
return CredentialClient.instance.credentialsClient;
}
}
/**
* The ECS Client singleton class manages ECS client instances.
*/
class EcsClient {
private static instance: EcsClient;
private readonly ecsClient: InstanceType<typeof Ecs20140526>;
private constructor(credentialClient: InstanceType<typeof Credential>) {
const config = new Config({
endpoint: 'ecs.cn-hangzhou.aliyuncs.com',
credential: credentialClient
});
this.ecsClient = new Ecs20140526(config);
}
static getInstance(credentialClient: InstanceType<typeof Credential>): InstanceType<typeof Ecs20140526> {
if (!EcsClient.instance) {
EcsClient.instance = new EcsClient(credentialClient);
}
return EcsClient.instance.ecsClient;
}
}
/**
* Execute the task logic.
*/
async function executeTask(): Promise<void> {
try {
const credentialClient = CredentialClient.getInstance();
const credential = await credentialClient.getCredential();
console.log(new Date());
console.log(`AK ID: ${credential.accessKeyId}`);
console.log(`AK Secret: ${credential.accessKeySecret}`);
console.log(`STS Token: ${credential.securityToken}`);
// This example calls an ECS API operation to verify the credential's validity. Modify this as needed.
const ecsClient = EcsClient.getInstance(credentialClient);
const request = new $Ecs20140526.DescribeRegionsRequest();
const runtime = new RuntimeOptions({});
const response = await ecsClient.describeRegionsWithOptions(request, runtime);
console.log(`Invoke result: ${response.statusCode}`);
} catch (error) {
throw new Error(`ECS client execution failed: ${error}`);
}
}
/**
* Schedule task execution by using a timer.
*/
function scheduleTasks(): void {
// Immediately run the task once.
executeTask();
// Set a delay for subsequent tasks.
setTimeout(executeTask, 600 * 1000); // Second run: after 600 seconds.
setTimeout(executeTask, 4200 * 1000); // Third run: after 4,200 seconds.
setTimeout(executeTask, 4300 * 1000); // Fourth run: after 4,300 seconds.
}
// Start task scheduling.
scheduleTasks();2025-05-28T09:22:29.584Z
AK ID: STS.NVS9xxx7DRbao
AK Secret: 9SoQxxxmVjVsED9ad47rcgMaw5XyQyXx
STS Token:
CAISyQJ1q6Ft5B2yfSjIr5Xmcu/irrxq0pWvU0PZhvVtS7hovafKjTz2IHhMeXZoA+4YsPw2mmFW6/sdlrpJTJtIfkHfdsp36LJe9A6dbpHd4xc1LGed0s/LI3OaLjKm9u2wCryLYbGwU/OpbE++5U0X6LDmdDKkckW40JmS8/BOZcgWWQ/KB1gvRq
0hRG1YpdQdKGHa0xxxWg0/ks0aH1war1bBL+tqofMP9MfMBZskvD42Hu8VtbbfE3SJq7BxHybx71qQs+02c5onAXAELvUvYa7OKo4MyCVBjBKEhALNBoeL7kfBobmFAAkgwYnynVMMisES3LOiIqKOsk1MdI9Cywly2y
vfiZZ1prmk1pV68xxxczc4yvhD2nuNe7rmc9Z3/JHusVmo7LiTxqAARdkoKCeYBvLk0ZFWccCiM0ZvdnRtv0VDOUfD1zQELQGL+xB5NrBmdzq2ePjFJbrkBGmy5EXD714jknyzM4lFic2dUQMi14NCHMVDVjGAf0qUs
F+PQW58jGb32fmFxxxTXOx82sdRQqW0/vTd2KQmIAA=
Invoke result: 200
2025-05-28T09:32:28.137Z
AK ID: STS.NVS9xxx7DRbao
AK Secret: 9SoQxxxmVjVsED9ad47rcgMaw5XyQyXx
STS Token:
CAISyQJ1q6Ft5B2yfSjIr5Xmcu/irrxq0pWvU0PZhvVtS7hovafKjTz2IHhMeXZoA+4YsPw2mmFW6/sdlrpJTJtIfkHfdsp36LJe9A6dbpHd4xc1LGed0s/LI3OaLjKm9u2wCryLYbGwU/OpbE++5U0X6LDmdDKkckW40JmS8/BOZcgWWQ/KB1gvRq
0hRG1YpdQdKGHa0xxxWg0/ks0aH1war1bBL+tqofMP9MfMBZskvD42Hu8VtbbfE3SJq7BxHybx71qQs+02c5onAXAELvUvYa7OKo4MyCVBjBKEhALNBoeL7kfBobmFAAkgwYnynVMMisES3LOiIqKOsk1MdI9Cywly2y
vfiZZ1prmk1pV68xxxczc4yvhD2nuNe7rmc9Z3/JHusVmo7LiTxqAARdkoKCeYBvLk0ZFWccCiM0ZvdnRtv0VDOUfD1zQELQGL+xB5NrBmdzq2ePjFJbrkBGmy5EXD714jknyzM4lFic2dUQMi14NCHMVDVjGAf0qUs
F+PQW58jGb32fmFxxxTXOx82sdRQqW0/vTd2KQmIAA=
Invoke result: 200
2025-05-28T10:32:29.771Z
AK ID: STS.NVuaxxxLFiPw8
AK Secret: 5dsoxxxpA5pCzfrek4KforS8MnJ6qHR9
STS Token:
CAISyQJ1q6Ft5B2yfSjIr5XAKsjd241w4PqgY1P2gDUvb8NqhpXc2jz2IHhMeXZoA+4YsPw2mmFW6/sdlrpJTJtIfkHfdsp36LJe9A6dbpHd4yVKL2Gd0s/LI3OaLjKm9u2wCryLYbGwU/OpbE++5U0X6LDmdDKkckW40JmS8/BOZcgWWQ/KB1gvRq
0hRG1YpdQdKGHa0xxxWg0/ks0aH1war1bBL+tqofMP9MfMBZskvD42Hu8VtbbfE3SJq7BxHybx71qQs+02c5onAXAELvUvYa7OKo4MyCVBjBKEhALNBoeL7kfBobmFAAkgwYnynVMMisES3LOjIqKOsk+Mdk9CiWv2y
vfiZZ1prmk1pV68xxxczc4yvhD2nuNe7rmc9Z3/KpUoQEo7LiTxqAAUyV7F+kpLHRG/yHw3JaVz14hqSj2hmxxkwgczUWIkpBLKHLeW0iI3sp2LNQO6iEAImLpSE0nRVBbcutIqxEuFzAs607jgOjHakTF7UZNoKVV
wb42xR4s4ThGd2PxxxqoUsrKfCq5lHiUiDq6L1VIAA=
Invoke result: 200
2025-05-28T10:34:08.130Z
AK ID: STS.NVuaxxxLFiPw8
AK Secret: 5dsoxxxpA5pCzfrek4KforS8MnJ6qHR9
STS Token:
CAISyQJ1q6Ft5B2yfSjIr5XAKsjd241w4PqgY1P2gDUvb8NqhpXc2jz2IHhMeXZoA+4YsPw2mmFW6/sdlrpJTJtIfkHfdsp36LJe9A6dbpHd4yVKL2Gd0s/LI3OaLjKm9u2wCryLYbGwU/OpbE++5U0X6LDmdDKkckW40JmS8/BOZcgWWQ/KB1gvRq
0hRG1YpdQdKGHa0xxxWg0/ks0aH1war1bBL+tqofMP9MfMBZskvD42Hu8VtbbfE3SJq7BxHybx71qQs+02c5onAXAELvUvYa7OKo4MyCVBjBKEhALNBoeL7kfBobmFAAkgwYnynVMMisES3LOjIqKOsk+Mdk9CiWv2y
vfiZZ1prmk1pV68xxxczc4yvhD2nuNe7rmc9Z3/KpUoQEo7LiTxqAAUyV7F+kpLHRG/yHw3JaVz14hqSj2hmxxkwgczUWIkpBLKHLeW0iI3sp2LNQO6iEAImLpSE0nRVBbcutIqxEuFzAs607jgOjHakTF7UZNoKVV
wb42xR4s4ThGd2PxxxqoUsrKfCq5lHiUiDq6L1VIAA=
Invoke result: 200
Analyse basée sur la sortie des journaux :
Lors du premier appel, le cache est vide. Le système récupère un identifiant selon votre configuration, puis le stocke dans le cache.
Le deuxième appel utilise le même identifiant que le premier, ce qui indique qu'il a été récupéré depuis le cache.
Lors du troisième appel, l'identifiant mis en cache a expiré. Sa durée d'expiration (
RoleSessionExpiration) est de 3 600 secondes, mais cet appel intervient 4 200 secondes après le premier. Par conséquent, le mécanisme de rafraîchissement automatique du SDK récupère un nouvel identifiant et met à jour le cache.Le quatrième appel utilise le même identifiant que le troisième, confirmant ainsi la mise à jour du cache.
Documents connexes
Pour une présentation des concepts de base de RAM, consultez Concepts de base.
Pour créer un AccessKey, consultez Créer un AccessKey.
Pour créer par programmation des utilisateurs RAM, des AccessKeys et des rôles RAM, définir des politiques d'autorisation et attribuer des autorisations, consultez Présentation du SDK RAM.
Pour assumer un rôle par programmation, consultez Présentation du SDK STS.
Pour plus de détails sur les API RAM et STS, consultez la Référence API.
Bonnes pratiques pour l'utilisation des identifiants d'accès afin d'appeler l'OpenAPI Alibaba Cloud