Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation des fournisseurs d'informations d'identification de la AWS SDK pour PHP version 3
Pour des informations de référence sur les mécanismes d'identification disponibles pour le AWS SDKs, voir [Identifiants et accès](https://docs.aws.amazon.com/sdkref/latest/guide/access.html) dans le *guide de référence des outils AWS SDKs et*.
**Important**
Pour des raisons de sécurité, nous vous *recommandons vivement* de ne **pas** utiliser le compte root pour AWS y accéder. Reportez-vous toujours aux [meilleures pratiques de sécurité d'IAM dans](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) le *guide de l'utilisateur IAM* pour connaître les dernières recommandations en matière de sécurité.
Le rôle d'un fournisseur d'informations d'identification dans la AWS SDK pour PHP version 3 est de rechercher et de fournir des informations d'identification aux Service AWS clients du SDK. Le SDK utilise les informations d'identification qu'il obtient pour s'authentifier auprès du service en signant cryptographiquement chaque demande. Les informations d'identification se composent généralement de clés d'accès : un identifiant de clé d'accès et une clé d'accès secrète combinés.
Lorsque vous utilisez des informations d'identification temporaires, par exemple lorsque vous [configurez l'authentification IAM Identity Center](credentials.md#use-idc-for-auth) ou que vous configurez votre environnement d'exécution pour [qu'il assume un rôle IAM](assumerole-provider.md), un jeton de session est ajouté aux clés d'accès, fournissant un accès limité dans le temps aux ressources. AWS
## Qu'est-ce qu'un fournisseur d'informations d'identification dans la AWS SDK pour PHP version 3 ?
Un fournisseur d'informations d'identification est une fonction qui renvoie un `GuzzleHttp\Promise\PromiseInterface` qui est exécutée avec une instance `Aws\Credentials\CredentialsInterface` ou rejetée avec une `Aws\Exception\CredentialsException`. Le [SDK fournit plusieurs implémentations](built-in-providers-in-the-sdk.md) de fonctions de fournisseur d'informations d'identification. Vous pouvez également [implémenter votre propre](creating-a-custom-provider.md) logique personnalisée pour créer des informations d'identification ou pour optimiser le chargement des informations d'identification.
Les fournisseurs d'informations d'identification sont transmis à l'option constructeur client `credentials`. Les fournisseurs d'informations d'identification sont asynchrones, ce qui les oblige à être lentement évalués chaque fois qu'une opération d'API est appelée. À ce titre, la transmission d'une fonction de fournisseur d'informations d'identification à un constructeur client SDK ne valide pas immédiatement les informations d'identification. Si le fournisseur d'informations d'identification ne renvoie pas l'objet des informations d'identification, une opération d'API sera rejetée avec une `Aws\Exception\CredentialsException`.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
// Use the ECS credential provider.
$provider = CredentialProvider::ecsCredentials();
// Be sure to memoize the credentials.
$memoizedProvider = CredentialProvider::memoize($provider);
// Pass the provider to the client
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $memoizedProvider
]);
```
# Comprendre la chaîne de fournisseurs d'informations d'identification par défaut dans la AWS SDK pour PHP version 3
La chaîne de fournisseurs d'informations d'identification par défaut est composée d'une série de fournisseurs d'informations d'identification intégrés invoqués par le SDK. Il est implémenté par la fonction de [fournisseur](defaultprovider-provider.md) d'informations d'identification DefaultProvider sans paramètres. Une fois les informations d’identification valides trouvées, la recherche s’arrête.
AWS SDK pour PHP Exécute les fournisseurs d'informations d'identification dans l'ordre suivant :
+ [**`env`fournisseur**](env-provider.md) : le SDK recherche les [clés d'AWS accès définies en tant que variables d'environnement](https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html).
+ [**`assumeRoleWithWebIdentityCredentialProvider`fournisseur**](assume-role-with-web-identity-provider.md) : le SDK recherche les paramètres des fichiers de rôle IAM et de jeton d'identité Web.
+ À ce stade de la chaîne, le SDK recherche la configuration dans le partage AWS `config` et `credentials` les fichiers. Le SDK recherche la configuration sous le profil « par défaut », mais si la variable d'`AWS_PROFILE`environnement est définie, le SDK utilise sa valeur de profil nommée.
+ [**`sso`fournisseur**](sso-provider.md) : le SDK recherche les [paramètres de configuration d'IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) dans le fichier partagé`config`.
+ [**`login provider`**](login-provider.md)- Le SDK recherche les paramètres de configuration de la session de connexion à la AWS console dans le `config` fichier partagé.
+ [**`process`fournisseur**](process-provider.md) : le SDK recherche le `credential_process` paramètre dans le `credentials` fichier partagé.
+ [**`ini`fournisseur**](ini-provider.md) : le SDK recherche les AWS informations d'identification ou les informations de rôle IAM dans le fichier partagé`credentials`.
+ [**`process`fournisseur**](process-provider.md) : le SDK recherche le `credential_process` paramètre dans le `config` fichier partagé.
+ [**`ini`fournisseur**](ini-provider.md) : le SDK recherche les AWS informations d'identification ou les informations de rôle IAM dans le fichier partagé`config`.
+ [**`ecsCredentials`fournisseur**](ecscredentials-provider.md) : le SDK recherche les variables d'environnement `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI ` ou les variables fournissant des informations `AWS_CONTAINER_CREDENTIALS_FULL_URI` permettant d'obtenir des informations d'identification temporaires.
+ [**`instanceProfile`fournisseur**](instanceprofile-provider.md) - Le SDK utilise le service de métadonnées d'instance EC2 pour obtenir le rôle IAM spécifié dans le profil d'instance. À l'aide des informations de rôle, le SDK obtient des informations d'identification temporaires.
**Note**
Le résultat du fournisseur par défaut est automatiquement mémoïsé.
Vous pouvez consulter le code de la chaîne dans le [code GitHub source](https://github.com/aws/aws-sdk-php/blob/0a99dab427f0a1c082775301141aeac3558691ad/src/Credentials/CredentialProvider.php#L77).
# Fournisseurs d'informations d'identification intégrés dans la AWS SDK pour PHP version 3
Le SDK fournit plusieurs fournisseurs d'informations d'identification intégrés que vous pouvez utiliser individuellement ou combiner dans une chaîne de fournisseurs d'[informations d'identification personnalisée](chaining-providers.md).
Lorsque vous spécifiez un fournisseur d'informations d'identification lors de la création du client de service, le SDK tente de charger les informations d'identification en utilisant uniquement le fournisseur d'informations d'identification spécifié. Il n'utilise pas la [chaîne de fournisseurs d'informations d'identification par défaut](guide_credentials_default_chain.md). Si vous savez que vous souhaitez qu'un client de service utilise le `instanceProfile` fournisseur, vous pouvez court-circuiter la chaîne par défaut en spécifiant le `instanceProfile` fournisseur dans le constructeur du client de service :
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::instanceProfile();
// Be sure to memoize the credentials
$memoizedProvider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'credentials' => $memoizedProvider // The default credential provider chain is not used.
]);
```
**Important**
Les fournisseurs d'informations d'identification sont appelés chaque fois qu'une opération d'API est effectuée. Si le chargement d'informations d'identification est une tâche coûteuse (par exemple, le chargement à partir d'un disque ou d'une ressource réseau) ou si les informations d'identification ne sont pas mises en cache par le fournisseur, envisagez d'encapsuler votre fournisseur d'informations d'identification dans une fonction `Aws\Credentials\CredentialProvider::memoize`. Le fournisseur d'informations d'identification par défaut utilisé par le kit SDK est automatiquement mémoïsé.
**Topics**
+ [`login`fournisseur dans le SDK pour PHP](login-provider.md)
+ [`assumeRole`fournisseur dans le SDK pour PHP](assumerole-provider.md)
+ [`sso`fournisseur dans le SDK pour PHP](sso-provider.md)
+ [`defaultProvider`fournisseur dans le SDK pour PHP](defaultprovider-provider.md)
+ [`ecsCredentials`fournisseur dans le SDK pour PHP](ecscredentials-provider.md)
+ [`env`fournisseur dans le SDK pour PHP](env-provider.md)
+ [`assumeRoleWithWebIdentityCredentialProvider`fournisseur dans le SDK pour PHP](assume-role-with-web-identity-provider.md)
+ [`ini`fournisseur dans le SDK pour PHP](ini-provider.md)
+ [`process`fournisseur dans le SDK pour PHP](process-provider.md)
+ [`instanceProfile`fournisseur dans le SDK pour PHP](instanceprofile-provider.md)
# `login`fournisseur dans le SDK pour PHP
`Aws\Credentials\CredentialProvider::login`tente de charger les informations d'identification configurées par une session de connexion basée sur un navigateur facilitée par des outils tels que la CLI AWS . Après l'authentification, AWS génère des informations d'identification temporaires qui fonctionnent au niveau local AWS SDKs et dans les outils.
Ce processus vous permet de vous authentifier à l'aide des informations d'identification root créées lors de la configuration initiale du compte, d'un utilisateur IAM ou d'une identité fédérée auprès de votre fournisseur d'identité. Le SDK for AWS PHP gère automatiquement les informations d'identification temporaires pour vous. Cette approche améliore la sécurité en éliminant le besoin de stocker des informations d'identification à long terme localement.
Lorsque vous exécutez la `aws login` commande, vous pouvez effectuer une sélection parmi vos sessions de console actives ou vous connecter via le flux d'authentification basé sur le navigateur, ce qui générera automatiquement des informations d'identification temporaires. Le AWS SDK pour PHP actualisera automatiquement ces informations d'identification, à l'aide du service de connexion, pendant 12 heures maximum.
Le fournisseur de connexion tente de charger le jeton d'accès généré par le flux de travail de session de connexion mentionné précédemment, en fonction du profil fourni. Si aucun profil n'est fourni lors de l'appel du fournisseur, celui-ci tentera de résoudre un profil en vérifiant d'abord la variable d'`AWS_PROFILE`environnement, avant de revenir au profil`default`. La configuration en code peut être transmise au fournisseur, qui recherchera une `region` valeur pour le client du service de connexion utilisé pour actualiser les informations d'identification. Si aucune région n'est fournie dans le tableau de configuration, le fournisseur tentera de résoudre une région en vérifiant la variable d'`AWS_REGION`environnement, puis une valeur de région définie dans le profil résolu. Si aucune région n'est trouvée, le fournisseur renvoie une promesse rejetée avec des instructions sur la façon de configurer une région.
Le fournisseur est appelé dans le cadre de la chaîne par défaut et peut être appelé directement.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::login(, ['region' => ]);
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'credentials' => $provider
]);
```
Par défaut, si aucune configuration d'informations d'identification n'est fournie sur le client de service que vous souhaitez utiliser, ce fournisseur sera appelé dans le cadre de la chaîne `defaultProvider()` d'informations d'identification. Dans ce scénario, la région du client de service est automatiquement transmise au `login()` fournisseur. Dans ce scénario également, la valeur de profil transmise au fournisseur de connexion sera résolue en vérifiant la variable d'`AWS_PROFILE`environnement, avant de revenir au profil`default`.
# `assumeRole`fournisseur dans le SDK pour PHP
Si vous utilisez `Aws\Credentials\AssumeRoleCredentialProvider` pour créer des informations d'identification en assumant un rôle, vous devez fournir les informations `'client'` avec un objet `StsClient` et des détails `'assume_role_params'` comme illustré.
**Note**
Pour éviter de récupérer inutilement les informations AWS STS d'identification à chaque opération d'API, vous pouvez utiliser cette `memoize` fonction pour gérer l'actualisation automatique des informations d'identification lorsqu'elles expirent. Consultez le code suivant pour obtenir un exemple.
```
use Aws\Credentials\CredentialProvider;
use Aws\Credentials\InstanceProfileProvider;
use Aws\Credentials\AssumeRoleCredentialProvider;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;
// Passing Aws\Credentials\AssumeRoleCredentialProvider options directly
$profile = new InstanceProfileProvider();
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";
$assumeRoleCredentials = new AssumeRoleCredentialProvider([
'client' => new StsClient([
'region' => 'us-east-2',
'version' => '2011-06-15',
'credentials' => $profile
]),
'assume_role_params' => [
'RoleArn' => $ARN,
'RoleSessionName' => $sessionName,
],
]);
// To avoid unnecessarily fetching STS credentials on every API operation,
// the memoize function handles automatically refreshing the credentials when they expire
$provider = CredentialProvider::memoize($assumeRoleCredentials);
$client = new S3Client([
'region' => 'us-east-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Pour plus d'informations concernant`'assume_role_params'`, voir [AssumeRole](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole).
# `sso`fournisseur dans le SDK pour PHP
`Aws\Credentials\CredentialProvider::sso`est le fournisseur d'identifiants de connexion unique. Ce fournisseur est également connu sous le nom de fournisseur d' AWS IAM Identity Center informations d'identification.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$credentials = CredentialProvider::sso('profile default');
$s3 = new Aws\S3\S3Client([
'version' => 'latest',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Si vous utilisez un profil nommé, remplacez le nom de votre profil par « `default` » dans l'exemple précédent. Pour en savoir plus sur la configuration de profils nommés, consultez la section [Shared `config` and `credentials` files](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) dans le *guide de référence AWS SDKs and Tools*. Vous pouvez également utiliser la variable d'[https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile)environnement pour spécifier les paramètres du profil à utiliser.
Pour en savoir plus sur le fonctionnement du fournisseur IAM Identity Center, consultez la section [Comprendre l'authentification IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html) dans le guide de *référence des outils AWS SDKs et*.
# `defaultProvider`fournisseur dans le SDK pour PHP
`Aws\Credentials\CredentialProvider::defaultProvider`est le fournisseur d'informations d'identification par défaut et est également appelé chaîne de [fournisseurs d'informations d'identification par défaut](guide_credentials_default_chain.md). Ce fournisseur est utilisé si vous omettez une option `credentials` lors de la création d'un client. Par exemple, si vous créez un S3Client comme indiqué dans l'extrait suivant, le SDK utilise le fournisseur par défaut :
```
$client = new S3Client([
'region' => 'us-west-2'
]);
```
Vous pouvez également utiliser le DefaultProvider dans le code si vous souhaitez fournir des paramètres à des fournisseurs d'informations d'identification spécifiques de la chaîne. Par exemple, l'exemple suivant fournit des paramètres personnalisés de délai d'expiration de connexion et de nouvelle tentative si la fonction `ecsCredentials` fournisseur est utilisée.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::defaultProvider([
'timeout' => '1.5',
'retries' => 5
]);
$client = new S3Client([
'region' => 'us-west-2',
'credentials' => $provider
]);
```
# `ecsCredentials`fournisseur dans le SDK pour PHP
`Aws\Credentials\CredentialProvider::ecsCredentials` tente de charger les informations d'identification via une demande `GET`, dont l'URI est spécifié par la variable d'environnement `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` dans le conteneur.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::ecsCredentials();
// Be sure to memoize the credentials
$memoizedProvider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $memoizedProvider
]);
```
# `env`fournisseur dans le SDK pour PHP
L'utilisation de variables d'environnement pour contenir vos informations d'identification vous empêche de partager accidentellement votre clé d'accès AWS secrète. Nous vous recommandons de ne jamais ajouter vos clés AWS d'accès directement au client dans les fichiers de production.
Pour vous authentifier auprès d'Amazon Web Services, le SDK vérifie d'abord les informations d'identification dans vos variables d'environnement. Le kit SDK utilise la fonction `getenv()` pour rechercher les variables d'environnement `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` et `AWS_SESSION_TOKEN`. Ces informations d’identification sont appelées informations d’identification d’environnement. Pour savoir comment obtenir ces valeurs, voir [Authentifier à l'aide d'informations d'identification à court terme](https://docs.aws.amazon.com/sdkref/latest/guide/access-temp-idc.html) dans le *guide de référence AWS SDKs and Tools*.
Si vous hébergez votre application sur [AWS Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_PHP_eb.html), vous pouvez définir les variables d'`AWS_SESSION_TOKEN`environnement `AWS_ACCESS_KEY_ID``AWS_SECRET_KEY`, et [via la AWS Elastic Beanstalk console](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environments-cfg-softwaresettings.html#environments-cfg-softwaresettings-console) afin que le SDK puisse utiliser ces informations d'identification automatiquement.
Pour plus d'informations sur la définition des variables d'environnement, consultez la section [Prise en charge des variables d'environnement](https://docs.aws.amazon.com/sdkref/latest/guide/environment-variables.html) dans le *Guide de référence des outils AWS SDKs et*. De plus, pour une liste de toutes les variables d'environnement prises en charge par la plupart AWS SDKs, voir [Liste des variables d'environnement](https://docs.aws.amazon.com/sdkref/latest/guide/settings-reference.html#EVarSettings).
Vous pouvez également définir les variables d'environnement dans la ligne de commande, comme indiqué ici.
**Linux**
```
$ export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
# The access key for your Compte AWS.
$ export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
# The secret access key for your Compte AWS.
$ export AWS_SESSION_TOKEN=AQoDYXdzEJr...
# The temporary session key for your Compte AWS.
# The AWS_SECURITY_TOKEN environment variable can also be used, but is only supported for backward compatibility purposes.
# AWS_SESSION_TOKEN is supported by multiple AWS SDKs other than PHP.
```
**Windows**
```
C:\> SET AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
# The access key for your Compte AWS.
C:\> SET AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
# The secret access key for your Compte AWS.
C:\> SET AWS_SESSION_TOKEN=AQoDYXdzEJr...
# The temporary session key for your Compte AWS.
# The AWS_SECURITY_TOKEN environment variable can also be used, but is only supported for backward compatibility purposes.
# AWS_SESSION_TOKEN is supported by multiple AWS SDKs besides PHP.
```
`Aws\Credentials\CredentialProvider::env` tente de charger les informations d'identification à partir des variables d'environnement.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => CredentialProvider::env()
]);
```
# `assumeRoleWithWebIdentityCredentialProvider`fournisseur dans le SDK pour PHP
`Aws\Credentials\CredentialProvider::assumeRoleWithWebIdentityCredentialProvider` tente de charger les informations d'identification en endossant un rôle. Si les variables d'environnement `AWS_ROLE_ARN` et `AWS_WEB_IDENTITY_TOKEN_FILE` sont présentes, le fournisseur tentera d'endosser le rôle spécifié à `AWS_ROLE_ARN` à l’aide du jeton sur le disque au chemin d'accès complet spécifié dans `AWS_WEB_IDENTITY_TOKEN_FILE`. Si les variables d'environnement sont utilisées, le fournisseur tentera de définir la session à partir de la variable d'environnement `AWS_ROLE_SESSION_NAME`.
Si les variables d'environnement ne sont pas définies, le fournisseur utilise le profil par défaut, ou celui défini en tant que `AWS_PROFILE`. Le fournisseur lit les profils à partir de `~/.aws/credentials` et `~/.aws/config` par défaut, et peut lire depuis des profils spécifiés dans l'option de configuration `filename`. Le fournisseur va endosser le rôle dans `role_arn` du profil, la lecture d'un jeton envoyé à partir du chemin d'accès complet défini dans `web_identity_token_file`. `role_session_name` sera utilisée si elle est définie sur le profil.
Le fournisseur est appelé dans le cadre de la chaîne par défaut et peut être appelé directement.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::assumeRoleWithWebIdentityCredentialProvider();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Par défaut, ce fournisseur d'informations d'identification héritera de la région configurée qui sera utilisée par le StsClient pour assumer le rôle. En option, une version complète StsClient peut être fournie. Les informations d'identification doivent être définies comme `false` sur toutes celles fournies StsClient.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
use Aws\Sts\StsClient;
$stsClient = new StsClient([
'region' => 'us-west-2',
'version' => 'latest',
'credentials' => false
])
$provider = CredentialProvider::assumeRoleWithWebIdentityCredentialProvider([
'stsClient' => $stsClient
]);
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
# `ini`fournisseur dans le SDK pour PHP
`Aws\Credentials\CredentialProvider::ini`tente de charger les informations d'identification depuis le partage `config` et `credentials` les fichiers. Par défaut, le SDK tente de charger le profil « par défaut » à partir du AWS `credentials` fichier partagé situé `~/.aws/credentials` dans. Si le SDK trouve la variable d'`AWS_SDK_LOAD_NONDEFAULT_CONFIG`environnement, il recherche également un profil « par défaut » dans le AWS `config` fichier partagé situé à `~/.aws/config` l'adresse.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::ini();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Vous pouvez utiliser un profil personnalisé ou un emplacement de fichier .ini en fournissant des arguments à la fonction qui crée le fournisseur.
```
$profile = 'production';
$path = '/full/path/to/credentials.ini';
$provider = CredentialProvider::ini($profile, $path);
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
# `process`fournisseur dans le SDK pour PHP
`Aws\Credentials\CredentialProvider::process`tente de charger les informations d'identification en exécutant `credential_process` la valeur spécifiée dans un profil dans un [fichier AWS de configuration partagé](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html).
Par défaut, le SDK tente de charger le profil « par défaut » d'abord à partir du AWS `credentials` fichier partagé situé `~/.aws/credentials` dans. Si le profil « par défaut » n'est pas trouvé dans le `credentials` fichier partagé, le SDK recherche le profil par défaut dans le `config` fichier partagé. Voici un exemple de configuration pour le `credentials` fichier partagé.
```
[default]
credential_process = /path/to/file/credential_returning_executable.sh --custom-command custom_parameter
```
Le SDK appellera la `credential_process` commande exactement comme indiqué en utilisant la `shell_exec` fonction de PHP, puis lira les données JSON depuis stdout. Les informations d'identification `credential_process` doivent être écrites sur stdout au format suivant :
```
{
"Version": 1,
"AccessKeyId": "",
"SecretAccessKey": "",
"SessionToken": "",
"Expiration": ""
}
```
`SessionToken` et `Expiration` sont facultatifs. Le cas échéant, les informations d'identification seront traitées comme temporaires.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::process();
// Cache the results in a memoize function to avoid loading and parsing
// the ini file on every API operation
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
Vous pouvez utiliser un profil personnalisé ou un emplacement de fichier .ini en fournissant des arguments à la fonction qui crée le fournisseur.
```
$profile = 'production';
$path = '/full/path/to/credentials.ini';
$provider = CredentialProvider::process($profile, $path);
$provider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $provider
]);
```
# `instanceProfile`fournisseur dans le SDK pour PHP
`Aws\Credentials\CredentialProvider::instanceProfile`tente de charger les informations d'identification pour un rôle IAM spécifié dans un profil d'instance Amazon EC2.
```
use Aws\Credentials\CredentialProvider;
use Aws\S3\S3Client;
$provider = CredentialProvider::instanceProfile();
// Be sure to memoize the credentials
$memoizedProvider = CredentialProvider::memoize($provider);
$client = new S3Client([
'region' => 'us-west-2',
'version' => '2006-03-01',
'credentials' => $memoizedProvider
]);
```
Par défaut, le fournisseur réessaie de récupérer les informations d'identification jusqu'à trois fois. Le nombre de tentatives peut être défini avec l'`retries`option, et complètement désactivé en définissant l'option sur `0` comme indiqué dans le code suivant.
```
use Aws\Credentials\CredentialProvider;
$provider = CredentialProvider::instanceProfile([
'retries' => 0
]);
$memoizedProvider = CredentialProvider::memoize($provider);
```
Si la variable d'environnement `AWS_METADATA_SERVICE_NUM_ATTEMPTS` est disponible, sa valeur a priorité sur l'option « réessayer » présentée précédemment.
**Note**
Vous pouvez désactiver cette tentative de chargement à partir des profils d'instance Amazon EC2 en définissant la variable d'`AWS_EC2_METADATA_DISABLED`environnement sur. `true`
# Enchaînement des fournisseurs d'identifiants dans le SDK for PHP
Vous pouvez chaîner des fournisseurs d'informations d'identification à l'aide de la fonction `Aws\Credentials\CredentialProvider::chain()`. Cette fonction accepte un nombre d'arguments variadique, chacun d'entre eux étant une fonction de fournisseur d'informations d'identification. Cette fonction renvoie ensuite une nouvelle fonction qui est la composition des fonctions fournies, de façon à ce qu'elles soient appelées les unes après les autres jusqu'à ce que l'un des fournisseurs renvoie une promesse tenue.
Le `defaultProvider` utilise cette composition pour vérifier plusieurs fournisseurs avant un échec. La source du `defaultProvider` illustre l'utilisation de la fonction `chain`.
```
// This function returns a provider
public static function defaultProvider(array $config = [])
{
// This function is the provider, which is actually the composition
// of multiple providers. Notice that we are also memoizing the result by
// default.
return self::memoize(
self::chain(
self::env(),
self::ini(),
self::instanceProfile($config)
)
);
}
```
# Création d'un fournisseur d'informations d'identification personnalisé à utiliser avec le SDK for PHP
Les fournisseurs d'informations d'identification sont simplement des fonctions qui, lorsqu'elles sont appelées, renvoient une promesse (`GuzzleHttp\Promise\PromiseInterface`) tenue grâce à un objet `Aws\Credentials\CredentialsInterface` ou rejetée via une `Aws\Exception\CredentialsException`.
Une bonne pratique pour créer des fournisseurs consiste à créer une fonction qui est appelée pour créer le véritable fournisseur d'informations d'identification. Par exemple, voici la source du fournisseur `env` (légèrement modifiée pour cet exemple). Notez qu'il s'agit d'une fonction qui renvoie la fonction du véritable fournisseur. Ceci vous permet de composer facilement des fournisseurs d'informations d'identification et de les transmettre comme valeurs.
```
use GuzzleHttp\Promise;
use GuzzleHttp\Promise\RejectedPromise;
// This function CREATES a credential provider
public static function env()
{
// This function IS the credential provider
return function () {
// Use credentials from environment variables, if available
$key = getenv(self::ENV_KEY);
$secret = getenv(self::ENV_SECRET);
if ($key && $secret) {
return Create::promise_for(
new Credentials($key, $secret, getenv(self::ENV_SESSION))
);
}
$msg = 'Could not find environment variable '
. 'credentials in ' . self::ENV_KEY . '/' . self::ENV_SECRET;
return new RejectedPromise(new CredentialsException($msg));
};
}
```
# Mémorisation des informations d'identification dans le SDK for PHP
Il est parfois nécessaire de créer un fournisseur d'informations d'identification qui se souvient de la dernière valeur renvoyée. Ceci peut être utile aux performances lorsque le chargement des informations d'identification est une opération coûteuse ou lors de l'usage de la classe `Aws\Sdk` pour partager un fournisseur d'informations d'identification entre plusieurs clients. Vous pouvez ajouter la mémoïsation à un fournisseur d'informations d'identification en encapsulant la fonction du fournisseur d'informations d'identification dans une fonction `memoize`.
```
use Aws\Credentials\CredentialProvider;
$provider = CredentialProvider::instanceProfile();
// Wrap the actual provider in a memoize function
$provider = CredentialProvider::memoize($provider);
// Pass the provider into the Sdk class and share the provider
// across multiple clients. Each time a new client is constructed,
// it will use the previously returned credentials as long as
// they haven't yet expired.
$sdk = new Aws\Sdk(['credentials' => $provider]);
$s3 = $sdk->getS3(['region' => 'us-west-2', 'version' => 'latest']);
$ec2 = $sdk->getEc2(['region' => 'us-west-2', 'version' => 'latest']);
assert($s3->getCredentials() === $ec2->getCredentials());
```
Lorsque les informations d'identification mémoïsées expirent, l'habillage mémoïsé appelle le fournisseur habillé dans une tentative de rafraîchissement des informations d'identification.
# Assumez un rôle IAM à l'aide de la AWS SDK pour PHP version 3
## Utilisation de rôles IAM pour les informations d'identification variables d'instance Amazon EC2
Si vous exécutez votre application sur une instance Amazon EC2, la méthode préférée pour fournir des informations d'identification pour les appels AWS consiste à utiliser un [rôle IAM](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) pour obtenir des informations de sécurité temporaires.
Lorsque vous utilisez des rôles IAM, vous n'avez pas à vous soucier de la gestion des informations d'identification depuis votre application. Ils permettent à une instance d' « assumer » un rôle en récupérant des informations d'identification temporaires depuis le serveur de métadonnées de l'instance Amazon EC2.
Les informations d'identification temporaires, souvent appelées **informations d'identification du profil d'instance**, permettent d'accéder aux actions et aux ressources autorisées par la politique du rôle. Amazon EC2 se charge de l'authentification sécurisée des instances auprès du service IAM pour qu'elles assument le rôle et de l'actualisation périodique des informations d'identification de rôle récupérées. Ceci permet de sécuriser l'application presque sans effort de votre part. Pour une liste des services prenant en charge les informations d’identification de sécurité temporaires, consultez [Services AWS qui fonctionnent avec IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) dans le *Guide de l’utilisateur IAM*.
**Note**
Pour éviter d'accéder au service de métadonnées chaque fois, vous pouvez transmettre une instance `Aws\CacheInterface` en tant qu'option `'credentials'` à un constructeur client. Ceci permet au kit SDK d'utiliser des informations d'identification du profil d'instance mises en cache à la place. Pour plus de détails, voir [Configuration pour la AWS SDK pour PHP version 3](guide_configuration.md).
*Pour plus d'informations sur le développement d'applications Amazon EC2 à l'aide de SDKs, consultez la section [Utilisation des rôles IAM pour les instances Amazon EC2](https://docs.aws.amazon.com/sdkref/latest/guide/access-iam-roles-for-ec2.html) dans le AWS SDKs guide de référence and Tools.*
### Création et attribution d'un rôle IAM à une instance Amazon EC2
1. Créez un client IAM.
**Importations**
```
require 'vendor/autoload.php';
use Aws\Iam\IamClient;
```
**Exemple de code**
```
$client = new IamClient([
'region' => 'us-west-2',
'version' => '2010-05-08'
]);
```
1. Créez un rôle IAM avec les autorisations nécessaires pour les actions et les ressources que vous utiliserez.
**Exemple de code**
```
$result = $client->createRole([
'AssumeRolePolicyDocument' => 'IAM JSON Policy', // REQUIRED
'Description' => 'Description of Role',
'RoleName' => 'RoleName', // REQUIRED
]);
```
1. Créez un profil d'instance IAM et stockez le nom de ressource Amazon (ARN) à partir du résultat.
**Note**
Si vous utilisez la console IAM au lieu de AWS SDK pour PHP, la console crée automatiquement un profil d'instance et lui donne le même nom que le rôle auquel il correspond.
**Exemple de code**
```
$IPN = 'InstanceProfileName';
$result = $client->createInstanceProfile([
'InstanceProfileName' => $IPN ,
]);
$ARN = $result['Arn'];
$InstanceID = $result['InstanceProfileId'];
```
1. Créez un client Amazon EC2.
**Importations**
```
require 'vendor/autoload.php';
use Aws\Ec2\Ec2Client;
```
**Exemple de code**
```
$ec2Client = new Ec2Client([
'region' => 'us-west-2',
'version' => '2016-11-15',
]);
```
1. Ajoutez le profil d'instance à une instance Amazon EC2 en cours d'exécution ou arrêtée. Utilisez le nom du profil d'instance de votre rôle IAM.
**Exemple de code**
```
$result = $ec2Client->associateIamInstanceProfile([
'IamInstanceProfile' => [
'Arn' => $ARN,
'Name' => $IPN,
],
'InstanceId' => $InstanceID
]);
```
Pour de plus amples informations sur les rôles IAM, veuillez consulter [Rôles IAM pour Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) dans le *Guide de l'utilisateur Amazon EC2*.
## Utilisation de rôles IAM pour les tâches Amazon ECS
Une tâche dans Amazon Elastic Container Service (Amazon ECS) peut assumer un rôle IAM pour AWS effectuer des appels d'API. Il s'agit d'une stratégie de gestion des informations d'identification à utiliser par vos applications, similaire à la manière dont les profils d'instance Amazon EC2 fournissent des informations d'identification aux instances Amazon EC2.
[Au lieu de créer et de distribuer des AWS informations d'identification à long terme aux conteneurs ou d'utiliser le rôle de l'instance Amazon EC2, vous pouvez associer un rôle IAM qui utilise des informations d'identification temporaires à une définition de tâche ECS ou `RunTask` à une opération d'API.](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-ecs-2014-11-13.html#runtask)
Pour plus d'informations sur l'utilisation des rôles IAM que les tâches de conteneur peuvent assumer, consultez la rubrique relative au [rôle IAM des tâches](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) dans le manuel *Amazon ECS Developer Guide*. Pour des exemples d'utilisation du rôle IAM de tâche sous la forme d'une `taskRoleArn` définition de tâche, consultez la section [Exemples de définitions de tâches](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-example-taskdefs.html) également dans le manuel *Amazon ECS Developer Guide*.
## Assumer un rôle IAM dans un autre Compte AWS
Lorsque vous travaillez dans un Compte AWS (compte A) et que vous souhaitez assumer un rôle dans un autre compte (compte B), vous devez d'abord créer un rôle IAM dans le compte B. Ce rôle permet aux entités de votre compte (compte A) d'effectuer des actions spécifiques dans le compte B. Pour plus d'informations sur l'accès entre comptes, voir [Tutoriel : déléguer l'accès entre AWS comptes à l'aide de rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html).
Une fois que vous avez créé un rôle dans le compte B, enregistrez l'ARN de rôle. Vous utiliserez cet ARN lorsque vous assumerez le rôle depuis le compte A. Vous assumez le rôle en utilisant les AWS informations d'identification associées à votre entité dans le compte A.
Créez un AWS STS client avec des informations d'identification pour votre Compte AWS. Dans ce qui suit, nous avons utilisé un profil d'informations d'identification, mais vous pouvez utiliser n'importe quelle méthode. Avec le client AWS STS que vous venez de créer, appelez la commande assume-role et fournissez un élément sessionName personnalisé. Récupérez les nouvelles informations d'identification temporaires à partir du résultat. Les informations d'identification durent une heure par défaut.
**Exemple de code**
```
$stsClient = new Aws\Sts\StsClient([
'profile' => 'default',
'region' => 'us-east-2',
'version' => '2011-06-15'
]);
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";
$result = $stsClient->AssumeRole([
'RoleArn' => $ARN,
'RoleSessionName' => $sessionName,
]);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
Pour plus d'informations, consultez la section [Utilisation des rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html) ou consultez le Guide [AssumeRole](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole)de référence de l' AWS SDK pour PHP API.
## Utilisation d'un rôle IAM avec une identité Web
La Fédération des identités Web permet aux clients d'utiliser des fournisseurs d'identité tiers pour s'authentifier lorsqu'ils accèdent aux AWS ressources. Pour pouvoir assumer un rôle avec la fédération d'identité web, vous devez créer un rôle IAM et configurer un fournisseur d'identité web (IdP). Pour de plus amples informations, veuillez consulter [Création d'un rôle pour la fédération d'identité web ou OpenID Connect Federation (Console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html).
Après avoir [créé un fournisseur d'identité](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html) et [créé un rôle pour votre identité Web](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp_oidc.html), utilisez un AWS STS client pour authentifier un utilisateur. Indiquez le webIdentityToken et ProviderId pour votre identité, et l'ARN du rôle IAM avec des autorisations pour l'utilisateur.
**Exemple de code**
```
$stsClient = new Aws\Sts\StsClient([
'profile' => 'default',
'region' => 'us-east-2',
'version' => '2011-06-15'
]);
$ARN = "arn:aws:iam::123456789012:role/xaccounts3access";
$sessionName = "s3-access-example";
$duration = 3600;
$result = $stsClient->AssumeRoleWithWebIdentity([
'WebIdentityToken' => "FACEBOOK_ACCESS_TOKEN",
'ProviderId' => "graph.facebook.com",
'RoleArn' => $ARN,
'RoleSessionName' => $sessionName,
]);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
Pour plus d'informations, consultez [AssumeRoleWithWebIdentity—Federation via un fournisseur d'identité basé sur le Web](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html#api_assumerolewithwebidentity.html) ou [AssumeRoleWithWebIdentity](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerolewithwebidentity)dans le manuel de référence des AWS SDK pour PHP API.
## Assumer un rôle avec un profil
### Définissez les profils dans `~/.aws/credentials`
Vous pouvez configurer le AWS SDK pour PHP pour utiliser un rôle IAM en définissant un profil dans`~/.aws/credentials`.
Créez un nouveau profil avec le `role_arn` paramètre correspondant au rôle que vous souhaitez assumer. Incluez également le `source_profile` paramètre d'un autre profil avec des informations d'identification autorisées à assumer le rôle IAM. Pour plus de détails sur ces paramètres de configuration, consultez la section [Assumer les informations d'identification du rôle](https://docs.aws.amazon.com/sdkref/latest/guide/feature-assume-role-credentials.html) dans le *guide de référence AWS SDKs et Tools*.
Par exemple, dans ce qui suit`~/.aws/credentials`, le `project1` profil définit `role_arn` et spécifie le `default` profil comme source des informations d'identification afin de vérifier que l'entité qui leur est associée peut assumer le rôle.
```
[project1]
role_arn = arn:aws:iam::123456789012:role/testing
source_profile = default
role_session_name = OPTIONAL_SESSION_NAME
[default]
aws_access_key_id = YOUR_AWS_ACCESS_KEY_ID
aws_secret_access_key = YOUR_AWS_SECRET_ACCESS_KEY
aws_session_token= YOUR_AWS_SESSION_TOKEN
```
Si vous définissez la variable d'`AWS_PROFILE`environnement ou si vous utilisez un `profile` paramètre lorsque vous instanciez un client de service, le rôle spécifié dans `project1` est assumé, en utilisant le `default` profil comme informations d'identification source.
L'extrait suivant montre l'utilisation du `profile` paramètre dans un `S3Client` constructeur. Ils `S3Client` auront les autorisations associées au rôle associé au `project1` profil.
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-1',
'version' => '2006-03-01',
'profile' => 'project1'
]);
```
### Définissez les profils dans `~/.aws/config`
Le `~/.aws/config` fichier peut également contenir les profils que vous souhaitez faire passer pour acquis. Si vous définissez la variable d'environnement`AWS_SDK_LOAD_NONDEFAULT_CONFIG`, le SDK for PHP charge les profils depuis `config` le fichier. Lorsque cette `AWS_SDK_LOAD_NONDEFAULT_CONFIG` option est définie, le SDK charge les profils à la fois depuis `~/.aws/config` et`~/.aws/credentials`. Les profils de `~/.aws/credentials` sont chargés en dernier et ont priorité sur un profil du `~/.aws/config` même nom. Les profils définis dans ces emplacements peuvent être utilisés en tant que `source_profile` ou que profil à assumer.
L'exemple suivant utilise le `project1` profil défini dans le `config` fichier et le `default` profil dans le `credentials` fichier. Le `AWS_SDK_LOAD_NONDEFAULT_CONFIG` est également défini.
```
# Profile in ~/.aws/config.
[profile project1]
role_arn = arn:aws:iam::123456789012:role/testing
source_profile = default
role_session_name = OPTIONAL_SESSION_NAME
```
```
# Profile in ~/.aws/credentials.
[default]
aws_access_key_id = YOUR_AWS_ACCESS_KEY_ID
aws_secret_access_key = YOUR_AWS_SECRET_ACCESS_KEY
aws_session_token= YOUR_AWS_SESSION_TOKEN
```
Lorsque le `S3Client` constructeur exécute l'extrait de code suivant, le rôle défini dans le `project1` profil sera assumé à l'aide des informations d'identification associées au profil. `default`
```
$s3 = new Aws\S3\S3Client([
'region' => 'us-east-1',
'version' => '2006-03-01',
'profile' => 'project1'
]);
```
# Utiliser des informations d'identification temporaires depuis AWS STS le SDK for PHP
AWS Security Token Service (AWS STS) vous permet de demander des privilèges limités, des **informations d'identification temporaires** pour les utilisateurs IAM ou pour les utilisateurs que vous authentifiez via la fédération d'identité. Pour une meilleure compréhension, consultez la section [Informations d'identification de sécurité temporaires](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) dans le *guide de l'utilisateur IAM*. Vous pouvez utiliser des informations d'identification de sécurité temporaires pour accéder à la plupart AWS des services. Pour une liste des services prenant en charge les informations d’identification de sécurité temporaires, consultez [Services AWS qui fonctionnent avec IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) dans le *Guide de l’utilisateur IAM*.
L'un des cas d'utilisation courants des informations d'identification temporaires consiste à accorder aux applications mobiles ou côté client l'accès aux AWS ressources en authentifiant les utilisateurs par le biais de fournisseurs d'identité tiers (voir Fédération des [identités Web](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html)).
## Obtenir des informations d'identification temporaires
AWS STS comporte plusieurs opérations qui renvoient des informations d'identification temporaires, mais l'`GetSessionToken`opération est la plus simple à démontrer. L'extrait suivant récupère les informations d'identification temporaires en appelant la `getSessionToken` méthode du client STS du SDK PHP.
```
$sdk = new Aws\Sdk([
'region' => 'us-east-1',
]);
$stsClient = $sdk->createSts();
$result = $stsClient->getSessionToken();
```
Le résultat pour `GetSessionToken` et les autres AWS STS opérations contient toujours une `'Credentials'` valeur. Si vous imprimez le `$result` (par exemple en utilisant`print_r($result)`), cela ressemble à ce qui suit.
```
Array
(
...
[Credentials] => Array
(
[SessionToken] => ''
[SecretAccessKey] => ''
[Expiration] => 2013-11-01T01:57:52Z
[AccessKeyId] => ''
)
...
)
```
## Fournir des informations d'identification temporaires au AWS SDK pour PHP
Vous pouvez utiliser des informations d'identification temporaires avec un autre AWS client en instanciant le client et en lui transmettant les valeurs reçues AWS STS directement.
```
use Aws\S3\S3Client;
$result = $stsClient->getSessionToken();
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => [
'key' => $result['Credentials']['AccessKeyId'],
'secret' => $result['Credentials']['SecretAccessKey'],
'token' => $result['Credentials']['SessionToken']
]
]);
```
Vous pouvez également construire un objet `Aws\Credentials\Credentials` et l'utiliser lorsque vous instanciez le client.
```
use Aws\Credentials\Credentials;
use Aws\S3\S3Client;
$result = $stsClient->getSessionToken();
$credentials = new Credentials(
$result['Credentials']['AccessKeyId'],
$result['Credentials']['SecretAccessKey'],
$result['Credentials']['SessionToken']
);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Toutefois, le *meilleur* moyen de fournir des informations d’identification temporaires consiste à utiliser la méthode d’assistance `createCredentials()` incluse avec le `StsClient`. Cette méthode extrait les données d'un AWS STS résultat et crée l'`Credentials`objet pour vous.
```
$result = $stsClient->getSessionToken();
$credentials = $stsClient->createCredentials($result);
$s3Client = new S3Client([
'version' => '2006-03-01',
'region' => 'us-west-2',
'credentials' => $credentials
]);
```
Pour plus d'informations sur les raisons pour lesquelles vous pourriez avoir besoin d'utiliser des informations d'identification temporaires dans votre application ou votre projet, consultez la section [Scénarios d'octroi d'un accès temporaire](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) dans la AWS STS documentation.
# Créez des clients anonymes dans le SDK for PHP
Dans certains cas, il se peut que vous souhaitiez créer un client qui n'est associé à aucune information d'identification. Ceci vous permet d'effectuer des demandes anonymes à un service.
Par exemple, vous pouvez configurer à la fois des objets Amazon S3 et des CloudSearch domaines Amazon pour autoriser un accès anonyme.
Pour créer un client anonyme, vous pouvez définir l'option `'credentials'` sur `false`.
```
$s3Client = new S3Client([
'version' => 'latest',
'region' => 'us-west-2',
'credentials' => false
]);
// Makes an anonymous request. The object would need to be publicly
// readable for this to succeed.
$result = $s3Client->getObject([
'Bucket' => 'amzn-s3-demo-bucket',
'Key' => 'my-key',
]);
```