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.
# Mise en route avec l’AWS CLI
Ce chapitre décrit les étapes à suivre pour démarrer avec la version 2 de l’AWS Command Line Interface (AWS CLI) et fournit des liens vers les instructions pertinentes.
1. **[Remplissez l’ensemble des conditions préalables](getting-started-prereqs.md)** : pour accéder aux services AWS à partir de l’AWS CLI, vous devez disposer au minimum d’un Compte AWS et d’informations d’identification IAM. Pour améliorer la sécurité de votre compte AWS, nous vous recommandons de ne pas utiliser les informations d’identification de votre compte racine. Vous devez créer un utilisateur doté du moindre privilège afin de fournir les informations d’identification pour l’accès aux tâches que vous allez exécuter dans AWS.
1. Installez ou obtenez un accès à l’AWS CLI en utilisant l’une des méthodes suivantes :
+ **(Recommandé)** [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md).
+ [Installation des versions précédentes de la AWS CLI version 2](getting-started-version.md). L’installation d’une version spécifique est principalement utilisée si votre équipe aligne ses outils sur une version spécifique.
+ [Création et installation du AWS CLI depuis le code source](getting-started-source-install.md). La création de l’AWS CLI à partir d’une source GitHub est une méthode plus approfondie qui est principalement utilisée par les clients qui travaillent sur des plateformes que nous ne prenons pas directement en charge avec nos programmes d’installation prédéfinis.
+ [Exécution des images officielles Amazon ECR Public ou Docker pour le AWS CLI](getting-started-docker.md).
+ Accédez à la version 2 de l’AWS CLI dans la console AWS depuis votre navigateur à l’aide de AWS CloudShell. Pour plus d’informations, consultez le [Guide de l’utilisateur AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/).
1. [Une fois que vous avez accès à l’AWS CLI, configurez votre compte AWS CLI avec vos informations d’identification IAM pour la première utilisation](getting-started-quickstart.md).
**Résolution des erreurs d’installation ou de configuration**
Si vous rencontrez des problèmes après l’installation, la désinstallation ou la configuration de l’AWS CLI, consultez [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md) pour connaître les étapes de résolution de problèmes.
**Topics**
+ [Prérequis pour utiliser la AWS CLI version 2](getting-started-prereqs.md)
+ [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md)
+ [Installation des versions précédentes de la AWS CLI version 2](getting-started-version.md)
+ [Création et installation du AWS CLI depuis le code source](getting-started-source-install.md)
+ [Exécution des images officielles Amazon ECR Public ou Docker pour le AWS CLI](getting-started-docker.md)
+ [Configuration du AWS CLI](getting-started-quickstart.md)
# Prérequis pour utiliser la AWS CLI version 2
Pour accéder aux AWS services avec le AWS CLI, vous avez besoin d'un Compte AWS identifiant IAM ou IAM Identity Center. Lors de l' AWS CLI exécution de AWS CLI commandes, ils doivent avoir accès à ces AWS informations d'identification. Pour renforcer la sécurité de votre AWS compte, nous vous recommandons de n'utiliser que des informations d'identification de courte durée lorsque vous utilisez des utilisateurs root ou IAM. Vous devez créer un utilisateur ayant le moins de privilèges pour fournir des informations d'accès aux tâches que vous allez exécuter AWS. Pour plus d'informations sur les meilleures pratiques, consultez [la section Meilleures pratiques en matière de sécurité](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) dans le guide de l'utilisateur IAM.
**Topics**
+ [Création d’un compte administratif IAM ou IAM Identity Center](#getting-started-prereqs-iam)
+ [Étapes suivantes](#getting-started-prereqs-next)
## Création d’un compte administratif IAM ou IAM Identity Center
Avant de pouvoir configurer le AWS CLI, vous devez créer un compte IAM ou IAM Identity Center.
**Options de création de compte**
| Choisissez un moyen de gérer vos informations d'identification | À | Comment créer un compte | Comment configurer l'accès programmatique au compte |
| --- | --- | --- | --- |
| AWS Identifiants de la console de gestion | Utilisez des informations d'identification à court terme correspondant à l'utilisateur root créé lors de la configuration initiale du compte, à un utilisateur IAM ou à une identité fédérée de votre fournisseur d'identité. | Ouvrez le [https://portal.aws.amazon.com/billing/formulaire d'inscription](https://portal.aws.amazon.com/billing/signup) et suivez les instructions en ligne. | Aucune étape supplémentaire n'est nécessaire. Pour vous connecter AWS CLI à votre AWS compte, voir [Connectez-vous pour le développement AWS local à l'aide des informations d'identification de console](cli-configure-sign-in.md) |
| IAM Identity Center | Utilisez des informations d'identification à court terme pour accéder aux AWS services. | Suivez les instructions de la section Getting started du guide de l'utilisateur d' AWS IAM Identity Center. | Configurez l'accès par programmation en configurant le à utiliser dans le guide de l'utilisateur d' AWS IAM Identity Center. |
| AWS Identity and Access Management(Non recommandé) | Utilisez des informations d'identification à long terme pour accéder aux AWS services. | Suivez les instructions de la section Créer un accès d'urgence dans le guide de l'utilisateur IAM. | Configurez l'accès programmatique en gérant les clés d'accès pour les utilisateurs dans le guide de l'utilisateur IAM. |
## Étapes suivantes
Après avoir créé des informations d'identification Compte AWS et IAM, pour les utiliser, AWS CLI vous pouvez effectuer l'une des opérations suivantes :
+ [Installez la dernière version](getting-started-install.md) de la AWS CLI version 2 sur votre ordinateur.
+ [Installez une version antérieure](getting-started-version.md) de la AWS CLI version 2 sur votre ordinateur.
+ Accédez à la AWS CLI version 2 depuis votre ordinateur à [l'aide d'une image Docker](getting-started-docker.md).
+ Accédez à la AWS CLI version 2 dans la AWS console depuis votre navigateur en utilisant AWS CloudShell. Pour plus d'informations, consultez le [Guide de l'utilisateur AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/).
# Installation ou mise à jour vers la dernière version du AWS CLI
Cette rubrique décrit comment installer ou mettre à jour la dernière version de AWS Command Line Interface (AWS CLI) sur les systèmes d'exploitation pris en charge. Pour plus d'informations sur les dernières versions de AWS CLI, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). GitHub
Pour installer une version antérieure du AWS CLI, voir[Installation des versions précédentes de la AWS CLI version 2](getting-started-version.md). Pour obtenir des instructions de désinstallation, consultez [Désinstaller la AWS CLI version 2](uninstall.md).
**Important**
AWS CLI les versions 1 et 2 utilisent le même nom de `aws` commande. Si vous avez déjà installé AWS CLI la version 1, consultez[Guide de migration pour la AWS CLI version 2](cliv2-migration.md).
**Topics**
+ [AWS CLI instructions d'installation et de mise à jour](#getting-started-install-instructions)
+ [Résolution des erreurs AWS CLI d'installation et de désinstallation](#install-tshoot)
+ [Étapes suivantes](#install-next-steps)
## AWS CLI instructions d'installation et de mise à jour
Pour obtenir des instructions d’installation, développez la section correspondant à votre système d’exploitation.
### Linux
#### Exigences d’installation et de mise à jour
+ Vous devez être en mesure d’extraire ou de « décompresser » le package téléchargé. Si votre système d'exploitation ne dispose pas de la commande `unzip` intégrée, utilisez un équivalent.
+ Les AWS CLI utilisations `glibc``groff`, et`less`. Ces commandes sont incluses par défaut dans la plupart des distributions majeures de Linux.
+ Nous prenons en charge AWS CLI les versions 64 bits des distributions récentes de CentOS, Fedora, Ubuntu, Amazon Linux 1, Amazon Linux 2, Amazon Linux 2023 et Linux ARM.
+ Dans la mesure où il AWS ne gère pas de référentiels tiers`snap`, nous ne pouvons garantir qu'ils contiennent la dernière version du AWS CLI.
#### Installez ou mettez à jour AWS CLI
**Avertissement**
S'il s'agit de votre première mise à jour sur Amazon Linux, pour installer la dernière version du AWS CLI, vous devez désinstaller la `yum` version préinstallée à l'aide de la commande suivante :
```
$ sudo yum remove awscli
```
Une fois l'`yum` AWS CLI installation supprimée, suivez les instructions d'installation de Linux ci-dessous.
Vous pouvez installer le AWS CLI en utilisant l'une des méthodes suivantes :
+ **Le programme d’installation en ligne de commande** est une bonne option pour le contrôle de version, car vous pouvez spécifier la version à installer. Cette option n’effectue pas de mise à jour automatique et vous devez télécharger un nouveau programme d’installation à chaque mise à jour afin de remplacer la version précédente.
+ **Le `snap` package officiellement pris en charge** est une bonne option pour toujours avoir la dernière version du package AWS CLI car les packages Snap sont automatiquement actualisés. Il n'existe aucun support intégré pour sélectionner des versions mineures de AWS CLI et n'est donc pas une méthode d'installation optimale si votre équipe a besoin d'épingler des versions.
------
#### [ Command line installer - Linux x86 (64-bit) ]
Pour mettre à jour votre installation actuelle de AWS CLI, téléchargez un nouveau programme d'installation à chaque mise à jour pour remplacer les versions précédentes. Suivez ces étapes depuis la ligne de commande pour installer AWS CLI le sous Linux.
Vous trouverez ci-dessous des étapes d’installation rapides dans un seul groupe de copier-coller pour une installation de base. Pour obtenir des instructions guidées, reportez-vous aux étapes ci-après.
**Note**
**(Facultatif)** La commande suivante bloque le téléchargement et l'installe AWS CLI sans vérifier au préalable l'intégrité de votre téléchargement. Pour vérifier l’intégrité de votre téléchargement, suivez les instructions détaillées ci-dessous.
**Pour installer** l’ AWS CLI, exécutez les commandes suivantes.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
**Pour mettre à jour votre installation actuelle** de l’ AWS CLI, ajoutez le lien symbolique et les informations d’installation existants afin de construire la commande `install` à l’aide des paramètres `--bin-dir`, `--install-dir` et `--update`. Le bloc de commande suivant utilise un exemple de lien symbolique */usr/local/bin* et un exemple d'emplacement du programme d'installation */usr/local/aws-cli* pour installer le fichier AWS CLI localement pour l'utilisateur actuel.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
**Étapes d’installation guidées**
1. Téléchargez le fichier d’installation de l’une des façons suivantes :
+ **Utilisation de la commande `curl`** : l’option `-o` spécifie le nom du fichier dans lequel le package téléchargé est écrit. Les options de l'exemple de commande suivant permettent de copier le fichier téléchargé dans le répertoire courant avec le nom local `awscliv2.zip`
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
```
+ **Téléchargement à partir de l’URL** : pour télécharger le programme d’installation via un navigateur, utilisez l’URL suivante : [https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip](https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip)
1. **(Facultatif) Vérification de l’intégrité du fichier zip téléchargé**
Si vous avez choisi de télécharger manuellement le package AWS CLI d'installation `.zip` en suivant les étapes ci-dessus, vous pouvez utiliser les étapes suivantes pour vérifier les signatures à l'aide de l'`GnuPG`outil.
Les `.zip` fichiers du package AWS CLI d'installation sont signés cryptographiquement à l'aide de signatures PGP. En cas de dommage ou d'altération des fichiers, cette vérification échoue et vous ne devez pas poursuivre l'installation.
1. Téléchargez et installez la commande `gpg` à l'aide de votre gestionnaire de packages. Pour plus d’informations sur `GnuPG`, consultez le [site Web GnuPG](https://www.gnupg.org/).
1. Pour créer le fichier de clé publique, créez un fichier texte et collez le texte suivant.
```
-----BEGIN PGP PUBLIC KEY BLOCK-----
mQINBF2Cr7UBEADJZHcgusOJl7ENSyumXh85z0TRV0xJorM2B/JL0kHOyigQluUG
ZMLhENaG0bYatdrKP+3H91lvK050pXwnO/R7fB/FSTouki4ciIx5OuLlnJZIxSzx
PqGl0mkxImLNbGWoi6Lto0LYxqHN2iQtzlwTVmq9733zd3XfcXrZ3+LblHAgEt5G
TfNxEKJ8soPLyWmwDH6HWCnjZ/aIQRBTIQ05uVeEoYxSh6wOai7ss/KveoSNBbYz
gbdzoqI2Y8cgH2nbfgp3DSasaLZEdCSsIsK1u05CinE7k2qZ7KgKAUIcT/cR/grk
C6VwsnDU0OUCideXcQ8WeHutqvgZH1JgKDbznoIzeQHJD238GEu+eKhRHcz8/jeG
94zkcgJOz3KbZGYMiTh277Fvj9zzvZsbMBCedV1BTg3TqgvdX4bdkhf5cH+7NtWO
lrFj6UwAsGukBTAOxC0l/dnSmZhJ7Z1KmEWilro/gOrjtOxqRQutlIqG22TaqoPG
fYVN+en3Zwbt97kcgZDwqbuykNt64oZWc4XKCa3mprEGC3IbJTBFqglXmZ7l9ywG
EEUJYOlb2XrSuPWml39beWdKM8kzr1OjnlOm6+lpTRCBfo0wa9F8YZRhHPAkwKkX
XDeOGpWRj4ohOx0d2GWkyV5xyN14p2tQOCdOODmz80yUTgRpPVQUtOEhXQARAQAB
tCFBV1MgQ0xJIFRlYW0gPGF3cy1jbGlAYW1hem9uLmNvbT6JAlQEEwEIAD4CGwMF
CwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQT7Xbd/1cEYuAURraimMQrMRnJHXAUC
aGveYQUJDMpiLAAKCRCmMQrMRnJHXKBYD/9Ab0qQdGiO5hObchG8xh8Rpb4Mjyf6
0JrVo6m8GNjNj6BHkSc8fuTQJ/FaEhaQxj3pjZ3GXPrXjIIVChmICLlFuRXYzrXc
Pw0lniybypsZEVai5kO0tCNBCCFuMN9RsmmRG8mf7lC4FSTbUDmxG/QlYK+0IV/l
uJkzxWa+rySkdpm0JdqumjegNRgObdXHAQDWlubWQHWyZyIQ2B4U7AxqSpcdJp6I
S4Zds4wVLd1WE5pquYQ8vS2cNlDm4QNg8wTj58e3lKN47hXHMIb6CHxRnb947oJa
pg189LLPR5koh+EorNkA1wu5mAJtJvy5YMsppy2y/kIjp3lyY6AmPT1posgGk70Z
CmToEZ5rbd7ARExtlh76A0cabMDFlEHDIK8RNUOSRr7L64+KxOUegKBfQHb9dADY
qqiKqpCbKgvtWlds909Ms74JBgr2KwZCSY1HaOxnIr4CY43QRqAq5YHOay/mU+6w
hhmdF18vpyK0vfkvvGresWtSXbag7Hkt3XjaEw76BzxQH21EBDqU8WJVjHgU6ru+
DJTs+SxgJbaT3hb/vyjlw0lK+hFfhWKRwgOXH8vqducF95NRSUxtS4fpqxWVaw3Q
V2OWSjbne99A5EPEySzryFTKbMGwaTlAwMCwYevt4YT6eb7NmFhTx0Fis4TalUs+
j+c7Kg92pDx2uQ==
=OBAt
-----END PGP PUBLIC KEY BLOCK-----
```
Pour référence, les détails de la clé publique sont les suivants.
```
Key ID: A6310ACC4672475C
Type: RSA
Size: 4096/4096
Created: 2019-09-18
Expires: 2026-07-07
User ID: AWS CLI Team
Key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
1. Importez la clé AWS CLI publique à l'aide de la commande suivante, en la *public-key-file-name* remplaçant par le nom de fichier de la clé publique que vous avez créée.
```
$ gpg --import public-key-file-name
gpg: /home/username/.gnupg/trustdb.gpg: trustdb created
gpg: key A6310ACC4672475C: public key "AWS CLI Team " imported
gpg: Total number processed: 1
gpg: imported: 1
```
1. Téléchargez le fichier de AWS CLI signature du package que vous avez téléchargé. Celui-ci a le même chemin d'accès et le même nom que le fichier `.zip` auquel il correspond, mais son extension est `.sig`. Dans les exemples suivants, nous l'enregistrons dans le répertoire courant sous la forme d'un fichier nommé `awscliv2.sig`.
**Pour la dernière version de AWS CLI,** utilisez le bloc de commande suivant :
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip.sig
```
1. Vérifiez la signature en transmettant les noms de fichiers `.sig` et `.zip` téléchargés sous forme de paramètres à la commande `gpg`.
```
$ gpg --verify awscliv2.sig awscliv2.zip
```
La sortie doit ressembler à ce qui suit :
```
gpg: Signature made Mon Nov 4 19:00:01 2019 PST
gpg: using RSA key FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
gpg: Good signature from "AWS CLI Team " [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
**Important**
L’avertissement mentionné dans la sortie est attendu et n’indique pas de problème. Cela se produit parce qu'il n'existe pas de chaîne de confiance entre votre clé PGP personnelle (si vous en avez une) et la clé AWS CLI PGP. Pour plus d’informations, consultez [Web of trust](https://en.wikipedia.org/wiki/Web_of_trust).
1. Décompressez le programme d'installation. Si votre distribution Linux n'a pas de commande `unzip` intégrée, utilisez un équivalent pour procéder à la décompression. L'exemple de commande suivant décompresse le package et crée un répertoire nommé `aws` dans le répertoire courant.
```
$ unzip awscliv2.zip
```
**Note**
Lors d’une mise à jour depuis une version précédente, la commande `unzip` invite à remplacer les fichiers existants. Pour ignorer ces invites, par exemple dans le cas d’une automatisation des scripts, utilisez l’indicateur de mise à jour `-u` pour `unzip`. Cet indicateur met automatiquement à jour les fichiers existants et en crée de nouveaux selon les besoins.
```
$ unzip -u awscliv2.zip
```
1. Exécutez le programme d’installation. La commande d'installation utilise un fichier nommé `install` dans le répertoire `aws` récemment décompressé. Par défaut, les fichiers sont tous installés dans `/usr/local/aws-cli` et un lien symbolique est créé dans `/usr/local/bin`. La commande inclut `sudo` pour accorder des autorisations d'écriture sur ces répertoires.
```
$ sudo ./aws/install
```
Vous pouvez effectuer l'installation sans `sudo` si vous spécifiez des répertoires sur lesquels vous disposez déjà d'autorisations en écriture. Utilisez les instructions suivantes pour la commande `install` de manière à spécifier l'emplacement d'installation :
+ Assurez-vous que les chemins d'accès que vous fournissez aux paramètres `-i` et `-b` ne contiennent aucun nom de volume ou de répertoire incluant des espaces quelconques. Dans le cas contraire, l'installation échouera.
+ `--install-dir` ou `-i` : cette option spécifie le répertoire vers lequel copier tous les fichiers.
La valeur par défaut est `/usr/local/aws-cli`.
+ `--bin-dir` ou `-b` : cette option spécifie que le programme `aws` principal du répertoire d’installation est lié symboliquement au fichier `aws` dans le chemin d’accès spécifié. Vous devez disposer des autorisations en écriture sur le répertoire spécifié. La création d'un lien symbolique vers un répertoire se trouvant déjà dans votre chemin d'accès vous dispense d'ajouter le répertoire d'installation à la variable `$PATH` de l'utilisateur.
La valeur par défaut est `/usr/local/bin`.
```
$ ./aws/install -i /usr/local/aws-cli -b /usr/local/bin
```
**Note**
Pour mettre à jour votre installation actuelle du AWS CLI, ajoutez votre lien symbolique et les informations d'installation existants pour créer la `install` commande avec le `--update` paramètre.
```
$ sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
Pour localiser le lien symbolique et le répertoire d’installation existants, procédez comme suit :
Utilisez la commande `which` pour rechercher votre lien symbolique. Cela vous indique le chemin à utiliser avec le paramètre `--bin-dir`.
```
$ which aws
/usr/local/bin/aws
```
Utilisez la commande `ls` pour rechercher le répertoire vers lequel votre lien symbolique pointe. Cela vous indique le chemin à utiliser avec le paramètre `--install-dir`.
```
$ ls -l /usr/local/bin/aws
lrwxrwxrwx 1 ec2-user ec2-user 49 Oct 22 09:49 /usr/local/bin/aws -> /usr/local/aws-cli/v2/current/bin/aws
```
1. Confirmez l’installation à l’aide de la commande suivante.
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Si la commande `aws` est introuvable, vous devrez peut-être redémarrer votre terminal ou suivre les instructions de résolution de problèmes dans [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Command line - Linux ARM ]
Pour mettre à jour votre installation actuelle de AWS CLI, téléchargez un nouveau programme d'installation à chaque mise à jour pour remplacer les versions précédentes. Suivez ces étapes depuis la ligne de commande pour installer AWS CLI le sous Linux.
Vous trouverez ci-dessous des étapes d’installation rapides dans un seul groupe de copier-coller pour une installation de base. Pour obtenir des instructions guidées, reportez-vous aux étapes ci-après.
**Note**
**(Facultatif)** La commande suivante bloque le téléchargement et l'installe AWS CLI sans vérifier au préalable l'intégrité de votre téléchargement. Pour vérifier l’intégrité de votre téléchargement, suivez les instructions détaillées ci-dessous.
**Pour installer** le AWS CLI, exécutez les commandes suivantes.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
**Pour mettre à jour votre installation actuelle** de l’ AWS CLI, ajoutez le lien symbolique et les informations d’installation existants afin de construire la commande `install` à l’aide des paramètres `--bin-dir`, `--install-dir` et `--update`. Le bloc de commande suivant utilise un exemple de lien symbolique */usr/local/bin* et un exemple d'emplacement du programme d'installation de*/usr/local/aws-cli*.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
**Étapes d’installation guidées**
1. Téléchargez le fichier d’installation de l’une des façons suivantes :
+ **Utilisation de la commande `curl`** : l’option `-o` spécifie le nom du fichier dans lequel le package téléchargé est écrit. Les options de l'exemple de commande suivant permettent de copier le fichier téléchargé dans le répertoire courant avec le nom local `awscliv2.zip`
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o "awscliv2.zip"
```
+ **Téléchargement à partir de l’URL** : pour télécharger le programme d’installation via un navigateur, utilisez l’URL suivante : [https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip](https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip)
1. **(Facultatif) Vérification de l’intégrité du fichier zip téléchargé**
Si vous avez choisi de télécharger manuellement le package AWS CLI d'installation `.zip` en suivant les étapes ci-dessus, vous pouvez utiliser les étapes suivantes pour vérifier les signatures à l'aide de l'`GnuPG`outil.
Les `.zip` fichiers du package AWS CLI d'installation sont signés cryptographiquement à l'aide de signatures PGP. En cas de dommage ou d'altération des fichiers, cette vérification échoue et vous ne devez pas poursuivre l'installation.
1. Téléchargez et installez la commande `gpg` à l'aide de votre gestionnaire de packages. Pour plus d’informations sur `GnuPG`, consultez le [site Web GnuPG](https://www.gnupg.org/).
1. Pour créer le fichier de clé publique, créez un fichier texte et collez le texte suivant.
```
-----BEGIN PGP PUBLIC KEY BLOCK-----
mQINBF2Cr7UBEADJZHcgusOJl7ENSyumXh85z0TRV0xJorM2B/JL0kHOyigQluUG
ZMLhENaG0bYatdrKP+3H91lvK050pXwnO/R7fB/FSTouki4ciIx5OuLlnJZIxSzx
PqGl0mkxImLNbGWoi6Lto0LYxqHN2iQtzlwTVmq9733zd3XfcXrZ3+LblHAgEt5G
TfNxEKJ8soPLyWmwDH6HWCnjZ/aIQRBTIQ05uVeEoYxSh6wOai7ss/KveoSNBbYz
gbdzoqI2Y8cgH2nbfgp3DSasaLZEdCSsIsK1u05CinE7k2qZ7KgKAUIcT/cR/grk
C6VwsnDU0OUCideXcQ8WeHutqvgZH1JgKDbznoIzeQHJD238GEu+eKhRHcz8/jeG
94zkcgJOz3KbZGYMiTh277Fvj9zzvZsbMBCedV1BTg3TqgvdX4bdkhf5cH+7NtWO
lrFj6UwAsGukBTAOxC0l/dnSmZhJ7Z1KmEWilro/gOrjtOxqRQutlIqG22TaqoPG
fYVN+en3Zwbt97kcgZDwqbuykNt64oZWc4XKCa3mprEGC3IbJTBFqglXmZ7l9ywG
EEUJYOlb2XrSuPWml39beWdKM8kzr1OjnlOm6+lpTRCBfo0wa9F8YZRhHPAkwKkX
XDeOGpWRj4ohOx0d2GWkyV5xyN14p2tQOCdOODmz80yUTgRpPVQUtOEhXQARAQAB
tCFBV1MgQ0xJIFRlYW0gPGF3cy1jbGlAYW1hem9uLmNvbT6JAlQEEwEIAD4CGwMF
CwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQT7Xbd/1cEYuAURraimMQrMRnJHXAUC
aGveYQUJDMpiLAAKCRCmMQrMRnJHXKBYD/9Ab0qQdGiO5hObchG8xh8Rpb4Mjyf6
0JrVo6m8GNjNj6BHkSc8fuTQJ/FaEhaQxj3pjZ3GXPrXjIIVChmICLlFuRXYzrXc
Pw0lniybypsZEVai5kO0tCNBCCFuMN9RsmmRG8mf7lC4FSTbUDmxG/QlYK+0IV/l
uJkzxWa+rySkdpm0JdqumjegNRgObdXHAQDWlubWQHWyZyIQ2B4U7AxqSpcdJp6I
S4Zds4wVLd1WE5pquYQ8vS2cNlDm4QNg8wTj58e3lKN47hXHMIb6CHxRnb947oJa
pg189LLPR5koh+EorNkA1wu5mAJtJvy5YMsppy2y/kIjp3lyY6AmPT1posgGk70Z
CmToEZ5rbd7ARExtlh76A0cabMDFlEHDIK8RNUOSRr7L64+KxOUegKBfQHb9dADY
qqiKqpCbKgvtWlds909Ms74JBgr2KwZCSY1HaOxnIr4CY43QRqAq5YHOay/mU+6w
hhmdF18vpyK0vfkvvGresWtSXbag7Hkt3XjaEw76BzxQH21EBDqU8WJVjHgU6ru+
DJTs+SxgJbaT3hb/vyjlw0lK+hFfhWKRwgOXH8vqducF95NRSUxtS4fpqxWVaw3Q
V2OWSjbne99A5EPEySzryFTKbMGwaTlAwMCwYevt4YT6eb7NmFhTx0Fis4TalUs+
j+c7Kg92pDx2uQ==
=OBAt
-----END PGP PUBLIC KEY BLOCK-----
```
Pour référence, les détails de la clé publique sont les suivants.
```
Key ID: A6310ACC4672475C
Type: RSA
Size: 4096/4096
Created: 2019-09-18
Expires: 2026-07-07
User ID: AWS CLI Team
Key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
1. Importez la clé AWS CLI publique à l'aide de la commande suivante, en la *public-key-file-name* remplaçant par le nom de fichier de la clé publique que vous avez créée.
```
$ gpg --import public-key-file-name
gpg: /home/username/.gnupg/trustdb.gpg: trustdb created
gpg: key A6310ACC4672475C: public key "AWS CLI Team " imported
gpg: Total number processed: 1
gpg: imported: 1
```
1. Téléchargez le fichier de AWS CLI signature du package que vous avez téléchargé. Celui-ci a le même chemin d'accès et le même nom que le fichier `.zip` auquel il correspond, mais son extension est `.sig`. Dans les exemples suivants, nous l'enregistrons dans le répertoire courant sous la forme d'un fichier nommé `awscliv2.sig`.
**Pour la dernière version de AWS CLI,** utilisez le bloc de commande suivant :
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip.sig
```
1. Vérifiez la signature en transmettant les noms de fichiers `.sig` et `.zip` téléchargés sous forme de paramètres à la commande `gpg`.
```
$ gpg --verify awscliv2.sig awscliv2.zip
```
La sortie doit ressembler à ce qui suit :
```
gpg: Signature made Mon Nov 4 19:00:01 2019 PST
gpg: using RSA key FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
gpg: Good signature from "AWS CLI Team " [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
**Important**
L’avertissement mentionné dans la sortie est attendu et n’indique pas de problème. Cela se produit parce qu'il n'existe pas de chaîne de confiance entre votre clé PGP personnelle (si vous en avez une) et la clé AWS CLI PGP. Pour plus d’informations, consultez [Web of trust](https://en.wikipedia.org/wiki/Web_of_trust).
1. Décompressez le programme d'installation. Si votre distribution Linux n'a pas de commande `unzip` intégrée, utilisez un équivalent pour procéder à la décompression. L'exemple de commande suivant décompresse le package et crée un répertoire nommé `aws` dans le répertoire courant.
```
$ unzip awscliv2.zip
```
**Note**
Lors d’une mise à jour depuis une version précédente, la commande `unzip` invite à remplacer les fichiers existants. Pour ignorer ces invites, par exemple dans le cas d’une automatisation des scripts, utilisez l’indicateur de mise à jour `-u` pour `unzip`. Cet indicateur met automatiquement à jour les fichiers existants et en crée de nouveaux selon les besoins.
```
$ unzip -u awscliv2.zip
```
1. Exécutez le programme d’installation. La commande d'installation utilise un fichier nommé `install` dans le répertoire `aws` récemment décompressé. Par défaut, les fichiers sont tous installés dans `/usr/local/aws-cli` et un lien symbolique est créé dans `/usr/local/bin`. La commande inclut `sudo` pour accorder des autorisations d'écriture sur ces répertoires.
```
$ sudo ./aws/install
```
Vous pouvez effectuer l'installation sans `sudo` si vous spécifiez des répertoires sur lesquels vous disposez déjà d'autorisations en écriture. Utilisez les instructions suivantes pour la commande `install` de manière à spécifier l'emplacement d'installation :
+ Assurez-vous que les chemins d'accès que vous fournissez aux paramètres `-i` et `-b` ne contiennent aucun nom de volume ou de répertoire incluant des espaces quelconques. Dans le cas contraire, l'installation échouera.
+ `--install-dir` ou `-i` : cette option spécifie le répertoire vers lequel copier tous les fichiers.
La valeur par défaut est `/usr/local/aws-cli`.
+ `--bin-dir` ou `-b` : cette option spécifie que le programme `aws` principal du répertoire d’installation est lié symboliquement au fichier `aws` dans le chemin d’accès spécifié. Vous devez disposer des autorisations en écriture sur le répertoire spécifié. La création d'un lien symbolique vers un répertoire se trouvant déjà dans votre chemin d'accès vous dispense d'ajouter le répertoire d'installation à la variable `$PATH` de l'utilisateur.
La valeur par défaut est `/usr/local/bin`.
```
$ ./aws/install -i /usr/local/aws-cli -b /usr/local/bin
```
**Note**
Pour mettre à jour votre installation actuelle du AWS CLI, ajoutez votre lien symbolique et les informations d'installation existants pour créer la `install` commande avec le `--update` paramètre.
```
$ sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
Pour localiser le lien symbolique et le répertoire d’installation existants, procédez comme suit :
Utilisez la commande `which` pour rechercher votre lien symbolique. Cela vous indique le chemin à utiliser avec le paramètre `--bin-dir`.
```
$ which aws
/usr/local/bin/aws
```
Utilisez la commande `ls` pour rechercher le répertoire vers lequel votre lien symbolique pointe. Cela vous indique le chemin à utiliser avec le paramètre `--install-dir`.
```
$ ls -l /usr/local/bin/aws
lrwxrwxrwx 1 ec2-user ec2-user 49 Oct 22 09:49 /usr/local/bin/aws -> /usr/local/aws-cli/v2/current/bin/aws
```
1. Confirmez l’installation à l’aide de la commande suivante.
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Si la commande `aws` est introuvable, vous devrez peut-être redémarrer votre terminal ou suivre les instructions de résolution de problèmes dans [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Snap package ]
Nous fournissons une version officielle AWS prise en charge AWS CLI du`snap`. Si vous souhaitez toujours avoir la dernière version AWS CLI installée sur votre système, un package Snap vous le fournit car il se met à jour automatiquement. Il n'existe pas de support intégré pour sélectionner des versions mineures de AWS CLI . Il ne s'agit donc pas d'une méthode d'installation optimale si votre équipe a besoin d'épingler des versions. Si vous souhaitez installer une version mineure spécifique de l’ AWS CLI, nous vous conseillons d’utiliser le programme d’installation en ligne de commande.
1. Si `snap` n’est pas déjà installé sur votre plate-forme Linux, installez `snap` sur votre plate-forme.
1. Pour en savoir plus sur l’installation de `snap`, consultez [Installation du démon](https://snapcraft.io/docs/installing-snapd) dans la *documentation Snap*.
1. Il est possible que vous deviez redémarrer votre système pour que vos variables `PATH` soient correctement mises à jour. Si vous rencontrez des problèmes d’installation, suivez les étapes décrites sur la page [Fix common issues](https://snapcraft.io/docs/fix-common-issues) de la *documentation Snap*.
1. Pour vérifier que `snap` est installé correctement, exécutez la commande suivante.
```
$ snap version
```
1. Exécutez la commande `snap install` suivante pour l’ AWS CLI.
```
$ snap install aws-cli --classic
```
En fonction de vos autorisations, vous pouvez avoir besoin d’ajouter `sudo` à la commande.
```
$ sudo snap install aws-cli --classic
```
**Note**
Pour consulter le référentiel de snapshots pour le AWS CLI, y compris `snap` les instructions supplémentaires, consultez la [https://snapcraft.io/aws-cli](https://snapcraft.io/aws-cli)page du site Web de *Canonical Snapcraft*.
1. Vérifiez qu'ils AWS CLI sont correctement installés.
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Si vous obtenez une erreur, consultez [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
------
### macOS
#### Exigences d’installation et de mise à jour
+ Nous les prenons en charge AWS CLI sur les versions 11 et ultérieures de macOS. Pour plus d'informations, consultez les [mises à jour de la politique de support de macOS pour la AWS CLI version v2](https://aws.amazon.com/blogs/developer/macos-support-policy-updates-for-the-aws-cli-v2/) sur le *blog AWS consacré aux outils* de développement.
+ Comme elle AWS ne gère pas de référentiels tiers, nous ne pouvons pas garantir qu'ils contiennent la dernière version du AWS CLI.
**Matrice de prise en charge des versions de macOS**
| AWS CLI version | Version de macOS prise en charge |
| --- | --- |
| 2.21.0 – Version actuelle | 11\$1 |
| 2.17.0 – 2.20.0 | 10.15\$1 |
| 2.0.0 – 2.16.12 | 10.14 et antérieures |
#### Installez ou mettez à jour AWS CLI
Si vous effectuez une mise à jour vers la dernière version, utilisez la même méthode d'installation que celle utilisée pour la version actuelle. Vous pouvez l'installer AWS CLI sur macOS de la manière suivante.
------
#### [ GUI installer ]
Les étapes suivantes indiquent comment installer la dernière version du à l'aide AWS CLI de l'interface utilisateur standard de macOS et de votre navigateur.
1. Dans le navigateur, téléchargez le fichier `pkg` macOS : [https://awscli.amazonaws.com/AWSCLIV2.pkg](https://awscli.amazonaws.com/AWSCLIV2.pkg)
1. Exécutez le fichier téléchargé, puis suivez les instructions à l’écran. Vous pouvez choisir d'installer AWS CLI le comme suit :
+ **Pour tous les utilisateurs de l'ordinateur (nécessite `sudo`)**
+ Vous pouvez installer dans n'importe quel dossier ou choisir le dossier par défaut recommandé, à savoir `/usr/local/aws-cli`.
+ Le programme d'installation crée automatiquement un lien symbolique à l'adresse `/usr/local/bin/aws` qui fait le lien avec le programme principal du dossier d'installation que vous avez choisi.
+ **Pour le seul utilisateur actuel (ne nécessite pas `sudo`)**
+ Vous pouvez installer dans n'importe quel dossier sur lequel vous disposez d'une autorisation d'écriture.
+ En raison des autorisations utilisateur standard, une fois le programme d'installation terminé, vous devez créer manuellement un fichier de lien symbolique dans votre variable `$PATH` qui pointe vers les programmes `aws` et `aws_completer` en entrant les commandes suivantes à l'invite de commandes. L’emplacement par défaut d’un lien symbolique est `/usr/local/bin/` :
```
$ ln -s /folder/installed/aws-cli/aws /usr/local/bin/aws
$ ln -s /folder/installed/aws-cli/aws_completer /usr/local/bin/aws_completer
```
Si vous ne disposez pas d’autorisations d’écriture sur le dossier, vous devrez peut-être utiliser `sudo` dans votre commande. L’exemple suivant utilise `sudo` avec `/usr/local/bin/` comme emplacement par défaut d’un lien symbolique :
```
$ sudo ln -s /folder/installed/aws-cli/aws /usr/local/bin/aws
$ sudo ln -s /folder/installed/aws-cli/aws_completer /usr/local/bin/aws_completer
```
**Note**
Vous pouvez afficher les journaux de débogage pour l'installation en appuyant sur **Cmd\$1L** n'importe où dans le programme d'installation. Un volet du journal s'ouvre alors qui vous permet de filtrer et d'enregistrer le journal. Le fichier journal est également automatiquement enregistré dans `/var/log/install.log`.
1. Pour vérifier que le shell peut rechercher et exécuter la commande `aws` dans votre variable `$PATH`, utilisez les commandes suivantes.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Si la commande `aws` est introuvable, vous devrez peut-être redémarrer votre terminal ou suivre les instructions de résolution de problèmes dans [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Command line installer - All users ]
Si vous disposez des autorisations `sudo`, vous pouvez installer l' AWS CLI pour tous les utilisateurs sur l'ordinateur. Nous fournissons les étapes dans un groupe facile à copier et coller. Consultez les descriptions de chaque ligne dans les étapes suivantes.
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
$ sudo installer -pkg AWSCLIV2.pkg -target /
```
**Instructions d’installation guidées**
1. Vous pouvez télécharger le fichier à l'aide de la commande `curl`. L’option `-o` spécifie le nom du fichier dans lequel le package téléchargé est écrit. Dans cet exemple, le fichier est écrit dans `AWSCLIV2.pkg` du dossier actuel.
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
```
1. Exécutez le programme `installer` macOS standard, en spécifiant le fichier `.pkg` téléchargé comme source. Utilisez le paramètre `-pkg` pour spécifier le nom du package à installer et le paramètre `-target /` pour spécifier l'unité sur laquelle le package doit être installé. Les fichiers sont installés dans `/usr/local/aws-cli`, et un lien symbolique est automatiquement créé dans `/usr/local/bin`. Vous devez inclure `sudo` dans la commande pour accorder les autorisations d'écriture à ces dossiers.
```
$ sudo installer -pkg ./AWSCLIV2.pkg -target /
```
Une fois l'installation terminée, les journaux de débogage sont écrits dans `/var/log/install.log`.
1. Pour vérifier que le shell peut rechercher et exécuter la commande `aws` dans votre variable `$PATH`, utilisez les commandes suivantes.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Si la commande `aws` est introuvable, vous devrez peut-être redémarrer votre terminal ou suivre les instructions de résolution de problèmes dans [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Command line - Current user ]
1. Pour spécifier le dossier dans lequel AWS CLI il est installé, vous devez créer un fichier XML portant n'importe quel nom de fichier. Ce fichier est un fichier au format XML qui ressemble à l'exemple suivant. Laissez toutes les valeurs comme indiqué, sauf que vous devez remplacer le chemin */Users/myusername* de la ligne 9 par le chemin du dossier dans lequel vous souhaitez l' AWS CLI installer. *Le dossier doit déjà exister, sinon la commande échoue.* L'exemple XML suivant, nommé*choices.xml*, indique le programme d'installation à installer AWS CLI dans le dossier`/Users/myusername`, où il crée un dossier nommé`aws-cli`.
```
choiceAttribute
customLocation
attributeSetting
/Users/myusername
choiceIdentifier
default
```
1. Téléchargez le programme d'installation `pkg` à l'aide de la commande `curl`. L’option `-o` spécifie le nom du fichier dans lequel le package téléchargé est écrit. Dans cet exemple, le fichier est écrit dans `AWSCLIV2.pkg` du dossier actuel.
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
```
1. Exécutez le programme `installer` macOS standard avec les options suivantes :
+ Spécifiez le nom du package à installer à l'aide du paramètre `-pkg`.
+ Spécifiez une installation pour l’*utilisateur actuel uniquement* en définissant le paramètre `-target` sur `CurrentUserHomeDirectory`.
+ Spécifiez le chemin d'accès (relatif au dossier actuel) et le nom du fichier XML que vous avez créé dans le paramètre `-applyChoiceChangesXML`.
L'exemple suivant installe le AWS CLI dans le dossier. `/Users/myusername/aws-cli`
```
$ installer -pkg AWSCLIV2.pkg \
-target CurrentUserHomeDirectory \
-applyChoiceChangesXML choices.xml
```
1. Les autorisations utilisateur standard n'autorisant généralement pas l'écriture dans les dossiers de votre variable `$PATH`, le programme d'installation de ce mode n'essaie pas d'ajouter les liens symboliques aux programmes `aws` et `aws_completer`. AWS CLI Pour que le programme s'exécute correctement, vous devez créer manuellement les liens symboliques une fois le programme d'installation terminé. Si votre variable `$PATH` inclut un dossier dans lequel vous pouvez écrire et que vous spécifiez ce dossier comme chemin d'accès de la cible, vous pouvez exécuter la commande suivante sans `sudo`. Si vous ne disposez pas d'un dossier accessible en écriture dans votre variable `$PATH`, vous devez utiliser `sudo` pour les autorisations d'écriture dans le dossier cible spécifié. L'emplacement par défaut d'un lien symbolique est `/usr/local/bin/`. Remplacez `folder/installed` par le chemin d’accès à votre installation de l’ AWS CLI .
```
$ sudo ln -s /folder/installed/aws-cli/aws /usr/local/bin/aws
$ sudo ln -s /folder/installed/aws-cli/aws_completer /usr/local/bin/aws_completer
```
Une fois l'installation terminée, les journaux de débogage sont écrits dans `/var/log/install.log`.
1. Pour vérifier que le shell peut rechercher et exécuter la commande `aws` dans votre variable `$PATH`, utilisez les commandes suivantes.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Si la commande `aws` est introuvable, vous devrez peut-être redémarrer votre terminal ou suivre les instructions de résolution de problèmes dans [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
------
### Windows
#### Exigences d’installation et de mise à jour
+ Nous prenons en charge les versions AWS CLI de Windows 64 bits prises en charge par Microsoft.
+ Droits d'administrateur pour installer le logiciel
#### Installez ou mettez à jour AWS CLI
Pour mettre à jour votre installation actuelle AWS CLI sous Windows, téléchargez un nouveau programme d'installation à chaque mise à jour pour remplacer les versions précédentes. AWS CLI est régulièrement mis à jour. Pour savoir quand la dernière version a été publiée, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). *GitHub*
1. Téléchargez et exécutez le programme d'installation AWS CLI MSI pour Windows (64 bits) :
[https://awscli.amazonaws.com/AWSCLIV2.msi](https://awscli.amazonaws.com/AWSCLIV2.msi)
Vous pouvez également exécuter la commande `msiexec` pour exécuter le programme d’installation MSI.
```
C:\> msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2.msi
```
Pour connaître les différents paramètres pouvant être utilisés avec `msiexec`, consultez [msiexec](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/msiexec) sur le site web *Microsoft Docs*. Par exemple, vous pouvez utiliser l’indicateur `/qn` pour une installation en mode silencieux.
```
C:\> msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2.msi /qn
```
1. Pour confirmer l'installation, ouvrez le menu **Démarrer**, recherchez `cmd` pour ouvrir une fenêtre d'invite de commandes et, à l'invite de commandes, utilisez la commande `aws --version`.
```
C:\> aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Si Windows ne trouve pas le programme, vous devrez peut-être fermer puis rouvrir la fenêtre d’invite de commande pour actualiser le chemin, ou suivre les instructions de résolution de problèmes dans[Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
## Résolution des erreurs AWS CLI d'installation et de désinstallation
Si vous rencontrez des problèmes après l'installation ou la désinstallation du AWS CLI, consultez les étapes de résolution [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md) des problèmes. Pour connaître les étapes de résolution de problèmes les plus pertinentes, consultez [Erreurs de type Commande introuvable](cli-chap-troubleshooting.md#tshoot-install-not-found), [La commande « `aws --version` » renvoie une version différente de celle que vous avez installée](cli-chap-troubleshooting.md#tshoot-install-wrong-version) et [La commande « `aws --version` » renvoie une version après avoir désinstallé le AWS CLI](cli-chap-troubleshooting.md#tshoot-uninstall-1).
## Étapes suivantes
Une fois que vous avez installé le AWS CLI, vous pouvez supprimer en toute sécurité les fichiers d'installation que vous avez téléchargés. Après avoir terminé les étapes [Prérequis pour utiliser la AWS CLI version 2](getting-started-prereqs.md) et installé le AWS CLI, vous devez effectuer un[Configuration du AWS CLI](getting-started-quickstart.md).
# Installation des versions précédentes de la AWS CLI version 2
Cette rubrique décrit comment installer les versions précédentes de la AWS Command Line Interface version 2 (AWS CLI) sur les systèmes d'exploitation pris en charge. Pour plus d'informations sur les AWS CLI versions 2, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). GitHub
AWS CLI instructions d'installation de la version 2 :
## Linux
### Exigences d’installation
+ Vous savez quelle version de la AWS CLI version 2 vous souhaitez installer. Pour une liste des versions, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). *GitHub*
+ Vous devez être en mesure d’extraire ou de « décompresser » le package téléchargé. Si votre système d'exploitation ne dispose pas de la commande `unzip` intégrée, utilisez un équivalent.
+ La AWS CLI version 2 utilise `glibc``groff`, et`less`. Ces commandes sont incluses par défaut dans la plupart des distributions majeures de Linux.
+ Nous prenons en charge la AWS CLI version 2 sur les versions 64 bits des distributions récentes de CentOS, Fedora, Ubuntu, Amazon Linux 1, Amazon Linux 2 et Linux ARM.
+ Comme elle AWS ne gère pas de référentiels tiers, nous ne pouvons pas garantir qu'ils contiennent la dernière version du AWS CLI.
### Instructions d'installation
Suivez ces étapes depuis la ligne de commande pour installer AWS CLI le sous Linux.
Nous fournissons les étapes dans un groupe facile à copier et coller selon que vous utilisez Linux 64 bits ou Linux ARM. Consultez les descriptions de chaque ligne dans les étapes suivantes.
------
#### [ Linux x86 (64-bit) ]
**Note**
**(Facultatif)** La commande suivante bloque le téléchargement et l'installe AWS CLI sans vérifier au préalable l'intégrité de votre téléchargement. Pour vérifier l’intégrité de votre téléchargement, suivez les instructions détaillées ci-dessous.
Pour une liste des versions, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). *GitHub*
**Pour installer** le AWS CLI, exécutez les commandes suivantes.
Pour spécifier une version, ajoutez un tiret et le numéro de version au nom de fichier. Dans cet exemple, le nom du fichier pour la version *2.0.30* entraînerait la commande suivante : `awscli-exe-linux-x86_64-2.0.30.zip`
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
**Pour mettre à jour votre installation actuelle** de l’ AWS CLI, ajoutez le lien symbolique et les informations d’installation existants afin de construire la commande `install` à l’aide des paramètres `--bin-dir`, `--install-dir` et `--update`. Le bloc de commande suivant utilise un exemple de lien symbolique */usr/local/bin* et un exemple d'emplacement du programme d'installation de*/usr/local/aws-cli*.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
------
#### [ Linux ARM ]
**Note**
**(Facultatif)** La commande suivante bloque le téléchargement et l'installe AWS CLI sans vérifier au préalable l'intégrité de votre téléchargement. Pour vérifier l’intégrité de votre téléchargement, suivez les instructions détaillées ci-dessous.
Pour une liste des versions, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). *GitHub*
**Pour installer** le AWS CLI, exécutez les commandes suivantes.
Pour spécifier une version, ajoutez un tiret et le numéro de version au nom de fichier. Dans cet exemple, le nom du fichier pour la version *2.0.30* entraînerait la commande suivante : `awscli-exe-linux-aarch64-2.0.30.zip`
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
**Pour mettre à jour votre installation actuelle** de l’ AWS CLI, ajoutez le lien symbolique et les informations d’installation existants afin de construire la commande `install` à l’aide des paramètres `--bin-dir`, `--install-dir` et `--update`. Le bloc de commande suivant utilise un exemple de lien symbolique */usr/local/bin* et un exemple d'emplacement du programme d'installation de*/usr/local/aws-cli*.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
------
1. Téléchargez le fichier d’installation de l’une des façons suivantes :
------
#### [ Linux x86 (64-bit) ]
+ **Utilisation de la commande `curl`** : l’option `-o` spécifie le nom du fichier dans lequel le package téléchargé est écrit. Les options de l'exemple de commande suivant permettent de copier le fichier téléchargé dans le répertoire courant avec le nom local `awscliv2.zip`
Pour spécifier une version, ajoutez un tiret et le numéro de version au nom de fichier. Dans cet exemple, le nom du fichier pour la version *2.0.30* entraînerait la commande suivante : `awscli-exe-linux-x86_64-2.0.30.zip`
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip" -o "awscliv2.zip"
```
Pour une liste des versions, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). *GitHub*
+ **Téléchargement depuis l’URL** :
Dans votre navigateur, téléchargez votre version spécifique du en AWS CLI ajoutant un trait d'union et le numéro de version au nom de fichier.
```
https://awscli.amazonaws.com/awscli-exe-linux-x86_64-version.number.zip
```
Dans cet exemple, le nom de fichier de la version *2.0.30* serait awscli-exe-linux-x 86\$164-2.0.30.zip, d'où le lien suivant : [https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip](https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip)
------
#### [ Linux ARM ]
+ **Utilisation de la commande `curl`** : l’option `-o` spécifie le nom du fichier dans lequel le package téléchargé est écrit. Les options de l'exemple de commande suivant permettent de copier le fichier téléchargé dans le répertoire courant avec le nom local `awscliv2.zip`
Pour spécifier une version, ajoutez un tiret et le numéro de version au nom de fichier. Dans cet exemple, le nom du fichier pour la version *2.0.30* entraînerait la commande suivante : `awscli-exe-linux-aarch64-2.0.30.zip`
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
+ **Téléchargement depuis l’URL** :
Dans votre navigateur, téléchargez votre version spécifique du en AWS CLI ajoutant un trait d'union et le numéro de version au nom de fichier.
```
https://awscli.amazonaws.com/awscli-exe-linux-aarch64-version.number.zip
```
Dans cet exemple, le nom de fichier de la version *2.0.30* donnerait `awscli-exe-linux-aarch64-2.0.30.zip` le lien suivant : [https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip](https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip)
------
1. **(Facultatif) Vérification de l’intégrité du fichier zip téléchargé**
Si vous avez choisi de télécharger manuellement le package AWS CLI d'installation `.zip` en suivant les étapes ci-dessus, vous pouvez utiliser les étapes suivantes pour vérifier les signatures à l'aide de l'`GnuPG`outil.
Les `.zip` fichiers du package AWS CLI d'installation sont signés cryptographiquement à l'aide de signatures PGP. En cas de dommage ou d'altération des fichiers, cette vérification échoue et vous ne devez pas poursuivre l'installation.
1. Téléchargez et installez la commande `gpg` à l'aide de votre gestionnaire de packages. Pour plus d’informations sur `GnuPG`, consultez le [site Web GnuPG](https://www.gnupg.org/).
1. Pour créer le fichier de clé publique, créez un fichier texte et collez le texte suivant.
```
-----BEGIN PGP PUBLIC KEY BLOCK-----
mQINBF2Cr7UBEADJZHcgusOJl7ENSyumXh85z0TRV0xJorM2B/JL0kHOyigQluUG
ZMLhENaG0bYatdrKP+3H91lvK050pXwnO/R7fB/FSTouki4ciIx5OuLlnJZIxSzx
PqGl0mkxImLNbGWoi6Lto0LYxqHN2iQtzlwTVmq9733zd3XfcXrZ3+LblHAgEt5G
TfNxEKJ8soPLyWmwDH6HWCnjZ/aIQRBTIQ05uVeEoYxSh6wOai7ss/KveoSNBbYz
gbdzoqI2Y8cgH2nbfgp3DSasaLZEdCSsIsK1u05CinE7k2qZ7KgKAUIcT/cR/grk
C6VwsnDU0OUCideXcQ8WeHutqvgZH1JgKDbznoIzeQHJD238GEu+eKhRHcz8/jeG
94zkcgJOz3KbZGYMiTh277Fvj9zzvZsbMBCedV1BTg3TqgvdX4bdkhf5cH+7NtWO
lrFj6UwAsGukBTAOxC0l/dnSmZhJ7Z1KmEWilro/gOrjtOxqRQutlIqG22TaqoPG
fYVN+en3Zwbt97kcgZDwqbuykNt64oZWc4XKCa3mprEGC3IbJTBFqglXmZ7l9ywG
EEUJYOlb2XrSuPWml39beWdKM8kzr1OjnlOm6+lpTRCBfo0wa9F8YZRhHPAkwKkX
XDeOGpWRj4ohOx0d2GWkyV5xyN14p2tQOCdOODmz80yUTgRpPVQUtOEhXQARAQAB
tCFBV1MgQ0xJIFRlYW0gPGF3cy1jbGlAYW1hem9uLmNvbT6JAlQEEwEIAD4CGwMF
CwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQT7Xbd/1cEYuAURraimMQrMRnJHXAUC
aGveYQUJDMpiLAAKCRCmMQrMRnJHXKBYD/9Ab0qQdGiO5hObchG8xh8Rpb4Mjyf6
0JrVo6m8GNjNj6BHkSc8fuTQJ/FaEhaQxj3pjZ3GXPrXjIIVChmICLlFuRXYzrXc
Pw0lniybypsZEVai5kO0tCNBCCFuMN9RsmmRG8mf7lC4FSTbUDmxG/QlYK+0IV/l
uJkzxWa+rySkdpm0JdqumjegNRgObdXHAQDWlubWQHWyZyIQ2B4U7AxqSpcdJp6I
S4Zds4wVLd1WE5pquYQ8vS2cNlDm4QNg8wTj58e3lKN47hXHMIb6CHxRnb947oJa
pg189LLPR5koh+EorNkA1wu5mAJtJvy5YMsppy2y/kIjp3lyY6AmPT1posgGk70Z
CmToEZ5rbd7ARExtlh76A0cabMDFlEHDIK8RNUOSRr7L64+KxOUegKBfQHb9dADY
qqiKqpCbKgvtWlds909Ms74JBgr2KwZCSY1HaOxnIr4CY43QRqAq5YHOay/mU+6w
hhmdF18vpyK0vfkvvGresWtSXbag7Hkt3XjaEw76BzxQH21EBDqU8WJVjHgU6ru+
DJTs+SxgJbaT3hb/vyjlw0lK+hFfhWKRwgOXH8vqducF95NRSUxtS4fpqxWVaw3Q
V2OWSjbne99A5EPEySzryFTKbMGwaTlAwMCwYevt4YT6eb7NmFhTx0Fis4TalUs+
j+c7Kg92pDx2uQ==
=OBAt
-----END PGP PUBLIC KEY BLOCK-----
```
Pour référence, les détails de la clé publique sont les suivants.
```
Key ID: A6310ACC4672
Type: RSA
Size: 4096/4096
Created: 2019-09-18
Expires: 2026-07-07
User ID: AWS CLI Team
Key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
1. Importez la clé AWS CLI publique à l'aide de la commande suivante, en la *public-key-file-name* remplaçant par le nom de fichier de la clé publique que vous avez créée.
```
$ gpg --import public-key-file-name
gpg: /home/username/.gnupg/trustdb.gpg: trustdb created
gpg: key A6310ACC4672475C: public key "AWS CLI Team " imported
gpg: Total number processed: 1
gpg: imported: 1
```
1. Téléchargez le fichier de AWS CLI signature du package que vous avez téléchargé. Celui-ci a le même chemin d'accès et le même nom que le fichier `.zip` auquel il correspond, mais son extension est `.sig`. Dans les exemples suivants, nous l'enregistrons dans le répertoire courant sous la forme d'un fichier nommé `awscliv2.sig`.
------
#### [ Linux x86 (64-bit) ]
**Pour la dernière version de AWS CLI,** utilisez le bloc de commande suivant :
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip.sig
```
**Pour une version spécifique de AWS CLI,** ajoutez un trait d'union et le numéro de version au nom du fichier. Dans cet exemple, le nom du fichier pour la version *2.0.30* entraînerait la commande suivante : `awscli-exe-linux-x86_64-2.0.30.zip.sig`
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip.sig
```
Pour une liste des versions, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). *GitHub*
------
#### [ Linux ARM ]
**Pour la dernière version de AWS CLI,** utilisez le bloc de commande suivant :
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip.sig
```
**Pour une version spécifique de AWS CLI,** ajoutez un trait d'union et le numéro de version au nom du fichier. Dans cet exemple, le nom du fichier pour la version *2.0.30* entraînerait la commande suivante : `awscli-exe-linux-aarch64-2.0.30.zip.sig`
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip.sig
```
Pour une liste des versions, consultez le journal des [modifications de la AWS CLI version 2 sur](https://github.com/aws/aws-cli/blob/v2/CHANGELOG.rst?plain=1). *GitHub*
------
1. Vérifiez la signature en transmettant les noms de fichiers `.sig` et `.zip` téléchargés sous forme de paramètres à la commande `gpg`.
```
$ gpg --verify awscliv2.sig awscliv2.zip
```
La sortie doit ressembler à ce qui suit :
```
gpg: Signature made Mon Nov 4 19:00:01 2019 PST
gpg: using RSA key FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
gpg: Good signature from "AWS CLI Team " [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
**Important**
L’avertissement mentionné dans la sortie est attendu et n’indique pas de problème. Cela se produit parce qu'il n'existe pas de chaîne de confiance entre votre clé PGP personnelle (si vous en avez une) et la clé AWS CLI PGP. Pour plus d’informations, consultez [Web of trust](https://en.wikipedia.org/wiki/Web_of_trust).
1. Décompressez le programme d'installation. Si votre distribution Linux n'a pas de commande `unzip` intégrée, utilisez un équivalent pour procéder à la décompression. L'exemple de commande suivant décompresse le package et crée un répertoire nommé `aws` dans le répertoire courant.
```
$ unzip awscliv2.zip
```
1. Exécutez le programme d’installation. La commande d'installation utilise un fichier nommé `install` dans le répertoire `aws` récemment décompressé. Par défaut, les fichiers sont tous installés dans `/usr/local/aws-cli` et un lien symbolique est créé dans `/usr/local/bin`. La commande inclut `sudo` pour accorder des autorisations d'écriture sur ces répertoires.
```
$ sudo ./aws/install
```
Vous pouvez effectuer l'installation sans `sudo` si vous spécifiez des répertoires sur lesquels vous disposez déjà d'autorisations en écriture. Utilisez les instructions suivantes pour la commande `install` de manière à spécifier l'emplacement d'installation :
+ Assurez-vous que les chemins d'accès que vous fournissez aux paramètres `-i` et `-b` ne contiennent aucun nom de volume ou de répertoire incluant des espaces quelconques. Dans le cas contraire, l'installation échouera.
+ `--install-dir` ou `-i` : cette option spécifie le répertoire vers lequel copier tous les fichiers.
La valeur par défaut est `/usr/local/aws-cli`.
+ `--bin-dir` ou `-b` : cette option spécifie que le programme `aws` principal du répertoire d’installation est lié symboliquement au fichier `aws` dans le chemin d’accès spécifié. Vous devez disposer des autorisations en écriture sur le répertoire spécifié. La création d'un lien symbolique vers un répertoire se trouvant déjà dans votre chemin d'accès vous dispense d'ajouter le répertoire d'installation à la variable `$PATH` de l'utilisateur.
La valeur par défaut est `/usr/local/bin`.
```
$ ./aws/install -i /usr/local/aws-cli -b /usr/local/bin
```
**Note**
Pour mettre à jour votre installation actuelle de la AWS CLI version 2 vers une version plus récente, ajoutez votre lien symbolique et les informations d'installation existants pour créer la `install` commande avec le `--update` paramètre.
```
$ sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
Pour localiser le lien symbolique et le répertoire d’installation existants, procédez comme suit :
Utilisez la commande `which` pour rechercher votre lien symbolique. Cela vous indique le chemin à utiliser avec le paramètre `--bin-dir`.
```
$ which aws
/usr/local/bin/aws
```
Utilisez la commande `ls` pour rechercher le répertoire vers lequel votre lien symbolique pointe. Cela vous indique le chemin à utiliser avec le paramètre `--install-dir`.
```
$ ls -l /usr/local/bin/aws
lrwxrwxrwx 1 ec2-user ec2-user 49 Oct 22 09:49 /usr/local/bin/aws -> /usr/local/aws-cli/v2/current/bin/aws
```
1. Confirmez l’installation à l’aide de la commande suivante.
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Si la commande `aws` est introuvable, vous devrez peut-être redémarrer votre terminal ou suivre les instructions de résolution de problèmes dans [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
## macOS
### Exigences d’installation
+ Vous savez quelle version de la AWS CLI version 2 vous souhaitez installer. Pour une liste des versions, consultez le journal des [modifications de la AWS CLI version 2 sur](https://github.com/aws/aws-cli/blob/v2/CHANGELOG.rst?plain=1). *GitHub*
+ Nous prenons en charge la AWS CLI version 2 sur les versions de macOS 64 bits compatibles avec Apple.
+ Comme elle AWS ne gère pas de référentiels tiers, nous ne pouvons pas garantir qu'ils contiennent la dernière version du AWS CLI.
### Instructions d'installation
Vous pouvez installer la AWS CLI version 2 sur macOS de différentes manières.
------
#### [ GUI installer ]
Les étapes suivantes montrent comment installer ou mettre à jour la dernière version de la version 2 de l’ AWS CLI à l’aide de l’interface utilisateur macOS standard et d’un navigateur. Si vous effectuez une mise à jour vers la dernière version, utilisez la même méthode d'installation que celle utilisée pour la version actuelle.
1. Dans votre navigateur, téléchargez votre version spécifique du en AWS CLI ajoutant un trait d'union et le numéro de version au nom de fichier.
```
https://awscli.amazonaws.com/AWSCLIV2-version.number.pkg
```
Pour cet exemple, le nom de fichier de la version *2.0.30* `AWSCLIV2-2.0.30.pkg` entraînerait le lien suivant :[https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg](https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg).
1. Exécutez le fichier téléchargé, puis suivez les instructions à l’écran. Vous pouvez choisir d'installer la AWS CLI version 2 de la manière suivante :
+ **Pour tous les utilisateurs de l'ordinateur (nécessite `sudo`)**
+ Vous pouvez installer dans n'importe quel dossier ou choisir le dossier par défaut recommandé, à savoir `/usr/local/aws-cli`.
+ Le programme d'installation crée automatiquement un lien symbolique à l'adresse `/usr/local/bin/aws` qui fait le lien avec le programme principal du dossier d'installation que vous avez choisi.
+ **Pour le seul utilisateur actuel (ne nécessite pas `sudo`)**
+ Vous pouvez installer dans n'importe quel dossier sur lequel vous disposez d'une autorisation d'écriture.
+ En raison des autorisations utilisateur standard, une fois le programme d'installation terminé, vous devez créer manuellement un fichier de lien symbolique dans votre variable `$PATH` qui pointe vers les programmes `aws` et `aws_completer` en entrant les commandes suivantes à l'invite de commandes. Si votre variable `$PATH` inclut un dossier dans lequel vous pouvez écrire, vous pouvez exécuter la commande suivante sans `sudo` si vous spécifiez ce dossier comme chemin d'accès de la cible. Si vous n'avez pas de dossier accessible en écriture dans votre variable `$PATH`, vous devez utiliser `sudo` dans les commandes pour obtenir les autorisations d'écriture dans le dossier cible spécifié. L'emplacement par défaut d'un lien symbolique est `/usr/local/bin/`.
```
$ sudo ln -s /folder/installed/aws-cli/aws /usr/local/bin/aws
$ sudo ln -s /folder/installed/aws-cli/aws_completer /usr/local/bin/aws_completer
```
**Note**
Vous pouvez afficher les journaux de débogage pour l'installation en appuyant sur **Cmd\$1L** n'importe où dans le programme d'installation. Un volet du journal s'ouvre alors qui vous permet de filtrer et d'enregistrer le journal. Le fichier journal est également automatiquement enregistré dans `/var/log/install.log`.
1. Pour vérifier que le shell peut rechercher et exécuter la commande `aws` dans votre variable `$PATH`, utilisez les commandes suivantes.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Si la commande `aws` est introuvable, vous devrez peut-être redémarrer votre terminal ou suivre les instructions de résolution de problèmes dans [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Command line installer - All users ]
Si vous disposez `sudo` d'autorisations, vous pouvez installer la AWS CLI version 2 pour tous les utilisateurs de l'ordinateur. Nous fournissons les étapes dans un groupe facile à copier et coller. Consultez les descriptions de chaque ligne dans les étapes suivantes.
Pour une version spécifique de AWS CLI, ajoutez un trait d'union et le numéro de version au nom du fichier. Dans cet exemple, le nom du fichier pour la version *2.0.30* entraînerait la commande suivante : `AWSCLIV2-2.0.30.pkg`
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg" -o "AWSCLIV2.pkg"
$ sudo installer -pkg AWSCLIV2.pkg -target /
```
1. Vous pouvez télécharger le fichier à l'aide de la commande `curl`. L’option `-o` spécifie le nom du fichier dans lequel le package téléchargé est écrit. Dans cet exemple, le fichier est écrit dans `AWSCLIV2.pkg` du dossier actuel.
Pour une version spécifique de AWS CLI, ajoutez un trait d'union et le numéro de version au nom du fichier. Dans cet exemple, le nom du fichier pour la version *2.0.30* entraînerait la commande suivante : `AWSCLIV2-2.0.30.pkg`
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg" -o "AWSCLIV2.pkg"
```
Pour une liste des versions, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). *GitHub*
1. Exécutez le programme `installer` macOS standard, en spécifiant le fichier `.pkg` téléchargé comme source. Utilisez le paramètre `-pkg` pour spécifier le nom du package à installer et le paramètre `-target /` pour spécifier l'unité sur laquelle le package doit être installé. Les fichiers sont installés dans `/usr/local/aws-cli`, et un lien symbolique est automatiquement créé dans `/usr/local/bin`. Vous devez inclure `sudo` dans la commande pour accorder les autorisations d'écriture à ces dossiers.
```
$ sudo installer -pkg ./AWSCLIV2.pkg -target /
```
Une fois l'installation terminée, les journaux de débogage sont écrits dans `/var/log/install.log`.
1. Pour vérifier que le shell peut rechercher et exécuter la commande `aws` dans votre variable `$PATH`, utilisez les commandes suivantes.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Si la commande `aws` est introuvable, vous devrez peut-être redémarrer votre terminal ou suivre les instructions de résolution de problèmes dans [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Command line - Current user ]
1. Pour spécifier le dossier dans lequel AWS CLI il est installé, vous devez créer un fichier XML. Ce fichier est un fichier au format XML qui ressemble à l'exemple suivant. Laissez toutes les valeurs comme indiqué, sauf que vous devez remplacer le chemin */Users/myusername* de la ligne 9 par le chemin du dossier dans lequel vous souhaitez installer la AWS CLI version 2. *Le dossier doit déjà exister, sinon la commande échoue.* Cet exemple XML indique que le programme d'installation installe le AWS CLI dans le dossier`/Users/myusername`, où il crée un dossier nommé`aws-cli`.
```
choiceAttribute
customLocation
attributeSetting
/Users/myusername
choiceIdentifier
default
```
1. Téléchargez le programme d'installation `pkg` à l'aide de la commande `curl`. L’option `-o` spécifie le nom du fichier dans lequel le package téléchargé est écrit. Dans cet exemple, le fichier est écrit dans `AWSCLIV2.pkg` du dossier actuel.
Pour la version spécifique de AWS CLI, ajoutez un trait d'union et le numéro de version au nom du fichier. Dans cet exemple, le nom du fichier pour la version *2.0.30* entraînerait la commande suivante : `AWSCLIV2-2.0.30.pkg`
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg" -o "AWSCLIV2.pkg"
```
Pour une liste des versions, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). *GitHub*
1. Exécutez le programme `installer` macOS standard avec les options suivantes :
+ Spécifiez le nom du package à installer à l'aide du paramètre `-pkg`.
+ Spécifiez une installation pour l’*utilisateur actuel uniquement* en définissant le paramètre `-target` sur `CurrentUserHomeDirectory`.
+ Spécifiez le chemin d'accès (relatif au dossier actuel) et le nom du fichier XML que vous avez créé dans le paramètre `-applyChoiceChangesXML`.
L'exemple suivant installe le AWS CLI dans le dossier. `/Users/myusername/aws-cli`
```
$ installer -pkg AWSCLIV2.pkg \
-target CurrentUserHomeDirectory \
-applyChoiceChangesXML choices.xml
```
1. Les autorisations utilisateur standard n'autorisant généralement pas l'écriture dans les dossiers de votre variable `$PATH`, le programme d'installation de ce mode n'essaie pas d'ajouter les liens symboliques aux programmes `aws` et `aws_completer`. AWS CLI Pour que le programme s'exécute correctement, vous devez créer manuellement les liens symboliques une fois le programme d'installation terminé. Si votre variable `$PATH` inclut un dossier dans lequel vous pouvez écrire et que vous spécifiez ce dossier comme chemin d'accès de la cible, vous pouvez exécuter la commande suivante sans `sudo`. Si vous ne disposez pas d'un dossier accessible en écriture dans votre variable `$PATH`, vous devez utiliser `sudo` pour les autorisations d'écriture dans le dossier cible spécifié. L'emplacement par défaut d'un lien symbolique est `/usr/local/bin/`.
```
$ sudo ln -s /folder/installed/aws-cli/aws /usr/local/bin/aws
$ sudo ln -s /folder/installed/aws-cli/aws_completer /usr/local/bin/aws_completer
```
Une fois l'installation terminée, les journaux de débogage sont écrits dans `/var/log/install.log`.
1. Pour vérifier que le shell peut rechercher et exécuter la commande `aws` dans votre variable `$PATH`, utilisez les commandes suivantes.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Si la commande `aws` est introuvable, vous devrez peut-être redémarrer votre terminal ou suivre les instructions de résolution de problèmes dans [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
------
## Windows
### Exigences d’installation
+ Vous savez quelle version de la AWS CLI version 2 vous souhaitez installer. Pour une liste des versions, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). *GitHub*
+ Nous prenons en charge les versions AWS CLI de Windows 64 bits prises en charge par Microsoft.
+ Droits d'administrateur pour installer le logiciel
### Instructions d'installation
Pour mettre à jour votre installation actuelle de la AWS CLI version 2 sous Windows, téléchargez un nouveau programme d'installation à chaque mise à jour pour remplacer les versions précédentes. AWS CLI est régulièrement mis à jour. Pour savoir quand la dernière version a été publiée, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). *GitHub*
1. Téléchargez et exécutez le programme d'installation AWS CLI MSI pour Windows (64 bits) de l'une des manières suivantes :
+ **Téléchargement et exécution du programme d'installation MSI :** pour créer votre lien de téléchargement pour une version spécifique du AWS CLI, ajoutez un tiret et le numéro de version au nom du fichier.
```
https://awscli.amazonaws.com/AWSCLIV2-version.number.msi
```
Pour cet exemple, le nom de fichier de la version *2.0.30* entraînerait le lien suivant :[https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi](https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi). `AWSCLIV2-2.0.30.msi`
+ **À l’aide de la commande msiexec :** vous pouvez également utiliser le programme d’installation MSI en ajoutant le lien vers la commande `msiexec`. Pour une version spécifique de AWS CLI, ajoutez un trait d'union et le numéro de version au nom du fichier.
```
C:\> msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2-version.number.msi
```
Dans cet exemple, le nom de fichier de la version *2.0.30* donnerait `AWSCLIV2-2.0.30.msi` le lien suivant[https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi](https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi).
```
C:\> msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi
```
Pour connaître les différents paramètres pouvant être utilisés avec `msiexec`, consultez [msiexec](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/msiexec) sur le site web *Microsoft Docs*.
Pour une liste des versions, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). *GitHub*
1. Pour confirmer l'installation, ouvrez le menu **Démarrer**, recherchez `cmd` pour ouvrir une fenêtre d'invite de commandes et, à l'invite de commandes, utilisez la commande `aws --version`.
```
C:\> aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Si Windows ne trouve pas le programme, vous devrez peut-être fermer puis rouvrir la fenêtre d’invite de commande pour actualiser le chemin, ou suivre les instructions de résolution de problèmes dans[Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
## Résolution des erreurs AWS CLI d'installation et de désinstallation
Si vous rencontrez des problèmes après l'installation ou la désinstallation du AWS CLI, consultez les étapes de résolution [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md) des problèmes. Pour connaître les étapes de résolution de problèmes les plus pertinentes, consultez [Erreurs de type Commande introuvable](cli-chap-troubleshooting.md#tshoot-install-not-found), [La commande « `aws --version` » renvoie une version différente de celle que vous avez installée](cli-chap-troubleshooting.md#tshoot-install-wrong-version) et [La commande « `aws --version` » renvoie une version après avoir désinstallé le AWS CLI](cli-chap-troubleshooting.md#tshoot-uninstall-1).
## Étapes suivantes
Après avoir terminé les étapes décrites dans [Prérequis pour utiliser la AWS CLI version 2](getting-started-prereqs.md) et installé l’ AWS CLI, vous devez procéder à une [Configuration du AWS CLI](getting-started-quickstart.md).
# Création et installation du AWS CLI depuis le code source
Cette rubrique décrit comment installer la dernière version de l’ AWS Command Line Interface (AWS CLI) depuis la source, ou effectuer une mise à jour depuis la source sur les systèmes d’exploitation pris en charge.
Pour plus d'informations sur les dernières versions de AWS CLI, consultez le journal des [modifications de la AWS CLI version 2 sur](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst). GitHub
**Important**
AWS CLI les versions 1 et 2 utilisent le même nom de `aws` commande. Si vous avez déjà installé AWS CLI la version 1, consultez[Guide de migration pour la AWS CLI version 2](cliv2-migration.md).
**Topics**
+ [Pourquoi créer depuis la source ?](#source-getting-started-install-why)
+ [Étapes rapides](#source-getting-started-install-quicksteps)
+ [Étape 1 : Configuration de toutes les exigences](#source-getting-started-install-reqs)
+ [Étape 2 : Configuration de l'installation AWS CLI source](#source-getting-started-install-config)
+ [Étape 3 : Création du AWS CLI](#source-getting-started-install-build)
+ [Étape 4 : Installation du AWS CLI](#source-getting-started-install-instructions)
+ [Étape 5 : vérification de l' AWS CLI installation](#source-getting-started-install-verify)
+ [Exemples de flux de travail](#source-getting-started-install-workflows)
+ [Résolution des erreurs AWS CLI d'installation et de désinstallation](#source-install-tshoot)
+ [Étapes suivantes](#source-install-next-steps)
## Pourquoi créer depuis la source ?
AWS CLI Il est [disponible sous forme d'installateurs prédéfinis](getting-started-install.md) pour la plupart des plateformes et environnements, ainsi que sous forme d'image Docker.
En général, ces programmes d’installation couvrent la plupart des cas d’utilisation. Les instructions d’installation depuis la source sont destinés à vous aider pour les cas d’utilisation non couverts par nos programmes d’installation. En voici certains :
+ Les programmes d’installation prédéfinis ne sont pas compatibles avec votre environnement. Par exemple, ARM 32 bits n’est pas pris en charge par les programmes d’installation prédéfinis.
+ Les programmes d’installation prédéfinis comportent des dépendances qui manquent dans votre environnement. Par exemple, Alpine Linux utilise [https://musl.libc.org/](https://musl.libc.org/), mais les programmes d’installation actuels nécessitent `glibc`, ce qui fait que les programmes d’installation prédéfinis ne fonctionnent pas immédiatement.
+ Les programmes d’installation prédéfinis nécessitent des ressources auxquelles votre environnement restreint l’accès. Par exemple, les systèmes de sécurité renforcés peuvent ne pas autoriser l’accès à la mémoire partagée. Ceci est nécessaire pour le programme d’installation `aws` figé.
+ Les programmes d’installation prédéfinis sont souvent des bloqueurs pour les responsables dans les gestionnaires de packages, car il est préférable de contrôler totalement le processus de création du code et des packages. Créer depuis la source permet aux responsables de la distribution de rationaliser le processus pour maintenir à jour l’ AWS CLI . L'activation des responsables fournit aux clients davantage de up-to-date versions du AWS CLI lors de l'installation à partir d'un gestionnaire de packages tiers tel que `brew``yum`, et. `apt`
+ Les clients qui utilisent des AWS CLI fonctionnalités de correctif doivent les créer et les installer AWS CLI depuis le code source. Cela est particulièrement important pour les membres de la communauté qui souhaitent tester les modifications qu'ils ont apportées à la source avant de les apporter au AWS CLI GitHub dépôt.
## Étapes rapides
**Note**
Tous les exemples de code sont supposés s’exécuter depuis la racine du répertoire source.
Pour créer et installer le AWS CLI depuis le code source, suivez les étapes décrites dans cette section. L’ AWS CLI utilise [GNU Autotools](https://www.gnu.org/software/automake/faq/autotools-faq.html) pour installer depuis la source. Dans le cas le plus simple, AWS CLI vous pouvez l'installer à partir de la source en exécutant les exemples de commandes par défaut depuis la racine du AWS CLI GitHub référentiel.
1. [Configurez toutes les exigences pour votre environnement.](#source-getting-started-install-reqs) Cela inclut de pouvoir exécuter les fichiers générés par [GNU Autotools](https://www.gnu.org/software/automake/faq/autotools-faq.html) et que Python 3.8 ou version ultérieure soit installé.
1. Dans votre terminal, naviguez jusqu'au niveau supérieur du dossier AWS CLI source et exécutez la `./configure` commande. Cette commande vérifie le système pour toutes les dépendances requises, et génère un fichier `Makefile` pour créer et installer l’ AWS CLI en fonction des configurations spécifiées et détectées.
------
#### [ Linux and macOS ]
L'exemple de `./configure` commande suivant définit la configuration de construction pour l' AWS CLI utilisation des paramètres par défaut.
```
$ ./configure
```
------
#### [ Windows PowerShell ]
Avant d'exécuter un appel de commande MSYS2, vous devez conserver votre répertoire de travail actuel :
```
PS C:\> $env:CHERE_INVOKING = 'yes'
```
Utilisez ensuite l'exemple de `./configure` commande suivant pour définir la configuration de compilation afin d' AWS CLI utiliser votre chemin local vers votre exécutable Python, de l'installer dans C:\$1Program Files \$1 AWSCLI et de télécharger toutes les dépendances.
```
PS C:\> C:\msys64\usr\bin\bash -lc " PYTHON='C:\path\to\python.exe' ./configure --prefix='C:\Program Files\AWSCLI' --with-download-deps "
```
------
Pour obtenir plus de détails, les options de configuration disponibles et les informations sur les paramètres par défaut, consultez la section [Étape 2 : Configuration de l'installation AWS CLI source](#source-getting-started-install-config).
1. Exécutez la commande `make`. Cette commande crée le AWS CLI en fonction de vos paramètres de configuration.
L’exemple de commande `make` suivant est généré avec les options par défaut utilisant vos paramètres `./configure` existants.
------
#### [ Linux and macOS ]
```
$ make
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "make"
```
------
Pour obtenir plus de détails et les options de build disponibles, consultez la section [Étape 3 : Création du AWS CLI](#source-getting-started-install-build).
1. Exécutez la commande `make install`. Cette commande installe votre build AWS CLI à l'emplacement configuré sur votre système.
L'exemple de `make install` commande suivant installe votre build AWS CLI et crée des liens symboliques dans les emplacements que vous avez configurés à l'aide des paramètres de commande par défaut.
------
#### [ Linux and macOS ]
```
$ make install
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "make install"
```
Après l'installation, ajoutez le chemin à l' AWS CLI aide de ce qui suit :
```
PS C:\> $Env:PATH +=";C:\Program Files\AWSCLI\bin\"
```
------
Pour obtenir plus de détails et les options d’installation disponibles, consultez la section [Étape 4 : Installation du AWS CLI](#source-getting-started-install-instructions).
1. Confirmez l'installation AWS CLI avec succès à l'aide de la commande suivante :
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Pour les étapes de résolution des erreurs d’installation, consultez la section [Résolution des erreurs AWS CLI d'installation et de désinstallation](#source-install-tshoot).
## Étape 1 : Configuration de toutes les exigences
Pour créer le fichier AWS CLI à partir des sources, vous devez au préalable remplir les conditions suivantes :
**Note**
Tous les exemples de code sont supposés s’exécuter depuis la racine du répertoire source.
1. Téléchargez le AWS CLI code source en bifurquant le AWS CLI GitHub dépôt ou en téléchargeant l'archive source. Suivez l’une des instructions suivantes :
+ Forker et cloner le [AWS CLI dépôt](https://github.com/aws/aws-cli) à partir de *GitHub*. Pour plus d'informations, voir [Forker un dépôt](https://docs.github.com/en/get-started/quickstart/fork-a-repo) dans la *GitHub documentation*.
+ Téléchargez la dernière archive de la source à l’adresse [https://awscli.amazonaws.com/awscli.tar.gz](https://awscli.amazonaws.com/awscli.tar.gz), puis extrayez le contenu à l’aide des commandes suivantes :
```
$ curl "https://awscli.amazonaws.com/awscli.tar.gz" -o "awscli.tar.gz"
$ tar -xzf awscli.tar.gz
```
**Note**
Pour télécharger une version spécifique, utilisez le format de lien suivant : [https://awscli.amazonaws.com*versionnumber*/awscli-.tar.gz](https://awscli.amazonaws.com/awscli.tar.gz)
[Par exemple, pour la version 2.10.0, le lien est le suivant : https://awscli.amazonaws.com /awscli- .tar.gz *2.10.0*](https://awscli.amazonaws.com/awscli.tar.gz)
Les versions source sont disponibles à partir de la version **2.10.0** de l’ AWS CLI.
**(Facultatif) Vérification de l’intégrité du fichier zip téléchargé en suivant les étapes ci-après :**
1. Vous pouvez utiliser les étapes suivantes pour vérifier les signatures à l'aide de l'outil `GnuPG`.
Les `.zip` fichiers du package AWS CLI d'installation sont signés cryptographiquement à l'aide de signatures PGP. En cas de dommage ou d'altération des fichiers, cette vérification échoue et vous ne devez pas poursuivre l'installation.
1. Téléchargez et installez la commande `gpg` à l'aide de votre gestionnaire de packages. Pour plus d’informations sur `GnuPG`, consultez le [site Web GnuPG](https://www.gnupg.org/).
1. Pour créer le fichier de clé publique, créez un fichier texte et collez le texte suivant.
```
-----BEGIN PGP PUBLIC KEY BLOCK-----
mQINBF2Cr7UBEADJZHcgusOJl7ENSyumXh85z0TRV0xJorM2B/JL0kHOyigQluUG
ZMLhENaG0bYatdrKP+3H91lvK050pXwnO/R7fB/FSTouki4ciIx5OuLlnJZIxSzx
PqGl0mkxImLNbGWoi6Lto0LYxqHN2iQtzlwTVmq9733zd3XfcXrZ3+LblHAgEt5G
TfNxEKJ8soPLyWmwDH6HWCnjZ/aIQRBTIQ05uVeEoYxSh6wOai7ss/KveoSNBbYz
gbdzoqI2Y8cgH2nbfgp3DSasaLZEdCSsIsK1u05CinE7k2qZ7KgKAUIcT/cR/grk
C6VwsnDU0OUCideXcQ8WeHutqvgZH1JgKDbznoIzeQHJD238GEu+eKhRHcz8/jeG
94zkcgJOz3KbZGYMiTh277Fvj9zzvZsbMBCedV1BTg3TqgvdX4bdkhf5cH+7NtWO
lrFj6UwAsGukBTAOxC0l/dnSmZhJ7Z1KmEWilro/gOrjtOxqRQutlIqG22TaqoPG
fYVN+en3Zwbt97kcgZDwqbuykNt64oZWc4XKCa3mprEGC3IbJTBFqglXmZ7l9ywG
EEUJYOlb2XrSuPWml39beWdKM8kzr1OjnlOm6+lpTRCBfo0wa9F8YZRhHPAkwKkX
XDeOGpWRj4ohOx0d2GWkyV5xyN14p2tQOCdOODmz80yUTgRpPVQUtOEhXQARAQAB
tCFBV1MgQ0xJIFRlYW0gPGF3cy1jbGlAYW1hem9uLmNvbT6JAlQEEwEIAD4CGwMF
CwkIBwIGFQoJCAsCBBYCAwECHgECF4AWIQT7Xbd/1cEYuAURraimMQrMRnJHXAUC
aGveYQUJDMpiLAAKCRCmMQrMRnJHXKBYD/9Ab0qQdGiO5hObchG8xh8Rpb4Mjyf6
0JrVo6m8GNjNj6BHkSc8fuTQJ/FaEhaQxj3pjZ3GXPrXjIIVChmICLlFuRXYzrXc
Pw0lniybypsZEVai5kO0tCNBCCFuMN9RsmmRG8mf7lC4FSTbUDmxG/QlYK+0IV/l
uJkzxWa+rySkdpm0JdqumjegNRgObdXHAQDWlubWQHWyZyIQ2B4U7AxqSpcdJp6I
S4Zds4wVLd1WE5pquYQ8vS2cNlDm4QNg8wTj58e3lKN47hXHMIb6CHxRnb947oJa
pg189LLPR5koh+EorNkA1wu5mAJtJvy5YMsppy2y/kIjp3lyY6AmPT1posgGk70Z
CmToEZ5rbd7ARExtlh76A0cabMDFlEHDIK8RNUOSRr7L64+KxOUegKBfQHb9dADY
qqiKqpCbKgvtWlds909Ms74JBgr2KwZCSY1HaOxnIr4CY43QRqAq5YHOay/mU+6w
hhmdF18vpyK0vfkvvGresWtSXbag7Hkt3XjaEw76BzxQH21EBDqU8WJVjHgU6ru+
DJTs+SxgJbaT3hb/vyjlw0lK+hFfhWKRwgOXH8vqducF95NRSUxtS4fpqxWVaw3Q
V2OWSjbne99A5EPEySzryFTKbMGwaTlAwMCwYevt4YT6eb7NmFhTx0Fis4TalUs+
j+c7Kg92pDx2uQ==
=OBAt
-----END PGP PUBLIC KEY BLOCK-----
```
Pour référence, les détails de la clé publique sont les suivants.
```
Key ID: A6310ACC4672
Type: RSA
Size: 4096/4096
Created: 2019-09-18
Expires: 2026-07-07
User ID: AWS CLI Team
Key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
1. Importez la clé AWS CLI publique à l'aide de la commande suivante, en la *public-key-file-name* remplaçant par le nom de fichier de la clé publique que vous avez créée.
```
$ gpg --import public-key-file-name
gpg: /home/username/.gnupg/trustdb.gpg: trustdb created
gpg: key A6310ACC4672475C: public key "AWS CLI Team " imported
gpg: Total number processed: 1
gpg: imported: 1
```
1. Téléchargez le fichier de AWS CLI signature du package que vous avez téléchargé sur [https://awscli.amazonaws.com/awscli.tar.gz.sig](https://awscli.amazonaws.com/awscli.tar.gz.sig). Celui-ci a le même chemin d’accès et le même nom que le fichier archive auquel il correspond, mais son extension est `.sig`. Enregistrez-le avec le même chemin que le fichier archive. Ou utilisez le bloc de commande suivant :
```
$ curl awscliv2.sig https://awscli.amazonaws.com/ -o awscli.tar.gz.sig
```
1. Vérifiez la signature en transmettant les noms de fichiers `.sig` et `.zip` téléchargés sous forme de paramètres à la commande `gpg`.
```
$ gpg --verify awscliv2.sig awscli.tar.gz
```
La sortie doit ressembler à ce qui suit :
```
gpg: Signature made Mon Nov 4 19:00:01 2019 PST
gpg: using RSA key FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
gpg: Good signature from "AWS CLI Team " [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg: There is no indication that the signature belongs to the owner.
Primary key fingerprint: FB5D B77F D5C1 18B8 0511 ADA8 A631 0ACC 4672 475C
```
**Important**
L’avertissement mentionné dans la sortie est attendu et n’indique pas de problème. Cela se produit parce qu'il n'existe pas de chaîne de confiance entre votre clé PGP personnelle (si vous en avez une) et la clé AWS CLI PGP. Pour plus d’informations, consultez [Web of trust](https://wikipedia.org/wiki/Web_of_trust).
1. Vous disposez d’un environnement capable d’exécuter des fichiers générés par [GNU Autotools](https://www.gnu.org/software/automake/faq/autotools-faq.html) tels que `configure` et `Makefile`. Ces fichiers sont largement portables sur les plateformes POSIX.
------
#### [ Linux and macOS ]
Si Autotools n’est pas encore installé dans votre environnement ou si vous devez le mettre à jour, suivez les instructions d’installation figurant dans [How do I install the Autotools (as user)?](https://www.gnu.org/software/automake/faq/autotools-faq.html#How-do-I-install-the-Autotools-_0028as-user_0029_003f) ou [Basic Installation](https://www.gnu.org/savannah-checkouts/gnu/automake/manual/automake.html#Basic-Installation) dans la *documentation GNU*.
------
#### [ Windows PowerShell ]
**Avertissement**
Si vous travaillez dans un environnement Windows, nous vous conseillons d’utiliser les programmes d’installation prédéfinis. Pour obtenir les instructions d’installation sur les programmes d’installation prédéfinis, consultez [Installation ou mise à jour vers la dernière version du AWS CLI](getting-started-install.md).
Windows n'étant pas fourni avec un shell compatible POSIX, vous devez installer un logiciel supplémentaire pour installer le shell AWS CLI depuis le code source. [MSYS2](https://www.msys2.org/)fournit un ensemble d'outils et de bibliothèques pour aider à créer et à installer des logiciels Windows, en particulier pour les scripts basés sur POSIX utilisés par Autotools.
1. Installez MSYS2. Pour plus d'informations sur l'installation et l'utilisation MSYS2, consultez les [instructions d'installation et d'utilisation](https://www.msys2.org/) dans la *MSYS2 documentation*.
1. Ouvrez le MSYS2 terminal et installez les outils automatiques à l'aide de la commande suivante.
```
$ pacman -S autotools
```
**Note**
Lorsque vous utilisez les exemples de code de configuration, de génération et d'installation présentés dans ce guide pour Windows, le chemin d' MSYS2 installation par défaut `C:\msys64\usr\bin\bash` est supposé. Lorsque vous appelez MSYS2 inside of, PowerShell vous utiliserez le format suivant, avec la commande bash entre guillemets :
```
PS C:\> C:\msys64\usr\bin\bash -lc "command example"
```
L’exemple de commande suivant appelle la commande `./configure` :
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure"
```
------
1. Un interpréteur Python 3.8 ou version ultérieure est installé. La version minimale de Python requise suit les mêmes délais que la [politique officielle de support de Python pour AWS SDKs et les outils](https://aws.amazon.com/blogs/developer/python-support-policy-updates-for-aws-sdks-and-tools/). Un interprète n'est pris en charge que 6 mois après sa end-of-support date.
1. **(Facultatif)** Installez toutes les dépendances de build et d’exécution de l’ AWS CLI de la bibliothèque Python. La commande `./configure` vous indique s’il vous manque des dépendances et comment les installer.
Vous pouvez installer et utiliser automatiquement ces dépendances via la configuration. Consultez [Téléchargement de dépendances](#source-getting-started-install-config-dependencies) pour plus d’informations.
## Étape 2 : Configuration de l'installation AWS CLI source
La configuration pour la création et l'installation du AWS CLI est spécifiée à l'aide du `configure` script. Pour la documentation de toutes les options de configuration, exécutez le script `configure` avec l’option `--help` :
------
#### [ Linux and macOS ]
```
$ ./configure --help
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure --help"
```
------
**Topics**
+ [Emplacement d’installation](#source-getting-started-install-config-location)
+ [Interpréteur Python](#source-getting-started-install-config-interpreter)
+ [Téléchargement de dépendances](#source-getting-started-install-config-dependencies)
+ [Type d’installation](#source-getting-started-install-config-type)
### Emplacement d’installation
L'installation source du AWS CLI utilise deux répertoires configurables pour installer AWS CLI :
+ `libdir`- Répertoire parent dans lequel le AWS CLI sera installé. Le chemin d'accès à l' AWS CLI installation est`/aws-cli`. La valeur par défaut `libdir` pour Linux et macOS est `/usr/local/lib`, ce qui fait que le répertoire d’installation par défaut est `/usr/local/lib/aws-cli`.
+ `bindir`- Répertoire dans lequel les AWS CLI exécutables sont installés. L'emplacement par défaut est `/usr/local/bin`.
Les options `configure` suivantes contrôlent les répertoires utilisés :
+ `--prefix` : définit le préfixe de répertoire à utiliser pour l’installation. La valeur par défaut pour Linux et macOS est `/usr/local`.
+ `--libdir` : définit le `libdir` à utiliser pour installer l’ AWS CLI. La valeur par défaut est `/lib`. Si ni `--libdir` ni `--prefix` ne sont spécifiés, la valeur par défaut pour Linux et macOS est `/usr/local/lib/`.
+ `--bindir`- Définit le `bindir` à utiliser pour installer les `aws_completer` exécutables AWS CLI `aws` et. La valeur par défaut est `/bin`. Si ni `bindir` ni `--prefix` ne sont spécifiés, la valeur par défaut pour Linux et macOS est `/usr/local/bin/`.
------
#### [ Linux and macOS ]
L’exemple de commande suivant utilise l’option `--prefix` afin d’effectuer une installation de l’ AWS CLI pour un utilisateur local. Cette commande installe le fichier AWS CLI in `$HOME/.local/lib/aws-cli` et les exécutables dans : `$HOME/.local/bin`
```
$ ./configure --prefix=$HOME/.local
```
L’exemple de commande suivant utilise l’option `--libdir` pour installer l’ AWS CLI en tant qu’application complémentaire dans le répertoire `/opt`. Cette commande installe le fichier AWS CLI at `/opt/aws-cli` et les exécutables à leur emplacement par défaut de. `/usr/local/bin`
```
$ ./configure --libdir=/opt
```
------
#### [ Windows PowerShell ]
L’exemple de commande suivant utilise l’option `--prefix` afin d’effectuer une installation de l’ AWS CLI pour un utilisateur local. Cette commande installe le fichier AWS CLI in `$HOME/.local/lib/aws-cli` et les exécutables dans : `$HOME/.local/bin`
```
$ C:\msys64\usr\bin\bash -lc "./configure --prefix='C:\Program Files\AWSCLI'"
```
L’exemple de commande suivant utilise l’option `--libdir` pour installer l’ AWS CLI en tant qu’application complémentaire dans le répertoire `/opt`. Cette commande installe le fichier AWS CLI at. `C:\Program Files\AWSCLI\opt\aws-cli`
------
### Interpréteur Python
**Note**
Il est vivement recommandé de spécifier l’interpréteur Python lors d’une installation pour Windows.
Le `./configure` script sélectionne automatiquement un interpréteur Python 3.8 ou version ultérieure installé à utiliser pour créer et exécuter la macro à l' AWS CLI aide de la macro [https://www.gnu.org/software/automake/manual/html_node/Python.html](https://www.gnu.org/software/automake/manual/html_node/Python.html)Autoconf.
L’interpréteur Python à utiliser peut être défini explicitement à l’aide de la variable d’environnement `PYTHON` lors de l’exécution du script `configure` :
------
#### [ Linux and macOS ]
```
$ PYTHON=/path/to/python ./configure
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "PYTHON='C:\path\to\python' ./configure"
```
------
### Téléchargement de dépendances
Par défaut, il est nécessaire que toutes les dépendances de build et d'exécution du AWS CLI soient déjà installées sur le système. Cela inclut toutes les dépendances des bibliothèques Python. Toutes les dépendances sont vérifiées lors de l’exécution du script `configure`, et si n’importe quelle dépendance Python est absente du système, le script `configure` génère une erreur.
L’exemple de code suivant génère des erreurs lorsque des dépendances sont absentes de votre système :
------
#### [ Linux and macOS ]
```
$ ./configure
checking for a Python interpreter with version >= 3.8... python
checking for python... /Users/username/.envs/env3.11/bin/python
checking for python version... 3.11
checking for python platform... darwin
checking for GNU default python prefix... ${prefix}
checking for GNU default python exec_prefix... ${exec_prefix}
checking for python script directory (pythondir)... ${PYTHON_PREFIX}/lib/python3.11/site-packages
checking for python extension module directory (pyexecdir)... ${PYTHON_EXEC_PREFIX}/lib/python3.11/site-packages
checking for --with-install-type... system-sandbox
checking for --with-download-deps... Traceback (most recent call last):
File "", line 198, in _run_module_as_main
File "", line 88, in _run_code
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 125, in
main()
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 121, in main
parsed_args.func(parsed_args)
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 49, in validate
validate_env(parsed_args.artifact)
File "/Users/username/aws-code/aws-cli/./backends/build_system/validate_env.py", line 68, in validate_env
raise UnmetDependenciesException(unmet_deps, in_venv)
validate_env.UnmetDependenciesException: Environment requires following Python dependencies:
awscrt (required: ('>=0.12.4', '<0.17.0')) (version installed: None)
We recommend using --with-download-deps flag to automatically create a virtualenv and download the dependencies.
If you want to manage the dependencies yourself instead, run the following pip command:
/Users/username/.envs/env3.11/bin/python -m pip install --prefer-binary 'awscrt>=0.12.4,<0.17.0'
configure: error: "Python dependencies not met."
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure"
checking for a Python interpreter with version >= 3.8... python
checking for python... /Users/username/.envs/env3.11/bin/python
checking for python version... 3.11
checking for python platform... darwin
checking for GNU default python prefix... ${prefix}
checking for GNU default python exec_prefix... ${exec_prefix}
checking for python script directory (pythondir)... ${PYTHON_PREFIX}/lib/python3.11/site-packages
checking for python extension module directory (pyexecdir)... ${PYTHON_EXEC_PREFIX}/lib/python3.11/site-packages
checking for --with-install-type... system-sandbox
checking for --with-download-deps... Traceback (most recent call last):
File "", line 198, in _run_module_as_main
File "", line 88, in _run_code
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 125, in
main()
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 121, in main
parsed_args.func(parsed_args)
File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 49, in validate
validate_env(parsed_args.artifact)
File "/Users/username/aws-code/aws-cli/./backends/build_system/validate_env.py", line 68, in validate_env
raise UnmetDependenciesException(unmet_deps, in_venv)
validate_env.UnmetDependenciesException: Environment requires following Python dependencies:
awscrt (required: ('>=0.12.4', '<0.17.0')) (version installed: None)
We recommend using --with-download-deps flag to automatically create a virtualenv and download the dependencies.
If you want to manage the dependencies yourself instead, run the following pip command:
/Users/username/.envs/env3.11/bin/python -m pip install --prefer-binary 'awscrt>=0.12.4,<0.17.0'
configure: error: "Python dependencies not met."
```
------
Pour installer automatiquement les dépendances Python requises, utilisez l’option `--with-download-deps`. Quand vous utilisez cet indicateur, le processus de génération effectue les opérations suivantes :
+ Ignore la vérification des dépendances de la bibliothèque Python.
+ Configure les paramètres pour télécharger toutes les dépendances Python requises et utilise **uniquement** les dépendances téléchargées pour créer l’ AWS CLI pendant la build `make`.
L’exemple de commande de configuration suivant utilise l’option `--with-download-deps` afin de télécharger et d’utiliser les dépendances Python :
------
#### [ Linux and macOS ]
```
$ ./configure --with-download-deps
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure --with-download-deps"
```
------
### Type d’installation
Le processus d’installation de la source prend en charge les types d’installation suivants :
+ `system-sandbox`- **(Par défaut)** Crée un environnement virtuel Python isolé, l'installe AWS CLI dans l'environnement virtuel et crée des liens symboliques vers le `aws` `aws_completer` fichier exécutable dans l'environnement virtuel. Cette installation de AWS CLI dépend directement de l'interpréteur Python sélectionné pour son exécution.
Il s'agit d'un mécanisme d'installation léger permettant de l' AWS CLI installer sur un système et qui suit les meilleures pratiques de Python en sandboxant l'installation dans un environnement virtuel. Cette installation est destinée aux clients qui souhaitent installer le fichier à AWS CLI partir du code source de la manière la plus fluide possible avec l'installation couplée à votre installation de Python.
+ `portable-exe`- Gèle le fichier AWS CLI dans un exécutable autonome qui peut être distribué dans des environnements d'architectures similaires. Il s’agit du même processus que celui utilisé pour générer les exécutables prédéfinis officiels de l’ AWS CLI. `portable-exe` se fige dans une copie de l’interpréteur Python choisi à l’étape `configure` afin d’être utilisé pour l’exécution du AWS CLI. Cela permet de le déplacer vers d’autres machines qui ne disposent peut-être pas d’un interpréteur Python.
Ce type de build est utile, car vous pouvez vous assurer que votre installation de l’ AWS CLI n’est pas couplée à la version Python installée dans l’environnement, et vous pouvez distribuer une build sur un autre système sur lequel Python n’est peut-être pas déjà installé. Cela vous permet de contrôler les dépendances et la sécurité des AWS CLI exécutables que vous utilisez.
Pour configurer le type d’installation, utilisez l’option `--with-install-type` et spécifiez la valeur `portable-exe` ou`system-sandbox`.
L’exemple de commande `./configure` suivant spécifie une valeur `portable-exe` :
------
#### [ Linux and macOS ]
```
$ ./configure --with-install-type=portable-exe
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure --with-install-type=portable-exe"
```
------
## Étape 3 : Création du AWS CLI
Utilisez la `make` commande pour créer le à l' AWS CLI aide de vos paramètres de configuration :
------
#### [ Linux and macOS ]
```
$ make
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "make"
```
------
**Note**
Un environnement virtuel est créé dans le répertoire de la build à l’aide du module Python [https://docs.python.org/3/library/venv.html](https://docs.python.org/3/library/venv.html). L’environnement virtuel est initialisé avec une [version de pip fournie dans la bibliothèque standard Python](https://docs.python.org/3/library/ensurepip.html).
Copie les dépendances de la bibliothèque Python. Selon que l’indicateur `--with-download-deps` est spécifié ou non dans la commande `configure`, cette étape effectue l’une des opérations suivantes :
L’indicateur `--with-download-deps` **est** spécifié. Les dépendances Python sont installées par pip. Cela inclut `wheel`, `setuptools` et toutes les dépendances d’exécution de l’ AWS CLI . Si vous générez l’exécutable `portable-exe`, `pyinstaller` est installé. Ces exigences sont toutes spécifiées dans les fichiers de verrouillage générés à partir de [https://github.com/jazzband/pip-tools](https://github.com/jazzband/pip-tools).
L’indicateur `--with-download-deps` **n’est pas** spécifié. Les bibliothèques Python du package du site de l’interpréteur Python ainsi que tous les scripts (par exemple, `pyinstaller`) sont copiés dans l’environnement virtuel utilisé pour la build.
S'exécute `pip install` directement sur la AWS CLI base de code pour effectuer une compilation hors ligne dans l'arborescence et l'installer AWS CLI dans l'environnement virtuel de génération. [Cette installation utilise les drapeaux pip [-- no-build-isolation ](https://pip.pypa.io/en/stable/cli/pip_install/#cmdoption-no-build-isolation), [--use-feature= in-tree-build ](https://pip.pypa.io/en/stable/cli/pip_install/#local-project-installs), -- et. no-cache-dir [https://pip.pypa.io/en/stable/cli/pip_install/#cmdoption-no-index](https://pip.pypa.io/en/stable/cli/pip_install/#cmdoption-no-index)](https://pip.pypa.io/en/stable/cli/pip_install/#caching)
**(Facultatif)** Si le paramètre `--install-type` est défini sur `portable-exe` dans la commande `configure`, génère un exécutable autonome à l’aide de [https://www.pyinstaller.org/](https://www.pyinstaller.org/).
## Étape 4 : Installation du AWS CLI
La `make install` commande installe votre build AWS CLI à l'emplacement configuré sur le système.
------
#### [ Linux and macOS ]
L'exemple de commande suivant installe le à l' AWS CLI aide de vos paramètres de configuration et de compilation :
```
$ make install
```
------
#### [ Windows PowerShell ]
L'exemple de commande suivant installe le à l' AWS CLI aide de vos paramètres de configuration et de construction, puis ajoute une variable d'environnement avec le chemin pour : AWS CLI
```
PS C:\> C:\msys64\usr\bin\bash -lc " make install "
PS C:\> $Env:PATH +=";C:\Program Files\AWSCLI\bin\"
```
------
La règle `make install` prend en charge la variable [https://www.gnu.org/software/make/manual/html_node/DESTDIR.html#DESTDIR](https://www.gnu.org/software/make/manual/html_node/DESTDIR.html#DESTDIR). Lorsqu’elle est spécifiée, cette variable préfixe le chemin spécifié au chemin d’installation déjà configuré lors de l’installation de l’ AWS CLI. Par défaut, aucune valeur n’est définie pour cette variable.
------
#### [ Linux and macOS ]
L’exemple de code suivant utilise un indicateur `--prefix=/usr/local` pour configurer un emplacement d’installation, puis modifie cette destination avec `DESTDIR=/tmp/stage` pour la commande `make install`. Ces commandes entraînent l'installation AWS CLI sur `/tmp/stage/usr/local/lib/aws-cli` et la localisation de ses exécutables dans. `/tmp/stage/usr/local/bin`
```
$ ./configure --prefix=/usr/local
$ make
$ make DESTDIR=/tmp/stage install
```
------
#### [ Windows PowerShell ]
L’exemple de code suivant utilise un indicateur `--prefix=\awscli` pour configurer un emplacement d’installation, puis modifie cette destination avec `DESTDIR=C:\Program Files` pour la commande `make install`. Ces commandes entraînent l' AWS CLI installation sur`C:\Program Files\awscli`.
```
$ ./configure --prefix=\awscli
$ make
$ make DESTDIR='C:\Program Files' install
```
------
**Note**
Déplace l’un des éléments suivants vers le répertoire d’installation configuré :
Si le type d’installation est `system-sandbox`, déplace l’environnement virtuel généré.
Si le type d’installation est un `portable-exe`, déplace l’exécutable autonome généré.
Crée des liens symboliques pour les exécutables `aws` et `aws_completer` dans le répertoire bin configuré.
## Étape 5 : vérification de l' AWS CLI installation
Confirmez l'installation AWS CLI avec succès à l'aide de la commande suivante :
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Si la commande `aws` n’est pas reconnue, vous devrez peut-être redémarrer votre terminal pour mettre à jour les nouveaux liens symboliques. Si vous rencontrez des problèmes supplémentaires après l'installation ou la désinstallation du AWS CLI, consultez les étapes de dépannage [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md) les plus courantes
## Exemples de flux de travail
Cette section fournit des exemples de flux de travail de base pour une installation depuis la source.
### Installation de base sous Linux et macOS
L'exemple suivant est un flux de travail d'installation de base dans lequel le AWS CLI est installé à l'emplacement par défaut de`/usr/local/lib/aws-cli`.
```
$ cd path/to/cli/respository/
$ ./configure
$ make
$ make install
```
### Installation automatisée sous Windows
**Note**
Vous devez vous présenter PowerShell en tant qu'administrateur pour utiliser ce flux de travail.
MSYS2 peut être utilisé de manière automatisée dans un paramètre CI, voir [Utilisation MSYS2 dans CI](https://www.msys2.org/docs/ci/) dans la *MSYS2 documentation*.
------
#### [ Downloaded Tarball ]
Téléchargez le fichier `awscli.tar.gz`, extrayez-le, puis installez l’ AWS CLI. Lorsque vous utilisez les commandes suivantes, remplacez les chemins suivants :
+ `C:\msys64\usr\bin\bash`avec l'emplacement de votre MSYS2 chemin.
+ `.\awscli-2.x.x\` avec le nom de dossier du fichier `awscli.tar.gz` extrait.
+ `PYTHON='C:\path\to\python.exe'` avec votre chemin local vers Python.
L'exemple de code suivant automatise la création et l'installation AWS CLI du formulaire à PowerShell l'aide MSYS2, et indique l'installation locale de Python à utiliser :
```
PS C:\> curl "https://awscli.amazonaws.com/awscli.tar.gz" -o "awscliv2.zip" # Download the awscli.tar.gz file in the current working directory
PS C:\> tar -xvzf .\awscli.tar.gz # Extract awscli.tar.gz file
PS C:\> cd .\awscli-2.x.x\ # Navigate to the root of the extracted files
PS C:\> $env:CHERE_INVOKING = 'yes' # Preserve the current working directory
PS C:\> C:\msys64\usr\bin\bash -lc " PYTHON='C:\path\to\python.exe' ./configure --prefix='C:\Program Files\AWSCLI' --with-download-deps "
PS C:\> C:\msys64\usr\bin\bash -lc "make"
PS C:\> C:\msys64\usr\bin\bash -lc "make install"
PS C:\> $Env:PATH +=";C:\Program Files\AWSCLI\bin\"
PS C:\> aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 source-sandbox/AMD64
```
------
#### [ GitHub Repository ]
Téléchargez le fichier `awscli.tar.gz`, extrayez-le, puis installez l’ AWS CLI. Lorsque vous utilisez les commandes suivantes, remplacez les chemins suivants :
+ `C:\msys64\usr\bin\bash`avec l'emplacement de votre MSYS2 chemin.
+ `C:path\to\cli\repository\`avec le chemin d'accès à votre [AWS CLI dépôt](https://github.com/aws/aws-cli) cloné à partir de *GitHub*. *Pour plus d'informations, voir [Forker un dépôt](https://docs.github.com/en/get-started/quickstart/fork-a-repo) dans la documentation GitHub *
+ `PYTHON='C:\path\to\python.exe'` avec votre chemin local vers Python.
L'exemple de code suivant automatise la création et l'installation AWS CLI du formulaire à PowerShell l'aide MSYS2, et indique l'installation locale de Python à utiliser :
```
PS C:\> cd C:path\to\cli\repository\
PS C:\> $env:CHERE_INVOKING = 'yes' # Preserve the current working directory
PS C:\> C:\msys64\usr\bin\bash -lc " PYTHON='C:\path\to\python.exe' ./configure --prefix='C:\Program Files\AWSCLI' --with-download-deps "
PS C:\> C:\msys64\usr\bin\bash -lc "make"
PS C:\> C:\msys64\usr\bin\bash -lc "make install"
PS C:\> $Env:PATH +=";C:\Program Files\AWSCLI\bin\"
PS C:\> aws --version
```
------
### Conteneur Alpine Linux
Vous trouverez ci-dessous un exemple de Dockerfile qui peut être utilisé pour obtenir une installation fonctionnelle de l’ AWS CLI dans un conteneur Alpine Linux comme [alternative aux fichiers binaires prédéfinis pour Alpine](https://github.com/aws/aws-cli/issues/4685). Lorsque vous utilisez cet exemple, remplacez-le *AWSCLI\$1VERSION* par le numéro de AWS CLI version souhaité :
```
1. FROM python:3.8-alpine AS builder
2.
3. ENV AWSCLI_VERSION=2.10.1
4.
5. RUN apk add --no-cache \
6. curl \
7. make \
8. cmake \
9. gcc \
10. g++ \
11. libc-dev \
12. libffi-dev \
13. openssl-dev \
14. && curl https://awscli.amazonaws.com/awscli-${AWSCLI_VERSION}.tar.gz | tar -xz \
15. && cd awscli-${AWSCLI_VERSION} \
16. && ./configure --prefix=/opt/aws-cli/ --with-download-deps \
17. && make \
18. && make install
19.
20. FROM python:3.8-alpine
21.
22. RUN apk --no-cache add groff
23.
24. COPY --from=builder /opt/aws-cli/ /opt/aws-cli/
25.
26. ENTRYPOINT ["/opt/aws-cli/bin/aws"]
```
Cette image est créée puis AWS CLI invoquée à partir d'un conteneur similaire à celui créé sur Amazon Linux 2 :
```
$ docker build --tag awscli-alpine .
$ docker run --rm -it awscli-alpine --version
aws-cli/2.2.1 Python/3.8.11 Linux/5.10.25-linuxkit source-sandbox/x86_64.alpine.3 prompt/off
```
La taille finale de cette image est inférieure à celle de l'image AWS CLI Docker officielle. Pour en savoir plus sur l’image Docker officielle, consultez [Exécution des images officielles Amazon ECR Public ou Docker pour le AWS CLI](getting-started-docker.md).
## Résolution des erreurs AWS CLI d'installation et de désinstallation
Pour connaître les étapes de résolution des problèmes d’erreurs d’installation courantes, consultez [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md). Pour connaître les étapes de résolution de problèmes les plus pertinentes, consultez [Erreurs de type Commande introuvable](cli-chap-troubleshooting.md#tshoot-install-not-found), [La commande « `aws --version` » renvoie une version différente de celle que vous avez installée](cli-chap-troubleshooting.md#tshoot-install-wrong-version) et [La commande « `aws --version` » renvoie une version après avoir désinstallé le AWS CLI](cli-chap-troubleshooting.md#tshoot-uninstall-1).
Pour tout problème non traité dans les guides de résolution des problèmes, recherchez les problèmes avec l'`source-distribution`étiquette figurant dans le [AWS CLI référentiel](https://github.com/aws/aws-cli/labels/source-distribution) sur *GitHub*. Si aucun problème existant ne couvre vos erreurs, [créez un nouveau problème](https://github.com/aws/aws-cli/issues/new?assignees=&labels=source-distribution%2Cneeds-triage&template=source-distribution.yml&title=%28short+issue+description%29) pour bénéficier de l'aide des AWS CLI responsables.
## Étapes suivantes
Après avoir installé le AWS CLI, vous devez effectuer un[Configuration du AWS CLI](getting-started-quickstart.md).
# Exécution des images officielles Amazon ECR Public ou Docker pour le AWS CLI
Cette rubrique décrit comment exécuter, contrôler les versions et configurer la AWS CLI version 2 sur Docker à l'aide de l'image officielle Amazon Elastic Container Registry Public (Amazon ECR Public) ou de Docker Hub. Pour plus d’informations sur l’utilisation de Docker, consultez la [Documentation de Docker](https://docs.docker.com/).
Les images officielles offrent une isolation, une portabilité et une sécurité qui les soutiennent et les maintiennent AWS directement. Cela vous permet d'utiliser la AWS CLI version 2 dans un environnement basé sur des conteneurs sans avoir à gérer vous-même l'installation.
**Topics**
+ [Conditions préalables](#cliv2-docker-prereq)
+ [Choix entre Amazon ECR Public et Docker Hub](#cliv2-docker-versus)
+ [Exécutez les images de AWS CLI la version officielle 2](#cliv2-docker-install)
+ [Remarques sur les interfaces et la rétrocompatibilité des images officielles](#cliv2-docker-install-notes)
+ [Utiliser des versions et des balises spécifiques](#cliv2-docker-upgrade)
+ [Mettre à jour vers la dernière image officielle](#cliv2-docker-update)
+ [Partage des fichiers d’hôte, des informations d’identification et de la configuration](#cliv2-docker-share-files)
+ [Abréviation de la commande docker run](#cliv2-docker-aliases)
## Conditions préalables
Docker doit être installé. Pour obtenir les instructions d'installation, consultez le [site web Docker](https://docs.docker.com/install/).
Pour vérifier votre installation de Docker, exécutez la commande suivante et vérifiez qu'il existe une sortie.
```
$ docker --version
Docker version 19.03.1
```
## Choix entre Amazon ECR Public et Docker Hub
Nous vous recommandons d'utiliser Amazon ECR Public via Docker Hub pour les AWS CLI images. Docker Hub impose des limites de débit plus stricts pour les consommateurs publics, ce qui peut entraîner des problèmes de limitation. En outre, Amazon ECR Public réplique les images dans plusieurs régions afin de garantir une disponibilité optimale et de gérer les problèmes de panne régionaux.
Pour plus d’informations sur les limites de débit Docker Hub, consultez [Understanding Docker Hub Rate Limiting](https://www.docker.com/increase-rate-limits/) sur le site web *Docker*.
## Exécutez les images de AWS CLI la version officielle 2
La première fois que vous utilisez la commande `docker run`, l’image la plus récente est téléchargée sur votre ordinateur. Chaque utilisation ultérieure de la commande `docker run` s'exécute à partir de votre copie locale.
Pour exécuter les images Docker AWS CLI version 2, utilisez la `docker run` commande.
------
#### [ Amazon ECR Public ]
[L'image officielle Amazon ECR Public AWS CLI version 2 est hébergée sur Amazon ECR Public dans le `aws-cli/aws-cli` référentiel.](https://gallery.ecr.aws/aws-cli/aws-cli)
```
$ docker run --rm -it public.ecr.aws/aws-cli/aws-cli command
```
------
#### [ Docker Hub ]
L'image Docker officielle de la AWS CLI version 2 est hébergée sur Docker Hub dans le `amazon/aws-cli` référentiel.
```
$ docker run --rm -it amazon/aws-cli command
```
------
La commande fonctionne de la manière suivante :
+ `docker run --rm -it repository/name` : équivalent de l’exécutable `aws`. Chaque fois que vous exécutez cette commande, Docker lance un conteneur de votre image téléchargée et exécute votre commande `aws`. Par défaut, l'image utilise la dernière version de la AWS CLI version 2.
Par exemple, pour appeler la commande `aws --version` dans Docker, vous exécutez ce qui suit.
------
#### [ Amazon ECR Public ]
```
$ docker run --rm -it public.ecr.aws/aws-cli/aws-cli --version
aws-cli/2.27.41 Python/3.7.3 Linux/4.9.184-linuxkit botocore/2.4.5dev10
```
------
#### [ Docker Hub ]
```
$ docker run --rm -it amazon/aws-cli --version
aws-cli/2.27.41 Python/3.7.3 Linux/4.9.184-linuxkit botocore/2.4.5dev10
```
------
+ `--rm` : spécifie de nettoyer le conteneur après la fin de la commande.
+ `-it` : spécifie d’ouvrir un pseudo TTY avec `stdin`. Cela vous permet de fournir des entrées à la AWS CLI version 2 lorsqu'elle s'exécute dans un conteneur, par exemple en utilisant les `aws help` commandes `aws configure` et. Lorsque vous choisissez d’exclure `-it`, tenez compte des éléments suivants :
+ `-it` n’est pas nécessaire si vous exécutez des scripts.
+ Si vous rencontrez des erreurs avec vos scripts, exclure `-it` de votre appel Docker peut résoudre le problème.
+ Si vous essayez de diriger la sortie, `-it` peut provoquer des erreurs et exclure `-it` de votre appel Docker peut résoudre ce problème. Si vous souhaitez conserver l’indicateur `-it`, mais que vous souhaitez tout de même diriger la sortie, désactiver le [pager côté client](cli-usage-pagination.md#cli-usage-pagination-clientside) que l’ AWS CLI utilise par défaut devrait résoudre le problème.
Pour plus d’informations sur la commande `docker run`, consultez le [Guide de référence Docker](https://docs.docker.com/engine/reference/run/).
## Remarques sur les interfaces et la rétrocompatibilité des images officielles
+ Le seul outil pris en charge sur l’image est l’ AWS CLI. Seul le fichier exécutable `aws` doit être exécuté directement. Par exemple, même si `less` et `groff` sont explicitement installés sur l'image, ils ne doivent pas être exécutés directement en dehors d'une AWS CLI commande.
+ Le répertoire de travail `/aws` est contrôlé par l’utilisateur. L'image n'écrira pas dans ce répertoire, sauf indication contraire de l'utilisateur lors de l'exécution d'une AWS CLI commande.
+ La balise « latest » n’offre aucune garantie de rétrocompatibilité. Pour garantir la rétrocompatibilité, vous devez épingler sur une balise `` spécifique, car celles-ci sont immuables et ne sont transmises qu’une seule fois.
## Utiliser des versions et des balises spécifiques
L'image officielle de la AWS CLI version 2 comporte plusieurs versions que vous pouvez utiliser, à commencer par la version`2.0.6`. Pour exécuter une version spécifique de la AWS CLI version 2, ajoutez la balise appropriée à votre `docker run` commande. La première fois que vous utilisez la commande `docker run` avec une balise, l’image la plus récente de cette balise est téléchargée sur votre ordinateur. Chaque utilisation ultérieure de la commande `docker run` avec cette balise s'exécute à partir de votre copie locale.
Vous pouvez utiliser deux types de balises :
+ `latest`— Définit la dernière version de la AWS CLI version 2 pour l'image. Nous vous recommandons d’utiliser la balise `latest` lorsque vous souhaitez obtenir la dernière version de la version 2 de l’ AWS CLI . Cependant, il n'y a aucune garantie de compatibilité descendante lorsque vous utilisez cette balise. La balise `latest` est utilisée par défaut dans la commande `docker run`. Pour utiliser explicitement la balise `latest`, ajoutez la balise au nom de l'image du conteneur.
------
#### [ Amazon ECR Public ]
```
$ docker run --rm -it public.ecr.aws/aws-cli/aws-cli:latest command
```
------
#### [ Docker Hub ]
```
$ docker run --rm -it amazon/aws-cli:latest command
```
------
+ ``— Définit une version spécifique de la AWS CLI version 2 pour l'image. Si vous envisagez d'utiliser une image officielle en production, nous vous recommandons d'utiliser une version spécifique de la AWS CLI version 2 pour garantir la rétrocompatibilité. Par exemple, pour exécuter la version `2.0.6`, ajoutez la version au nom de l’image du conteneur.
------
#### [ Amazon ECR Public ]
```
$ docker run --rm -it public.ecr.aws/aws-cli/aws-cli:2.0.6 command
```
------
#### [ Docker Hub ]
```
$ docker run --rm -it amazon/aws-cli:2.0.6 command
```
------
## Mettre à jour vers la dernière image officielle
La dernière image n’étant téléchargée sur votre ordinateur que la première fois que vous utilisez la commande `docker run`, vous devez extraire manuellement une image mise à jour. Pour mettre à jour manuellement vers la dernière version, nous vous recommandons d'extraire l'image balisée `latest`. L’extraction de l’image télécharge la dernière version sur votre ordinateur.
------
#### [ Amazon ECR Public ]
```
$ docker pull public.ecr.aws/aws-cli/aws-cli:latest
```
------
#### [ Docker Hub ]
```
$ docker pull amazon/aws-cli:latest
```
------
## Partage des fichiers d’hôte, des informations d’identification et de la configuration
La AWS CLI version 2 étant exécutée dans un conteneur, la CLI ne peut pas accéder par défaut au système de fichiers hôte, qui inclut la configuration et les informations d'identification. Pour partager le système de fichiers hôte, les informations d'identification et la configuration avec le conteneur, montez le répertoire `~/.aws` du système hôte sur le conteneur à l'adresse `/root/.aws` avec l'indicateur `-v` défini sur la commande `docker run`. Cela permet à la AWS CLI version 2 exécutée dans le conteneur de localiser les informations du fichier hôte.
------
#### [ Amazon ECR Public ]
**Linux et macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli command
```
**Invite de commande Windows**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli command
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli command
```
------
#### [ Docker Hub ]
**Linux et macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws amazon/aws-cli command
```
**Invite de commande Windows**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws amazon/aws-cli command
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws amazon/aws-cli command
```
------
Pour plus d’informations sur l’indicateur `-v` et le montage, consultez le [Guide de référence Docker](https://docs.docker.com/storage/volumes/).
**Note**
Pour en savoir plus sur les fichiers `config` et `credentials`, consultez [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md).
### Exemple 1 : Fourniture d'informations d'identification et configuration
Dans cet exemple, nous fournissons les informations d’identification de l’hôte et la configuration lors de l’exécution de la commande `s3 ls` afin de répertorier vos compartiments dans Amazon Simple Storage Service (Amazon S3). Les exemples ci-dessous utilisent l'emplacement par défaut pour les AWS CLI informations d'identification et les fichiers de configuration. Pour utiliser un autre emplacement, modifiez le chemin du fichier.
------
#### [ Amazon ECR Public ]
**Linux et macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Invite de commande Windows**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli s3 ls
```
------
#### [ Docker Hub ]
**Linux et macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Invite de commande Windows**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws amazon/aws-cli s3 ls
```
------
Vous pouvez appeler des variables d’environnement spécifiques à un système à l’aide de l’indicateur `-e`. Pour utiliser une variable d’environnement, appelez-la par son nom.
------
#### [ Amazon ECR Public ]
**Linux et macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -e ENVVAR_NAME public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Invite de commande Windows**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -e ENVVAR_NAME public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -e ENVVAR_NAME public.ecr.aws/aws-cli/aws-cli s3 ls
```
------
#### [ Docker Hub ]
**Linux et macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -e ENVVAR_NAME amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Invite de commande Windows**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -e ENVVAR_NAME amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -e ENVVAR_NAME amazon/aws-cli s3 ls
```
------
### Exemple 2 : téléchargement d’un fichier Amazon S3 sur votre système hôte
Pour certaines commandes de AWS CLI la version 2, vous pouvez lire des fichiers depuis le système hôte dans le conteneur ou écrire des fichiers depuis le conteneur vers le système hôte.
Dans cet exemple, nous téléchargeons l'objet `S3` `s3://aws-cli-docker-demo/hello` sur votre système de fichiers local en installant le répertoire de travail actuel dans le répertoire `/aws` du conteneur. En téléchargeant l'objet `hello` dans le répertoire `/aws` du conteneur, le fichier est également enregistré dans le répertoire de travail actuel du système hôte.
------
#### [ Amazon ECR Public ]
**Linux et macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws public.ecr.aws/aws-cli/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
download: s3://aws-cli-docker-demo/hello to ./hello
```
**Invite de commande Windows**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws public.ecr.aws/aws-cli/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
download: s3://aws-cli-docker-demo/hello to ./hello
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws public.ecr.aws/aws-cli/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
```
------
#### [ Docker Hub ]
**Linux et macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws amazon/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
download: s3://aws-cli-docker-demo/hello to ./hello
```
**Invite de commande Windows**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws amazon/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
download: s3://aws-cli-docker-demo/hello to ./hello
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws amazon/aws-cli s3 cp s3://aws-cli-docker-demo/hello .
```
------
Pour confirmer que le fichier téléchargé existe dans le système de fichiers local, exécutez la procédure suivante.
**Linux et macOS**
```
$ cat hello
Hello from Docker!
```
**Windows PowerShell**
```
$ type hello
Hello from Docker!
```
### Exemple 3 : Utilisation de votre variable d' AWS\$1PROFILEenvironnement
Vous pouvez appeler des variables d’environnement spécifiques à un système à l’aide de l’indicateur `-e`. Appelez chaque variable d’environnement que vous souhaitez utiliser. Dans cet exemple, nous fournissons les informations d'identification de l'hôte, la configuration et la variable d'*AWS\$1PROFILE*environnement lors de l'exécution de la `s3 ls` commande pour répertorier vos buckets dans Amazon Simple Storage Service (Amazon S3).
------
#### [ Amazon ECR Public ]
**Linux et macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -e AWS_PROFILE public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Invite de commande Windows**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -e AWS_PROFILE public.ecr.aws/aws-cli/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -e AWS_PROFILE public.ecr.aws/aws-cli/aws-cli s3 ls
```
------
#### [ Docker Hub ]
**Linux et macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws -e AWS_PROFILE amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Invite de commande Windows**
```
$ docker run --rm -it -v %userprofile%\.aws:/root/.aws -e AWS_PROFILE amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Windows PowerShell**
```
C:\> docker run --rm -it -v $env:userprofile\.aws:/root/.aws -e AWS_PROFILE amazon/aws-cli s3 ls
```
------
## Abréviation de la commande docker run
Pour abréger la commande `docker run`, nous vous suggérons d’utiliser la capacité de votre système d’exploitation afin de créer un [https://www.linux.com/topic/desktop/understanding-linux-links/](https://www.linux.com/topic/desktop/understanding-linux-links/) (lien symbolique) ou un [https://www.linux.com/topic/desktop/aliases-diy-shell-commands/](https://www.linux.com/topic/desktop/aliases-diy-shell-commands/) dans Linux et macOS, ou une [https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/doskey](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/doskey) dans Windows. Pour définir l'alias `aws`, vous pouvez exécuter l'une des commandes suivantes.
+ Pour un accès de base aux commandes `aws`, exécutez la procédure suivante.
------
#### [ Amazon ECR Public ]
**Linux et macOS**
```
$ alias aws='docker run --rm -it public.ecr.aws/aws-cli/aws-cli'
```
**Invite de commande Windows**
```
C:\> doskey aws=docker run --rm -it public.ecr.aws/aws-cli/aws-cli $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it public.ecr.aws/aws-cli/aws-cli $args}
Set-Alias -Name aws -Value AWSCLI
```
------
#### [ Docker Hub ]
**Linux et macOS**
```
$ alias aws='docker run --rm -it amazon/aws-cli'
```
**Invite de commande Windows**
```
C:\> doskey aws=docker run --rm -it amazon/aws-cli $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it amazon/aws-cli $args}
Set-Alias -Name aws -Value AWSCLI
```
------
+ Pour accéder au système de fichiers hôte et aux paramètres de configuration lors de l'utilisation des commandes `aws`, exécutez la procédure suivante.
------
#### [ Amazon ECR Public ]
**Linux et macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws public.ecr.aws/aws-cli/aws-cli'
```
**Invite de commande Windows**
```
C:\> doskey aws=docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws public.ecr.aws/aws-cli/aws-cli $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws public.ecr.aws/aws-cli/aws-cli $args}
Set-Alias -Name aws -Value AWSCLI
```
------
#### [ Docker Hub ]
**Linux et macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws amazon/aws-cli'
```
**Invite de commande Windows**
```
C:\> doskey aws=docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws amazon/aws-cli $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws amazon/aws-cli $args}
Set-Alias -Name aws -Value AWSCLI
```
------
+ Pour affecter une version spécifique à utiliser dans votre alias `aws`, ajoutez votre balise de version.
------
#### [ Amazon ECR Public ]
**Linux et macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws public.ecr.aws/aws-cli/aws-cli:2.0.6'
```
**Invite de commande Windows**
```
C:\> doskey aws=docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws public.ecr.aws/aws-cli/aws-cli:2.0.6 $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws public.ecr.aws/aws-cli/aws-cli:2.0.6 $args}
Set-Alias -Name aws -Value AWSCLI
```
------
#### [ Docker Hub ]
**Linux et macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws amazon/aws-cli:2.0.6'
```
**Invite de commande Windows**
```
C:\> doskey aws=docker run --rm -it -v %userprofile%\.aws:/root/.aws -v %cd%:/aws amazon/aws-cli:2.0.6 $*
```
**Windows PowerShell**
```
C:\> Function AWSCLI {docker run --rm -it -v $env:userprofile\.aws:/root/.aws -v $pwd\aws:/aws amazon/aws-cli:2.0.6 $args}
Set-Alias -Name aws -Value AWSCLI
```
------
Après avoir défini votre alias, vous pouvez exécuter la AWS CLI version 2 depuis un conteneur comme si elle était installée sur votre système hôte.
```
$ aws --version
aws-cli/2.27.41 Python/3.7.3 Linux/4.9.184-linuxkit botocore/2.4.5dev10
```
# Configuration du AWS CLI
Cette rubrique explique comment configurer rapidement les paramètres de base avec lesquels le AWS Command Line Interface (AWS CLI) interagit AWS. Il s'agit notamment de vos informations de sécurité, du format de sortie par défaut et de la AWS région par défaut.
**Topics**
+ [Recueil de vos informations d’identification pour un accès par programmation](#getting-started-prereqs-keys)
+ [Paramétrage d’une nouvelle configuration et de nouvelles informations d’identification](#getting-started-quickstart-new)
+ [Utilisation de fichiers de configuration et d’informations d’identification existants](#getting-started-quickstart-existing)
## Recueil de vos informations d’identification pour un accès par programmation
Vous aurez besoin d'un accès programmatique si vous souhaitez interagir avec AWS l'extérieur du AWS Management Console. Pour obtenir des instructions concernant l’authentification et les informations d’identification, choisissez l’une des options suivantes :
****
| 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) |
## Paramétrage d’une nouvelle configuration et de nouvelles informations d’identification
AWS CLI Stocke vos informations de configuration et d'identification dans un *profil* (un ensemble de paramètres) dans les `config` fichiers `credentials` et.
**Topics**
+ [Configuration à l'aide de AWS CLI commandes](#getting-started-quickstart-new-command)
+ [Modification manuelle des fichiers de configuration et d’informations d’identification](#getting-started-quickstart-new-file)
Les exemples suivants utilisent des exemples de valeurs pour chacune des méthodes d’authentification. Remplacez ceux-ci par vos propres valeurs.
### Configuration à l'aide de AWS CLI commandes
Pour une utilisation générale, les commandes `aws configure` ou `aws configure sso` de votre terminal préféré constituent le moyen le plus rapide de configurer votre installation de l’ AWS CLI . En fonction de la méthode d'identification que vous préférez, vous êtes AWS CLI invité à saisir les informations pertinentes. 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 les fichiers `credentials` et `config`, consultez [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md).
------
#### [ Console sessions as short-term credentials ]
Cet exemple vous permet d'utiliser vos informations d'identification de console existantes avec la `aws login` commande. Cette méthode de connexion peut être utilisée avec les informations d'identification root créées lors de la configuration initiale du compte, un utilisateur IAM ou une identité fédérée auprès de votre fournisseur d'identité. Pour plus d'informations, voir [Connexion pour le développement AWS local à l'aide des informations d'identification de console](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sign-in.html).
```
$ aws login
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]: us-east-1
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://us-east-1.signin.aws.amazon.com/v1/authorize
If you cannot connect to this URL, make sure that you have specified a valid region.
Waiting for login...
Logged in with role `arn:aws:sts::012345678910:user/iam-user`, and configured profile
`default` to use `us-east-1`. This session will expire on October 14, 2025 at 2:04 PST. After this time, you
can renew your session with `aws login`.
```
------
#### [ IAM Identity Center (SSO) ]
Cet exemple concerne AWS IAM Identity Center l'utilisation de l'`aws configure sso`assistant. Pour de plus amples informations, veuillez consulter [Configuration de l'authentification IAM Identity Center à l'aide du AWS CLI](cli-configure-sso.md).
```
$ 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
Attempting to automatically open the SSO authorization page in your default browser.
There are 2 AWS accounts available to you.
> DeveloperAccount, developer-account-admin@example.com (111122223333)
ProductionAccount, production-account-admin@example.com (444455556666)
Using the account ID 111122223333
There are 2 roles available to you.
> ReadOnly
FullAccess
Using the role name "ReadOnly"
CLI default client Region [None]: us-west-2
CLI default output format [None]: json
CLI profile name [123456789011_ReadOnly]: user1
```
------
#### [ IAM Identity Center (Legacy SSO) ]
Cet exemple concerne l'ancienne méthode d' AWS IAM Identity Center utilisation de l'`aws configure sso`assistant. Pour utiliser l’authentification unique héritée, laissez le nom de session vide. Pour de plus amples informations, veuillez consulter [Configuration de l'authentification IAM Identity Center à l'aide du AWS CLI](cli-configure-sso.md).
```
$ aws configure sso
SSO session name (Recommended):
SSO start URL [None]: https://my-sso-portal.awsapps.com/start
SSO region [None]:us-east-1
SSO authorization page has automatically been opened in your default browser.
Follow the instructions in the browser to complete this authorization request.
There are 2 AWS accounts available to you.
> DeveloperAccount, developer-account-admin@example.com (111122223333)
ProductionAccount, production-account-admin@example.com (444455556666)
Using the account ID 111122223333
There are 2 roles available to you.
> ReadOnly
FullAccess
Using the role name "ReadOnly"
CLI default client Region [None]: us-west-2
CLI default output format [None]: json
CLI profile name [123456789011_ReadOnly]: user1
```
------
#### [ Short-term credentials ]
Cet exemple concerne les informations d’identification Gestion des identités et des accès AWSà court terme. L’assistant de configuration AWS est utilisé pour définir les valeurs initiales, puis la commande `aws configure set` attribue la dernière valeur requise. Pour de plus amples informations, veuillez consulter [Authentification à l'aide d'informations d'identification à court terme pour AWS CLI](cli-authentication-short-term.md).
```
$ 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
$ aws configure set aws_session_token fcZib3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
------
#### [ IAM role ]
Cet exemple concerne l’endossement d’un rôle IAM. Les profils qui utilisent des rôles IAM extraient les informations d’identification d’un autre profil, puis appliquent les autorisations des rôles IAM. Dans les exemples suivants, `default` est le profil source des informations d’identification et `user1` emprunte les mêmes informations d’identification, puis endosse un nouveau rôle. Il n’existe pas d’assistant pour ce processus, chaque valeur est donc définie à l’aide de la commande `aws configure set`. Pour de plus amples informations, veuillez consulter [Utilisation d'un rôle IAM dans AWS CLI](cli-configure-role.md).
```
$ aws configure set role_arn arn:aws:iam::123456789012:role/defaultrole
$ aws configure set source_profile default
$ aws configure set role_session_name session_user1
$ aws configure set region us-west-2
$ aws configure set output json
```
------
#### [ Amazon EC2 instance metadata credentials ]
Cet exemple concerne les informations d’identification obtenues à partir des métadonnées de l’instance d’hébergement Amazon EC2. Il n’existe pas d’assistant pour ce processus, chaque valeur est donc définie à l’aide de la commande `aws configure set`. Pour de plus amples informations, veuillez consulter [Utilisation des métadonnées de l'instance Amazon EC2 comme informations d'identification dans AWS CLI](cli-configure-metadata.md).
```
$ aws configure set role_arn arn:aws:iam::123456789012:role/defaultrole
$ aws configure set credential_source Ec2InstanceMetadata
$ aws configure set region us-west-2
$ aws configure set output json
```
------
#### [ Long-term credentials ]
**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).
Cet exemple concerne les informations d’identification à long terme d’ Gestion des identités et des accès AWS. Pour de plus amples informations, veuillez consulter [Authentification à l'aide des informations d'identification utilisateur IAM pour AWS CLI](cli-authentication-user.md).
```
$ 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
```
------
Pour plus d’informations sur les méthodes d’authentification et les informations d’identification, consultez [Authentification et informations d'accès pour AWS CLI](cli-chap-authentication.md).
### Modification manuelle des fichiers de configuration et d’informations d’identification
Quand vous copiez et collez des informations, nous vous suggérons de modifier manuellement les fichiers `config` et `credentials`. Selon la méthode d’identification que vous préférez, les fichiers sont configurés différemment.
Les fichiers sont stockés dans votre répertoire de base, sous le dossier `.aws`. L’emplacement du répertoire de base varie selon le système d’exploitation, mais il est référencé à l’aide de variables d’environnement `%UserProfile%` sous Windows et `$HOME` ou `~` (tilde) sur les systèmes Unix. Pour plus d’informations sur l’emplacement de stockage de ces paramètres, consultez [Où les paramètres de configuration sont-ils stockés ?](cli-configure-files.md#cli-configure-files-where).
Les exemples suivants montrent un profil `default` ainsi qu’un profil nommé `user1`, et utilisent des exemples de valeurs. Remplacez ceux-ci par vos propres valeurs. Pour plus d’informations sur les fichiers `credentials` et `config`, consultez [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md).
------
#### [ IAM Identity Center (SSO) ]
Cet exemple est pour AWS IAM Identity Center. Pour de plus amples informations, veuillez consulter [Configuration de l'authentification IAM Identity Center à l'aide du AWS CLI](cli-configure-sso.md).
**Fichier d’informations d’identification**
Le fichier `credentials` n’est pas utilisé pour cette méthode d’authentification.
**Fichier de configuration**
```
[default]
sso_session = my-sso
sso_account_id = 111122223333
sso_role_name = readOnly
region = us-west-2
output = text
[profile user1]
sso_session = my-sso
sso_account_id = 444455556666
sso_role_name = readOnly
region = us-east-1
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
```
------
#### [ IAM Identity Center (Legacy SSO) ]
Cet exemple concerne l'ancienne méthode de AWS IAM Identity Center. Pour de plus amples informations, veuillez consulter [Configuration de l'authentification IAM Identity Center à l'aide du AWS CLI](cli-configure-sso.md).
**Fichier d’informations d’identification**
Le fichier `credentials` n’est pas utilisé pour cette méthode d’authentification.
**Fichier de configuration**
```
[default]
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_region = us-east-1
sso_account_id = 111122223333
sso_role_name = readOnly
region = us-west-2
output = text
[profile user1]
sso_start_url = https://my-sso-portal.awsapps.com/start
sso_region = us-east-1
sso_account_id = 444455556666
sso_role_name = readOnly
region = us-east-1
output = json
```
------
#### [ Short-term credentials ]
Cet exemple concerne les informations d’identification Gestion des identités et des accès AWSà court terme. Pour de plus amples informations, veuillez consulter [Authentification à l'aide d'informations d'identification à court terme pour AWS CLI](cli-authentication-short-term.md).
**Fichier d’informations d’identification**
```
[default]
aws_access_key_id=ASIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
[user1]
aws_access_key_id=ASIAI44QH8DHBEXAMPLE
aws_secret_access_key=je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY
aws_session_token = fcZib3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
**Fichier de configuration**
```
[default]
region=us-west-2
output=json
[profile user1]
region=us-east-1
output=text
```
------
#### [ IAM role ]
Cet exemple concerne l’endossement d’un rôle IAM. Les profils qui utilisent des rôles IAM extraient les informations d’identification d’un autre profil, puis appliquent les autorisations des rôles IAM. Dans les exemples suivants, `default` est le profil source des informations d’identification et `user1` emprunte les mêmes informations d’identification, puis endosse un nouveau rôle. Pour de plus amples informations, veuillez consulter [Utilisation d'un rôle IAM dans AWS CLI](cli-configure-role.md).
**Fichier d’informations d’identification**
Le fichier `credentials` dépend de l’authentification utilisée par votre profil source. Dans l’exemple suivant, le profil source utilise des informations d’identification à court terme.
```
[default]
aws_access_key_id=ASIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
**Fichier de configuration**
```
[default]
region=us-west-2
output=json
[profile user1]
role_arn=arn:aws:iam::777788889999:role/user1role
source_profile=default
role_session_name=session_user1
region=us-east-1
output=text
```
------
#### [ Amazon EC2 instance metadata credentials ]
Cet exemple concerne les informations d’identification obtenues à partir des métadonnées de l’instance d’hébergement Amazon EC2. Pour de plus amples informations, veuillez consulter [Utilisation des métadonnées de l'instance Amazon EC2 comme informations d'identification dans AWS CLI](cli-configure-metadata.md).
**Fichier d’informations d’identification**
Le fichier `credentials` n’est pas utilisé pour cette méthode d’authentification.
**Fichier de configuration**
```
[default]
role_arn=arn:aws:iam::123456789012:role/defaultrole
credential_source=Ec2InstanceMetadata
region=us-west-2
output=json
[profile user1]
role_arn=arn:aws:iam::777788889999:role/user1role
credential_source=Ec2InstanceMetadata
region=us-east-1
output=text
```
------
#### [ Long-term credentials ]
**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).
Cet exemple concerne les informations d’identification à long terme d’ Gestion des identités et des accès AWS. Pour de plus amples informations, veuillez consulter [Authentification à l'aide des informations d'identification utilisateur IAM pour AWS CLI](cli-authentication-user.md).
**Fichier d’informations d’identification**
```
[default]
aws_access_key_id=AKIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
[user1]
aws_access_key_id=AKIAI44QH8DHBEXAMPLE
aws_secret_access_key=je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY
```
**Fichier de configuration**
```
[default]
region=us-west-2
output=json
[profile user1]
region=us-east-1
output=text
```
------
Pour plus d’informations sur les méthodes d’authentification et les informations d’identification, consultez [Authentification et informations d'accès pour AWS CLI](cli-chap-authentication.md).
## Utilisation de fichiers de configuration et d’informations d’identification existants
Si vous disposez de fichiers de configuration et d’informations d’identification existants, vous pouvez utiliser ceux-ci pour l’ AWS CLI.
Pour utiliser les fichiers `config` et `credentials`, déplacez-les vers le dossier nommé `.aws` dans votre répertoire de base. L’emplacement du répertoire de base varie selon le système d’exploitation, mais il est référencé à l’aide de variables d’environnement `%UserProfile%` sous Windows et `$HOME` ou `~` (tilde) sur les systèmes Unix.
Pour spécifier un emplacement autre que celui par défaut pour les fichiers `config` et `credentials`, définissez un autre chemin local pour les variables d’environnement `AWS_CONFIG_FILE` et `AWS_SHARED_CREDENTIALS_FILE`. Consultez [Configuration des variables d'environnement pour AWS CLI](cli-configure-envvars.md) pour plus de détails.
Pour plus d’informations sur les fichiers de configuration et d’informations d’identification, consultez [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md).