Le SDK Alibaba Cloud utilise l'outil Credentials pour gérer centralisément 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 servent à vérifier l'identité d'un utilisateur lors de l'accès à un système. Les types courants sont les suivants :
Une paire d'AccessKey (AK) constitue un identifiant permanent pour un compte Alibaba Cloud ou un utilisateur RAM. Elle se compose d'un AccessKey ID et d'un AccessKey Secret.
Un jeton STS est un identifiant de sécurité temporaire associé à un rôle RAM Alibaba Cloud, dont la validité et les permissions sont personnalisables. Qu'est-ce que STS.
Un jeton bearer sert à l'authentification et à l'autorisation.
Prérequis
PHP 5.6 ou version ultérieure est requis. L'extension cURL avec cURL 7.16.2+ et un backend TLS est fortement recommandée.
Le SDK Alibaba Cloud V2.0 est nécessaire.
Installer credentials
Si Composer est installé globalement, exécutez cette commande pour ajouter Alibaba Cloud Credentials pour PHP :
composer require alibabacloud/credentials
Utilisez la version la plus récente afin de garantir la prise en charge de tous les types d'identifiants.
Toutes les versions publiées sont répertoriées dans le CHANGELOG.
Paramètres des identifiants
Les paramètres de configuration sont définis dans AlibabaCloud\Credentials\Credential\Config. Définissez le paramètre type requis pour spécifier le type d'identifiant, puis configurez les paramètres correspondants. Le tableau suivant liste les valeurs de type et les paramètres pris en charge, où √ = requis, - = facultatif, × = non pris en charge.
N'utilisez pas de types d'identifiants ou de paramètres absents du tableau.
|
Paramètre |
access_key |
sts |
ram_role_arn |
ecs_ram_role |
oidc_role_arn |
credentials_uri |
bearer |
|
accessKeyId : l'Access Key ID. |
√ |
√ |
√ |
× |
× |
× |
× |
|
accessKeySecret : le secret de l'Access Key. |
√ |
√ |
√ |
× |
× |
× |
× |
|
securityToken : le jeton Security Token Service (STS). |
× |
√ |
- |
× |
× |
× |
× |
|
roleArn : l'Alibaba Cloud Resource Name (ARN) du rôle RAM. |
× |
× |
√ |
× |
√ |
× |
× |
|
roleSessionName : un nom de session personnalisé. La valeur 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é. La valeur par défaut est |
× |
× |
× |
- |
× |
× |
× |
|
bearerToken : le jeton bearer. |
× |
× |
× |
× |
× |
× |
√ |
|
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'Alibaba Cloud Resource Name (ARN) du fournisseur d'identité OIDC. |
× |
× |
× |
× |
√ |
× |
× |
|
oidcTokenFilePath : le chemin du fichier du jeton OIDC. |
× |
× |
× |
× |
√ |
× |
× |
|
externalId : l'ID externe du rôle RAM, utilisé pour éviter le problème du mandataire confus. |
× |
× |
- |
× |
× |
× |
× |
|
credentialsURI : l'URI de l'identifiant. |
× |
× |
× |
× |
× |
√ |
× |
|
STSEndpoint : l'endpoint STS. Les endpoints VPC et publics sont tous deux pris en charge. Valeurs valides : Endpoints. Par défaut : |
× |
× |
- |
× |
- |
× |
× |
|
timeout : le délai d'attente de lecture HTTP en millisecondes. La valeur par défaut est 5000. |
× |
× |
- |
- |
- |
- |
× |
|
connectTimeout : le délai d'attente de connexion 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 mieux adaptée à votre scénario.
Stocker un AccessKey en texte brut présente un risque de sécurité. Une mauvaise configuration du référentiel peut exposer l'AccessKey et compromettre toutes les ressources du compte. Stockez les AccessKeys dans des variables d'environnement ou des fichiers de configuration.
Adoptez le modèle singleton avec l'outil Credentials. Cela active le cache d'identifiants intégré, évite la limitation due aux appels API fréquents et prévient le gaspillage de ressources lié à la création de multiples instances. Mécanisme de rafraîchissement automatique des identifiants de session.
Méthode 1 : Utiliser la chaîne de fournisseurs d'identifiants par défaut
Un client Credentials initialisé sans paramètres utilise la chaîne de fournisseurs d'identifiants par défaut.
<?php
use AlibabaCloud\Credentials\Credential;
// Use the Composer autoloader by requiring the autoload.php file from the vendor directory.
require_once 'vendor/autoload.php';
// No parameters specified.
$credClient = new Credential();
$credential = $credClient->getCredential();
$credential->getAccessKeyId();
$credential->getAccessKeySecret();
Exemple d'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 permissions complètes sur toutes ses ressources. Un AK exposé représente donc 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.
<?php
use AlibabaCloud\Credentials\Credential;
use AlibabaCloud\Credentials\Credential\Config;
// Enable the Composer autoloader.
require_once 'vendor/autoload.php';
$credConfig = new Config([
'type' => 'access_key',
'accessKeyId' => getenv('ALIBABA_CLOUD_ACCESS_KEY_ID'),
'accessKeySecret' => getenv('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
]);
$credClient = new Credential($credConfig);
$credential = $credClient->getCredential();
$credential->getAccessKeyId();
$credential->getAccessKeySecret();
Exemple d'API
Méthode 3 : Utiliser un jeton STS
L'outil Credentials utilise le jeton STS statique fourni comme identifiant d'accès.
<?php
use AlibabaCloud\Credentials\Credential;
use AlibabaCloud\Credentials\Credential\Config;
// Include 'vendor/autoload.php' to enable Composer autoloading.
require_once 'vendor/autoload.php';
$credConfig = new Config([
'type' => 'sts',
// Get the AccessKey ID from the environment variable.
'accessKeyId' => getenv('ALIBABA_CLOUD_ACCESS_KEY_ID'),
// Get the AccessKey Secret from the environment variable.
'accessKeySecret' => getenv('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
// Get the security token from the environment variable.
'securityToken' => getenv('ALIBABA_CLOUD_SECURITY_TOKEN'),
]);
$credClient = new Credential($credConfig);
$credential = $credClient->getCredential();
$credential->getAccessKeyId();
$credential->getAccessKeySecret();
$credential->getSecurityToken();
Exemple d'API
Méthode 4 : Utiliser un AccessKey et un ARN de rôle RAM
Cette méthode obtient un jeton STS en endossant un rôle RAM. Vous pouvez attribuer une policy pour restreindre les permissions de la session.
<?php
use AlibabaCloud\Credentials\Credential;
use AlibabaCloud\Credentials\Credential\Config;
// Include the Composer autoloader.
require_once 'vendor/autoload.php';
$credConfig = new Config([
'type' => 'ram_role_arn',
'accessKeyId' => getenv('ALIBABA_CLOUD_ACCESS_KEY_ID'),
'accessKeySecret' => getenv('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
// The ARN for the RAM role to assume. Can be set with the ALIBABA_CLOUD_ROLE_ARN environment variable. Example: acs:ram::123456789012****:role/adminrole.
'roleArn' => '<RoleArn>',
// A custom role session name. Can be set with the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
'roleSessionName' => '<RoleSessionName>',
// Optional. A policy that further restricts the session's permissions. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}.
'policy' => '<Policy>',
// Optional. The session expiration in seconds. Default value: 3600.
'roleSessionExpiration' => 3600,
]);
$credClient = new Credential($credConfig);
$credential = $credClient->getCredential();
$credential->getAccessKeyId();
$credential->getAccessKeySecret();
$credential->getSecurityToken();
Exemple d'appel API
Méthode 5 : Utiliser un rôle RAM d'instance ECS
Attachez un rôle RAM d'instance aux instances ECS ou ECI. Les applications s'exécutant sur ces instances peuvent alors utiliser l'outil Credentials pour obtenir automatiquement un jeton STS.
Par défaut, l'outil Credentials accède au service de métadonnées ECS en mode de renforcement de la sécurité (IMDSv2), avec un retour au mode normal en cas d'échec. Contrôlez ce comportement via le paramètre disableIMDSv1 ou la variable d'environnement ALIBABA_CLOUD_IMDSV1_DISABLE :
Si la valeur est false (par défaut), l'outil revient au mode normal.
Si la valeur est true, l'outil utilise exclusivement le mode de renforcement de la sécurité et lève une exception en cas d'échec, sans retour arrière.
La prise en charge d'IMDSv2 dépend de la configuration de votre serveur.
Pour désactiver l'accès aux identifiants via les métadonnées ECS, définissez la variable d'environnement ALIBABA_CLOUD_ECS_METADATA_DISABLED=true.
L'obtention d'un identifiant temporaire en mode de renforcement de la sécurité nécessite la version 1.2.0 ou ultérieure de Credentials.
Métadonnées d'instance ECS : Obtenir les métadonnées d'instance.
Attribuer un rôle RAM à une instance ECS ou ECI : Rôles RAM d'instance, Utiliser un rôle RAM d'instance via des appels API.
<?php
use AlibabaCloud\Credentials\Credential;
use AlibabaCloud\Credentials\Credential\Config;
// Enable autoloading for Composer by using the autoload.php file in the vendor directory.
require_once 'vendor/autoload.php';
$credConfig = new Config([
'type' => 'ecs_ram_role',
// Optional. The name of the ECS RAM role. If not specified, the role name is automatically retrieved. Specifying this parameter reduces requests. You can also set the role name by using the ALIBABA_CLOUD_ECS_METADATA environment variable.
'roleName' => '<RoleName>',
// Optional. Defaults to false. When set to true, this enforces security hardening mode. When false, the system first tries to retrieve the credential in security hardening mode and falls back to normal mode (IMDSv1) on failure.
// 'disableIMDSv1' => true,
]);
$credClient = new Credential($credConfig);
$credential = $credClient->getCredential();
$credential->getAccessKeyId();
$credential->getAccessKeySecret();
$credential->getSecurityToken();
Appel API
Méthode 6 : Utiliser un ARN de rôle OIDC
Après avoir créé un rôle RAM pour un fournisseur d'identité OIDC, transmettez l'ARN du fournisseur OIDC, le jeton OIDC et l'ARN du rôle RAM à l'outil Credentials. Celui-ci appelle AssumeRoleWithOIDC pour obtenir un jeton STS, avec un mécanisme de rafraîchissement automatique des identifiants de session. Par exemple, dans un cluster ACK où RRSA est activé, l'outil lit la configuration OIDC depuis les variables d'environnement du Pod et obtient un jeton STS pour le rôle de service.
<?php
use AlibabaCloud\Credentials\Credential;
use AlibabaCloud\Credentials\Credential\Config as CredentialConfig;
// Enable autoloading for Composer by using the autoload.php file in the vendor directory.
require_once 'vendor/autoload.php';
// Initialize a credential client to assume a RAM role via an OIDC IdP.
$credConfig = new CredentialConfig([
// The credential type.
'type' => 'oidc_role_arn',
// The OIDC provider ARN. Can also be set via the ALIBABA_CLOUD_OIDC_PROVIDER_ARN environment variable.
'oidcProviderArn' => '<OidcProviderArn>',
// The OIDC token file path. Can also be set via the ALIBABA_CLOUD_OIDC_TOKEN_FILE environment variable.
'oidcTokenFilePath' => '<OidcTokenFilePath>',
// The RAM role ARN to assume. Can also be set via the ALIBABA_CLOUD_ROLE_ARN environment variable. Example: acs:ram::123456789012****:role/adminrole.
'roleArn' => '<RoleArn>',
// The custom role session name. Can also be set via the ALIBABA_CLOUD_ROLE_SESSION_NAME environment variable.
'roleSessionName' => '<RoleSessionName>',
// Optional. A more restrictive session policy. Example: {"Statement": [{"Action": ["*"],"Effect": "Allow","Resource": ["*"]}],"Version":"1"}.
'policy' => '<Policy>',
// Optional. The session expiration, in seconds.
'roleSessionExpiration' => 3600,
]);
$credClient = new Credential($credConfig);
$credential = $credClient->getCredential();
$credential->getAccessKeyId();
$credential->getAccessKeySecret();
$credential->getSecurityToken();
Exemple d'appel API
Méthode 7 : Utiliser un identifiant URI
Encapsulez un service STS derrière une URI pour éviter d'exposer les AccessKeys. L'outil Credentials récupère un jeton STS depuis l'URI et le rafraîchit automatiquement. Rafraîchissement automatique des identifiants de type session.
<?php
namespace AlibabaCloud\SDK\Sample;
use AlibabaCloud\Credentials\Credential;
use AlibabaCloud\Credentials\Credential\Config;
// Enable Composer autoloading by including the vendor/autoload.php file.
require_once 'vendor/autoload.php';
// Use a URI credential to initialize the credential client.
$credConfig = new Config([
// The credential type.
'type' => 'credentials_uri',
// The credential URI, for example, http://local_or_remote_uri/. Alternatively, set the ALIBABA_CLOUD_CREDENTIALS_URI environment variable.
'credentialsURI' => '<CredentialsUri>',
]);
$credClient = new Credential($credConfig);
$credential = $credClient->getCredential();
$credential->getAccessKeyId();
$credential->getAccessKeySecret();
$credential->getSecurityToken();
L'URI doit respecter les exigences suivantes :
Prendre en charge les requêtes GET.
Retourner un code de statut 200.
-
Le corps de la réponse doit être un objet JSON contenant les champs suivants :
{ "AccessKeyId": "AccessKeyId", "AccessKeySecret": "AccessKeySecret", "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.
<?php
use AlibabaCloud\Credentials\Credential;
use AlibabaCloud\Credentials\Credential\Config;
// Load the Composer autoloader.
require_once 'vendor/autoload.php';
$credConfig = new Config([
'type' => 'bearer',
// Set your bearer token.
'bearerToken' => '<BearerToken>',
]);
$credClient = new Credential($credConfig);
$credential = $credClient->getCredential();
$credential->getBearerToken();
Exemple d'API
Chaîne de fournisseurs d'identifiants par défaut
La chaîne de fournisseurs d'identifiants par défaut permet d'utiliser une base de code unique dans différents environnements en contrôlant la récupération des identifiants via une configuration externe. Lors d'une initialisation sans paramètres avec $credential = new Credential();, le SDK recherche les identifiants dans l'ordre suivant :
1. 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ôle RAM pour un IdP 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 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. Fichier 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 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 |
|
profiles |
Contient un ensemble 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 obtient les identifiants du rôle RAM d'instance ECS via le service de métadonnées en mode renforcé (IMDSv2). Cela nécessite deux requêtes ; définissez ALIBABA_CLOUD_ECS_METADATA sur le nom du rôle pour réduire ce nombre à une seule requête. En cas d'échec IMDSv2, le SDK revient au mode normal. Définissez ALIBABA_CLOUD_IMDSV1_DISABLE pour contrôler ce comportement de repli :
Lorsque la valeur est
false, le SDK revient au mode normal pour récupérer les identifiants.Lorsque la valeur est
true, seul le mode renforcé est utilisé, et une exception est levée en cas d'échec.
La prise en charge d'IMDSv2 dépend de la configuration de votre serveur.
Pour désactiver l'accès aux identifiants via les métadonnées ECS, définissez la variable d'environnement ALIBABA_CLOUD_ECS_METADATA_DISABLED sur true.
Métadonnées d'instance ECS : Métadonnées d'instance.
Attacher un rôle RAM à une instance ECS ou ECI : Créer un rôle RAM, 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.
Chaîne de fournisseurs d'identifiants personnalisée
Vous pouvez remplacer l'ordre de recherche par défaut en utilisant une chaîne de fournisseurs d'identifiants personnalisée. Il est également possible de transmettre un fournisseur sous forme de closure.
<?php
use AlibabaCloud\Credentials\Providers\ChainProvider;
ChainProvider::set(
ChainProvider::ini(),
ChainProvider::env(),
ChainProvider::instance()
);
Rafraîchissement automatique des identifiants de session
L'outil Credentials rafraîchit automatiquement les identifiants de session pour les types ram_role_arn, ecs_ram_role, oidc_role_arn et credentials_uri. Les identifiants sont mis en cache lors de la première récupération, puis rafraîchis automatiquement à leur expiration.
Pour les identifiants de type ecs_ram_role, l'outil Credentials rafraîchit proactivement l'identifiant 15 minutes avant son expiration.
Cet exemple utilise le modèle singleton pour créer un client d'identifiants, récupère les identifiants à différents intervalles et effectue un appel API pour vérifier leur validité.
<?php
namespace Sample;
require_once 'vendor/autoload.php';
use AlibabaCloud\Credentials\Credential;
use AlibabaCloud\Credentials\Credential\Config as CredentialConfig;
use AlibabaCloud\SDK\Ecs\V20140526\Ecs;
use AlibabaCloud\SDK\Ecs\V20140526\Models\DescribeRegionsRequest;
use Darabonba\OpenApi\Models\Config as OpenApiConfig;
use RuntimeException;
class Sample
{
/**
* @var Credential|null
*/
private static $credentialInstance = null;
/**
* @return Credential
* @throws RuntimeException
*/
private static function getCredentialClient(): Credential
{
if (self::$credentialInstance === null) {
try {
$config = new CredentialConfig([
'type' => 'ram_role_arn',
'accessKeyId' => getenv('ALIBABA_CLOUD_ACCESS_KEY_ID'),
'accessKeySecret' => getenv('ALIBABA_CLOUD_ACCESS_KEY_SECRET'),
'roleArn' => getenv('ALIBABA_CLOUD_ROLE_ARN'),
'roleSessionName' => 'RamRoleArnTest',
'roleSessionExpiration' => 3600,
]);
self::$credentialInstance = new Credential($config);
} catch (\Exception $e) {
throw new RuntimeException("Credential initialization failed: " . $e->getMessage(), 0, $e);
}
}
return self::$credentialInstance;
}
/**
* @var Ecs|null
*/
private static $ecsClientInstance = null;
/**
* @return Ecs
* @throws RuntimeException
*/
private static function getEcsClient(): Ecs
{
if (self::$ecsClientInstance === null) {
try {
$config = new OpenApiConfig([
'credential' => self::getCredentialClient(),
'endpoint' => 'ecs.cn-hangzhou.aliyuncs.com'
]);
self::$ecsClientInstance = new Ecs($config);
} catch (\Exception $e) {
throw new RuntimeException("ECS client initialization failed: " . $e->getMessage(), 0, $e);
}
}
return self::$ecsClientInstance;
}
public static function main(): void
{
$task = function () {
// Obtain and print the credential.
$credentialClient = self::getCredentialClient();
$credential = $credentialClient->getCredential();
echo date('c') . PHP_EOL;
echo "AK ID: {$credential->accessKeyId}" . PHP_EOL;
echo "AK Secret: {$credential->accessKeySecret}" . PHP_EOL;
echo "STS Token: {$credential->securityToken}" . PHP_EOL;
// Call an ECS API operation to test whether the credential is valid.
$ecsClient = self::getEcsClient();
$request = new DescribeRegionsRequest();
try {
$response = $ecsClient->describeRegions($request);
echo sprintf("Invoke result: %d" . PHP_EOL, $response->statusCode);
} catch (\Exception $e) {
throw new RuntimeException("ECS client execution failed: " . $e->getMessage(), 0, $e);
}
};
call_user_func($task); // Immediately call the operation.
sleep(600); // Call the operation after 600 seconds.
call_user_func($task);
sleep(3600); // Call the operation after 3,600 seconds.
call_user_func($task);
sleep(100); // Call the operation after 100 seconds.
call_user_func($task);
}
}
// Run the main function.
Sample::main();

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.
Au troisième appel, l'identifiant 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 associés
Pour une vue d'ensemble des concepts fondamentaux de RAM, consultez Concepts de base.
Pour créer un AccessKey, reportez-vous à Créer un AccessKey.
Pour créer programmatiquement des utilisateurs RAM, des AccessKeys et des rôles RAM, définir des politiques de permissions et attribuer des autorisations, consultez Vue d'ensemble du SDK RAM.
Pour endosser un rôle de manière programmatique, voir Vue d'ensemble du SDK STS.
Pour plus de détails sur les API RAM et STS, consultez la référence API.