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.
# Authentification et informations d'accès pour AWS CLI
Vous devez établir la manière dont ils AWS CLI s'authentifient AWS lorsque vous développez avec des AWS services. Pour configurer les informations d'identification pour l'accès par programmation au AWS CLI, choisissez l'une des options suivantes. Les options sont présentées par ordre de recommandation.
****
| Type d’authentification | Objectif | Instructions |
| --- | --- | --- |
| AWS Identifiants de la console de gestion | **(Recommandé)** Utilisez des informations d'identification à court terme en vous connectant à la AWS CLI avec les informations d'identification de votre console. Recommandé si vous utilisez root, des utilisateurs IAM ou une fédération avec IAM pour AWS accéder au compte | [Connectez-vous pour le développement AWS local à l'aide des informations d'identification de console](cli-configure-sign-in.md) |
| Informations d’identification à court terme des utilisateurs du personnel IAM Identity Center | Utilisez des informations d'identification à court terme pour un utilisateur du personnel d'IAM Identity Center.La meilleure pratique en matière de sécurité consiste AWS Organizations à utiliser IAM Identity Center. Ce service combine les informations d’identification à court terme à un annuaire d’utilisateurs, comme l’annuaire intégré IAM Identity Center ou Active Directory. | [Configuration de l'authentification IAM Identity Center à l'aide du AWS CLI](cli-configure-sso.md) |
| Informations d’identification à court terme pour les utilisateurs IAM | Utiliser les informations d’identification à court terme pour les utilisateurs IAM, qui sont plus sécurisées que celles à long terme. Si des informations d’identification sont compromises, leur durée d’utilisation est limitée avant qu’elles n’expirent. | [Authentification à l'aide d'informations d'identification à court terme pour AWS CLI](cli-authentication-short-term.md) |
| Utilisateurs IAM ou IAM Identity Center sur une instance Amazon EC2. | Utiliser les métadonnées d’une instance Amazon EC2 pour demander des informations d’identification temporaires à l’aide du rôle attribué à l’instance Amazon EC2. | [Utilisation des métadonnées de l'instance Amazon EC2 comme informations d'identification dans AWS CLI](cli-configure-metadata.md) |
| Endosser des rôles pour les autorisations | Associer une autre méthode d’identification et endosser un rôle pour un accès temporaire aux Services AWS auxquels le compte utilisateur n’a peut-être pas accès. | [Utilisation d'un rôle IAM dans AWS CLI](cli-configure-role.md) |
| Informations d’identification à long terme des utilisateurs IAM | (Non recommandé) Utiliser des informations d’identification à long terme qui n’expirent jamais. | [Authentification à l'aide des informations d'identification utilisateur IAM pour AWS CLI](cli-authentication-user.md) |
| Stockage externe des utilisateurs du personnel IAM ou IAM Identity Center | (Non recommandé) Associer une autre méthode d’identification, mais stocker les valeurs d’informations d’identification dans un emplacement extérieur à l’ AWS CLI. Cette méthode n’est sécurisée que dans la mesure où l’emplacement externe où les informations d’identification sont stockées est sûr. | [Obtenir des informations d'identification par le biais d'un processus externe dans le AWS CLI](cli-configure-sourcing-external.md) |
## Configuration et priorité des informations d’identification
Les informations d'identification et les paramètres de configuration se trouvent à plusieurs endroits, tels que les variables d'environnement système ou utilisateur, les fichiers de AWS configuration locaux, ou sont explicitement déclarés sur la ligne de commande en tant que paramètre. Certaines authentifications ont priorité sur d’autres. Les paramètres d’authentification de l’ AWS CLI sont prioritaires dans l’ordre suivant :
1. **[Options de ligne de commande](cli-configure-options.md)** : remplacent les paramètres de tout autre emplacement, par exemple les paramètres `--region`, `--output` et `--profile`.
1. **[Variables d’environnement](cli-configure-envvars.md)** : vous pouvez stocker les valeurs dans les variables d’environnement système.
1. **[Endosser un rôle](cli-configure-role.md)** : endossez les autorisations d’un rôle IAM au moyen de la configuration ou de la commande [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html).
1. **[Endosser un rôle avec une identité web](cli-configure-role.md)** : endossez les autorisations d’un rôle IAM utilisant une identité web au moyen de la configuration ou de la commande [https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role-with-web-identity.html).
1. **[AWS IAM Identity Center](cli-configure-files.md)** : les paramètres de configuration d’IAM Identity Center stockés dans le fichier `config` sont mis à jour lorsque vous exécutez la commande `aws configure sso`. Les informations d’identification sont ensuite authentifiées lorsque vous exécutez la commande `aws sso login`. Le fichier `config` est situé dans `~/.aws/config` sous Linux ou macOS, ou dans `C:\Users\USERNAME\.aws\config` sous Windows.
1. **[Fichier d’informations d’identification](cli-configure-files.md)** : les fichiers `credentials` et `config` sont mis à jour lorsque vous exécutez la commande `aws configure`. Le fichier `credentials` est situé dans `~/.aws/credentials` sous Linux ou macOS, ou dans `C:\Users\USERNAME\.aws\credentials` sous Windows.
1. **[Processus personnalisé](cli-configure-sourcing-external.md)** : obtenez vos informations d’identification auprès d’une source externe.
1. **[Fichier de configuration](cli-configure-files.md)** : les fichiers `credentials` et `config` sont mis à jour lorsque vous exécutez la commande `aws configure`. Le fichier `config` est situé dans `~/.aws/config` sous Linux ou macOS, ou dans `C:\Users\USERNAME\.aws\config` sous Windows.
1. **[Informations d’identification de conteneur](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html)** : vous pouvez associer un rôle IAM à chacune de vos définitions de tâches Amazon Elastic Container Service (Amazon ECS). Les informations d’identification temporaires pour ce rôle sont ensuite disponibles pour les conteneurs de cette tâche. Pour plus d’informations, consultez [Rôles IAM pour les tâches](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) dans le *Guide du développeur Amazon Elastic Container Service*.
1. **[Informations d’identification de profil d’instance Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html)** : vous pouvez associer un rôle IAM à chacune de vos instances Amazon Elastic Compute Cloud (Amazon EC2). Les informations d’identification temporaires pour ce rôle sont ensuite disponibles pour l’exécution du code dans l’instance. Les informations d’identification sont fournies au moyen du service de métadonnées Amazon EC2. Pour plus d’informations, consultez [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* et [Utilisation des profils d’instance](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html) dans le *Guide de l’utilisateur IAM*.
## Rubriques supplémentaires de cette section
+ [Configuration de l'authentification IAM Identity Center à l'aide du AWS CLI](cli-configure-sso.md)
+ [Authentification à l'aide d'informations d'identification à court terme pour AWS CLI](cli-authentication-short-term.md)
+ [Utilisation d'un rôle IAM dans AWS CLI](cli-configure-role.md)
+ [Authentification à l'aide des informations d'identification utilisateur IAM pour AWS CLI](cli-authentication-user.md)
+ [Utilisation des métadonnées de l'instance Amazon EC2 comme informations d'identification dans AWS CLI](cli-configure-metadata.md)
+ [Obtenir des informations d'identification par le biais d'un processus externe dans le AWS CLI](cli-configure-sourcing-external.md)
# Connectez-vous pour le développement AWS local à l'aide des informations d'identification de 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 la AWS CLI, AWS Tools for PowerShell et. AWS SDKs Cette fonctionnalité simplifie le processus de configuration et de gestion des informations d'identification de la AWS CLI, en particulier si vous préférez l'authentification interactive à la gestion des clés d'accès à long terme.
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é, et la AWS CLI 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. La CLI actualisera automatiquement ces informations d'identification pendant 12 heures maximum.
Une fois configurée, votre session peut être utilisée dans la AWS CLI et dans d'autres AWS SDKs outils.
**Topics**
+ [Conditions préalables](#cli-configure-sign-in-prerequisites)
+ [Connectez-vous à la AWS CLI à l'aide de la `aws login` commande.](#cli-configure-sign-in-login-command)
+ [Exécutez une commande avec votre profil](#cli-configure-sign-in-with-profile)
+ [Déconnectez-vous de votre session à l'aide de la commande aws logout](#cli-configure-sign-in-sign-out)
+ [Résolution des problèmes](#cli-configure-sign-in-troubleshooting)
+ [Ressources connexes](#cli-configure-sign-in-resources)
## Conditions préalables
+ Installez la AWS CLI. Pour de plus amples informations, veuillez consulter [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md). Une version minimale de 2.32.0 est requise pour utiliser la `aws login` commande.
+ Accès pour se connecter à la console AWS de gestion en tant qu'utilisateur root, utilisateur IAM ou via une fédération avec IAM. Si vous utilisez IAM Identity Center, rendez-vous [Configuration de l'authentification IAM Identity Center à l'aide du AWS CLI](cli-configure-sso.md) plutôt sur.
+ Assurez-vous que l'identité IAM dispose des autorisations appropriées. Associez la politique [SignInLocalDevelopmentAccess](https://docs.aws.amazon.com/signin/latest/userguide/security-iam-awsmanpol.html)gérée à votre utilisateur, rôle ou groupe IAM. Si vous vous connectez en tant qu'utilisateur root, aucune autorisation supplémentaire n'est requise.
## Connectez-vous à la AWS CLI à l'aide de la `aws login` commande.
Exécutez la `aws login` commande pour vous authentifier à l'aide de vos informations d'identification existantes AWS de la console de gestion. Si vous n'avez pas encore configuré de profil, vous êtes invité à fournir des informations supplémentaires. Pour vous connecter ou configurer un profil, suivez les étapes ci-dessous.
1. Dans votre terminal préféré, exécutez la commande `aws login`.
```
$ aws login
```
Pour vous connecter à un profil nommé ou en créer un nouveau, utilisez l'`--profile`option.
```
$ aws login --profile my-dev-profile
```
+ S'il s'agit d'un nouveau profil ou si aucune AWS région n'a été spécifiée, la AWS CLI vous invite à fournir une région.
```
No AWS region has been configured. The AWS region is the geographic location of
your AWS resources.
If you've used AWS before and already have resources in your account, tell us
which region they were created in. If you haven't created resources in your account
before, you can pick the region closest to you:
https://docs.aws.amazon.com/global-infrastructure/latest/regions/aws-regions.html.
You are able to change the region in the CLI at any time with the command
`aws configure set region NEW_REGION`.
AWS Region [us-east-1]:
```
+ Si le périphérique utilisant la AWS CLI ne possède pas de navigateur, vous pouvez utiliser l'`--remote`option permettant de fournir une URL à ouvrir sur un appareil compatible avec un navigateur.
```
$ aws login --remote
```
**Note**
Vous pouvez contrôler l'accès à l'authentification sur un même appareil (`aws login`) et sur plusieurs appareils (`aws login --remote`). Utilisez la ressource suivante ARNs dans toute politique IAM pertinente.
`arn:aws:signin:region:account-id:oauth2/public-client/localhost`— Utilisez cet ARN pour l'authentification sur le même appareil avec. `aws login`
`arn:aws:signin:region:account-id:oauth2/public-client/remote`— Utilisez cet ARN pour l'authentification multi-appareils avec`aws login --remote`.
1. La AWS CLI tente d'ouvrir votre navigateur par défaut pour le processus de connexion de votre AWS compte.
```
Attempting to open the login page for `us-east-1` in your default browser.
If the browser does not open, use the following URL to complete your login:
https://signin.us-east-1.amazonaws.com/authorize?
If you cannot connect to this URL, make sure that you have specified a valid region.
```
+ Si vous avez utilisé `--remote` cette option, les instructions pour démarrer manuellement le processus de connexion s'affichent en fonction du type d'autorisation que vous utilisez. L'URL affichée est une URL unique commençant par : https://us-east-1.signin.amazonaws.com /authorize. Une fois la connexion au navigateur terminée, vous devrez copier-coller le code d'autorisation obtenu dans la CLI.
```
Browser will not be automatically opened.
Please visit the following URL:
https://region.signin.amazonaws.com/authorize?
Please enter the authorization code displayed in the browser:
```
1. Dans le navigateur, sélectionnez les informations d'identification à utiliser dans la liste affichée, puis retournez sur votre terminal.
+ Si le profil que vous configurez possède une session de connexion précédemment configurée qui ne correspond pas à votre nouvelle session, la AWS CLI vous invite à confirmer que vous changez de session correspondant au profil existant.
```
Profile signin is already configured to use session arn:aws:iam::0123456789012:user/ReadOnly.
Do you want to overwrite it to use arn:aws:iam::0123456789012:user/Admin instead? (y/n):.
```
1. Un message final décrit la configuration de profil terminée. Vous pouvez désormais utiliser ce profil pour demander des informations d’identification. Utilisez la commande `aws login` pour demander et extraire les informations d’identification temporaires nécessaires à l’exécution des commandes.
Le jeton d'authentification est mis en cache sur le disque sous le `.aws/login/cache` répertoire avec un nom de fichier basé sur le profil résolu.
### Fichier de configuration généré
Ces étapes aboutissent à la création du `default` profil dans le `config` fichier qui ressemble à ce qui suit :
```
[default]
login_session = arn:aws:iam::0123456789012:user/username
region = us-east-1
```
## Exécutez une commande avec votre profil
Une fois connecté, vous pouvez utiliser vos informations d'identification pour appeler des commandes AWS CLI avec le profil associé. L'exemple suivant appelle la `get-caller-identity` commande à l'aide du `default` profil :
```
$ aws sts get-caller-identity
```
Pour vous connecter à une session spécifique, utilisez l'`--profile`option.
```
$ aws sts get-caller-identity --profile my-dev-profile
```
La AWS CLI SDKs actualisera automatiquement les informations d'identification mises en cache toutes les 15 minutes selon les besoins. La session globale sera valide jusqu'à la durée de session définie par le principal IAM (12 heures maximum), après quoi vous devrez vous lancer `aws login` à nouveau.
## Déconnectez-vous de votre session à l'aide de la commande aws logout
Lorsque vous avez terminé d'utiliser votre session, vous pouvez laisser vos informations d'identification expirer ou exécuter la `aws logout` commande pour supprimer vos informations d'identification mises en cache. Si aucun profil n'est spécifié sur la ligne de commande ou dans la variable d'`AWS_PROFILE`environnement, la commande vous déconnecte de votre profil par défaut. L'exemple suivant vous déconnecte de votre profil par défaut.
```
$ aws logout
```
Pour vous déconnecter d'une session spécifique, utilisez l'`--profile`option.
```
$ aws logout --profile my-dev-profile
```
Pour vous déconnecter de tous les profils utilisant des informations de connexion, utilisez l'`--all`option.
```
$ aws logout --all
```
### Informations d'identification mises en cache
Les informations d'identification temporaires mises en cache, ainsi que les métadonnées requises pour les actualiser, sont stockées par défaut sous `~/.aws/login/cache` Linux et macOS, ou `%USERPROFILE%\.aws\login\cache` sous Windows.
Pour stocker le cache des informations d'identification à court terme dans un autre emplacement, définissez la variable d'`AWS_LOGIN_CACHE_DIRECTORY`environnement.
#### Partage des identifiants de connexion en tant qu'identifiants de processus
Les anciennes versions des outils de développement AWS SDKs ou d'autres outils de développement ne prennent peut-être pas encore en charge les informations d'identification de console. Pour contourner le problème, vous pouvez configurer la AWS CLI pour qu'elle serve de fournisseur d'informations d'identification de processus. La CLI continuera à actualiser les informations d'identification selon les besoins, tout en les partageant avec les outils configurés pour utiliser le profil credential\$1process.
Dans cet exemple, utilisez la AWS CLI pour vous connecter d'abord pour la connexion au profil :
```
$ aws login --profile signin
```
Configurez ensuite manuellement un profil avec l'option credential\$1process, qui pointe vers le profil de connexion. Vous pouvez maintenant configurer nos SDKs outils pour utiliser le profil de processus, qui appellera la CLI pour partager les informations d'identification du profil de connexion.
```
[profile signin]
login_session = arn:aws:iam::0123456789012:user/username
region = us-east-1
[profile process]
credential_process = aws configure export-credentials --profile signin --format process
region = us-east-1
```
## Résolution des problèmes
Cette page contient des recommandations pour résoudre les problèmes liés à la connexion pour le développement AWS local à l'aide des informations d'identification de console pour la CLI. AWS
**Note**
Pour résoudre d'autres problèmes que vous pourriez rencontrer lors de l'utilisation de la AWS CLI, consultez[Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
### ExpiredToken ou AccessDeniedException des erreurs après avoir utilisé « aws login »
Lorsque vous exécutez une commande AWS CLI après l'avoir exécutée `aws login` pour un profil donné, vous pouvez rencontrer une erreur d'identification expirée ou non valide.
```
$ aws s3 ls
An error occurred (ExpiredToken) when calling the ListBuckets operation: The provided token has expired.
```
**Cause possible :** vous avez un mélange d'informations d'identification existantes et de nouvelles informations de connexion dans ce profil
Exécutez `aws configure list` ou `aws configure list --profile ` pour imprimer l'endroit à partir duquel la CLI résout les informations d'identification pour le profil par défaut ou pour le profil donné.
Si la colonne TYPE est autre chose que login, cela signifie qu'un autre type d'informations d'identification est toujours défini dans le profil cible.
Dans cet exemple, les informations d'identification sont résolues à partir du fichier d'informations d'identification partagé de votre répertoire personnel, qui a priorité sur les informations de connexion.
```
$ aws configure list
NAME : VALUE : TYPE : LOCATION
profile : : None : None
access_key : ****************MPLE : shared-credentials-file :
secret_key : ****************EKEY : shared-credentials-file :
region : us-east-1 : config-file : ~/.aws/config
```
Pour résoudre ce problème, supprimez manuellement toutes les informations d'identification existantes de votre fichier de configuration et d'informations d'identification pour le profil cible. Une fois que vous l'avez fait, vous devriez voir les informations de connexion lors de la `aws configure list` prochaine exécution.
```
$ aws configure list
NAME : VALUE : TYPE : LOCATION
profile : : None : None
access_key : ****************MPLE : login :
secret_key : ****************EKEY : login :
region : us-east-1 : config-file : ~/.aws/config
```
Sinon, l'utilisation de `--debug` cette option indiquera d'où la CLI résout les informations d'identification.
### Pare-feu bloquant l'accès au réseau lors de l'exécution de « aws login »
Lors de l'exécution, `aws login` vous pouvez rencontrer une fenêtre contextuelle ou un message provenant de votre logiciel de pare-feu qui empêche la AWS CLI d'accéder à votre réseau.
**Cause possible :** votre pare-feu ou votre logiciel de sécurité empêche la AWS CLI d'ouvrir le port utilisé pour gérer le OAuth rappel.
Pour éviter ce problème, utilisez plutôt l'`--remote`option. Cela vous invitera à copier-coller le code d'autorisation au lieu d'utiliser le OAuth rappel.
```
$ aws login --remote
```
## Ressources connexes
Les ressources supplémentaires sont les suivantes.
+ [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md)
+ [`aws login`dans la référence de la version 2 de la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/)
+ [`aws logout`dans la référence de la version 2 de la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/)
# Configuration de l'authentification IAM Identity Center à l'aide du AWS CLI
Cette rubrique fournit des instructions sur la façon de configurer le AWS CLI with AWS IAM Identity Center (IAM Identity Center) pour récupérer les informations d'identification permettant d'exécuter des AWS CLI commandes. Il existe principalement deux méthodes pour authentifier les utilisateurs auprès d'IAM Identity Center afin d'obtenir les informations d'identification nécessaires pour exécuter des AWS CLI commandes via le `config` fichier :
+ **(Recommandé)** Configuration du fournisseur de jetons SSO.
+ Configuration non actualisable héritée.
Pour plus d'informations sur l'utilisation de l'authentification au porteur, qui n'utilise aucun identifiant de compte ni rôle, consultez la section [Configuration pour utiliser l'authentification AWS CLI avec CodeCatalyst dans le guide](https://docs.aws.amazon.com/codecatalyst/latest/userguide/set-up-cli.html) de * CodeCatalyst l'utilisateur Amazon*.
**Note**
Pour un processus guidé d'utilisation d'IAM Identity Center avec des AWS CLI commandes, voir[Tutoriel : Utilisation d'IAM Identity Center pour exécuter des commandes Amazon S3 dans AWS CLI](cli-configure-sso-tutorial.md).
**Rubriques**
+ [Conditions préalables](#cli-configure-sso-prereqs)
+ [Configuration de votre profil à l’aide de l’assistant `aws configure sso`](#cli-configure-sso-configure)
+ [Configuration uniquement de votre section `sso-session` à l’aide de l’assistant `aws configure sso-session`](#cli-configure-sso-session)
+ [Configuration manuelle à l’aide du fichier `config`](#cli-configure-sso-manual)
+ [Connexion à une session IAM Identity Center](#cli-configure-sso-login)
+ [Exécution d’une commande avec votre profil IAM Identity Center](#cli-configure-sso-use)
+ [Déconnexion de vos sessions IAM Identity Center](#cli-configure-sso-logout)
+ [Résolution des problèmes](#cli-configure-sso-tshoot)
+ [Ressources connexes](#cli-configure-sso-resources)
## Conditions préalables
+ Installez le AWS CLI. Pour de plus amples informations, veuillez consulter [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md).
+ Vous devez d’abord avoir accès à l’authentification SSO dans IAM Identity Center. Choisissez l'une des méthodes suivantes pour accéder à vos AWS informations d'identification.
### Je ne dispose pas d’un accès établi via IAM Identity Center
Suivez les instructions de [Mise en route](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *. Ce processus active IAM Identity Center, crée un utilisateur administratif et ajoute un jeu d’autorisations de moindre privilège approprié.
**Note**
Créez un jeu d’autorisations qui applique les autorisations de moindre privilège. Nous vous recommandons d’utiliser le jeu d’autorisations `PowerUserAccess` prédéfini, sauf si votre employeur a créé un jeu d’autorisations personnalisé à cette fin.
Quittez le portail et reconnectez-vous pour voir vos Comptes AWS informations d'accès programmatiques et les options pour `Administrator` ou`PowerUserAccess`. Sélectionnez `PowerUserAccess` lorsque vous utilisez le kit SDK.
### J'y ai déjà accès AWS via un fournisseur d'identité fédéré géré par mon employeur (tel qu'Azure AD ou Okta)
Connectez-vous AWS via le portail de votre fournisseur d'identité. Si votre administrateur cloud vous a accordé des autorisations `PowerUserAccess` (de développeur), vous voyez Comptes AWS celles auxquelles vous avez accès et votre ensemble d'autorisations. En regard du nom de votre jeu d’autorisations, vous pouvez voir des options permettant d’accéder aux comptes manuellement ou par programmation à l’aide de ce jeu d’autorisations.
Les implémentations personnalisées peuvent entraîner des expériences différentes, telles que des noms de jeux d’autorisations différents. Si vous avez des doutes sur le jeu d’autorisations à utiliser, contactez votre équipe informatique pour obtenir de l’aide.
### J'y ai déjà accès AWS via le portail AWS d'accès géré par mon employeur
Connectez-vous AWS via votre portail AWS d'accès. Si votre administrateur cloud vous a accordé des autorisations `PowerUserAccess` (de développeur), vous voyez Comptes AWS celles auxquelles vous avez accès et votre ensemble d'autorisations. En regard du nom de votre jeu d’autorisations, vous pouvez voir des options permettant d’accéder aux comptes manuellement ou par programmation à l’aide de ce jeu d’autorisations.
### J'y ai déjà accès AWS via un fournisseur d'identité personnalisé fédéré géré par mon employeur
Contactez votre équipe informatique pour obtenir de l’aide.
Dès que vous disposez d’un accès à IAM Identity Center, recueillez les informations IAM Identity Center en procédant comme suit :
1. Recueillez les valeurs `SSO Start URL` et `SSO Region` dont vous avez besoin pour exécuter `aws configure sso`
1. Dans votre portail AWS d'accès, sélectionnez l'ensemble d'autorisations que vous utilisez pour le développement, puis cliquez sur le lien **Clés d'accès**.
1. Dans la boîte de dialogue **Obtenir des informations d’identification**, choisissez l’onglet correspondant à votre système d’exploitation.
1. Choisissez la méthode **Informations d’identification IAM Identity Center** pour obtenir les valeurs `SSO Start URL` et `SSO Region`.
1. À compter de la version 2.22.0, vous pouvez également utiliser l’URL de l’émetteur au lieu de l’URL de démarrage. L'URL de l'émetteur se trouve dans la AWS IAM Identity Center console à l'un des emplacements suivants :
+ Sur la page **Tableau de bord**, l’URL de l’émetteur se trouve dans le récapitulatif des paramètres.
+ Sur la page **Paramètres**, l’URL de l’émetteur se trouve dans les paramètres de la **source d’identité**.
1. Pour plus d'informations sur la valeur d'étendue à enregistrer, consultez la section Étendue [d'accès OAuth 2.0 dans le guide](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) de l'utilisateur d'*IAM Identity Center*.
## Configuration de votre profil à l’aide de l’assistant `aws configure sso`
**Pour configurer un profil IAM Identity Center pour votre AWS CLI :**
1. Dans votre terminal préféré, exécutez la commande `aws configure sso`.
------
#### [ (Recommended) IAM Identity Center ]
Créez un nom de session, indiquez l'URL de démarrage de votre IAM Identity Center ou l'URL de l'émetteur, Région AWS celle qui héberge le répertoire du IAM Identity Center et le périmètre d'enregistrement.
```
$ aws configure sso
SSO session name (Recommended): my-sso
SSO start URL [None]: https://my-sso-portal.awsapps.com/start
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
Pour la prise en charge de la double pile, utilisez l'URL de démarrage SSO à double pile :
```
$ aws configure sso
SSO session name (Recommended): my-sso
SSO start URL [None]: https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
L'autorisation PKCE (Proof Key for Code Exchange) est utilisée par défaut à AWS CLI partir de la version **2.22.0** et doit être utilisée sur les appareils dotés d'un navigateur. Pour continuer à utiliser l’autorisation d’appareil, ajoutez l’option `--use-device-code`.
```
$ aws configure sso --use-device-code
```
------
#### [ Legacy IAM Identity Center ]
Ignorez le nom de session, puis indiquez l’URL de démarrage d’IAM Identity Center et la région AWS qui héberge l’annuaire Identity Center.
```
$ aws configure sso
SSO session name (Recommended):
SSO start URL [None]: https://my-sso-portal.awsapps.com/start
SSO region [None]:us-east-1
```
Pour le support à double pile :
```
$ aws configure sso
SSO session name (Recommended):
SSO start URL [None]: https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
SSO region [None]:us-east-1
```
------
1. Les AWS CLI tentatives d'ouverture de votre navigateur par défaut pour le processus de connexion de votre compte IAM Identity Center. Ce processus peut vous demander d'autoriser l' AWS CLI accès à vos données. Étant donné que le AWS CLI est construit au-dessus du SDK pour Python, les messages d'autorisation peuvent contenir des variantes du `botocore` nom.
+ **S'il n'est AWS CLI pas possible d'ouvrir le navigateur**, les instructions pour démarrer manuellement le processus de connexion s'affichent en fonction du type d'autorisation que vous utilisez.
------
#### [ PKCE authorization ]
L'autorisation Proof Key for Code Exchange (PKCE) est utilisée par défaut à AWS CLI partir de la version 2.22.0. L'URL affichée est une URL unique commençant par :
+ IPv4: *https://oidc.us-east-1.amazonaws.com/authorize*
+ Double pile : *https://oidc.us-east-1.api.aws/authorize*
L'autorisation PKCE URLs doit être ouverte sur le même appareil que celui sur lequel vous vous connectez et doit être utilisée pour un appareil doté d'un navigateur.
```
Attempting to automatically open the SSO authorization page in your
default browser.
If the browser does not open or you wish to use a different device to
authorize the request, open the following URL:
https://oidc.us-east-1.amazonaws.com/authorize?
```
------
#### [ Device authorization ]
L'autorisation de l'appareil OAuth 2.0 est utilisée par AWS CLI les versions antérieures à 2.22.0. Vous pouvez activer cette méthode sur les versions plus récentes à l’aide de l’option `--use-device-code`.
L'autorisation de l'appareil URLs n'a pas besoin d'être ouverte sur le même appareil que celui sur lequel vous vous connectez et peut être utilisée pour un appareil avec ou sans navigateur. Le format du point de terminaison dépend de votre configuration :
+ IPv4: *https://device.sso.us-west-2.amazonaws.com/*
+ Double pile : *https://device.sso.us-west-2.api.aws/*
```
If the browser does not open or you wish to use a different device to
authorize this request, open the following URL:
https://device.sso.us-west-2.amazonaws.com/
Then enter the code:
QCFK-N451
```
------
1. Sélectionnez le AWS compte à utiliser dans la liste qui s'affiche. Si vous n'êtes autorisé à utiliser qu'un seul compte, celui-ci est AWS CLI automatiquement sélectionné et ignore l'invite.
```
There are 2 AWS accounts available to you.
> DeveloperAccount, developer-account-admin@example.com (123456789011)
ProductionAccount, production-account-admin@example.com (123456789022)
```
1. Sélectionnez le rôle IAM à utiliser dans la liste qui s’affiche. S'il n'y a qu'un seul rôle disponible, il le sélectionne AWS CLI automatiquement et ignore l'invite.
```
Using the account ID 123456789011
There are 2 roles available to you.
> ReadOnly
FullAccess
```
1. Spécifiez le [format de sortie par défaut](cli-configure-files.md#cli-config-output), la [Région AWS par défaut](cli-configure-files.md#cli-config-region) à laquelle envoyer les commandes, ainsi qu’un [nom pour le profil](cli-configure-files.md). Si vous spécifiez `default` comme nom de profil, ce profil devient le profil par défaut utilisé. Dans l’exemple suivant, l’utilisateur entre une région par défaut, un format de sortie par défaut et le nom du profil.
```
Default client Region [None]: us-west-2
CLI default output format (json if not specified) [None]: json
Profile name [123456789011_ReadOnly]: my-dev-profile
```
1. Un message final décrit la configuration de profil terminée. Vous pouvez désormais utiliser ce profil pour demander des informations d’identification. Utilisez la commande `aws sso login` pour demander et extraire les informations d’identification temporaires nécessaires à l’exécution des commandes. Pour obtenir des instructions, consultez [Connexion à une session IAM Identity Center](#cli-configure-sso-login).
### Fichier de configuration généré
Ces étapes aboutissent à la création de la section `sso-session` et du profil nommé dans le fichier `config` qui se présente comme suit :
------
#### [ IAM Identity Center ]
```
[profile my-dev-profile]
sso_session = my-sso
sso_account_id = 123456789011
sso_role_name = readOnly
region = us-west-2
output = json
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_registration_scopes = sso:account:access
```
Pour le support à double pile :
```
[profile my-dev-profile]
sso_session = my-sso
sso_account_id = 123456789011
sso_role_name = readOnly
region = us-west-2
output = json
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
sso_registration_scopes = sso:account:access
```
------
#### [ Legacy IAM Identity Center ]
```
[profile my-dev-profile]
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_region = us-east-1
sso_account_id = 123456789011
sso_role_name = readOnly
region = us-west-2
output = json
```
Pour le support à double pile :
```
[profile my-dev-profile]
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
sso_region = us-east-1
sso_account_id = 123456789011
sso_role_name = readOnly
region = us-west-2
output = json
```
------
## Configuration uniquement de votre section `sso-session` à l’aide de l’assistant `aws configure sso-session`
**Note**
Cette configuration n’est pas compatible avec IAM Identity Center hérité.
La commande `aws configure sso-session` met à jour les sections `sso-session` dans le fichier `~/.aws/config`. Exécutez la `aws configure sso-session` commande et indiquez l'URL de démarrage ou l'URL de l'émetteur de votre IAM Identity Center, ainsi que la AWS région qui héberge le répertoire de l'IAM Identity Center.
```
$ aws configure sso-session
SSO session name: my-sso
SSO start URL [None]: https://my-sso-portal.awsapps.com/start
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
Pour la prise en charge de la double pile, utilisez l'URL de démarrage SSO à double pile :
```
$ aws configure sso-session
SSO session name: my-sso
SSO start URL [None]: https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
## Configuration manuelle à l’aide du fichier `config`
Les informations de configuration d’IAM Identity Center sont stockées dans le fichier `config` et elles peuvent être modifiées à l’aide d’un éditeur de texte. Pour ajouter manuellement la prise en charge d’IAM Identity Center dans un profil nommé, vous devez ajouter des clés et des valeurs au fichier `config`.
### Fichier de configuration IAM Identity Center
La `sso-session` section du `config` fichier est utilisée pour regrouper les variables de configuration permettant d'acquérir des jetons d'accès SSO, qui peuvent ensuite être utilisés pour acquérir des AWS informations d'identification. Les paramètres suivants sont utilisés :
+ **(Obligatoire)** `sso\$1start\$1url`
+ **(Obligatoire)** `sso\$1region`
+ `sso\$1account\$1id`
+ `sso\$1role\$1name`
+ `sso\$1registration\$1scopes`
Vous définissez une section `sso-session` et vous l’associez à un profil. Les paramètres `sso_region` et `sso_start_url` doivent être définis dans la section `sso-session`. Généralement, `sso_account_id` et `sso_role_name` doivent être définis dans la section `profile` afin que le kit SDK puisse demander des informations d’identification SSO.
L’exemple suivant configure le kit SDK pour demander des informations d’identification SSO et il prend en charge l’actualisation automatique des jetons :
```
[profile dev]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://my-sso-portal.awsapps.com/start
```
Pour la prise en charge de la double pile, utilisez le format d'URL de démarrage SSO à double pile :
```
[profile dev]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
```
Cela permet également de réutiliser les configurations `sso-session` dans plusieurs profils :
```
[profile dev]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[profile prod]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole2
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://my-sso-portal.awsapps.com/start
```
Pour la prise en charge de la double pile, utilisez le format d'URL de démarrage SSO à double pile :
```
[profile dev]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[profile prod]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole2
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
```
Cependant, `sso_account_id` et `sso_role_name` ne sont pas obligatoires pour tous les scénarios de configuration de jetons SSO. Si votre application utilise uniquement des AWS services qui prennent en charge l'authentification par porteur, les informations d' AWS identification traditionnelles ne sont pas nécessaires. L’authentification par jeton de porteur est un schéma d’authentification HTTP qui utilise des jetons de sécurité appelés jetons de porteur. Dans ce scénario, `sso_account_id` et `sso_role_name` ne sont pas obligatoires. Consultez le guide individuel de votre AWS service pour déterminer s'il prend en charge l'autorisation par jeton au porteur.
De plus, les portées d’enregistrement peuvent être configurées dans le cadre d’une `sso-session`. Scope est un mécanisme de la OAuth version 2.0 qui limite l'accès d'une application au compte d'un utilisateur. Une application peut demander une ou plusieurs portées, et le jeton d’accès émis pour l’application sera limité aux portées accordées. Ces portées définissent les autorisations demandées à accorder au client OIDC enregistré ainsi que les jetons d’accès que ce client obtient. L’exemple suivant définit `sso_registration_scopes` afin de fournir un accès permettant de répertorier les comptes et les rôles :
```
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_registration_scopes = sso:account:access
```
Pour le support à double pile :
```
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
sso_registration_scopes = sso:account:access
```
Le jeton d’authentification est mis en cache sur le disque sous le répertoire `sso/cache` avec un nom de fichier basé sur le nom de session.
### Fichier de configuration IAM Identity Center hérité
**Note**
L’actualisation automatique des jetons n’est pas prise en charge avec la configuration non actualisable héritée. Nous vous recommandons d’utiliser la configuration de jeton SSO.
Pour ajouter manuellement la prise en charge d’IAM Identity Center dans un profil nommé, vous devez ajouter les clés et valeurs suivantes à la définition de profil dans le fichier `config`.
+ `sso\$1start\$1url`
+ `sso\$1region`
+ `sso\$1account\$1id`
+ `sso\$1role\$1name`
Vous pouvez inclure toutes les autres clés et valeurs valides dans le fichier `.aws/config`. L’exemple suivant est un profil IAM Identity Center :
```
[profile my-sso-profile]
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_region = us-west-2
sso_account_id = 111122223333
sso_role_name = SSOReadOnlyRole
region = us-west-2
output = json
```
Pour le support à double pile :
```
[profile my-sso-profile]
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
sso_region = us-west-2
sso_account_id = 111122223333
sso_role_name = SSOReadOnlyRole
region = us-west-2
output = json
```
Pour exécuter des commandes, vous devez d’abord utiliser [Connexion à une session IAM Identity Center](#cli-configure-sso-login) afin de demander et d’obtenir vos informations d’identification temporaires.
Pour plus d’informations sur les fichiers `config` et `credentials`, consultez [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md).
## Connexion à une session IAM Identity Center
**Note**
Le processus de connexion peut vous demander d'autoriser l' AWS CLI accès à vos données. Étant donné que le AWS CLI est construit au-dessus du SDK pour Python, les messages d'autorisation peuvent contenir des variantes du `botocore` nom.
Pour récupérer et mettre en cache un jeu d’informations d’identification IAM Identity Center, exécutez la commande suivante pour l’ AWS CLI afin d’ouvrir votre navigateur par défaut et de vérifier votre connexion à IAM Identity Center.
```
$ aws sso login --profile my-dev-profile
SSO authorization page has automatically been opened in your default browser.
Follow the instructions in the browser to complete this authorization request.
Successfully logged into Start URL: https://my-sso-portal.awsapps.com/start
```
Les informations d'identification de votre session IAM Identity Center sont mises en cache et les AWS CLI utilisent pour récupérer en toute sécurité les AWS informations d'identification pour le rôle IAM spécifié dans le profil.
### Si vous ne AWS CLI parvenez pas à ouvrir votre navigateur
S'il n'est AWS CLI pas possible d'ouvrir automatiquement votre navigateur, les instructions pour démarrer manuellement le processus de connexion s'affichent en fonction du type d'autorisation que vous utilisez.
------
#### [ PKCE authorization ]
L'autorisation Proof Key for Code Exchange (PKCE) est utilisée par défaut à AWS CLI partir de la version 2.22.0. L'URL affichée est une URL unique commençant par :
+ IPv4: *https://oidc.us-east-1.amazonaws.com/authorize*
+ Double pile : *https://oidc.us-east-1.api.aws/authorize*
L'autorisation PKCE URLs doit être ouverte sur le même appareil que celui sur lequel vous vous connectez et doit être utilisée pour un appareil doté d'un navigateur.
```
Attempting to automatically open the SSO authorization page in your
default browser.
If the browser does not open or you wish to use a different device to
authorize the request, open the following URL:
https://oidc.us-east-1.amazonaws.com/authorize?
```
------
#### [ Device authorization ]
L'autorisation de l'appareil OAuth 2.0 est utilisée par AWS CLI les versions antérieures à 2.22.0. Vous pouvez activer cette méthode sur les versions plus récentes à l’aide de l’option `--use-device-code`.
L'autorisation de l'appareil URLs n'a pas besoin d'être ouverte sur le même appareil que celui sur lequel vous vous connectez et peut être utilisée pour un appareil avec ou sans navigateur.
```
If the browser does not open or you wish to use a different device to
authorize this request, open the following URL:
https://device.sso.us-west-2.amazonaws.com/
Then enter the code:
QCFK-N451
```
------
Vous pouvez également spécifier le profil `sso-session` à utiliser lors de la connexion à l’aide du paramètre `--sso-session` de la commande `aws sso login`. L’option `sso-session` n’est pas disponible pour IAM Identity Center hérité.
```
$ aws sso login --sso-session my-dev-session
```
À compter de la version 2.22.0, l’autorisation PKCE est la valeur par défaut. Pour utiliser l’autorisation d’appareil pour vous connecter, ajoutez l’option `--use-device-code`.
```
$ aws sso login --profile my-dev-profile --use-device-code
```
Le jeton d’authentification est mis en cache sur le disque sous le répertoire `~/.aws/sso/cache` avec un nom de fichier basé sur la valeur `sso_start_url`.
## Exécution d’une commande avec votre profil IAM Identity Center
Une fois connecté, vous pouvez utiliser vos informations d'identification pour appeler des AWS CLI commandes avec le profil nommé associé. L’exemple suivant montre une commande utilisant un profil :
```
$ aws sts get-caller-identity --profile my-dev-profile
```
Tant que vous êtes connecté à IAM Identity Center et que ces informations d'identification mises en cache n'ont pas expiré, les informations d'identification expirées sont AWS CLI automatiquement renouvelées en cas de besoin AWS . Toutefois, si vos informations d’identification IAM Identity Center expirent, vous devez les renouveler explicitement en vous connectant à nouveau à votre compte IAM Identity Center.
## Déconnexion de vos sessions IAM Identity Center
Lorsque vous avez terminé d’utiliser votre profil IAM Identity Center, vous pouvez laisser vos informations d’identification expirer ou exécuter la commande suivante pour supprimer vos informations d’identification mises en cache.
```
$ aws sso logout
Successfully signed out of all SSO profiles.
```
## Résolution des problèmes
Si vous rencontrez des problèmes lors de l'utilisation du AWS CLI, consultez les étapes [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md) de résolution des problèmes.
## Ressources connexes
Les ressources supplémentaires sont les suivantes.
+ [Concepts AWS IAM Identity Center pour l’AWS CLI](cli-configure-sso-concepts.md)
+ [Tutoriel : Utilisation d'IAM Identity Center pour exécuter des commandes Amazon S3 dans AWS CLI](cli-configure-sso-tutorial.md)
+ [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md)
+ [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md)
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html) dans la *Référence de l’AWS CLI version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html) dans la *Référence de l’AWS CLI version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/login.html](https://docs.aws.amazon.com/cli/latest/reference/sso/login.html) dans la *Référence de l’AWS CLI version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html](https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html) dans la *Référence de l’AWS CLI version 2*
+ [Configuration pour utiliser le AWS CLI with CodeCatalyst](https://docs.aws.amazon.com/codecatalyst/latest/userguide/set-up-cli.html) dans le *guide de CodeCatalyst l'utilisateur Amazon*
+ [OAuth Étendue d'accès 2.0 dans le](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) guide de l'utilisateur d'*IAM Identity Center*
+ [Didacticiels de démarrage](https://docs.aws.amazon.com/singlesignon/latest/userguide/tutorials.html) dans le *Guide de l’utilisateur IAM Identity Center*
# Concepts AWS IAM Identity Center pour l’AWS CLI
Cette rubrique décrit les concepts clés d’AWS IAM Identity Center (IAM Identity Center). IAM Identity Center est un service IAM basé sur le cloud qui simplifie la gestion de l’accès des utilisateurs à plusieurs Comptes AWS, kits SDK et outils en s’intégrant aux fournisseurs d’identité (IdP) existants. Il permet l’authentification unique sécurisée, la gestion des autorisations et l’audit via un portail utilisateur centralisé, rationalisant ainsi la gouvernance des identités et des accès pour les entreprises.
**Topics**
+ [Qu’est-ce que IAM Identity Center](#cli-configure-sso-concepts-what)
+ [Conditions](#cli-configure-sso-terms)
+ [Fonctionnement d’IAM Identity Center](#cli-configure-sso-concepts-process)
+ [Ressources supplémentaires](#cli-configure-sso-concepts-resources)
## Qu’est-ce que IAM Identity Center
IAM Identity Center est un service de gestion des identités et des accès (IAM) basé sur le cloud qui vous permet de gérer de manière centralisée l’accès à plusieurs Comptes AWS et applications professionnelles.
Il fournit un portail utilisateur où les utilisateurs autorisés peuvent accéder aux Comptes AWS et aux applications pour lesquels ils ont obtenu une autorisation, en utilisant leurs informations d’identification professionnelles existantes. Cela permet aux entreprises d’appliquer des politiques de sécurité cohérentes et de rationaliser la gestion des accès des utilisateurs.
Quel que soit l’IdP que vous utilisez, IAM Identity Center élimine ces distinctions. Par exemple, vous pouvez connecter Microsoft Azure AD comme décrit dans l’article de blog [The Next Evolution in IAM Identity Center](https://aws.amazon.com/blogs/aws/the-next-evolution-in-aws-single-sign-on/).
**Note**
Pour plus d’informations sur l’utilisation de l’authentification par jeton de porteur, qui n’utilise aucun ID de compte ni rôle, consultez [Configuration pour l’utilisation de l’AWS CLI avec CodeCatalyst](https://docs.aws.amazon.com/codecatalyst/latest/userguide/set-up-cli.html) dans le *Guide de l’utilisateur Amazon CodeCatalyst*.
## Conditions
Les termes courants utilisés lors de l’utilisation d’IAM Identity Center sont les suivants :
**Fournisseur d’identité (IdP)**
Un système de gestion des identités tel que IAM Identity Center, Microsoft Azure AD, Okta ou votre propre service d’annuaire d’entreprise.
**AWS IAM Identity Center**
IAM Identity Center est le service IdP détenu par AWS. Il était anciennement appelé Authentification unique AWS. Les kits SDK et les outils conservent les espaces de noms des API `sso` à des fins de rétrocompatibilité. Pour plus d’informations, consultez [IAM Identity Center rename](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html#renamed) dans le *Guide de l’utilisateur AWS IAM Identity Center*.
**URL Portail d'accès AWS, URL de démarrage SSO, URL de démarrage**
URL IAM Identity Center unique de votre organisation pour accéder à vos Comptes AWS, services et ressources autorisés.
**URL de l’émetteur**
URL de l’émetteur IAM Identity Center unique de votre organisation pour un accès par programmation à vos Comptes AWS, services et ressources autorisés. À compter de la version 2.22.0 de l’AWS CLI, l’URL de l’émetteur peut être utilisée de manière interchangeable avec l’URL de démarrage.
**Fédération**
Processus qui consiste à établir un lien de confiance entre IAM Identity Center et un fournisseur d’identité pour activer l’authentification unique (SSO).
**Comptes AWS**
Comptes AWS dont vous autorisez l’accès aux utilisateurs via AWS IAM Identity Center.
**Jeu d’autorisations, informations d’identification AWS, informations d’identification, informations d’identification sigv4**
Collections prédéfinies d’autorisations qui peuvent être attribuées à des utilisateurs ou à des groupes afin de leur accorder l’accès aux Services AWS.
**Portées d’enregistrement, portées d’accès, portées**
Les portées sont un mécanisme OAuth 2.0 permettant de limiter l’accès d’une application au compte d’un utilisateur. Une application peut demander une ou plusieurs portées, et le jeton d’accès émis pour l’application est limité aux portées accordées. Pour plus d’informations sur les portées, consultez [Portées des accès](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) dans le *Guide de l’utilisateur IAM Identity Center*.
**Jetons, jeton d’actualisation, jeton d’accès**
Les jetons sont des informations d’identification temporaires qui vous sont délivrés lors de l’authentification. Ces jetons contiennent des informations sur votre identité et les autorisations qui vous ont été accordées.
Lorsque vous accédez à une ressource ou à une application AWS via le portail IAM Identity Center, votre jeton est présenté à AWS à des fins d’authentification et d’autorisation. Cela permet à AWS de vérifier votre identité et de vérifier que vous disposez des autorisations nécessaires pour exécuter les actions demandées.
Le jeton d’authentification est mis en cache sur le disque sous le répertoire `~/.aws/sso/cache` avec un nom de fichier JSON basé sur le nom de session.
**Session**
Une session IAM Identity Center fait référence à la période pendant laquelle un utilisateur est authentifié et autorisé à accéder à des ressources ou à des applications AWS. Lorsqu’un utilisateur se connecte au portail IAM Identity Center, une session est établie et le jeton de l’utilisateur est valide pendant une durée spécifiée. Pour plus d’informations sur la définition des durées de session, consultez [Définir la durée de la session](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html) dans le *Guide de l’utilisateur AWS IAM Identity Center*.
Au cours de la session, vous pouvez naviguer entre différents comptes et applications AWS sans avoir à vous authentifier à nouveau, tant que leur session reste active. Lorsque la session expire, reconnectez-vous pour renouveler votre accès.
Les sessions IAM Identity Center contribuent à offrir une expérience utilisateur fluide tout en appliquant les meilleures pratiques de sécurité en limitant la validité des informations d’identification des utilisateurs.
**Octroi de code d’autorisation avec PKCE, PKCE, Proof Key for Code Exchange**
À compter de la version 2.22.0, PKCE (Proof Key for Code Exchange) est un flux d’autorisation d’authentification OAuth 2.0 pour les appareils dotés d’un navigateur. PKCE est un moyen simple et sûr de vous authentifier et d’obtenir le consentement pour accéder à vos ressources AWS à partir d’ordinateurs de bureau et d’appareils mobiles équipés de navigateurs Web. Il s’agit du comportement d’autorisation par défaut. Pour plus d’informations sur PKCE, consultez [Octroi de code d’autorisation avec PKCE](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#auth-code-grant-pkce) dans le *Guide de l’utilisateur AWS IAM Identity Center*.
**Octroi d’autorisation d’appareil**
Un flux d’autorisation d’authentification OAuth 2.0 pour les appareils avec ou sans navigateur Web. Pour plus d’informations sur la définition des durées de session, consultez [Octroi d’autorisation d’appareil](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#device-auth-grant) dans le *Guide de l’utilisateur AWS IAM Identity Center*.
## Fonctionnement d’IAM Identity Center
IAM Identity Center s’intègre au fournisseur d’identité de votre organisation, tel que IAM Identity Center, Microsoft Azure AD ou Okta. Les utilisateurs s’authentifient auprès de ce fournisseur d’identité, et IAM Identity Center associe ensuite ces identités aux autorisations et aux accès appropriés au sein de votre environnement AWS.
Le flux de travail IAM Identity Center suivant suppose que vous avez déjà configuré votre AWS CLI pour utiliser IAM Identity Center :
1. Dans votre terminal préféré, exécutez la commande `aws sso login`.
1. Connectez-vous à votre Portail d'accès AWS pour démarrer une nouvelle session.
+ Lorsque vous démarrez une nouvelle session, vous recevez un jeton d’actualisation et un jeton d’accès mis en cache.
+ Si vous avez déjà une session active, la session existante est réutilisée et expire en même temps que la session existante.
1. Sur la base du profil que vous avez défini dans votre fichier `config`, IAM Identity Center utilise les jeux d’autorisations appropriés, en accordant l’accès aux Comptes AWS et aux applications pertinents.
1. L’AWS CLI, les kits SDK et les outils utilisent votre rôle IAM assumé pour effectuer des appels aux Services AWS, notamment pour demander la création de compartiments Amazon S3 jusqu’à l’expiration de cette session.
1. Le jeton d’accès d’IAM Identity Center est vérifié toutes les heures et est automatiquement actualisé à l’aide du jeton d’actualisation.
+ Si le jeton d’accès a expiré, le kit SDK ou l’outil utilise le jeton d’actualisation pour obtenir un nouveau jeton d’accès. Les durées de session de ces jetons sont ensuite comparées, et si le jeton d’actualisation n’a pas expiré, IAM Identity Center fournit un nouveau jeton d’accès.
+ Si le jeton d’actualisation a expiré, aucun nouveau jeton d’accès n’est fourni et votre session est terminée.
1. Les sessions se terminent après l’expiration des jetons d’actualisation ou lorsque vous vous déconnectez manuellement à l’aide de la commande `aws sso logout`. Les informations d’identification mises en cache sont supprimées. Pour continuer à accéder aux services via IAM Identity Center, vous devez démarrer une nouvelle session à l’aide de la commande `aws sso login`.
## Ressources supplémentaires
Les ressources supplémentaires sont les suivantes.
+ [Configuration de l'authentification IAM Identity Center à l'aide du AWS CLI](cli-configure-sso.md)
+ [Tutoriel : Utilisation d'IAM Identity Center pour exécuter des commandes Amazon S3 dans AWS CLI](cli-configure-sso-tutorial.md)
+ [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md)
+ [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md)
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html) dans la *Référence de l’AWS CLI version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html) dans la *Référence de l’AWS CLI version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/login.html](https://docs.aws.amazon.com/cli/latest/reference/sso/login.html) dans la *Référence de l’AWS CLI version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html](https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html) dans la *Référence de l’AWS CLI version 2*
+ [Configuration pour utiliser l’AWS CLI avec CodeCatalyst dans le *Guide de l’utilisateur Amazon CodeCatalyst*](https://docs.aws.amazon.com/codecatalyst/latest/userguide/set-up-cli.html)
+ [IAM Identity Center rename](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html#renamed) dans le *Guide de l’utilisateur AWS IAM Identity Center*
+ [Portées des accès OAuth 2.0](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) dans le *Guide de l’utilisateur IAM Identity Center*
+ [Définir la durée de la session](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosessionduration.html) dans le *Guide de l’utilisateur AWS IAM Identity Center*
+ [Didacticiels de démarrage](https://docs.aws.amazon.com/singlesignon/latest/userguide/tutorials.html) dans le *Guide de l’utilisateur IAM Identity Center*
# Tutoriel : Utilisation d'IAM Identity Center pour exécuter des commandes Amazon S3 dans AWS CLI
Cette rubrique décrit comment configurer les commandes AWS CLI pour authentifier les utilisateurs auprès de Current AWS IAM Identity Center (IAM Identity Center) afin de récupérer les informations d'identification pour exécuter AWS Command Line Interface (AWS CLI) les commandes Amazon Simple Storage Service (Amazon S3).
**Topics**
+ [Étape 1 : authentification dans IAM Identity Center](#cli-configure-sso-tutorial-authentication)
+ [Étape 2 : recueil des informations d’IAM Identity Center](#cli-configure-sso-tutorial-gather)
+ [Étape 3 : création de compartiments Amazon S3](#cli-configure-sso-tutorial-buckets)
+ [Étape 4 : Installation du AWS CLI](#cli-configure-sso-tutorial-install)
+ [Étape 5 : Configuration de votre AWS CLI profil](#cli-configure-sso-tutorial-configure)
+ [Étape 6 : connexion à IAM Identity Center](#cli-configure-sso-tutorial-login.title)
+ [Étape 7 : exécution de commandes Amazon S3](#cli-configure-sso-tutorial-commands)
+ [Étape 8 : déconnexion d’IAM Identity Center](#cli-configure-sso-tutorial-logout)
+ [Étape 9 : nettoyage des ressources](#cli-configure-sso-tutorial-cleanup)
+ [Résolution des problèmes](#cli-configure-sso-tutorial-tshoot)
+ [Ressources supplémentaires](#cli-configure-sso-tutorial-resources.title)
## Étape 1 : authentification dans IAM Identity Center
Obtenez accès à l’authentification SSO dans IAM Identity Center. Choisissez l'une des méthodes suivantes pour accéder à vos AWS informations d'identification.
### Je ne dispose pas d’un accès établi via IAM Identity Center
Suivez les instructions de [Mise en route](https://docs.aws.amazon.com/singlesignon/latest/userguide/getting-started.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *. Ce processus active IAM Identity Center, crée un utilisateur administratif et ajoute un jeu d’autorisations de moindre privilège approprié.
**Note**
Créez un jeu d’autorisations qui applique les autorisations de moindre privilège. Nous vous recommandons d’utiliser le jeu d’autorisations `PowerUserAccess` prédéfini, sauf si votre employeur a créé un jeu d’autorisations personnalisé à cette fin.
Quittez le portail et reconnectez-vous pour voir vos Comptes AWS informations d'accès programmatiques et les options pour `Administrator` ou`PowerUserAccess`. Sélectionnez `PowerUserAccess` lorsque vous utilisez le kit SDK.
### J'y ai déjà accès AWS via un fournisseur d'identité fédéré géré par mon employeur (tel qu'Azure AD ou Okta)
Connectez-vous AWS via le portail de votre fournisseur d'identité. Si votre administrateur cloud vous a accordé des autorisations `PowerUserAccess` (de développeur), vous voyez Comptes AWS celles auxquelles vous avez accès et votre ensemble d'autorisations. En regard du nom de votre jeu d’autorisations, vous pouvez voir des options permettant d’accéder aux comptes manuellement ou par programmation à l’aide de ce jeu d’autorisations.
Les implémentations personnalisées peuvent entraîner des expériences différentes, telles que des noms de jeux d’autorisations différents. Si vous avez des doutes sur le jeu d’autorisations à utiliser, contactez votre équipe informatique pour obtenir de l’aide.
### J'y ai déjà accès AWS via le portail AWS d'accès géré par mon employeur
Connectez-vous AWS via votre portail AWS d'accès. Si votre administrateur cloud vous a accordé des autorisations `PowerUserAccess` (de développeur), vous voyez Comptes AWS celles auxquelles vous avez accès et votre ensemble d'autorisations. En regard du nom de votre jeu d’autorisations, vous pouvez voir des options permettant d’accéder aux comptes manuellement ou par programmation à l’aide de ce jeu d’autorisations.
### J'y ai déjà accès AWS via un fournisseur d'identité personnalisé fédéré géré par mon employeur
Contactez votre équipe informatique pour obtenir de l’aide.
## Étape 2 : recueil des informations d’IAM Identity Center
Après avoir obtenu l'accès à AWS, collectez les informations de votre centre d'identité IAM en effectuant les opérations suivantes :
1. Recueillez les valeurs `SSO Start URL` et `SSO Region` dont vous avez besoin pour exécuter `aws configure sso`
1. Dans votre portail AWS d'accès, sélectionnez l'ensemble d'autorisations que vous utilisez pour le développement, puis cliquez sur le lien **Clés d'accès**.
1. Dans la boîte de dialogue **Obtenir des informations d’identification**, choisissez l’onglet correspondant à votre système d’exploitation.
1. Choisissez la méthode **Informations d’identification IAM Identity Center** pour obtenir les valeurs `SSO Start URL` et `SSO Region`.
1. À compter de la version 2.22.0, vous pouvez également utiliser la nouvelle URL de l’émetteur au lieu de l’URL de démarrage. L'URL de l'émetteur se trouve dans la AWS IAM Identity Center console à l'un des emplacements suivants :
+ Sur la page **Tableau de bord**, l’URL de l’émetteur se trouve dans le récapitulatif des paramètres.
+ Sur la page **Paramètres**, l’URL de l’émetteur se trouve dans les paramètres de la **source d’identité**.
1. Pour plus d'informations sur la valeur d'étendue à enregistrer, consultez la section Étendue [d'accès OAuth 2.0 dans le guide](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) de l'utilisateur d'*IAM Identity Center*.
## Étape 3 : création de compartiments Amazon S3
Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
Pour ce didacticiel, créez quelques compartiments à extraire ultérieurement dans une liste.
## Étape 4 : Installation du AWS CLI
Installez les instructions AWS CLI suivantes pour votre système d'exploitation. Pour de plus amples informations, veuillez consulter [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md).
Une fois l’installation terminée, vous pouvez vérifier l’installation en ouvrant le terminal de votre choix et en exécutant la commande suivante. Cela devrait afficher la version que vous avez installée du AWS CLI.
```
$ aws --version
```
## Étape 5 : Configuration de votre AWS CLI profil
Configurez votre profil à l’aide d’une des méthodes suivantes.
### Configuration de votre profil à l’aide de l’assistant `aws configure sso`
La `sso-session` section du `config` fichier est utilisée pour regrouper les variables de configuration permettant d'acquérir des jetons d'accès SSO, qui peuvent ensuite être utilisés pour acquérir des AWS informations d'identification. Les paramètres suivants sont utilisés :
+ **(Obligatoire)** `sso\$1start\$1url`
+ **(Obligatoire)** `sso\$1region`
+ `sso\$1account\$1id`
+ `sso\$1role\$1name`
+ `sso\$1registration\$1scopes`
Vous définissez une section `sso-session` et vous l’associez à un profil. Les paramètres `sso_region` et `sso_start_url` doivent être définis dans la section `sso-session`. Généralement, `sso_account_id` et `sso_role_name` doivent être définis dans la section `profile` afin que le kit SDK puisse demander des informations d’identification SSO.
L’exemple suivant configure le kit SDK pour demander des informations d’identification SSO et il prend en charge l’actualisation automatique des jetons :
```
$ aws configure sso
SSO session name (Recommended): my-sso
SSO start URL [None]: https://my-sso-portal.awsapps.com/start
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
Pour la prise en charge de la double pile, vous pouvez utiliser le format d'URL de démarrage SSO à double pile :
```
$ aws configure sso
SSO session name (Recommended): my-sso
SSO start URL [None]: https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
SSO region [None]: us-east-1
SSO registration scopes [None]: sso:account:access
```
L’autorisation PKCE (Proof Key for Code Exchange) est utilisée par défaut pour l’ AWS CLI à compter de la version 2.22.0 et elle doit être utilisée sur les appareils disposant d’un navigateur. Pour continuer à utiliser l’autorisation d’appareil, ajoutez l’option `--use-device-code`.
```
$ aws configure sso --use-device-code
```
### Configuration manuelle à l’aide du fichier `config`
La `sso-session` section du `config` fichier est utilisée pour regrouper les variables de configuration permettant d'acquérir des jetons d'accès SSO, qui peuvent ensuite être utilisés pour acquérir des AWS informations d'identification. Les paramètres suivants sont utilisés :
+ **(Obligatoire)** `sso\$1start\$1url`
+ **(Obligatoire)** `sso\$1region`
+ `sso\$1account\$1id`
+ `sso\$1role\$1name`
+ `sso\$1registration\$1scopes`
Vous définissez une section `sso-session` et vous l’associez à un profil. `sso_region` et `sso_start_url` doivent être définis dans la section `sso-session`. Généralement, `sso_account_id` et `sso_role_name` doivent être définis dans la section `profile` afin que le kit SDK puisse demander des informations d’identification SSO.
L’exemple suivant configure le kit SDK pour demander des informations d’identification SSO et il prend en charge l’actualisation automatique des jetons :
```
[profile my-dev-profile]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_registration_scopes = sso:account:access
```
Pour la prise en charge de la double pile, utilisez le format d'URL de démarrage SSO à double pile :
```
[profile my-dev-profile]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = SampleRole
[sso-session my-sso]
sso_region = us-east-1
sso_start_url = https://ssoins-1234567890abcdef.portal.us-east-1.app.aws
sso_registration_scopes = sso:account:access
```
Le jeton d’authentification est mis en cache sur le disque sous le répertoire `~/.aws/sso/cache` avec un nom de fichier basé sur le nom de session.
## Étape 6 : connexion à IAM Identity Center
**Note**
Le processus de connexion peut vous demander d'autoriser l' AWS CLI accès à vos données. Étant donné que le AWS CLI est construit au-dessus du SDK pour Python, les messages d'autorisation peuvent contenir des variantes du `botocore` nom.
Pour récupérer et mettre en cache vos informations d’identification IAM Identity Center, exécutez la commande suivante pour l’ AWS CLI afin d’ouvrir votre navigateur par défaut et de vérifier votre connexion à IAM Identity Center.
```
$ aws sso login --profile my-dev-profile
```
À compter de la version 2.22.0, l’autorisation PKCE est la valeur par défaut. Pour utiliser l’autorisation d’appareil pour vous connecter, ajoutez l’option `--use-device-code`.
```
$ aws sso login --profile my-dev-profile --use-device-code
```
## Étape 7 : exécution de commandes Amazon S3
Pour répertorier les compartiments que vous avez créés précédemment, utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html). L’exemple suivant répertorie tous les compartiments Amazon S3.
```
$ aws s3 ls
2018-12-11 17:08:50 my-bucket
2018-12-14 14:55:44 my-bucket2
```
## Étape 8 : déconnexion d’IAM Identity Center
Lorsque vous avez terminé d’utiliser votre profil IAM Identity Center, exécutez la commande suivante pour supprimer vos informations d’identification mises en cache.
```
$ aws sso logout
Successfully signed out of all SSO profiles.
```
## Étape 9 : nettoyage des ressources
Une fois ce didacticiel terminé, nettoyez toutes les ressources que vous avez créées au cours de ce didacticiel dont vous n’avez plus besoin, y compris les compartiments Amazon S3.
## Résolution des problèmes
Si vous rencontrez des problèmes lors de l'utilisation du AWS CLI, consultez [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md) les étapes de dépannage les plus courantes.
## Ressources supplémentaires
Les ressources supplémentaires sont les suivantes.
+ [Concepts AWS IAM Identity Center pour l’AWS CLI](cli-configure-sso-concepts.md)
+ [Configuration de l'authentification IAM Identity Center à l'aide du AWS CLI](cli-configure-sso.md)
+ [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md)
+ [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md)
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso.html) dans la *Référence de l’AWS CLI version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html](https://docs.aws.amazon.com/cli/latest/reference/configure/sso-session.html) dans la *Référence de l’AWS CLI version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/login.html](https://docs.aws.amazon.com/cli/latest/reference/sso/login.html) dans la *Référence de l’AWS CLI version 2*
+ [https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html](https://docs.aws.amazon.com/cli/latest/reference/sso/logout.html) dans la *Référence de l’AWS CLI version 2*
+ [Configuration pour utiliser le AWS CLI with CodeCatalyst](https://docs.aws.amazon.com/codecatalyst/latest/userguide/set-up-cli.html) dans le *guide de CodeCatalyst l'utilisateur Amazon*
+ [OAuth Étendue d'accès 2.0 dans le](https://docs.aws.amazon.com/singlesignon/latest/userguide/customermanagedapps-saml2-oauth2.html#oidc-concept) guide de l'utilisateur d'*IAM Identity Center*
+ [Didacticiels de démarrage](https://docs.aws.amazon.com/singlesignon/latest/userguide/tutorials.html) dans le *Guide de l’utilisateur IAM Identity Center*
# Authentification à l'aide d'informations d'identification à court terme pour AWS CLI
Nous vous recommandons de configurer votre kit SDK ou votre outil pour utiliser l’[authentification IAM Identity Center](https://docs.aws.amazon.com/sdkref/latest/guide/access-sso.html) avec des options d’extension de la durée des sessions. Toutefois, vous pouvez copier et utiliser les informations d'identification temporaires disponibles sur le portail AWS d'accès. De nouvelles informations d’identification devront être copiées à leur expiration. 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.
1. [Connectez-vous au portail d' AWS accès](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtosignin.html).
1. Suivez [ces instructions](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtogetcredentials.html) pour copier les informations d'identification du rôle IAM depuis le portail AWS d'accès.
1. Pour l'étape 2 des instructions associées, choisissez le AWS compte et le nom du rôle IAM qui accordent l'accès pour vos besoins de développement. Ce rôle porte généralement un nom tel que **PowerUserAccess**« **Développeur** ».
1. Pour l’étape 4, sélectionnez l’option **Ajouter un profil à votre fichier d’informations d’identification AWS ** et copiez le contenu.
1. Créez ou ouvrez le fichier `credentials` partagé. Ce fichier est `~/.aws/credentials` sous Linux et macOS, et `%USERPROFILE%\.aws\credentials` sous Windows. Pour de plus amples informations, veuillez consulter [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md).
1. Ajoutez le texte suivant au fichier `credentials` partagé. Remplacez les exemples de valeurs par les informations d’identification que vous avez copiées.
```
[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
1. Ajoutez la région et le format par défaut de votre choix au fichier `config` partagé.
```
[default]
region=us-west-2
output=json
[profile user1]
region=us-east-1
output=text
```
Lorsque le kit SDK 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 2a 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.
Répétez ces étapes chaque fois que vos informations d’identification expirent.
# Utilisation d'un rôle IAM dans AWS CLI
Un [rôle Gestion des identités et des accès AWS (IAM)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) est un outil d'autorisation qui permet à un utilisateur d'obtenir des autorisations supplémentaires (ou différentes), ou d'obtenir des autorisations pour effectuer des actions dans un autre AWS compte.
**Topics**
+ [Conditions préalables](#cli-role-prereqs)
+ [Présentation de l’utilisation des rôles IAM](#cli-role-overview)
+ [Configuration et utilisation d’un rôle](#cli-role-prepare)
+ [Utilisation de l’authentification multifactorielle](#cli-configure-role-mfa)
+ [Rôles entre comptes et ID externe](#cli-configure-role-xaccount)
+ [Spécification d’un nom de session de rôle pour faciliter l’audit](#cli-configure-role-session-name)
+ [Utilisation d’un rôle à l’aide d’une identité web](#cli-configure-role-oidc)
+ [Suppression des informations d’identification mises en cache](#cli-configure-role-cache)
## Conditions préalables
Pour utiliser les commandes `iam`, vous devez installer et configurer l’ AWS CLI. Cela inclut la configuration d’un profil configuré, en supposant qu’un rôle soit associé à une autre méthode d’informations d’identification. Pour plus d’informations, consultez [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md).
## Présentation de l’utilisation des rôles IAM
Vous pouvez configurer le AWS Command Line Interface (AWS CLI) pour utiliser un rôle IAM en définissant un profil pour le rôle dans le `~/.aws/config` fichier.
L’exemple suivant illustre un profil de rôle nommé `marketingadmin`. Si vous exécutez des commandes avec `--profile marketingadmin` (ou si vous le spécifiez avec la [variable d'AWS\$1PROFILE environnement](cli-configure-envvars.md)), AWS CLI utilise les informations d'identification définies dans un profil distinct `user1` pour assumer le rôle avec l'Amazon Resource Name (ARN)`arn:aws:iam::123456789012:role/marketingadminrole`. Vous pouvez exécuter toutes les opérations permises par les autorisations affectées à ce rôle.
```
[profile marketingadmin]
role_arn = arn:aws:iam::123456789012:role/marketingadminrole
source_profile = user1
```
Vous pouvez ensuite spécifier un `source_profile` qui pointe sur un profil nommé séparé qui contient les informations d’identification de l’utilisateur avec l’autorisation d’utiliser ce rôle. Dans l’exemple précédent, le profil `marketingadmin` utilise les informations d’identification du profil `user1`. Lorsque vous spécifiez qu'une AWS CLI commande doit utiliser le profil`marketingadmin`, elle recherche AWS CLI automatiquement les informations d'identification du `user1` profil lié et les utilise pour demander des informations d'identification temporaires pour le rôle IAM spécifié. Pour ce faire, la CLI utilise l'AssumeRoleopération [sts :](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html) en arrière-plan. Ces informations d’identification temporaires sont ensuite utilisées pour exécuter la commande d’ AWS CLI demandée. Le rôle spécifié doit être associé à des politiques d'autorisation IAM autorisant l'exécution de la AWS CLI commande demandée.
Pour exécuter une AWS CLI commande depuis une instance Amazon Elastic Compute Cloud (Amazon EC2) ou un conteneur Amazon Elastic Container Service (Amazon ECS), vous pouvez utiliser un rôle IAM associé au profil d'instance ou au conteneur. Si vous ne spécifiez aucun profil ni ne définissez aucune variable d’environnement, ce rôle est utilisé directement. Cela vous permet d’éviter de stocker des clés d’accès à longue durée de vie sur vos instances. Vous pouvez également utiliser ces rôles d’instance ou de conteneur uniquement pour obtenir les informations d’identification d’un autre rôle. Pour ce faire, vous devez utiliser `credential_source` (au lieu de `source_profile`) pour spécifier comment trouver les informations d’identification. L’attribut `credential_source` prend en charge les valeurs suivantes :
+ `Environment` : extrait les informations d’identification source à partir des variables d’environnement.
+ `Ec2InstanceMetadata` : utilise le rôle IAM attaché au profil d’instance Amazon EC2.
+ `EcsContainer` : utilise le rôle IAM attaché au conteneur Amazon ECS.
L’exemple suivant illustre le même rôle `marketingadminrole` utilisé en référençant un profil d’instance Amazon EC2.
```
[profile marketingadmin]
role_arn = arn:aws:iam::123456789012:role/marketingadminrole
credential_source = Ec2InstanceMetadata
```
Lorsque vous invoquez un rôle, vous disposez d’options supplémentaires dont vous pouvez avoir besoin, telles que l’utilisation d’une authentification multifactorielle et d’un ID externe (utilisé par des sociétés tierces pour accéder aux ressources de leurs clients). Vous pouvez également spécifier des noms de session de rôle uniques qui peuvent être audités plus facilement dans AWS CloudTrail les journaux.
## Configuration et utilisation d’un rôle
Lorsque vous exécutez des commandes à l'aide d'un profil qui spécifie un rôle IAM, il AWS CLI utilise les informations d'identification du profil source pour appeler AWS Security Token Service (AWS STS) et demander des informations d'identification temporaires pour le rôle spécifié. L’utilisateur dans le profil source doit avoir l’autorisation d’appeler `sts:assume-role` pour le rôle dans le profil spécifié. Le rôle doit avoir une relation d’approbation qui permet à l’utilisateur dans le profil source d’utiliser le rôle. Le processus de récupération, puis d’utilisation d’informations d’identification temporaires pour un rôle revient à *assumer le rôle*.
Vous pouvez créer un rôle dans IAM avec les autorisations que vous souhaitez que les utilisateurs endossent en suivant la procédure [Création d’un rôle pour déléguer des autorisations à un utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) dans le *Guide de l’utilisateur Gestion des identités et des accès AWS *. Si le rôle et l’utilisateur du profil source sont dans le même compte, vous pouvez entrer votre propre ID de compte lors de la configuration de la relation de confiance du rôle.
Une fois le rôle créé, modifiez la relation de confiance afin d’autoriser l’utilisateur à assumer ce rôle.
L’exemple suivant illustre une politique d’approbation que vous pouvez attacher à un rôle. Cette politique autorise le rôle à être assumé par n’importe quel utilisateur dans le compte 123456789012 ***si*** l’administrateur de ce compte accorde explicitement l’autorisation `sts:AssumeRole` à l’utilisateur.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:root"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
La politique d’approbation n’accorde pas réellement d’autorisations. L’administrateur du compte doit déléguer l’autorisation d’assumer le rôle à des utilisateurs individuels en associant une politique aux autorisations appropriées. L’exemple suivant illustre une politique que vous pouvez attacher à un utilisateur et qui permet à l’utilisateur d’assumer uniquement le rôle `marketingadminrole`. Pour plus d’informations sur l’octroi d’un accès utilisateur pour assumer un rôle, consultez [Octroi d’autorisations à un utilisateur pour assumer un rôle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_permissions-to-switch.html) dans le *Guide de l’utilisateur IAM*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::123456789012:role/marketingadminrole"
}
]
}
```
------
L'utilisateur n'a pas besoin d'autorisations supplémentaires pour exécuter les AWS CLI commandes à l'aide du profil de rôle. Au lieu de cela, les autorisations pour exécuter la commande proviennent de celles qui sont attachées au *rôle*. Vous associez des politiques d'autorisation au rôle pour spécifier quelles actions peuvent être effectuées sur quelles AWS ressources. Pour plus d’informations sur l’attachement d’autorisations à un rôle (qui fonctionne de manière identique à un utilisateur), consultez [Modification des autorisations pour un utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html) dans le *Guide de l’utilisateur IAM*.
Maintenant que vous avez correctement configuré le profil de rôle, les autorisations de rôle, la relation d’approbation du rôle et les autorisations utilisateur, vous pouvez utiliser ce rôle au niveau de la ligne de commande en appelant l’option `--profile`. Par exemple, ce qui suit appelle la commande `ls` d’Amazon S3 en utilisant les autorisations attachées au rôle `marketingadmin`, tel que défini par l’exemple au début de cette rubrique.
```
$ aws s3 ls --profile marketingadmin
```
Si vous souhaitez utiliser le rôle pour plusieurs appels, vous pouvez définir la variable d’environnement `AWS_PROFILE` pour la session en cours à partir de la ligne de commande. Lorsque cette variable d’environnement est définie, vous n’avez pas besoin de spécifier l’option `--profile` pour chaque commande.
**Linux ou macOS**
```
$ export AWS_PROFILE=marketingadmin
```
**Windows**
```
C:\> setx AWS_PROFILE marketingadmin
```
Pour plus d’informations sur la configuration des utilisateurs et des rôles, consultez [Identités IAM (utilisateurs, groupes d’utilisateurs et rôles)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html) et [Rôles IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id-roles.html) dans le *Guide de l’utilisateur IAM*.
## Utilisation de l’authentification multifactorielle
Pour une sécurité accrue, vous pouvez exiger que les utilisateurs fournissent une clé à usage unique générée à partir d’un périphérique d’authentification multifactorielle (MFA), d’un appareil U2F ou d’une application mobile lorsqu’ils essaient d’effectuer un appel en utilisant le profil de rôle.
Tout d’abord, vous pouvez choisir de modifier la relation d’approbation sur le rôle IAM pour exiger une authentification MFA. De cette façon, aucun utilisateur ne peut utiliser le rôle sans l’authentification MFA. Pour obtenir un exemple, consultez la ligne `Condition` dans l’exemple suivant. Cette politique permet à l’utilisateur nommé `anika` d’assumer le rôle auquel la politique est attachée, mais uniquement s’il s’authentifie à l’aide de l’authentification MFA.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::123456789012:user/anika" },
"Action": "sts:AssumeRole",
"Condition": { "Bool": { "aws:multifactorAuthPresent": true } }
}
]
}
```
------
Ajoutez ensuite une ligne au profil de rôle qui spécifie l’ARN du périphérique MFA de l’utilisateur. L’exemple de fichier `config` suivant montre deux profils de rôle qui utilisent tous deux les clés d’accès pour l’utilisateur `anika` afin de demander des informations d’identification temporaires pour le rôle `cli-role`. L’utilisateur `anika` dispose des autorisations requises pour assumer le rôle, accordées par la politique d’approbation du rôle.
```
[profile role-without-mfa]
region = us-west-2
role_arn= arn:aws:iam::128716708097:role/cli-role
source_profile=cli-user
[profile role-with-mfa]
region = us-west-2
role_arn= arn:aws:iam::128716708097:role/cli-role
source_profile = cli-user
mfa_serial = arn:aws:iam::128716708097:mfa/cli-user
[profile cli-user]
region = us-west-2
output = json
```
Le paramètre `mfa_serial` peut utiliser un ARN, comme indiqué, ou le numéro de série d’un jeton MFA matériel.
Le premier profil, `role-without-mfa`, ne nécessite pas d’authentification MFA. Cependant, étant donné que l’exemple précédent de politique d’approbation attachée au rôle exige l’authentification MFA, toute tentative d’exécuter une commande avec ce profil échoue.
```
$ aws iam list-users --profile role-without-mfa
An error occurred (AccessDenied) when calling the AssumeRole operation: Access denied
```
La deuxième entrée de profil, `role-with-mfa`, identifie un périphérique MFA à utiliser. Lorsque l'utilisateur tente d'exécuter une AWS CLI commande avec ce profil, il est AWS CLI invité à saisir le mot de passe à usage unique (OTP) fourni par le dispositif MFA. Si l’authentification MFA réussit, la commande exécute l’opération demandée. L’OTP ne s’affiche pas à l’écran.
```
$ aws iam list-users --profile role-with-mfa
Enter MFA code for arn:aws:iam::123456789012:mfa/cli-user:
{
"Users": [
{
...
```
## Rôles entre comptes et ID externe
Vous pouvez permettre aux utilisateurs d’utiliser des rôles qui appartiennent à différents comptes en configurant le rôle en tant que rôle entre comptes. Lors de la création du rôle, définissez le type de rôle sur **Autre compte AWS **, comme décrit dans [Création d’un rôle pour déléguer des autorisations à un utilisateur IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html). Le cas échéant, sélectionnez **MFA obligatoire**. L’option **MFA obligatoire** configure la condition appropriée dans la relation de confiance comme décrit dans la section [Utilisation de l’authentification multifactorielle](#cli-configure-role-mfa).
Si vous utilisez un [ID externe](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html) pour accorder un contrôle supplémentaire aux personnes susceptibles d’utiliser un rôle entre les comptes, vous devez ajouter le paramètre `external_id` au profil de rôle. Généralement, vous utilisez uniquement cette option lorsque l’autre compte est contrôlé par une personne qui ne fait pas partie de votre entreprise ou organisation.
```
[profile crossaccountrole]
role_arn = arn:aws:iam::234567890123:role/SomeRole
source_profile = default
mfa_serial = arn:aws:iam::123456789012:mfa/saanvi
external_id = 123456
```
## Spécification d’un nom de session de rôle pour faciliter l’audit
Lorsque de nombreuses personnes partagent un rôle, la vérification devient plus difficile. Vous souhaitez associer chaque opération appelée à la personne à l’origine de cet appel. Toutefois, lorsque la personne utilise un rôle, la prise en charge du rôle est une action distincte de l’appel d’une opération, et vous devez corréler les deux manuellement.
Vous pouvez simplifier cela en spécifiant des noms de session de rôle uniques lorsque les utilisateurs assument un rôle. Pour ce faire, vous devez ajouter un paramètre `role_session_name` à chaque profil nommé dans le fichier `config` qui spécifie un rôle. La valeur de `role_session_name` est transmise à l’opération `AssumeRole` et devient partie intégrante de l’ARN de la session de rôle. Il est également inclus dans les AWS CloudTrail journaux de toutes les opérations enregistrées.
Par exemple, vous pouvez créer un profil basé sur le rôle comme suit :
```
[profile namedsessionrole]
role_arn = arn:aws:iam::234567890123:role/SomeRole
source_profile = default
role_session_name = Session_Maria_Garcia
```
La session de rôle prend alors l’ARN suivant.
```
arn:aws:iam::234567890123:assumed-role/SomeRole/Session_Maria_Garcia
```
En outre, tous les AWS CloudTrail journaux incluent le nom de session du rôle dans les informations capturées pour chaque opération.
## Utilisation d’un rôle à l’aide d’une identité web
Vous pouvez configurer un profil pour indiquer qu'il AWS CLI doit assumer un rôle à l'aide de la [fédération d'identité Web et d'Open ID Connect (OIDC)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html). Lorsque vous le spécifiez dans un profil, il AWS CLI passe automatiquement l' AWS STS `AssumeRoleWithWebIdentity`appel correspondant pour vous.
**Note**
Lorsque vous spécifiez un profil qui utilise un rôle IAM, il AWS CLI effectue les appels appropriés pour récupérer des informations d'identification temporaires. Ces informations d’identification sont stockées dans `~/.aws/cli/cache`. Les AWS CLI commandes suivantes qui spécifient le même profil utilisent les informations d'identification temporaires mises en cache jusqu'à leur expiration. À ce stade, les informations d'identification AWS CLI sont automatiquement actualisées.
Pour récupérer et utiliser des informations d’identification temporaires à l’aide de la fédération d’identité web, vous pouvez spécifier les valeurs de configuration suivantes dans un profil partagé.
[role\$1arn](#cli-configure-role)
Spécifie l’ARN du rôle à assumer.
web\$1identity\$1token\$1file
Spécifie le chemin d'accès à un fichier contenant un jeton d'accès OAuth 2.0 ou un jeton d'identification OpenID Connect fourni par le fournisseur d'identité. L’ AWS CLI charge ce fichier et transmet son contenu en tant qu’argument `WebIdentityToken` de l’opération `AssumeRoleWithWebIdentity`.
[role\$1session\$1name](#cli-configure-role-session-name)
Spécifie un nom facultatif appliqué à cette session assume-role.
Voici un exemple de configuration pour la configuration minimale requise pour configurer un profil de rôle de responsable avec profil identité web :
```
# In ~/.aws/config
[profile web-identity]
role_arn=arn:aws:iam:123456789012:role/RoleNameToAssume
web_identity_token_file=/path/to/a/token
```
Vous pouvez également fournir cette configuration à l’aide de [variables d’environnement](cli-configure-envvars.md).
AWS\$1ROLE\$1ARN
ARN du rôle à assumer.
AWS\$1WEB\$1FICHIER\$1JETON D'IDENTITÉ
Chemin d’accès au fichier de jeton d’identité web.
AWS\$1ROLE\$1NOM\$1SESSION
Nom appliqué à cette session assume-role.
**Note**
Ces variables d’environnement s’appliquent actuellement uniquement au rôle « assume » avec le fournisseur d’identité web. Ils ne s’appliquent pas à la configuration générale du fournisseur de rôle.
## Suppression des informations d’identification mises en cache
Lorsque vous utilisez un rôle, les informations d'identification temporaires sont mises en AWS CLI cache localement jusqu'à leur expiration. La prochaine fois que vous essaierez de les utiliser, ils AWS CLI essaieront de les renouveler en votre nom.
Si les informations d’identification temporaires de votre rôle sont [révoquées](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_revoke-sessions.html), elles ne sont pas renouvelées automatiquement et les tentatives d’utilisation échouent. Cependant, vous pouvez supprimer le cache pour forcer le AWS CLI à récupérer de nouvelles informations d'identification.
**Linux ou macOS**
```
$ rm -r ~/.aws/cli/cache
```
**Windows**
```
C:\> del /s /q %UserProfile%\.aws\cli\cache
```
# Authentification à l'aide des informations d'identification utilisateur IAM pour AWS CLI
**Avertissement**
Afin d’éviter les risques de sécurité, n’employez pas les utilisateurs IAM pour l’authentification lorsque vous développez des logiciels spécialisés ou lorsque vous travaillez avec des données réelles. Préférez la fédération avec un fournisseur d’identité tel que [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
Cette section explique comment configurer les paramètres de base avec un utilisateur IAM. Il s’agit notamment de vos informations d’identification de sécurité à l’aide des fichiers `config` et `credentials`. Pour afficher plutôt les instructions de configuration pour AWS IAM Identity Center, consultez [Configuration de l'authentification IAM Identity Center à l'aide du AWS CLI](cli-configure-sso.md).
**Contents**
+ [Étape 1 : création de votre utilisateur IAM](#cli-authentication-user-create)
+ [Étape 2 : récupération de vos clés d’accès](#cli-authentication-user-get)
+ [Étape 3 : configurer le AWS CLI](#cli-authentication-user-configure.title)
+ [Utilisation de `aws configure`](#cli-authentication-user-configure-wizard)
+ [Importation de clés d’accès au moyen d’un fichier .CSV](#cli-authentication-user-configure-csv)
+ [Modification directe des fichiers `config` et `credentials`](#cli-authentication-user-configure-csv.titlecli-authentication-user-configure-file)
+ [(Facultatif) Utilisation de l'authentification multifactorielle avec vos informations d'identification utilisateur IAM](#cli-authentication-user-configure-csv.titlecli-authentication-user-mfa)
## Étape 1 : création de votre utilisateur IAM
Créez votre utilisateur IAM en suivant la procédure [Création d’utilisateurs IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html#id_users_create_console) du *Guide de l’utilisateur IAM*.
+ Pour **Options d’autorisation**, choisissez **Attacher directement les politiques** pour définir la manière dont vous souhaitez affecter des autorisations à cet utilisateur.
+ La plupart des didacticiels du kit SDK « Démarrage » utilisent le service Amazon S3 comme exemple. Pour fournir à votre application un accès complet à Amazon S3, sélectionnez la politique `AmazonS3FullAccess` à attacher à cet utilisateur.
## Étape 2 : récupération de vos clés d’accès
1. Connectez-vous à la console IAM AWS Management Console et ouvrez-la à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse.
1. Dans le volet de navigation de la console IAM, sélectionnez **Utilisateurs**, puis le **`User name`** de l’utilisateur que vous avez créé précédemment.
1. Sur la page de l’utilisateur, sélectionnez la page **Informations d’identification de sécurité**. Ensuite, sous **Clés d’accès**, sélectionnez **Créer une clé d’accès**.
1. Pour **Créer une clé d’accès – Étape 1**, sélectionnez **Interface de ligne de commande (CLI)**.
1. Pour **Créer une clé d’accès – Étape 2**, saisissez une balise facultative, puis cliquez sur **Suivant**.
1. Pour **Créer une clé d’accès – Étape 3**, sélectionnez **Télécharger le fichier .csv** afin d’enregistrer le fichier `.csv` contenant la clé d’accès et la clé d’accès secrète de l’utilisateur IAM. Vous aurez besoin de ces informations ultérieurement.
1. Sélectionnez Terminé.
## Étape 3 : configurer le AWS CLI
Pour une utilisation générale, les AWS CLI informations suivantes sont nécessaires :
+ ID de clé d’accès
+ Clé d’accès secrète
+ AWS Région
+ Format de sortie
AWS CLI Stocke ces informations dans un *profil* (un ensemble de paramètres) nommé `default` dans le `credentials` fichier. Par défaut, les informations de ce profil sont utilisées lorsque vous exécutez une AWS CLI commande qui ne spécifie pas explicitement le profil à utiliser. Pour plus d’informations sur le fichier `credentials`, consultez [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md).
Pour configurer le AWS CLI, appliquez l'une des procédures suivantes :
**Topics**
+ [Utilisation de `aws configure`](#cli-authentication-user-configure-wizard)
+ [Importation de clés d’accès au moyen d’un fichier .CSV](#cli-authentication-user-configure-csv)
+ [Modification directe des fichiers `config` et `credentials`](#cli-authentication-user-configure-csv.titlecli-authentication-user-configure-file)
### Utilisation de `aws configure`
Pour une utilisation générale, la `aws configure` commande est le moyen le plus rapide de configurer votre AWS CLI installation. Cet assistant de configuration vous invite à saisir toutes les informations dont vous avez besoin pour commencer. Sauf indication contraire à l'aide de l'`--profile`option, cette information est AWS CLI stockée dans le `default` profil.
L’exemple suivant configure un profil `default` à l’aide d’exemples de valeurs. Remplacez-les par vos propres valeurs comme décrit dans les sections suivantes.
```
$ aws configure
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]: json
```
L’exemple suivant configure un profil nommé `userprod` à l’aide d’exemples de valeurs. Remplacez-les par vos propres valeurs comme décrit dans les sections suivantes.
```
$ aws configure --profile userprod
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]: json
```
### Importation de clés d’accès au moyen d’un fichier .CSV
Au lieu de saisir des clés d’accès à l’aide de `aws configure`, vous pouvez importer le fichier `.csv` texte brut que vous avez téléchargé après avoir créé vos clés d’accès.
Le fichier `.csv` doit comporter les en-têtes suivants.
+ Nom d’utilisateur : cette colonne doit être ajoutée à votre fichier `.csv`. Ceci permet de créer le nom de profil utilisé dans les fichiers `config` et `credentials` lors de l’importation.
+ ID de clé d’accès
+ Clé d’accès secrète
**Note**
Lors de la création initiale des clés d’accès, après avoir fermé la boîte de dialogue **Télécharger le fichier .csv**, vous ne pouvez plus accéder à votre clé d’accès secrète. Si vous avez besoin d’un fichier `.csv`, vous devez en créer un vous-même avec les en-têtes requis et les informations relatives à vos clés d’accès enregistrées. Si vous n’avez pas accès aux informations relatives à vos clés d’accès, vous devez créer des clés d’accès.
Importez le fichier `.csv` à l’aide de la commande `aws configure import` avec l’option `--csv` comme suit :
```
$ aws configure import --csv file://credentials.csv
```
Pour de plus amples informations, veuillez consulter `aws\$1configure\$1import`.
### Modification directe des fichiers `config` et `credentials`
Pour modifier directement les fichiers `config` et `credentials`, procédez comme suit.
1. Créez ou ouvrez le fichier AWS `credentials` partagé. Ce fichier est `~/.aws/credentials` sous Linux et macOS, et `%USERPROFILE%\.aws\credentials` sous Windows. Pour de plus amples informations, veuillez consulter [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md).
1. Ajoutez le texte suivant au fichier `credentials` partagé. Remplacez les exemples de valeurs dans le fichier `.csv` que vous avez téléchargé précédemment et enregistrez le fichier.
```
[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```
## (Facultatif) Utilisation de l'authentification multifactorielle avec vos informations d'identification utilisateur IAM
Pour plus de sécurité, vous pouvez utiliser une clé à usage unique générée à partir d'un appareil d'authentification multifactorielle (MFA), d'un appareil U2F ou d'une application mobile lorsque vous tentez de passer un appel.
Avec votre utilisateur IAM compatible MFA, exécutez la [https://docs.aws.amazon.com/cli/latest/reference/configure/mfa-login.html](https://docs.aws.amazon.com/cli/latest/reference/configure/mfa-login.html)commande pour configurer un nouveau profil à utiliser avec l'authentification multifactorielle (MFA) pour le profil spécifié. Si aucun profil n'est spécifié, le MFA est basé sur le `default` profil. Si aucun profil par défaut n'est configuré, la `mfa-login` commande vous invite à entrer vos AWS informations d'identification avant de demander les informations de votre MFA. L'exemple de commande suivant utilise votre configuration par défaut et crée un profil MFA.
```
$ aws configure mfa-login
MFA serial number or ARN: arn:aws:iam::123456789012:mfa/MFADeviceName
MFA token code: 123456
Profile to update [session-MFADeviceName]:
Temporary credentials written to profile 'session-MFADeviceName'
Credentials will expire at 2023-05-19 18:06:10 UTC
To use these credentials, specify --profile session-MFADeviceName when running AWS CLI commands
```
Pour mettre à jour un profil existant, utilisez le `--update-profile` paramètre.
```
$ aws configure mfa-login --profile myprofile --update-profile mfaprofile
MFA token code: 123456
Temporary credentials written to profile 'mfaprofile'
Credentials will expire at 2023-05-19 18:06:10 UTC
To use these credentials, specify --profile mfaprofile when running AWS CLI commands
```
Cette commande ne prend actuellement en charge que les authentificateurs par mot de passe à usage unique (OTP) matériels ou logiciels. Les clés d'accès et les appareils U2F ne sont actuellement pas pris en charge avec cette commande.
Pour utiliser votre profil MFA, utilisez l'`--profile`option avec vos commandes.
```
$ aws s3 ls --profile mfaprofile
```
*Pour plus d'informations sur l'utilisation de l'authentification multifacteur avec IAM, notamment sur la manière d'attribuer une authentification MFA à un utilisateur IAM, consultez la section [Authentification àAWS facteurs multiples](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa.html) dans IAM dans le guide de l'utilisateur.Gestion des identités et des accès AWS *
# Utilisation des métadonnées de l'instance Amazon EC2 comme informations d'identification dans AWS CLI
Lorsque vous exécutez le formulaire AWS CLI depuis une instance Amazon Elastic Compute Cloud (Amazon EC2), vous pouvez simplifier la fourniture d'informations d'identification pour vos commandes. Chaque instance Amazon EC2 contient des métadonnées que l’ AWS CLI peut interroger directement pour obtenir les informations d’identification temporaires. Lorsqu'un rôle IAM est attaché à l'instance, il récupère AWS CLI automatiquement et en toute sécurité les informations d'identification à partir des métadonnées de l'instance.
Pour désactiver ce service, utilisez la variable d'environnement [AWS\$1EC2\$1METADATA\$1DISABLED](cli-configure-envvars.md#envvars-list-AWS_EC2_METADATA_DISABLED).
**Topics**
+ [Conditions préalables](#cli-configure-metadata-prereqs)
+ [Configuration d’un profil pour les métadonnées Amazon EC2](#cli-configure-metadata-configure)
## Conditions préalables
Pour utiliser les informations d'identification Amazon EC2 avec le AWS CLI, vous devez effectuer les opérations suivantes :
+ Installez et configurez l’ AWS CLI. Pour plus d’informations, consultez [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md) et [Authentification et informations d'accès pour AWS CLI](cli-chap-authentication.md).
+ Vous comprenez les fichiers de configuration et les profils nommés. Pour de plus amples informations, veuillez consulter [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md).
+ Vous avez créé un rôle Gestion des identités et des accès AWS (IAM) qui a accès aux ressources nécessaires, et vous avez attaché ce rôle à l'instance Amazon EC2 lorsque vous la lancez. *Pour plus d'informations, consultez [les politiques IAM pour Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) EC2 dans le guide de l'*utilisateur Amazon EC2* [et l'octroi de l'accès AWS aux ressources aux applications exécutées sur des instances Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/role-usecase-ec2app.html) dans le guide de l'utilisateur IAM.*
## Configuration d’un profil pour les métadonnées Amazon EC2
Pour spécifier que vous voulez utiliser les informations d’identification disponibles dans le profil d’instance Amazon EC2 d’hébergement, utilisez la syntaxe suivante dans le profil nommé dans votre fichier de configuration. Consultez les étapes suivantes pour plus d’instructions.
```
[profile profilename]
role_arn = arn:aws:iam::123456789012:role/rolename
credential_source = Ec2InstanceMetadata
region = region
```
1. Créez un profil dans votre fichier de configuration.
```
[profile profilename]
```
1. Ajoutez votre rôle ARN IAM qui a accès aux ressources nécessaires.
```
role_arn = arn:aws:iam::123456789012:role/rolename
```
1. Spécifiez `Ec2InstanceMetadata` comme source d’informations d’identification.
```
credential_source = Ec2InstanceMetadata
```
1. Définissez votre région.
```
region = region
```
**Exemple**
L’exemple suivant suppose le rôle *`marketingadminrole`* et utilise la région `us-west-2` dans un profil d’instance Amazon EC2 nommé `marketingadmin`.
```
[profile marketingadmin]
role_arn = arn:aws:iam::123456789012:role/marketingadminrole
credential_source = Ec2InstanceMetadata
region = us-west-2
```
# Obtenir des informations d'identification par le biais d'un processus externe dans le AWS CLI
**Avertissement**
Cette rubrique aborde l’utilisation d’informations d’identification provenant d’un processus externe. Un risque de sécurité peut exister si la commande de génération des informations d’identification devient accessible à des processus ou utilisateurs non approuvés. Nous vous recommandons d'utiliser les alternatives sécurisées prises en charge par le AWS CLI et AWS afin de réduire le risque de compromettre vos informations d'identification. Veillez à sécuriser le fichier `config` et tous les outils et fichiers de support afin d’éviter toute divulgation.
Assurez-vous que votre outil d'identification personnalisé n'écrit aucune information secrète, `StdErr` car le SDKs et AWS CLI peut capturer et enregistrer ces informations, les exposant potentiellement à des utilisateurs non autorisés.
Si vous disposez d'une méthode pour générer ou rechercher des informations d'identification qui n'est pas directement prise en charge par le AWS CLI, vous pouvez la configurer AWS CLI pour l'utiliser en configurant le `credential_process` paramètre dans le `config` fichier.
Par exemple, vous pourriez inclure une entrée comme celle-ci dans le fichier `config` :
```
[profile developer]
credential_process = /opt/bin/awscreds-custom --username helen
```
**Syntaxe**
Pour créer cette chaîne d’une manière compatible avec n’importe quel système d’exploitation, suivez ces règles :
+ Si le chemin d’accès ou le nom du fichier contient un espace, entourez le chemin d’accès complet et le nom du fichier de guillemets doubles (" "). Le chemin et le nom de fichier peuvent contenir uniquement les caractères suivants : A-Z a-z 0-9 - \$1. espace
+ Si un nom de paramètre ou une valeur de paramètre contient un espace, entourez cet élément de guillemets doubles (" "). Entourez uniquement le nom ou la valeur, pas la paire.
+ N’incluez aucune variable d’environnement dans les chaînes. Par exemple, vous ne pouvez pas inclure `$HOME` ou `%USERPROFILE%`.
+ Ne spécifiez pas le dossier de base comme `~`. Vous devez spécifier le chemin d’accès complet.
**Exemple pour Windows**
```
credential_process = "C:\Path\To\credentials.cmd" parameterWithoutSpaces "parameter with spaces"
```
**Exemple pour Linux ou macOS**
```
credential_process = "/Users/Dave/path/to/credentials.sh" parameterWithoutSpaces "parameter with spaces"
```
**Sortie attendue du programme d’informations d’identification**
AWS CLI Exécute la commande comme indiqué dans le profil, puis lit les données à partir de`STDOUT`. La commande que vous spécifiez doit générer sur `STDOUT` une sortie JSON qui correspond à la syntaxe suivante :
```
{
"Version": 1,
"AccessKeyId": "an AWS access key",
"SecretAccessKey": "your AWS secret access key",
"SessionToken": "the AWS session token for temporary credentials",
"Expiration": "ISO8601 timestamp when the credentials expire"
}
```
**Note**
À la date de cette publication, la clé `Version` doit être définie sur `1`. Cela pourrait augmenter avec le temps à mesure que la structure évolue.
La `Expiration` clé est un [ISO8601](https://en.wikipedia.org/wiki/ISO_8601)horodatage formaté. Si la clé `Expiration` n’est pas présente dans la sortie de l’outil, l’interface de ligne de commande suppose que les informations d’identification sont des informations d’identification à long terme qui ne s’actualisent pas. Dans le cas contraire, les informations d’identification sont considérées comme temporaires et sont actualisées automatiquement en réexécutant la commande `credential_process` avant leur expiration.
**Note**
Le AWS CLI ne met ***pas*** en cache les informations d'identification des processus externes de la même manière qu'il assume les informations d'identification des rôles. Si la mise en cache est obligatoire, vous devez la mettre en œuvre dans le processus externe.
Le processus externe peut renvoyer un code de retour non nul pour indiquer qu’une erreur s’est produite lors de la récupération des informations d’identification.