Le SDK Alibaba Cloud utilise l'outil Credentials pour gérer de manière centralisée les identifiants, tels que votre AccessKey et votre STS Token. Cette rubrique décrit les types d'identifiants pris en charge ainsi que leurs méthodes de configuration.
Prérequis
.NET Framework 4.5 ou version ultérieure.
.NET Standard 2.0 ou version ultérieure.
C# 4.0 ou version ultérieure.
Alibaba Cloud SDK for .NET V2.0 ou version ultérieure.
Installation de l'outil d'identifiants
Si vous avez déjà installé Alibaba Cloud Credentials for .NET, ignorez cette étape. Utilisez la dernière version du package d'identifiants afin de garantir la prise en charge de tous les types d'identifiants. Pour obtenir des informations sur toutes les versions publiées, consultez le fichier ChangeLog.md.
Installez Alibaba Cloud Credentials for .NET selon l'une des méthodes suivantes :
-
Installez le package à l'aide de l'interface CLI .NET.
dotnet add package Aliyun.Credentials -
Installez le package via le gestionnaire de packages NuGet.
Cliquez avec le bouton droit sur votre projet dans l'
Explorateur de solutionset sélectionnezGérer les packages NuGet.Dans le
Gestionnaire de packages NuGet, cliquez sur l'ongletParcouriret saisissezAliyun.Credentials.Dans la liste, sélectionnez le package officiel dont le champ
AuteursindiqueAlibaba Cloud, puis cliquez sur Installer.
Une fois l'installation terminée, exécutez la commande suivante. La sortie répertorie Aliyun.Credentials ainsi que son numéro de version :
dotnet list package
Paramètres de l'outil d'identifiants
Les paramètres de configuration de l'outil d'identifiants sont définis dans Aliyun.Credentials.Models.Config. Le paramètre obligatoire type spécifie le type d'identifiant. Après avoir sélectionné un type d'identifiant, configurez ses paramètres correspondants. Le tableau suivant détaille les valeurs valides pour type ainsi que les paramètres pris en charge par chaque type d'identifiant. Dans ce tableau, √ indique un paramètre obligatoire, - indique un paramètre facultatif et × indique un paramètre non pris en charge.
Utilisez uniquement les types d'identifiants et les paramètres répertoriés dans le tableau suivant.
|
Type |
access_key |
sts |
ram_role_arn |
ecs_ram_role |
oidc_role_arn |
credentials_uri |
bearer |
|
AccessKeyId : L'ID de la clé d'accès. |
√ |
√ |
√ |
× |
× |
× |
× |
|
AccessKeySecret : Le secret de la clé d'accès. |
√ |
√ |
√ |
× |
× |
× |
× |
|
SecurityToken : Le jeton de sécurité. |
× |
√ |
- |
× |
× |
× |
× |
|
RoleArn : L'ARN du rôle RAM. |
× |
× |
√ |
× |
√ |
× |
× |
|
RoleSessionName : Le nom de la session personnalisée. Le format par défaut est |
× |
× |
- |
× |
- |
× |
× |
|
RoleName : Le nom du rôle RAM. |
× |
× |
× |
- |
× |
× |
× |
|
DisableIMDSv1 : Indique s'il faut désactiver IMDSv1 pour appliquer le mode de renforcement de la sécurité (IMDSv2). La valeur par défaut est |
× |
× |
× |
- |
× |
× |
× |
|
BearerToken : Le jeton porteur. |
× |
× |
× |
× |
× |
× |
√ |
|
Policy : Une politique personnalisée. |
× |
× |
- |
× |
- |
× |
× |
|
RoleSessionExpiration : La durée d'expiration de la session, en secondes. La valeur par défaut est 3600. |
× |
× |
- |
× |
- |
× |
× |
|
OidcProviderArn : L'ARN du fournisseur d'identité OIDC. |
× |
× |
× |
× |
√ |
× |
× |
|
OidcTokenFilePath : Le chemin d'accès au fichier du jeton OIDC. |
× |
× |
× |
× |
√ |
× |
× |
|
ExternalId : Un ID externe utilisé pour éviter le problème du « confused deputy ». Pour plus d'informations, consultez Utiliser un ID externe pour éviter le problème du confused deputy. |
× |
× |
- |
× |
× |
× |
× |
|
CredentialsURI : L'URI de l'identifiant. |
× |
× |
× |
× |
× |
√ |
× |
|
STSEndpoint : L'endpoint de STS. Les endpoints VPC et publics sont tous deux pris en charge. Pour obtenir la liste des valeurs valides, consultez Endpoints. La valeur par défaut est |
× |
× |
- |
× |
- |
× |
× |
|
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. |
× |
× |
- |
- |
- |
- |
× |
Initialisation du 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 mieux adaptée à votre scénario.
L'intégration en dur d'un AccessKey dans votre projet engendre des risques de sécurité. Une mauvaise gestion des permissions du dépôt peut exposer toutes les ressources de votre compte. Nous vous recommandons de stocker l'AccessKey dans des variables d'environnement ou des fichiers de configuration.
Adoptez le modèle singleton avec l'outil Credentials. Ce modèle active la mise en cache intégrée des identifiants, ce qui évite la limitation de débit due aux appels API fréquents et prévient le gaspillage de ressources lié à la création de multiples instances. Pour plus d'informations, consultez Actualisation automatique des identifiants de session.
Méthode 1 : Chaîne de fournisseurs d'identifiants par défaut
Si vous initialisez un client Credentials sans aucun paramètre, l'outil Credentials utilise la chaîne de fournisseurs d'identifiants par défaut. Pour comprendre comment le SDK charge les identifiants par défaut, consultez Chaîne de fournisseurs d'identifiants par défaut.
using Aliyun.Credentials.Models;
namespace credentials_demo
{
class Program
{
static void Main(string[] args)
{
// Pass no parameters, or pass null.
var credential = new Aliyun.Credentials.Client();
// var credential = new Aliyun.Credentials.Client(null);
}
}
}
Exemple d'appel API
Méthode 2 : AccessKey
L'outil Credentials utilise l'AccessKey que vous fournissez comme identifiant d'accès.
Un compte Alibaba Cloud (compte racine) dispose de permissions complètes sur toutes 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.
Privilégiez l'AK d'un utilisateur RAM doté de permissions minimales.
using Aliyun.Credentials.Models;
namespace credentials_demo
{
class Program
{
static void Main(string[] args)
{
Config config = new Config()
{
Type = "access_key",
AccessKeyId = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_ID"),
AccessKeySecret = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_SECRET")
};
var akCredential = new Aliyun.Credentials.Client(config);
string accessKeyId = akCredential.GetAccessKeyId();
string accessSecret = akCredential.GetAccessKeySecret();
string credentialType = akCredential.GetType();
}
}
}
Exemple d'API
Méthode 3 : Utilisation d'un jeton STS
L'outil Credentials utilise le jeton STS statique que vous fournissez comme identifiant d'accès.
using Aliyun.Credentials.Models;
namespace credentials_demo
{
class Program
{
static void Main(string[] args)
{
Config config = new Config()
{
Type = "sts",
// Get the AccessKey ID from an environment variable.
AccessKeyId = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_ID"),
// Get the AccessKey Secret from an environment variable.
AccessKeySecret = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_SECRET"),
// Get the security token from an environment variable.
SecurityToken = Environment.GetEnvironmentVariable("<ALIBABA_CLOUD_SECURITY_TOKEN>")
};
var stsCredential = new Aliyun.Credentials.Client(config);
string accessKeyId = stsCredential.GetAccessKeyId();
string accessSecret = stsCredential.GetAccessKeySecret();
string credentialType = stsCredential.GetType();
string securityToken = stsCredential.GetSecurityToken();
}
}
Exemple d'appel API
Méthode 4 : Clé d'accès et ARN de rôle RAM
Cette méthode utilise un jeton STS en interne. Lorsque vous spécifiez l'ARN (Alibaba Cloud Resource Name) d'un rôle RAM, l'outil d'identifiants obtient un jeton STS auprès de STS. Vous pouvez également utiliser le paramètre Policy pour appliquer un ensemble de permissions restreint au rôle RAM.
using Aliyun.Credentials.Models;
namespace credentials_demo
{
class Program
{
static void Main(string[] args)
{
Config config = new Config()
{
Type = "ram_role_arn",
AccessKeyId = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_ID"),
AccessKeySecret = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_SECRET"),
// The ARN of the RAM role to assume. Example: acs:ram::123456789012****:role/adminrole. You can also set this using the ALIBABA_CLOUD_ROLE_ARN environment variable.
RoleArn = "<RoleArn>",
// The role session name. You can also set this using the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
RoleSessionName = "<RoleSessionName>",
};
var arnCredential = new Aliyun.Credentials.Client(config);
string accessKeyId = arnCredential.GetAccessKeyId();
string accessSecret = arnCredential.GetAccessKeySecret();
string credentialType = arnCredential.GetType();
string securityToken = arnCredential.GetSecurityToken();
}
}
}
Appel API
Méthode 5 : Rôle RAM d'instance ECS
Vous pouvez attacher un rôle RAM d'instance aux instances ECS et ECI, permettant ainsi aux applications s'exécutant sur ces instances d'utiliser l'outil Credentials pour récupérer automatiquement le jeton STS du rôle et initialiser un client d'identifiants.
Par défaut, l'outil Credentials utilise le mode de renforcement de la sécurité (IMDSv2) pour accéder au serveur de métadonnées ECS. En cas d'erreur, l'outil revient au mode normal pour récupérer l'identifiant d'accès. Vous pouvez configurer ce comportement de repli en définissant le paramètre disableIMDSv1 ou la variable d'environnement ALIBABA_CLOUD_IMDSV1_DISABLE :
Si la valeur est
false(par défaut), l'outil continue de récupérer l'identifiant d'accès en mode normal.Si la valeur est
true, l'outil utilise exclusivement le mode de renforcement de la sécurité. En cas d'échec de récupération, il lève une exception.
La prise en charge d'IMDSv2 dépend de la configuration du serveur.
Vous pouvez également définir la variable d'environnement ALIBABA_CLOUD_ECS_METADATA_DISABLED=true pour désactiver la récupération des identifiants depuis les métadonnées de l'instance ECS.
Pour obtenir des identifiants de sécurité temporaires en mode de renforcement de la sécurité, assurez-vous que la version de l'outil Credentials est 1.4.2 ou ultérieure.
Pour plus d'informations sur les métadonnées d'instance ECS, consultez métadonnées d'instance.
Pour savoir comment attribuer un rôle RAM aux instances ECS et ECI, consultez Étape 1 : Créer un rôle RAM et Attribuer un rôle RAM d'instance à une instance ECI.
using Aliyun.Credentials.Models;
namespace credentials_demo
{
class Program
{
static void Main(string[] args)
{
var config = new Config()
{
Type = "ecs_ram_role",
// Optional. The ECS RAM role name. Specify this parameter to reduce the number of requests. If omitted, the system automatically retrieves the role name. You can also set the role name by using the ALIBABA_CLOUD_ECS_METADATA environment variable.
RoleName = "<RoleName>"
};
// Optional. Default: false. Set to true to enforce security hardening mode. If false, the system first attempts to retrieve the access credentials in security hardening mode and falls back to normal mode (IMDSv1) on failure.
// config.DisableIMDSv1 = true;
var ecsCredential = new Aliyun.Credentials.Client(config);
string accessKeyId = ecsCredential.GetAccessKeyId();
string accessSecret = ecsCredential.GetAccessKeySecret();
string credentialType = ecsCredential.GetType();
string securityToken = ecsCredential.GetSecurityToken();
}
}
}
Exemple d'API
Méthode 6 : Utilisation d'OIDCRoleArn
Si vous utilisez OIDC pour l'authentification et que vous avez créé un rôle RAM pour un fournisseur d'identité OIDC, vous pouvez fournir l'ARN du fournisseur OIDC, le chemin du fichier de jeton OIDC et l'ARN du rôle RAM à l'outil Credentials. L'outil appelle alors automatiquement l'API AssumeRoleWithOIDC pour obtenir un jeton STS pour le rôle RAM, qui sert d'identifiant d'accès. Les identifiants obtenus de cette manière prennent en charge l'actualisation automatique. Pour plus d'informations, consultez Actualisation automatique des identifiants de session. Par exemple, si votre application s'exécute dans un cluster Container Service for Kubernetes (ACK) avec RRSA activé, l'outil Credentials peut lire la configuration OIDC depuis les variables d'environnement du pod et appeler l'API AssumeRoleWithOIDC pour obtenir un jeton STS. Vous pouvez ensuite utiliser ce jeton STS pour accéder aux services Alibaba Cloud.
using Aliyun.Credentials.Models;
namespace credentials_demo
{
class Program
{
static void Main(string[] args)
{
Config config = new Config()
{
Type = "oidc_role_arn",
// The ARN of the RAM role to assume. Set with the ALIBABA_CLOUD_ROLE_ARN environment variable.
RoleArn = "<RoleArn>",
// The ARN of the OIDC IdP. Set with the ALIBABA_CLOUD_OIDC_PROVIDER_ARN environment variable.
OIDCProviderArn = "<OidcProviderArn>",
// The path of the OIDC token file. Set with the ALIBABA_CLOUD_OIDC_TOKEN_FILE environment variable.
OIDCTokenFilePath = "<OidcTokenFilePath>",
// The role session name. Set with the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
RoleSessionName = "<RoleSessionName>",
// Optional. A custom policy that limits the permissions for the role session. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}
Policy = "<Policy>",
RoleSessionExpiration = 3600
};
var ecsCredential = new Aliyun.Credentials.Client(config);
}
}
}
Exemple d'API
Méthode 7 : URI d'identifiant
Vous pouvez encapsuler le Security Token Service (STS) derrière une URI de service, permettant ainsi aux services externes d'obtenir un jeton STS sans exposer d'informations sensibles comme les AK. L'outil Credentials peut ensuite utiliser cette URI pour récupérer un jeton STS servant d'identifiant d'accès. Les identifiants obtenus de cette manière prennent en charge l'actualisation automatique. Pour plus d'informations, consultez Actualisation automatique des identifiants de session.
using Aliyun.Credentials.Models;
namespace credentials_demo
{
class Program
{
static void Main(string[] args)
{
Config config = new Config()
{
Type = "credentials_uri",
// Specifies the URI for fetching the credential, e.g., http://local_or_remote_uri/. Alternatively, set the ALIBABA_CLOUD_CREDENTIALS_URI environment variable.
CredentialsURI = "<CredentialsURI>"
};
}
}
}
Exemple d'API
Méthode 8 : Jeton Bearer
Seul Cloud Call Center (CCC) prend en charge l'initialisation des identifiants avec un jeton bearer.
using Aliyun.Credentials.Models;
namespace credentials_demo
{
class Program
{
static void Main(string[] args)
{
Config config = new Config()
{
Type = "bearer",
// Enter your Bearer Token.
BearerToken = "<BearerToken>"
};
var bearerCredential = new Aliyun.Credentials.Client(config);
string bearerToken = bearerCredential.GetBearerToken();
string credentialType = bearerCredential.GetType();
}
}
}
Exemple d'API
Chaîne de fournisseurs d'identifiants par défaut
Lorsque votre application utilise des identifiants différents pour ses environnements de développement et de production, les développeurs écrivent généralement du code conditionnel pour charger le jeu approprié pour chaque environnement. La chaîne de fournisseurs d'identifiants par défaut vous permet d'utiliser le même code et de gérer les identifiants pour différents environnements via une configuration externe. Lorsque vous initialisez un client d'identifiants en appelant new Client(config) sans paramètres ou avec null, le SDK Alibaba Cloud tente de trouver des 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 tous deux 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. Utilisation d'un rôle RAM OIDC
Si aucun identifiant n'a été trouvé, la chaîne de fournisseurs recherche 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 d'accès au fichier du 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. Utilisation de 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'Alibaba Cloud CLI ou créez manuellement un fichier config.json dans le 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 d'identifiant correspondante. Le nom de l'identifiant 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 votre application s'exécute sur une instance Elastic Compute Service (ECS) ou Elastic Container Instance (ECI) dotée d'un rôle RAM attribué, l'outil Credentials récupère un jeton STS depuis les métadonnées de l'instance pour l'utiliser comme identifiant d'accès. Lors de l'accès aux métadonnées de l'instance, l'outil récupère d'abord le nom du rôle RAM attribué à l'instance. Vous pouvez spécifier le nom du rôle RAM à l'aide du paramètre roleName ou de la variable d'environnement ALIBABA_CLOUD_ECS_METADATA afin de réduire le temps de récupération et d'améliorer l'efficacité. Les identifiants obtenus de cette manière prennent en charge l'actualisation automatique. Pour plus d'informations, consultez Actualisation automatique des identifiants de session.
Si la valeur est
false(par défaut), l'outil revient au mode normal pour récupérer l'identifiant.Si la valeur est
true, l'outil utilise uniquement le mode sécurisé et lève une exception en cas d'échec d'accès.
La prise en charge d'IMDSv2 par votre serveur dépend de sa configuration.
Pour désactiver l'accès aux identifiants depuis les métadonnées de l'instance, définissez la variable d'environnement ALIBABA_CLOUD_ECS_METADATA_DISABLED=true.
Pour plus d'informations sur les métadonnées d'instance, consultez Métadonnées d'instance.
Pour savoir comment attribuer un rôle RAM à une instance ECS ou ECI, consultez Étape 1 : Créer un rôle RAM et Attribuer un rôle RAM d'instance à une instance ECI.
La version 0.3.10 ou ultérieure de credentials-java est requise pour obtenir des identifiants temporaires en mode sécurisé.
5. URI de l'outil Credentials
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 à l'URI pour récupérer un jeton STS.
Actualisation automatique des identifiants de session
Les types d'identifiants de session, tels que ram_role_arn, ecs_ram_role, oidc_role_arn et credentials_uri, prennent en charge l'actualisation automatique grâce à un mécanisme intégré au fournisseur d'identifiants. Lorsqu'un client d'identifiants récupère un identifiant pour la première fois, le fournisseur le stocke dans un cache. Lors des opérations suivantes, la même instance de client récupère automatiquement l'identifiant depuis ce cache. Si l'identifiant mis en cache a expiré, l'instance de client en récupère un nouveau et met à jour le cache en conséquence.
Pour les identifiants ecs_ram_role, le fournisseur d'identifiants les actualise de manière proactive 15 minutes avant leur expiration.
L'exemple suivant utilise le modèle singleton pour créer un client d'identifiants. Il illustre le mécanisme d'actualisation en récupérant un identifiant à différents intervalles de temps et en appelant une opération OpenAPI pour vérifier que l'identifiant est utilisable.
using System;
using System.Threading.Tasks;
using Aliyun.Credentials.Models;
using AlibabaCloud.SDK.Ecs20140526;
using AlibabaCloud.OpenApiClient.Models;
using AlibabaCloud.TeaUtil.Models;
namespace Example
{
/// <summary>
/// The Credential class manages the Alibaba Cloud credential instance by using the static singleton pattern.
/// </summary>
public static class Credential
{
private static readonly Lazy<Aliyun.Credentials.Client> _instance = new(() =>
{
try
{
var config = new Aliyun.Credentials.Models.Config
{
Type = "ram_role_arn",
AccessKeyId = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_ID"),
AccessKeySecret = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_SECRET"),
RoleArn = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ROLE_ARN"),
RoleSessionName = "RamRoleArnTest",
RoleSessionExpiration = 3600
};
return new Aliyun.Credentials.Client(config);
}
catch (Exception ex)
{
throw new InvalidOperationException("Credential initialization failed: " + ex.Message, ex);
}
});
public static Aliyun.Credentials.Client Instance => _instance.Value;
}
/// <summary>
/// The EcsClient class manages the ECS client instance by using the static singleton pattern.
/// You must set the endpoint and credential by using Initialize.
/// </summary>
public static class EcsClient
{
private static string _endpoint = string.Empty; // Explicitly initialize. The value cannot be null.
private static Aliyun.Credentials.Client _credential = null!; // Explicitly initialize. The value cannot be null.
private static readonly Lazy<AlibabaCloud.SDK.Ecs20140526.Client> _instance = new(() =>
{
if (string.IsNullOrEmpty(_endpoint))
{
throw new InvalidOperationException("Endpoint must be set before initializing the ECS client.");
}
if (_credential == null)
{
throw new InvalidOperationException("Credential must be set before initializing the ECS client.");
}
try
{
var ecsConfig = new AlibabaCloud.OpenApiClient.Models.Config
{
Endpoint = _endpoint,
Credential = _credential
};
return new AlibabaCloud.SDK.Ecs20140526.Client(ecsConfig);
}
catch (Exception ex)
{
throw new InvalidOperationException("ECS client initialization failed: " + ex.Message, ex);
}
});
public static void Initialize(string endpoint, Aliyun.Credentials.Client credential)
{
if (string.IsNullOrEmpty(endpoint))
{
throw new ArgumentException("Endpoint cannot be null or empty.", nameof(endpoint));
}
if (credential == null)
{
throw new ArgumentNullException(nameof(credential), "Credential cannot be null.");
}
_endpoint = endpoint;
_credential = credential;
}
public static AlibabaCloud.SDK.Ecs20140526.Client Instance => _instance.Value;
}
public class Program
{
public static async Task Main(string[] args)
{
// Initialize the EcsClient.
EcsClient.Initialize("ecs.cn-hangzhou.aliyuncs.com", Credential.Instance);
Action task = () =>
{
try
{
var credential = Credential.Instance.GetCredential();
Console.WriteLine(DateTime.Now);
Console.WriteLine($"AK ID: {credential.AccessKeyId}, AK Secret: {credential.AccessKeySecret}, STS Token: {credential.SecurityToken}");
var ecsClient = EcsClient.Instance;
var request = new AlibabaCloud.SDK.Ecs20140526.Models.DescribeRegionsRequest();
var runtime = new AlibabaCloud.TeaUtil.Models.RuntimeOptions();
var response = ecsClient.DescribeRegionsWithOptions(request, runtime);
Console.WriteLine($"Invoke result: {response.StatusCode}");
}
catch (Exception ex)
{
Console.WriteLine($"ECS client execution failed: {ex.Message}");
}
};
// Run the task immediately.
task();
// Start asynchronous tasks concurrently.
var tasks = new[]
{
ScheduleTaskAsync(task, 600),
ScheduleTaskAsync(task, 4200),
ScheduleTaskAsync(task, 4300)
};
await Task.WhenAll(tasks);
Console.WriteLine("All tasks completed.");
}
private static async Task ScheduleTaskAsync(Action task, int delaySeconds)
{
await Task.Delay(TimeSpan.FromSeconds(delaySeconds));
task();
}
}
}
2025/5/29 10:33:24
AK ID: STS.NVR3xxx P8KrfgTK, AK Secret: 6hsZk211xxx
PeZZ8NHSBeQo, STS Token: CAISxAJ1q6Ft5B2yf5jIr5XneN+ChrwS1It+pcEXr0DkFNMReiaL/qTz2IHhMeXZoA+4YsPu2mmFW6/sdlqdJQpp/QkjJRNF20plM7VtBkQt5I
pbng4YfgbiJREKxaXeirukwDsz9SNTCA JlhHL91N0vCGlgpPtpNIRZ4o8I3LGbYMe3XUiTmM3NFkFlyGEe4CFdkf3jm5bHu0WB0gCkk7FO/trLT8L6P5U2DvBWsMyo2eF6TK3F3RNL5gJCnKUM1/QcpGif51/DXQEIvUIYbreL6L9mNxRkY6UgHkpJ
vCxxBmi0fUW5fe3VvPUtVVk900y3LAsg 3PjcmYvy1dKzlhvI856BxNHBq+A748VMgj01iX9IIPPtJO3TwsQdpz0agaAFJZJGZS4RxwNkWL934H/nip/ameLEvxylbsU0x8]AMGRtHmlzYuolmGovqyeKhpDOT+H0am7tG2LvzKHoyVN8Kuck/qb/JAX/
xV1mHcLp3iPma8q+9xboP81YeU06c0vy bzA2n7QI37852WyAA
Invoke result: 200
2025/5/29 10:43:25
AK ID: STS.NVR3xxx P8KrfgTK, AK Secret: 6hsZk211xxx
PeZZ8NHSBeQo, STS Token: CAISxAJ1q6Ft5B2yf5jIr5XneN+ChrwS1It+pcEXr0DkFNMReiaL/qTz2IHhMeXZoA+4YsPu2mmFW6/sdlqdJQpp/QkjJRNF20plM7VtBkQt5I
pbng4YfgbiJREKxaXeirukwDsz9SNTCA JlhHL91N0vCGlgpPtpNIRZ4o8I3LGbYMe3XUiTmM3NFkFlyGEe4CFdkf3jm5bHu0WB0gCkk7FO/trLT8L6P5U2DvBWsMyo2eF6TK3F3RNL5gJCnKUM1/QcpGif51/DXQEIvUIYbreL6L9mNxRkY6UgHkpJ
vCxxBmi0fUW5fe3VvPUtVVk900y3LAsg 3PjcmYvy1dKzlhvI856BxNHBq+A748VMgj01iX9IIPPtJO3TwsQdpz0agaAFJZJGZS4RxwNkWL934H/nip/ameLEvxylbsU0x8]AMGRtHmlzYuolmGovqyeKhpDOT+H0am7tG2LvzKHoyVN8Kuck/qb/JAX/
xV1mHcLp3iPma8q+9xboP81YeU06c0vy bzA2n7QI37852WyAA
Invoke result: 200
2025/5/29 11:43:25
AK ID: STS.NWuFxxx BwvauFkU, AK Secret: 6fBbjmvd2T
ChJTi9gPixZE, STS Token: CAISxAJ1q6Ft5B2yf5jIrSTAG/74uLB13aeARFwQlYXe/lNmoPAtzz2IHhMeXZoA+4YsPu2mmFW6/sdlqdJQpp/QkjJRNF20plM7VtdxAt7I
pbng4YfgbiJREKxaXeirukwDsz9SNTCA iJlhHL91N0vCGlgpPtpNIRZ4o8I3LGbYMe3XUiTmM3NFkFlyGEe4CFdkf3jm5bHu0WB0gCkk7FO/trLT8L6P5U2DvBWsMyo2eF6TK3F3RNL5gJCnKUM1/QcpGif51/DXQEIvUIYbreL6L9mNxRkY6UgHkpJ
vCxxBmi0fUW5fe3VvPUtVVk900y3LAtQ JU1tKDlwTxgBGOFKIQQrKj9PMSqhAcLJtS6MDE7NJKbt10KxV8Qdpz0agaAE7zrIhzsIKFMhIAyquB0Z8/YXeYdmswQUMbqmr+0gX306/0U9iWS612r6AalQSomcAD0eijKFnE8PFyx3YifekzIBCjr17TR
ujPRXpMzvxuXfvzz9eszDB0o0AXX5gTQ IKDI4Y7necJANrPiAA
Invoke result: 200
2025/5/29 11:45:05
AK ID: STS.NWuPxxx bwvauFkU, AK Secret: 6fBbjmvd2T
ChJTi9gPixZE, STS Token: CAISxAJ1q6Ft5B2yf5jIrSTAG/74uLB13aeARFwQlYXe/lNmoPAtzz2IHhMeXZoA+4YsPu2mmFW6/sdlqdJQpp/QkjJRNF20plM7VtdxAt7I
pbng4YfgbiJREKxaXeirukwDsz9SNTCA iJlhHL91N0vCGlgpPtpNIRZ4o8I3LGbYMe3XUiTmM3NFkFlyGEe4CFdkf3jm5bHu0WB0gCkk7FO/trLT8L6P5U2DvBWsMyo2eF6TK3F3RNL5gJCnKUM1/QcpGif51/DXQEIvUIYbreL6L9mNxRkY6UgHkpJ
vCxxBmi0fUW5fe3VvPUtVVk900y3LAtQ U1U1tKDlwTxgBGOFKIQQrKj9PMSqhAcLJtS6MDE7NJKbt10KxV8Qdpz0agaAE7zrIhzsIKFMhIAyquB0Z8/YXeYdmswQUMbqmr+0gX306/0U9iWS612r6AalQSomcAD0eijKFnE8PFyx3YifekZIBCjr17TR
ujPRXpMzvxuXfvzz9eszDB0o0AXX5gTQ IKDI4Y7necJANrPiAA
Invoke result: 200
All tasks completed.
Analyse basée sur la sortie du journal :
Lors du premier appel, le cache est vide. Le système récupère un identifiant en fonction de 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 d'actualisation 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 vue d'ensemble 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 de permissions et attribuer des permissions, consultez Vue d'ensemble du SDK RAM.
Pour endosser un rôle par programmation, consultez Vue d'ensemble du SDK STS.
Pour plus de détails sur les API RAM et STS, consultez la référence API.