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.
# En utilisant les fournisseurs d'informations d'identification dans AWS SDK for Java 2.x
Le rôle d'un fournisseur d'informations d'identification dans le AWS SDK for Java 2.x 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, qui sont utilisées lorsque vous configurez la configuration du [fournisseur de jetons SSO](https://docs.aws.amazon.com/sdkref/latest/guide/feature-sso-credentials.html#sso-token-config) ou que vous configurez votre environnement d'exécution pour [qu'il assume un rôle IAM (Gestion des identités et des accès AWS)](https://docs.aws.amazon.com/sdkref/latest/guide/access-assume-role.html#credOrSourceAssumeRole), par exemple, un jeton de session est ajouté aux clés d'accès, fournissant un accès limité dans le temps aux ressources. AWS
Cette rubrique décrit plusieurs manières d'activer le SDK pour accéder aux informations d'identification.
**Topics**
+ [Travail de développement interactif](credentials-temporary.md)
+ [Chaîne de fournisseurs d'informations d'identification par défaut](credentials-chain.md)
+ [Mise en cache des informations d'identification](credential-caching.md)
+ [Spécifier un fournisseur d'informations d'identification spécifique](credentials-providers.md)
+ [Utiliser des profils de configuration partagés](credentials-profiles.md)
+ [Utiliser un processus externe](credentials-process.md)
+ [Fournir les informations d'identification dans le code](credentials-explicit.md)
+ [Lire les informations d'identification du rôle IAM sur Amazon EC2](ec2-iam-roles.md)
# Identifiants d'accès pour les travaux de développement interactifs à l'aide de AWS SDK for Java 2.x
Pour une sécurité accrue, il est AWS recommandé de configurer le SDK pour Java de manière [à utiliser des informations d'identification temporaires](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) plutôt que des informations d'identification de longue durée. Les informations d'identification temporaires se composent de clés d'accès (identifiant de clé d'accès et clé d'accès secrète) et d'un jeton de session.
Plusieurs approches s'offrent à vous pour travailler avec des informations d'identification temporaires. L'approche que vous utilisez, et donc la configuration que vous fournissez au SDK, dépendent de votre cas d'utilisation.
Lorsque vous effectuez un travail de développement interactif avec le SDK Java, nous vous recommandons d'utiliser les informations de connexion à AWS la console.
## Utilisation des informations de connexion à la console
Vous pouvez utiliser vos identifiants de connexion existants à la console de AWS gestion pour accéder aux AWS services par programmation. Après un flux d'authentification basé sur un navigateur, AWS génère des informations d'identification temporaires qui fonctionnent avec les outils de développement locaux tels que le SDK for Java AWS CLI 2.x et le SDK pour Java.
Grâce à ce processus, vous pouvez 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é, qui gère AWS CLI 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 SDK pour Java 2.x actualisera automatiquement ces informations d'identification pendant 12 heures maximum.
**Important**
Outre la configuration que vous définissez dans le fichier de configuration partagé qui fonctionne pour tous les projets, chaque projet Java individuel nécessite la dépendance suivante dans le `pom.xml` fichier Maven :
```
software.amazon.awssdk
signin
```
La `signin` dépendance fournit le code qui permet au SDK pour Java 2.x d'accéder aux informations de connexion à la console et de les utiliser.
Pour plus d'informations sur les prérequis, la connexion et la déconnexion, consultez la section [Connexion pour le développement AWS local à l'aide des informations d'identification de console](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html) dans le Guide de *référence du AWS SDK et des outils*.
## Single-sign-on approche
Lorsque vous effectuez un travail de développement interactif avec le SDK Java, vous pouvez également utiliser l'approche d'authentification unique. Cette approche nécessite la configuration suivante :
+ [Configuration via le IAM Identity Center](get-started-auth.md#setup-auth)
+ [Configuration d'un profil dans le fichier de configuration AWS partagé](get-started-auth.md#setup-credentials)
+ utilisation de la commande AWS CLI et [exécution d'une commande](get-started-auth.md#setup-login-sso) pour se connecter et créer une session active
### Configuration du centre d'identité IAM
Lorsque vous configurez le SDK pour utiliser l'accès par authentification unique à IAM Identity Center, comme décrit [Présentation de la configuration](setup.md#setup-overview) dans ce guide, le SDK utilise des informations d'identification temporaires.
Le SDK utilise le jeton d'accès IAM Identity Center pour accéder au rôle IAM configuré avec le `sso_role_name` paramètre de votre fichier. `config` Le SDK assume ce rôle IAM et récupère les informations d'identification temporaires pour signer les demandes. Service AWS
Pour plus de détails sur la manière dont le SDK obtient des informations d'identification temporaires à partir de la configuration, consultez la section [Comprendre l'authentification IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html) du guide de référence AWS SDKs and Tools.
**Important**
Outre la configuration que vous définissez dans le `config` fichier partagé et qui fonctionne pour tous les projets, chaque projet Java individuel nécessite les dépendances suivantes dans le `pom.xml` fichier Maven :
```
software.amazon.awssdk
sso
software.amazon.awssdk
ssooidc
```
Les `ssooidc` dépendances `sso` et fournissent le code qui permet au SDK pour Java 2.x d'accéder aux informations d'identification temporaires.
### Récupérez les informations d'identification temporaires depuis le portail AWS d'accès
Comme alternative à la configuration d'authentification unique d'IAM Identity Center, vous pouvez copier et utiliser les informations d'identification temporaires disponibles sur le portail d' AWS accès. Vous pouvez utiliser les informations d’identification temporaires dans un profil ou les utiliser comme valeurs pour les propriétés système et les variables d’environnement.
**Configuration d'un fichier d'informations d'identification local pour les informations d'identification temporaires**
1. [Création d'un fichier d'informations d'identification partagé](https://docs.aws.amazon.com/sdkref/latest/guide/file-location.html)
1. Dans le fichier d'informations d'identification, collez le texte d'espace réservé suivant jusqu'à ce que vous y colliez des informations d'identification temporaires fonctionnelles.
```
[default]
aws_access_key_id=
aws_secret_access_key=
aws_session_token=
```
1. Enregistrez le fichier. Le fichier `~/.aws/credentials` devrait maintenant exister sur votre système de développement local. Ce fichier contient le [profil [par défaut]](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html#file-format-profile) utilisé par le SDK for Java si aucun profil nommé spécifique n'est spécifié.
1. [Connectez-vous au portail d' AWS accès](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosignin.html)
1. Suivez ces instructions sous l'en-tête [Actualisation manuelle des informations d'identification](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html#how-to-get-temp-credentials) pour copier les informations d'identification du rôle IAM depuis le portail d' AWS accès.
1. Pour l'étape 2 des instructions liées, choisissez `Access keys` le nom du rôle IAM qui accorde l'accès pour vos besoins de développement. Ce rôle porte généralement un nom tel que **PowerUserAccess**« **Développeur** ».
1. Dans la boîte de dialogue modale, sélectionnez votre système d'exploitation et copiez le contenu de l'onglet **Ajouter un profil dans votre fichier AWS d'informations d'identification**.
1. Collez les informations d'identification copiées dans votre `credentials` fichier local et supprimez le nom de profil généré. Votre fichier doit ressembler à ce qui suit.
```
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token=IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
1. Enregistrez le fichier `credentials`.
Lorsque le SDK for Java crée un client de service, il accède à ces informations d'identification temporaires et les utilise pour chaque demande. Les paramètres du rôle IAM choisi à l'étape 5a déterminent [la durée de validité des informations d'identification temporaires](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html). La durée maximale est de douze heures.
Une fois les informations d'identification temporaires expirées, répétez les étapes 4 à 7.
# Chaîne de fournisseurs d'informations d'identification par défaut dans AWS SDK for Java 2.x
La chaîne de fournisseurs d'informations d'identification par défaut recherche AWS SDK for Java 2.x automatiquement les AWS informations d'identification dans une séquence d'emplacements prédéfinie, ce qui permet aux applications de s'authentifier Services AWS sans spécifier explicitement les sources d'informations d'identification.
La chaîne de fournisseurs d'informations d'identification par défaut est implémentée par la [DefaultCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/DefaultCredentialsProvider.html)classe. Il délègue de manière séquentielle à d'autres fournisseurs d'informations d'identification les implémentations qui vérifient la configuration à différents endroits. Le premier fournisseur d'informations d'identification capable de trouver tous les éléments de configuration nécessaires met fin à la chaîne.
Pour utiliser la chaîne de fournisseurs d'informations d'identification par défaut pour fournir des informations d'identification temporaires, créez un générateur de clients de services, mais ne spécifiez pas de fournisseur d'informations d'identification. L'extrait de code suivant crée un fichier `DynamoDbClient` qui utilise la chaîne de fournisseurs d'informations d'identification par défaut pour localiser et récupérer les paramètres de configuration.
```
// Any external Region configuration is overridden.
// The SDK uses the default credentials provider chain because no specific credentials provider is specified.
Region region = Region.US_WEST_2;
DynamoDbClient ddb =
DynamoDbClient.builder()
.region(region)
.build();
```
## Ordre de récupération des paramètres d'identification
La chaîne de fournisseurs d'informations d'identification par défaut du SDK for Java 2.x recherche la configuration dans votre environnement à l'aide d'une séquence prédéfinie.
1. Propriétés du système Java
+ Le SDK utilise la [SystemPropertyCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/SystemPropertyCredentialsProvider.html)classe pour charger des informations d'identification temporaires à partir des propriétés système `aws.accessKeyId``aws.secretAccessKey`,, et `aws.sessionToken` Java.
**Note**
Pour plus d'informations sur la façon de définir les propriétés du système Java, consultez le didacticiel [des propriétés système](https://docs.oracle.com/javase/tutorial/essential/environment/sysprop.html) sur le site Web officiel des *didacticiels Java*.
1. Variables d’environnement
+ Le SDK utilise la [EnvironmentVariableCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/EnvironmentVariableCredentialsProvider.html)classe pour charger des informations d'identification temporaires à partir des variables d'`AWS_SESSION_TOKEN`environnement `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`,, et.
1. Jeton d'identité Web et ARN du rôle IAM
+ Le SDK utilise la [WebIdentityTokenFileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/WebIdentityTokenFileCredentialsProvider.html)classe pour charger les informations d'identification en assumant un rôle à l'aide d'un jeton d'identité Web.
+ Le fournisseur d'informations d'identification recherche les variables d'environnement ou les propriétés du système JVM suivantes :
+ `AWS_WEB_IDENTITY_TOKEN_FILE or aws.webIdentityTokenFile`
+ `AWS_ROLE_ARN` ou `aws.roleArn`
+ `AWS_ROLE_SESSION_NAME`ou `aws.roleSessionName` (facultatif)
+ Une fois que le SDK a acquis les valeurs, il appelle le AWS Security Token Service (STS) et utilise les informations d'identification temporaires qu'il renvoie pour signer les demandes.
+ Les environnements d'exécution tels qu'Amazon Elastic Kubernetes Service (EKS) mettent automatiquement à disposition des jetons d'identité Web, ce qui permet aux applications d'obtenir des informations AWS SDKs d'identification temporaires. AWS
1. Le partage `credentials` et les `config` fichiers
+ Le SDK utilise le [ProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProfileCredentialsProvider.html)pour charger les paramètres d'authentification unique ou les informations d'identification temporaires d'IAM Identity Center à partir du `[default]` profil dans les fichiers partagés `credentials` et. `config`
Le guide de référence AWS SDKs and Tools contient [des informations détaillées](https://docs.aws.amazon.com/sdkref/latest/guide/understanding-sso.html#idccredres) sur la façon dont le SDK for Java fonctionne avec le jeton d'authentification unique IAM Identity Center pour obtenir des informations d'identification temporaires que le SDK utilise pour appeler. Services AWS
**Note**
Les `config` fichiers `credentials` et sont partagés par divers AWS SDKs outils. Pour plus d'informations, consultez [le. aws/credentials and .aws/config](https://docs.aws.amazon.com/sdkref/latest/guide/creds-config-files.html)fichiers du guide de référence AWS SDKs et des outils.
+ Comme un profil dans `credentials` les `config` fichiers partagés peut contenir de nombreux ensembles de paramètres différents, les `ProfileCredentialsProvider` délégués se chargent de rechercher les paramètres sous le `[default]` profil à une série d'autres fournisseurs :
+ Informations d'**identification du jeton d'identité Web** (classe`WebIdentityTokenCredentialsProvider`) : lorsque le profil contient `role_arn` et`web_identity_token_file`.
+ **Informations d'identification SSO** (classe`SsoCredentialsProvider`) : lorsque le profil contient des propriétés liées à l'authentification unique telles que,. `sso_role_name` `sso_account_id`
+ **Informations d'identification basées sur les rôles avec profil source** (classe`StsAssumeRoleCredentialsProvider`) : lorsque le profil contient `role_arn` et. `source_profile`
+ **Informations d'identification basées sur les rôles avec source d'informations d'identification** (classe`StsAssumeRoleWithSourceCredentialsProvider`) : lorsque le profil contient et. `role_arn` `credential_source`
+ Quand `credential_source = Environment` : il utilise une chaîne de `SystemPropertyCredentialsProvider` et `EnvironmentVariableCredentialsProvider`
+ Quand `credential_source = Ec2InstanceMetadata` : il utilise `InstanceProfileCredentialsProvider`
+ Quand `credential_source = EcsContainer` : il utilise `ContainerCredentialsProvider`
+ **Informations d'identification de connexion à la console** (classe`LoginCredentialsProvider`) : lorsque le profil contient `login_session`
+ **Informations d'identification du processus** (classe`ProcessCredentialsProvider`) : lorsque le profil contient`credential_process`.
+ **Informations d'identification de session** (classe`StaticSessionCredentialsProvider`) : lorsque le profil contient `aws_access_key_id``aws_secret_access_key`, et`aws_session_token`.
+ **Informations d'identification de base** (classe`StaticCredentialsProvider`) : lorsque le profil contient `aws_access_key_id` et`aws_secret_access_key`.
1. Amazon ECS informations d'identification du conteneur
+ Le SDK utilise la [ContainerCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ContainerCredentialsProvider.html)classe pour charger des informations d'identification temporaires à l'aide des variables d'environnement suivantes :
1. `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` ou `AWS_CONTAINER_CREDENTIALS_FULL_URI`
1. `AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE` ou `AWS_CONTAINER_AUTHORIZATION_TOKEN`
L'agent de conteneur ECS définit automatiquement la variable d'`AWS_CONTAINER_CREDENTIALS_RELATIVE_URI`environnement, qui pointe vers le point de terminaison des informations d'identification ECS. Les autres variables d'environnement sont généralement définies dans des scénarios spécifiques dans lesquels le point de terminaison d'identification ECS standard n'est pas utilisé.
1. Amazon EC2 informations d'identification fournies par le rôle IAM de l'instance
+ Le SDK utilise la [InstanceProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/InstanceProfileCredentialsProvider.html)classe pour charger des informations d'identification temporaires à partir du service de Amazon EC2 métadonnées.
1. Si le SDK ne trouve pas les paramètres de configuration nécessaires au cours de toutes les étapes répertoriées ci-dessus, il génère une exception avec un résultat similaire à ce qui suit :
```
software.amazon.awssdk.core.exception.SdkClientException: Unable to load credentials from any of the providers
in the chain AwsCredentialsProviderChain(credentialsProviders=[SystemPropertyCredentialsProvider(),
EnvironmentVariableCredentialsProvider(), WebIdentityTokenCredentialsProvider(), ProfileCredentialsProvider(),
ContainerCredentialsProvider(), InstanceProfileCredentialsProvider()])
```
## Utilisez le code `DefaultCredentialsProvider` d'entrée
Vous pouvez utiliser explicitement la chaîne de fournisseurs d'informations d'identification par défaut dans votre code. Sur le plan fonctionnel, cela revient à ne pas spécifier du tout de fournisseur d'informations d'identification, puisque le SDK l'utilise `DefaultCredentialsProvider` par défaut. Cependant, son utilisation explicite peut rendre votre code plus lisible et plus autodocumenté. Cela montre clairement votre intention d'utiliser la chaîne d'informations d'identification par défaut.
```
import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
public class ExplicitDefaultCredentialsExample {
public static void main(String[] args) {
// Explicitly create the DefaultCredentialsProvider.
DefaultCredentialsProvider defaultCredentialsProvider = DefaultCredentialsProvider
.builder().build();
// Use it with any service client.
S3Client s3Client = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(defaultCredentialsProvider)
.build();
// Now you can use the client with the default credentials chain.
s3Client.listBuckets();
}
}
```
Lorsque vous créez le fournisseur d'informations d'identification par défaut, vous pouvez fournir une configuration supplémentaire :
```
DefaultCredentialsProvider customizedProvider = DefaultCredentialsProvider.builder()
.profileName("custom-profile") // Use a specific profile if the chain gets to the `ProfileCredentialsProvider` stage.
.asyncCredentialUpdateEnabled(true) // Enable async credential updates.
.build();
```
Cette approche vous donne plus de contrôle tout en vous offrant la commodité de la chaîne d'informations d'identification par défaut.
# Mise en cache des informations d'identification dans AWS SDK for Java 2.x
AWS SDK for Java 2.x implémente la mise en cache des informations d'identification pour améliorer les performances et réduire les appels aux sources d'informations d'identification. Cette section explique comment fonctionne la mise en cache des informations d'identification et comment vous pouvez la configurer pour vos applications.
## Comprendre la mise en cache des fournisseurs d'informations d'identification
Les fournisseurs d'identifiants du SDK pour Java 2.x utilisent différentes stratégies de mise en cache :
+ **Mise en cache interne des informations d'identification : de** nombreux fournisseurs mettent en cache les informations d'identification qu'ils récupèrent.
+ **Actualisation automatique** : les fournisseurs dont les informations d'identification sont mises en cache mettent en œuvre des mécanismes d'actualisation.
### Fournisseurs dotés d'une mise en cache interne des informations d'identification
Les fournisseurs d'informations d'identification suivants mettent en cache les informations d'identification en interne, même lorsque vous créez de nouvelles instances :
+ **Fournisseur d'informations d'identification de profil d'instance** : met en cache les informations d'identification provenant du service de métadonnées Amazon EC2.
+ **Fournisseur d'informations d'identification du conteneur** : met en cache les informations d'identification depuis le point de terminaison des métadonnées du conteneur.
+ **Fournisseurs basés sur STS** : mettez en cache les informations d'identification temporaires provenant de AWS Security Token Service (STS).
+ **Fournisseurs de jetons d'identité Web** : mettez en cache les informations d'identification obtenues à partir de jetons d'identité Web.
+ **Fournisseur d'informations d'identification de processus** : met en cache les informations d'identification provenant de processus externes.
### Fournisseurs sans mise en cache interne
Les fournisseurs suivants n'implémentent pas de mise en cache interne :
+ **Fournisseur d'informations d'identification variables d'environnement**
+ **Fournisseur d'informations d'identification des propriétés du système**
+ **Fournisseur d'informations d'identification statiques**
## Configuration de la mise en cache des informations d'identification
Vous pouvez personnaliser le comportement de mise en cache lorsque vous créez des fournisseurs d'informations d'identification :
### Temps périmé
Contrôle lorsque les informations d'identification sont considérées comme périmées et doivent être actualisées :
```
.staleTime(Duration.ofMinutes(2)) // Consider stale 2 minutes before expiration.
```
### Heure de prélecture
Détermine quand commencer à actualiser les informations d'identification avant leur expiration :
```
.prefetchTime(Duration.ofMinutes(10)) // Start refresh 10 minutes before expiration.
```
### Mises à jour asynchrones
Permet d'actualiser les informations d'identification en arrière-plan :
```
.asyncCredentialUpdateEnabled(true) // Refresh credentials in background thread.
```
### Durée de la session
Pour les fournisseurs basés sur STS, contrôle la durée de validité des informations d'identification temporaires :
```
.refreshRequest(r -> r.durationSeconds(3600)) // 1 hour session.
```
## Exemple de configuration des informations d'identification de mise en cache
À titre d'exemple de configuration de la mise en cache pour l'implémentation d'un fournisseur d'informations d'identification, vous pouvez demander au SDK d'utiliser un thread d'arrière-plan pour pré-récupérer (récupérer à l'avance) les informations d'identification avant leur expiration. De cette façon, vous pouvez éviter l'appel bloquant qui permet de récupérer de nouvelles informations d'identification.
L'exemple suivant montre un exemple qui crée un `[StsAssumeRoleCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsAssumeRoleCredentialsProvider.html)` qui utilise un thread d'arrière-plan pour pré-récupérer les informations d'identification en définissant la `[asyncCredentialUpdateEnabled](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#asyncCredentialUpdateEnabled(java.lang.Boolean))` propriété `true` sur le générateur :
```
StsAssumeRoleCredentialsProvider provider = StsAssumeRoleCredentialsProvider.builder()
.refreshRequest(r -> r
.roleArn("arn:aws:iam::111122223333:role/example-role")
.roleSessionName("example-session")
.durationSeconds(3600)) // 1 hour session
.staleTime(Duration.ofMinutes(5)) // Consider stale 5 minutes before expiration
.prefetchTime(Duration.ofMinutes(10)) // Start refresh 10 minutes before expiration
.asyncCredentialUpdateEnabled(true) // Refresh in background
.build();
S3Client s3 = S3Client.builder()
.credentialsProvider(provider)
.build();
```
Lorsque vous invoquez une opération `s3Client` pour la première fois, un signal `[AssumeRoleRequest](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/model/AssumeRoleRequest.html)` est envoyé au AWS Security Token Service (STS). STS renvoie des informations d'identification temporaires valides pendant 15 minutes (900 secondes). L'`s3Client`instance utilise les informations d'identification mises en cache jusqu'à ce qu'il soit temps de les actualiser avant l'expiration des 15 minutes. Par défaut, le SDK tente de récupérer les nouvelles informations d'identification pour une nouvelle session entre 5 minutes et 1 minute avant l'heure d'expiration de la session en cours. La fenêtre de pré-extraction est configurable à l'aide des propriétés `[prefetchTime](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#prefetchTime(java.time.Duration))` et`[staleTime](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/sts/auth/StsCredentialsProvider.BaseBuilder.html#staleTime(java.time.Duration))`.
Vous pouvez configurer les fournisseurs d'informations d'identification basés sur les sessions suivants de la même manière :
+ `StsWebIdentityTokenFileCredentialsProvider`
+ `StsGetSessionTokenCredentialsProvider`
+ `StsGetFederationTokenCredentialsProvider`
+ `StsAssumeRoleWithWebIdentityCredentialsProvider`
+ `StsAssumeRoleWithSamlCredentialsProvider`
+ `StsAssumeRoleCredentialsProvider`
+ `DefaultCredentialsProvider`(lorsqu'il délègue au fournisseur d'informations d'identification qui utilise des sessions)
+ `ProcessCredentialsProvider`
+ `WebIdentityTokenFileCredentialsProvider`
+ `ContainerCredentialsProvider`
+ `InstanceProfileCredentialsProvider`
Comprendre la mise en cache des informations d'identification vous permet d'optimiser les performances et la fiabilité de votre application lorsque vous travaillez avec. Services AWS
# Spécifiez un fournisseur d'informations d'identification spécifique dans AWS SDK for Java 2.x
Bien que la chaîne de fournisseurs d'informations d'identification par défaut soit pratique pour de nombreux scénarios, la spécification explicite des fournisseurs d'informations d'identification vous permet de mieux contrôler le comportement, les performances et la sécurité de l'authentification.
Les raisons pour lesquelles vous souhaiterez peut-être spécifier un fournisseur d'informations d'identification peuvent inclure :
+ La chaîne de fournisseurs par défaut vérifie plusieurs sources de manière séquentielle, ce qui peut ajouter de la latence :
```
// The default provider chain checks might check multiple sources until it finds
// sufficient configuration.
S3Client s3Client = S3Client.builder().build();
// You can specify exactly where to look.
S3Client optimizedClient = S3Client.builder()
.credentialsProvider(InstanceProfileCredentialsProvider.create())
.build();
```
+ Vous devez utiliser des emplacements non standard pour accéder à la configuration des informations d'identification :
```
// Use configuration from a custom file location.
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.builder()
.profileFile(ProfileFile.builder()
.content(Paths.get("/custom/path/to/configuration/file"))
.type(ProfileFile.Type.CONFIGURATION) // Expects all non-default profiles to be prefixed with "profile".
.build())
.profileName("custom")
.build())
.build();
```
+ Utilisez des informations d'identification différentes pour les différents clients du service. Par exemple, si votre application doit accéder à plusieurs AWS comptes ou utiliser des autorisations différentes pour différents services :
```
// S3 client using one set of credentials.
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.create("s3-readonly"))
.build();
// DynamoDB client using different credentials.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.credentialsProvider(ProfileCredentialsProvider.create("dynamodb-admin"))
.build();
```
+ Contrôlez le comportement d'actualisation des informations d'identification :
```
// Create a provider with custom refresh behavior.
StsAssumeRoleCredentialsProvider customRefreshProvider =
StsAssumeRoleCredentialsProvider.builder()
.refreshRequest(AssumeRoleRequest.builder()
.roleArn("arn:aws:iam::123456789012:role/my-role")
.roleSessionName("custom-session")
.build())
.stsClient(StsClient.create())
.asyncCredentialUpdateEnabled(true) // Use a background thread to prefetch credentials.
.build();
S3Client s3Client = S3Client.builder()
.credentialsProvider(customRefreshProvider)
.build();
```
# Utilisez des profils de configuration AWS partagés dans AWS SDK for Java 2.x
À l'aide du `credentials` fichier partagé `config` et du fichier, vous pouvez configurer plusieurs profils. Cela permet à votre application d'utiliser plusieurs ensembles de configuration d'informations d'identification. Le `[default]` profil a été mentionné précédemment. Le SDK utilise la [ProfileCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProfileCredentialsProvider.html)classe pour charger les paramètres à partir des profils définis dans le `credentials` fichier partagé.
L'extrait de code suivant montre comment créer un client de service qui utilise les paramètres définis dans le cadre du profil nommé. `my_profile`
```
Region region = Region.US_WEST_2;
DynamoDbClient ddb = DynamoDbClient.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("my_profile"))
.build();
```
## Définir un profil différent comme profil par défaut
Pour définir un profil autre que le `[default]` profil par défaut pour votre application, définissez la variable d'`AWS_PROFILE`environnement sur le nom de votre profil personnalisé.
Pour définir cette variable sous Linux, macOS ou Unix, utilisez `export` :
```
export AWS_PROFILE="other_profile"
```
Pour définir ces variables sous Windows, utilisez `set` :
```
set AWS_PROFILE="other_profile"
```
Vous pouvez également définir la propriété système `aws.profile` Java sur le nom du profil.
## Recharger les informations d'identification du profil
Vous pouvez configurer n'importe quel fournisseur d'informations d'identification dont le générateur dispose d'une `profileFile()` méthode permettant de recharger les informations d'identification du profil. Ces classes de profil d'identification sont les suivantes : `ProfileCredentialsProvider``DefaultCredentialsProvider`,`InstanceProfileCredentialsProvider`, et `ProfileTokenProvider.`
**Note**
Le rechargement des informations d'identification du profil ne fonctionne qu'avec les paramètres suivants du fichier de profil : `aws_access_key_id``aws_secret_access_key`, et. `aws_session_token`
Les paramètres tels que`region`, `sso_session``sso_account_id`, et `source_profile` sont ignorés.
Pour configurer un fournisseur d'informations d'identification pris en charge afin de recharger les paramètres de profil, fournissez une instance [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html)de la méthode `profileFile()` Builder. L'exemple de code suivant illustre un système `ProfileCredentialsProvider` qui recharge les paramètres d'identification à partir du `[default]` profil.
```
ProfileCredentialsProvider provider = ProfileCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.defaultSupplier())
.build();
// Set up a service client with the provider instance.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.region(Region.US_EAST_1)
.credentialsProvider(provider)
.build();
/*
Before dynamoDbClient makes a request, it reloads the credentials settings
by calling provider.resolveCredentials().
*/
```
Lorsqu'il `ProfileCredentialsProvider.resolveCredentials()` est appelé, le SDK for Java recharge les paramètres. `ProfileFileSupplier.defaultSupplier()`est l'une des [nombreuses implémentations pratiques](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/profiles/ProfileFileSupplier.html) `ProfileFileSupplier` fournies par le SDK. Si votre cas d'utilisation l'exige, vous pouvez fournir votre propre implémentation.
L'exemple suivant montre l'utilisation de la méthode `ProfileFileSupplier.reloadWhenModified()` pratique. `reloadWhenModified()`prend un `Path` paramètre, ce qui vous permet de désigner le fichier source pour la configuration plutôt que l'emplacement standard `~/.aws/credentials` (ou`config`).
Les paramètres seront rechargés lors `resolveCredentials()` de l'appel uniquement si le SDK détermine que le contenu du fichier a été modifié.
```
Path credentialsFilePath = ...
ProfileCredentialsProvider provider = ProfileCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.reloadWhenModified(credentialsFilePath, ProfileFile.Type.CREDENTIALS))
.profileName("my-profile")
.build();
/*
A service client configured with the provider instance calls provider.resolveCredential()
before each request.
*/
```
Le `ProfileFileSupplier.aggregate()` procédé fusionne le contenu de plusieurs fichiers de configuration. Vous décidez si un fichier est rechargé par appel à `resolveCredentials()` ou si les paramètres d'un fichier sont fixés au moment de sa première lecture.
L'exemple suivant montre un `DefaultCredentialsProvider` qui fusionne les paramètres de deux fichiers contenant des paramètres de profil. Le SDK recharge les paramètres dans le fichier pointé par la `credentialsFilePath` variable chaque fois qu'`resolveCredentials()`il est appelé et que les paramètres sont modifiés. Les paramètres de l'`profileFile`objet restent les mêmes.
```
Path credentialsFilePath = ...;
ProfileFile profileFile = ...;
DefaultCredentialsProvider provider = DefaultCredentialsProvider
.builder()
.profileFile(ProfileFileSupplier.aggregate(
ProfileFileSupplier.reloadWhenModified(credentialsFilePath, ProfileFile.Type.CREDENTIALS),
ProfileFileSupplier.fixedProfileFile(profileFile)))
.profileName("my-profile")
.build();
/*
A service client configured with the provider instance calls provider.resolveCredential()
before each request.
*/
```
# Chargez les informations d'identification à partir d'un processus externe à l'aide du AWS SDK for Java 2.x
**Avertissement**
Ce qui suit décrit une méthode d'obtention d'informations d'identification temporaires auprès d'un processus externe. Cela peut être dangereux, alors soyez prudent. Nous vous recommandons d'utiliser d'autres fournisseurs d'informations d'identification dans la mesure du possible. Si vous utilisez cette option, nous vous recommandons de vous assurer que le `config` fichier est aussi verrouillé que possible conformément aux meilleures pratiques de sécurité de votre système d'exploitation.
Assurez-vous que votre outil d'identification personnalisé n'écrit aucune information secrète dans`StdErr`. SDKs et AWS CLI peut capturer et enregistrer ces informations, les exposant potentiellement à des utilisateurs non autorisés.
Avec le SDK pour Java 2.x, vous pouvez obtenir des informations d'identification temporaires auprès d'un processus externe pour des cas d'utilisation personnalisés. Il existe deux manières de configurer cette fonctionnalité.
## Utiliser le `credential_process` réglage
Si vous disposez d'une méthode qui fournit des informations d'identification temporaires, vous pouvez l'intégrer en ajoutant le `credential_process` paramètre dans le cadre d'une définition de profil dans le `config` fichier. La valeur que vous spécifiez doit utiliser le chemin complet du fichier de commandes. Si le chemin du fichier contient des espaces, vous devez l'entourer de guillemets.
Le SDK appelle la commande exactement comme indiqué, puis lit les données JSON depuis`stdout`.
Les exemples suivants montrent l'utilisation de ce paramètre pour les chemins de fichiers sans espaces et les chemins de fichiers contenant des espaces.
------
#### [ Linux/macOS ]
**Aucun espace dans le chemin du fichier**
```
[profile process-credential-profile]
credential_process = /path/to/credential/file/credential_file.sh --custom-command custom_parameter
```
**Espaces dans le chemin du fichier**
```
[profile process-credential-profile]
credential_process = "/path/with/space to/credential/file/credential_file.sh" --custom-command custom_parameter
```
------
#### [ Windows ]
**Aucun espace dans le chemin du fichier**
```
[profile process-credential-profile]
credential_process = C:\Path\To\credentials.cmd --custom_command custom_parameter
```
**Espaces dans le chemin du fichier**
```
[profile process-credential-profile]
credential_process = "C:\Path\With Space To\credentials.cmd" --custom_command custom_parameter
```
------
L'extrait de code suivant montre comment créer un client de service qui utilise les informations d'identification temporaires définies dans le cadre du profil nommé. `process-credential-profile`
```
Region region = Region.US_WEST_2;
S3Client s3Client = S3Client.builder()
.region(region)
.credentialsProvider(ProfileCredentialsProvider.create("process-credential-profile"))
.build();
```
Pour obtenir des informations détaillées sur l'utilisation d'un processus externe comme source d'informations d'identification temporaires, reportez-vous à la [section relative aux informations d'identification du processus](https://docs.aws.amazon.com/sdkref/latest/guide/feature-process-credentials.html) dans le Guide de référence des outils AWS SDKs et outils.
## Utilisez un `ProcessCredentialsProvider`
Au lieu d'utiliser les paramètres du `config` fichier, vous pouvez utiliser le SDK `[ProcessCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProcessCredentialsProvider.html)` pour charger des informations d'identification temporaires à l'aide de Java.
Les exemples suivants montrent différentes versions de la manière de spécifier un processus externe à l'aide des informations d'identification temporaires `ProcessCredentialsProvider` et de la configuration d'un client de service utilisant les informations d'identification temporaires.
------
#### [ Linux/macOS ]
**Aucun espace dans le chemin du fichier**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("/path/to/credentials.sh optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
**Espaces dans le chemin du fichier**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("/path\\ with\\ spaces\\ to/credentials.sh optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
------
#### [ Windows ]
**Aucun espace dans le chemin du fichier**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("C:\\Path\\To\\credentials.exe optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
**Espaces dans le chemin du fichier**
```
ProcessCredentialsProvider credentials =
ProcessCredentialsProvider
.builder()
.command("\"C:\\Path\\With Spaces To\\credentials.exe\" optional_param1 optional_param2")
.build();
S3Client s3 = S3Client.builder()
.region(Region.US_WEST_2)
.credentialsProvider(credentials)
.build();
```
------
## Utiliser IAM Roles Anywhere pour l'authentification
[IAM Roles Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html) vous permet d'obtenir Service AWS des informations d' AWS identification temporaires pour les charges de travail exécutées en dehors de. AWS Il permet un accès sécurisé aux AWS ressources à partir d'environnements sur site ou dans d'autres environnements cloud.
Avant de pouvoir authentifier les demandes avec IAM Roles Anywhere, vous devez d'abord rassembler les informations requises et télécharger l'outil d'aide aux informations [d'identification](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/credential-helper.html). En suivant les instructions de [démarrage](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/getting-started.html) du guide de l'utilisateur d'IAM Roles Anywhere, vous pouvez créer les artefacts nécessaires.
Le SDK for Java ne dispose pas d'un fournisseur d'informations d'identification dédié pour récupérer les informations d'identification temporaires auprès d'IAM Roles Anywhere, mais vous pouvez utiliser l'outil d'assistance aux informations d'identification ainsi que l'une des options permettant de [récupérer les informations d'identification d'](#credentials-process)un processus externe.
### Utiliser le `credential_process` paramètre dans un profil
L'extrait suivant du fichier de AWS configuration partagé montre un profil nommé `roles_anywhere` qui utilise le `credential_process` paramètre :
```
[profile roles_anywhere]
credential_process = ./aws_signing_helper credential-process \
--certificate /path/to/certificate \
--private-key /path/to/private-key \
--trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \
--profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \
--role-arn arn:aws:iam::account:role/role-name-with-path
```
Vous devez remplacer le texte affiché en rouge par vos valeurs après avoir assemblé tous les artefacts. Le premier élément du paramètre est l'exécutable de l'outil d'aide aux informations d'identification et `credential-process` est la commande. `aws_signing_helper`
Lorsque vous configurez un client de service pour utiliser le `roles_anywhere` profil, comme indiqué dans le code suivant, le SDK met en cache les informations d'identification temporaires et les actualise avant leur expiration :
```
S3Client s3Client = S3Client.builder()
.credentialsProvider(ProfileCredentialsProvider.builder()
.profileName("roles_anywhere").build())
.build();
```
### Configurez un `ProcessCredentialsProvider`
Comme indiqué ci-dessous, vous pouvez utiliser une approche basée uniquement sur le code avec les paramètres de profil au `ProcessCredentialsProvider` lieu d'utiliser :
```
ProcessCredentialsProvider processCredentialsProvider = ProcessCredentialsProvider.builder()
.command("""
./aws_signing_helper credential-process \
--certificate /path/to/certificate \
--private-key /path/to/private-key \
--trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \
--profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \
--role-arn arn:aws:iam::account:role/role-name-with-path
""").build();
S3Client s3Client = S3Client.builder()
.credentialsProvider(processCredentialsProvider)
.build();
```
Remplacez le texte affiché en rouge par vos valeurs après avoir assemblé tous les artefacts.
# Entrez les informations d'identification dans le code à l'aide du AWS SDK for Java 2.x
Si la chaîne d'informations d'identification par défaut ou un fournisseur ou une chaîne de fournisseurs spécifique ou personnalisée ne fonctionnent pas pour votre application, vous pouvez fournir des informations d'identification temporaires directement dans le code. Il peut s'agir [d'informations d'identification de rôle IAM](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html) [décrites ci-dessus](credentials-temporary.md#credentials-temporary-from-portal) ou d'informations d'identification temporaires extraites de AWS Security Token Service (AWS STS). Si vous avez récupéré des informations d'identification temporaires à l'aide de AWS STS, fournissez-les à un Service AWS client comme indiqué dans l'exemple de code suivant.
1. Assumez un rôle en appelant`StsClient.assumeRole()`.
1. Créez un [StaticCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/StaticCredentialsProvider.html)objet et fournissez-le avec l'`AwsSessionCredentials`objet.
1. Configurez le générateur de clients de service avec `StaticCredentialsProvider` et créez le client.
L'exemple suivant crée un client de service Amazon S3 à l'aide d'informations d'identification temporaires renvoyées par AWS STS pour un rôle assumé par IAM.
```
// The AWS IAM Identity Center identity (user) who executes this method does not have permission to list buckets.
// The identity is configured in the [default] profile.
public static void assumeRole(String roleArn, String roleSessionName) {
// The IAM role represented by the 'roleArn' parameter can be assumed by identities in two different accounts
// and the role permits the user to only list buckets.
// The SDK's default credentials provider chain will find the single sign-on settings in the [default] profile.
// The identity configured with the [default] profile needs permission to call AssumeRole on the STS service.
try {
Credentials tempRoleCredentials;
try (StsClient stsClient = StsClient.create()) {
AssumeRoleRequest roleRequest = AssumeRoleRequest.builder()
.roleArn(roleArn)
.roleSessionName(roleSessionName)
.build();
AssumeRoleResponse roleResponse = stsClient.assumeRole(roleRequest);
tempRoleCredentials = roleResponse.credentials();
}
// Use the following temporary credential items for the S3 client.
String key = tempRoleCredentials.accessKeyId();
String secKey = tempRoleCredentials.secretAccessKey();
String secToken = tempRoleCredentials.sessionToken();
// List all buckets in the account associated with the assumed role
// by using the temporary credentials retrieved by invoking stsClient.assumeRole().
StaticCredentialsProvider staticCredentialsProvider = StaticCredentialsProvider.create(
AwsSessionCredentials.create(key, secKey, secToken));
try (S3Client s3 = S3Client.builder()
.credentialsProvider(staticCredentialsProvider)
.build()) {
List buckets = s3.listBuckets().buckets();
for (Bucket bucket : buckets) {
System.out.println("bucket name: " + bucket.name());
}
}
} catch (StsException | S3Exception e) {
logger.error(e.getMessage());
System.exit(1);
}
}
```
## Ensemble d'autorisations
L'ensemble d'autorisations suivant défini dans AWS IAM Identity Center permet à l'identité (utilisateur) d'effectuer les deux opérations suivantes
1. `GetObject`Fonctionnement du service Amazon Simple Storage.
1. Le `AssumeRole` fonctionnement du AWS Security Token Service.
Si vous n'assumez pas le rôle, la `s3.listBuckets()` méthode illustrée dans l'exemple échouerait.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"sts:AssumeRole"
],
"Resource": [
"*"
]
}
]
}
```
------
## Rôle endossé
### Politique d'autorisation des rôles assumés
La politique d'autorisation suivante est attachée au rôle assumé dans l'exemple précédent. Cette politique d'autorisation permet de répertorier tous les buckets dans le même compte que le rôle.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets"
],
"Resource": [
"*"
]
}
]
}
```
------
### Politique de confiance fondée sur les rôles assumés
La politique de confiance suivante est attachée au rôle assumé dans l'exemple précédent. La politique permet aux identités (utilisateurs) d'assumer le rôle dans deux comptes.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:root",
"arn:aws:iam::555555555555:root"
]
},
"Action": "sts:AssumeRole",
"Condition": {}
}
]
}
```
------
# Lisez les informations d'identification du rôle IAM sur Amazon EC2 à l'aide du SDK pour Java 2.x
Vous pouvez utiliser un rôle IAM pour gérer les informations d'identification temporaires pour les applications qui s'exécutent sur une instance EC2 et qui envoient des demandes AWS CLI d' AWS API. Cette solution est préférable au stockage des clés d’accès au sein de l’instance EC2. Pour attribuer un AWS rôle à une instance EC2 et le mettre à la disposition de toutes ses applications, vous devez créer un profil d'instance attaché à l'instance. Un profil d’instance contient le rôle et permet aux programmes qui s’exécutent sur l’instance EC2 d’obtenir des informations d’identification temporaires. Pour plus d’informations, consultez [Utilisation d’un rôle IAM pour accorder des autorisations à des applications s’exécutant sur des instances Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html) dans le *Guide de l’utilisateur IAM*.
Cette rubrique fournit des informations sur la façon de configurer votre application Java pour qu'elle s'exécute sur une instance EC2 et de lui permettre d'acquérir des informations AWS SDK for Java 2.x d'identification de IAM rôle.
## Acquérir les informations d'identification des rôles IAM auprès de l'environnement
Si votre application crée un client de AWS service à l'aide de la `create` méthode (ou `builder().build()` des méthodes), le SDK for Java utilise *la chaîne de fournisseurs d'informations d'identification par défaut*. La chaîne de fournisseurs d'informations d'identification par défaut recherche dans l'environnement d'exécution des éléments de configuration que le SDK peut échanger contre des informations d'identification temporaires. La [Chaîne de fournisseurs d'informations d'identification par défaut dans AWS SDK for Java 2.x](credentials-chain.md) section décrit le processus de recherche complet.
La dernière étape de la chaîne de fournisseurs par défaut n'est disponible que lorsque votre application s'exécute sur une Amazon EC2 instance. Au cours de cette étape, le SDK utilise un `InstanceProfileCredentialsProvider` pour lire le rôle IAM défini dans le profil d'instance EC2. Le SDK acquiert ensuite des informations d'identification temporaires pour ce rôle IAM.
Bien que ces informations d'identification soient temporaires et finiront par expirer, elles sont `InstanceProfileCredentialsProvider` régulièrement actualisées pour vous afin qu'elles continuent à autoriser l'accès à AWS.
## Acquérir les informations d'identification des rôles IAM par programmation
Comme alternative à la chaîne de fournisseurs d'informations d'identification par défaut qui utilise éventuellement un `InstanceProfileCredentialsProvider` sur EC2, vous pouvez configurer un client de service de manière explicite avec un`InstanceProfileCredentialsProvider`. Cette approche est illustrée dans l'extrait suivant.
```
S3Client s3 = S3Client.builder()
.credentialsProvider(InstanceProfileCredentialsProvider.create())
.build();
```
## Acquérir des informations d'identification de rôle IAM en toute
Par défaut, les instances EC2 exécutent le service [IMDS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html) (Instance Metadata Service) qui permet aux SDK d'accéder `InstanceProfileCredentialsProvider` à des informations telles que le rôle IAM configuré. Les instances EC2 exécutent deux versions d'IMDS par défaut :
+ Service de métadonnées d'instance version 1 (IMDSv1) — une request/response méthode
+ Service de métadonnées d'instance version 2 (IMDSv2) : méthode orientée session
[IMDSv2 est une approche plus sûre](https://aws.amazon.com/blogs/security/defense-in-depth-open-firewalls-reverse-proxies-ssrf-vulnerabilities-ec2-instance-metadata-service/) que IMDSv1.
Par défaut, le SDK Java essaie d'abord IMDSv2 d'obtenir le rôle IAM, mais en cas d'échec, il essaie. IMDSv1 Cependant, étant donné que IMDSv1 c'est moins sûr, il est AWS recommandé de IMDSv2 n'utiliser que le SDK et de désactiver toute tentative IMDSv1.
Pour utiliser l'approche la plus sécurisée, désactivez l'utilisation du SDK en IMDSv1 fournissant l'un des paramètres suivants avec une valeur de`true`.
+ Variable d'environnement : `AWS_EC2_METADATA_V1_DISABLED`
+ Propriété du système JVM : aws. `disableEc2MetadataV1`
+ Paramètre du fichier de configuration partagé : `ec2_metadata_v1_disabled`
Lorsque l'un de ces paramètres est défini sur`true`, le SDK ne charge pas les informations d'identification du rôle IMDS en IMDSv1 cas d'échec de l' IMDSv2 appel initial.