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.
# 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`