

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.

# Création et installation du AWS CLI depuis le code source
<a name="getting-started-source-install"></a>

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 ?
<a name="source-getting-started-install-why"></a>

 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
<a name="source-getting-started-install-quicksteps"></a>

**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
<a name="source-getting-started-install-reqs"></a>

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 <aws-cli@amazon.com>
        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 <aws-cli@amazon.com>" 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 <aws-cli@amazon.com>" [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
<a name="source-getting-started-install-config"></a>

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
<a name="source-getting-started-install-config-location"></a>

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`<libdir-value>/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 `<prefix-value>/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 `<prefix-value>/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
<a name="source-getting-started-install-config-interpreter"></a>

**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
<a name="source-getting-started-install-config-dependencies"></a>

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 "<frozen runpy>", line 198, in _run_module_as_main
  File "<frozen runpy>", line 88, in _run_code
  File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 125, in <module>
    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 "<frozen runpy>", line 198, in _run_module_as_main
  File "<frozen runpy>", line 88, in _run_code
  File "/Users/username/aws-code/aws-cli/./backends/build_system/__main__.py", line 125, in <module>
    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
<a name="source-getting-started-install-config-type"></a>

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
<a name="source-getting-started-install-build"></a>

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
<a name="source-getting-started-install-instructions"></a>

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
<a name="source-getting-started-install-verify"></a>

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
<a name="source-getting-started-install-workflows"></a>

Cette section fournit des exemples de flux de travail de base pour une installation depuis la source.

### Installation de base sous Linux et macOS
<a name="source-getting-started-install-workflows-basic"></a>

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
<a name="source-getting-started-install-workflows-win"></a>

**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
<a name="source-getting-started-install-workflows-alpine"></a>

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
<a name="source-install-tshoot"></a>

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
<a name="source-install-next-steps"></a>

Après avoir installé le AWS CLI, vous devez effectuer un[Configuration du AWS CLI](getting-started-quickstart.md).