Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Compilazione e installazione del file AWS CLI dal codice sorgente
Questo argomento descrive come installare o aggiornare dall’origine l’ultima versione di AWS Command Line Interface (AWS CLI) sui sistemi operativi supportati.
Per informazioni sulle ultime versioni di AWS CLI, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. GitHub
**Importante**
AWS CLI le versioni 1 e 2 utilizzano lo stesso nome di `aws` comando. Se in precedenza hai installato AWS CLI la versione 1, vedi[Guida alla migrazione per la AWS CLI versione 2](cliv2-migration.md).
**Topics**
+ [Perché compilare dall’origine?](#source-getting-started-install-why)
+ [Passaggi rapidi](#source-getting-started-install-quicksteps)
+ [Passaggio 1: configurare tutti i requisiti](#source-getting-started-install-reqs)
+ [Fase 2: Configurazione dell'installazione del codice sorgente AWS CLI](#source-getting-started-install-config)
+ [Fase 3: Creazione del AWS CLI](#source-getting-started-install-build)
+ [Fase 4: Installazione di AWS CLI](#source-getting-started-install-instructions)
+ [Fase 5: Verifica dell'installazione AWS CLI](#source-getting-started-install-verify)
+ [Esempi di flussi di lavoro](#source-getting-started-install-workflows)
+ [Risoluzione degli errori di AWS CLI installazione e disinstallazione](#source-install-tshoot)
+ [Fasi successive](#source-install-next-steps)
## Perché compilare dall’origine?
AWS CLI È [disponibile come programmi di installazione predefiniti](getting-started-install.md) per la maggior parte delle piattaforme e degli ambienti, nonché come immagine Docker.
In genere, questi programmi di installazione forniscono la copertura per la maggior parte dei casi d’uso. Le istruzioni per l’installazione dall’origine servono a risolvere i casi d’uso non coperti dai programmi di installazione. Alcuni di questi casi d’uso sono i seguenti:
+ I programmi di installazione predefiniti non supportano l’ambiente in uso. Ad esempio, ARM a 32 bit non è supportato dai programmi di installazione predefiniti.
+ I programmi di installazione predefiniti hanno dipendenze che non sono presenti nell’ambiente. Ad esempio, Alpine Linux utilizza [https://musl.libc.org/](https://musl.libc.org/), ma gli attuali programmi di installazione richiedono `glibc`, il che impedisce il funzionamento immediato dei programmi di installazione predefiniti.
+ I programmi di installazione predefiniti richiedono risorse a cui l’ambiente limita l’accesso. Ad esempio, i sistemi con hardening della sicurezza potrebbero non fornire le autorizzazioni per la memoria condivisa. Questo comportamento è necessario per il programma di installazione `aws` bloccato.
+ I programmi di installazione predefiniti spesso rappresentano un ostacolo per i manutentori dei gestori di pacchetti, in quanto è preferibile avere il pieno controllo sul processo di compilazione del codice e dei pacchetti. La compilazione dall’origine consente ai manutentori della distribuzione di utilizzare un processo più semplice per mantenere AWS CLI aggiornato. L'abilitazione dei manutentori fornisce ai clienti più up-to-date versioni di AWS CLI quando si installa da un gestore di pacchetti di terze parti come, e. `brew` `yum` `apt`
+ I clienti che dispongono della AWS CLI funzionalità di patch richiedono la creazione e l'installazione del codice AWS CLI sorgente. Ciò è particolarmente importante per i membri della community che desiderano testare le modifiche apportate al codice sorgente prima di apportare la modifica al AWS CLI GitHub repository.
## Passaggi rapidi
**Nota**
Si presume che tutti gli esempi di codice vengano eseguiti dalla root della directory di origine.
Per creare e installare il file AWS CLI dal codice sorgente, segui i passaggi descritti in questa sezione. AWS CLI utilizza [GNU Autotools](https://www.gnu.org/software/automake/faq/autotools-faq.html) per l’installazione dall’origine. Nel caso più semplice, AWS CLI può essere installato dal codice sorgente eseguendo i comandi di esempio predefiniti dalla radice del AWS CLI GitHub repository.
1. [Impostare tutti i requisiti per l’ambiente.](#source-getting-started-install-reqs) Ciò include la possibilità di eseguire file generati da [GNU Autotools](https://www.gnu.org/software/automake/faq/autotools-faq.html) e installare Python 3.8 o versioni successive.
1. Nel tuo terminale, vai al livello superiore della cartella dei AWS CLI sorgenti ed esegui il `./configure` comando. Questo comando verifica la presenza di tutte le dipendenze richieste nel sistema e genera un `Makefile` per la compilazione e l’installazione di AWS CLI in base alle configurazioni rilevate e specificate.
------
#### [ Linux and macOS ]
Il seguente esempio di `./configure` comando imposta la configurazione di build per l' AWS CLI utilizzo delle impostazioni predefinite.
```
$ ./configure
```
------
#### [ Windows PowerShell ]
Prima di eseguire qualsiasi chiamata ai comandi MSYS2, è necessario conservare la directory di lavoro corrente:
```
PS C:\> $env:CHERE_INVOKING = 'yes'
```
Quindi usa il seguente esempio di `./configure` comando per impostare la configurazione di build per l' AWS CLI utilizzo del percorso locale dell'eseguibile Python, l'installazione in C:\$1Program Files\$1 AWSCLI e il download di tutte le dipendenze.
```
PS C:\> C:\msys64\usr\bin\bash -lc " PYTHON='C:\path\to\python.exe' ./configure --prefix='C:\Program Files\AWSCLI' --with-download-deps "
```
------
Per i dettagli, le opzioni di configurazione disponibili e le informazioni sulle impostazioni predefinite, consulta la sezione [Fase 2: Configurazione dell'installazione del codice sorgente AWS CLI](#source-getting-started-install-config).
1. Esegui il comando `make`. Questo comando crea il file in AWS CLI base alle impostazioni di configurazione.
Il seguente comando `make` di esempio compila con le opzioni predefinite utilizzando le impostazioni `./configure` esistenti.
------
#### [ Linux and macOS ]
```
$ make
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "make"
```
------
Per i dettagli e le opzioni di compilazione disponibili, consulta la sezione [Fase 3: Creazione del AWS CLI](#source-getting-started-install-build).
1. Esegui il comando `make install`. Questo comando installa il build AWS CLI nella posizione configurata del sistema.
Il seguente esempio di `make install` comando installa il comando build AWS CLI e crea collegamenti simbolici nelle posizioni configurate utilizzando le impostazioni di comando predefinite.
------
#### [ Linux and macOS ]
```
$ make install
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "make install"
```
Dopo l'installazione, aggiungi il percorso a AWS CLI utilizzando quanto segue:
```
PS C:\> $Env:PATH +=";C:\Program Files\AWSCLI\bin\"
```
------
Per i dettagli e le opzioni di installazione disponibili, consulta la sezione [Fase 4: Installazione di AWS CLI](#source-getting-started-install-instructions).
1. Conferma l'installazione AWS CLI con successo utilizzando il seguente comando:
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Per il passaggi della risoluzione dei problemi di installazione, consulta la sezione [Risoluzione degli errori di AWS CLI installazione e disinstallazione](#source-install-tshoot).
## Passaggio 1: configurare tutti i requisiti
Per compilare il AWS CLI codice sorgente è necessario completare prima quanto segue:
**Nota**
Si presume che tutti gli esempi di codice vengano eseguiti dalla root della directory di origine.
1. Scaricate il AWS CLI codice sorgente eseguendo il forking del AWS CLI GitHub repository o scaricando il tarball dei sorgenti. Seguire una delle seguenti istruzioni:
+ [Fork e clona il repository da.AWS CLI*GitHub*](https://github.com/aws/aws-cli) *Per maggiori informazioni, consulta [Fork a repo nei Documenti](https://docs.github.com/en/get-started/quickstart/fork-a-repo). GitHub *
+ Scaricare il tarball di origine più recente da [https://awscli.amazonaws.com/awscli.tar.gz](https://awscli.amazonaws.com/awscli.tar.gz) ed estrarne il contenuto utilizzando i seguenti comandi:
```
$ curl "https://awscli.amazonaws.com/awscli.tar.gz" -o "awscli.tar.gz"
$ tar -xzf awscli.tar.gz
```
**Nota**
[Per scaricare una versione specifica, utilizza il seguente formato di collegamento: /awscli- .tar.gz https://awscli.amazonaws.com *versionnumber*](https://awscli.amazonaws.com/awscli.tar.gz)
[Ad esempio, per la versione 2.10.0 il link è il seguente: /awscli- .tar.gz https://awscli.amazonaws.com *2.10.0*](https://awscli.amazonaws.com/awscli.tar.gz)
Le versioni di origine sono disponibili a partire dalla versione **2.10.0** di AWS CLI.
**(Facoltativo) Verificare l’integrità del file zip scaricato completando i seguenti passaggi:**
1. Puoi utilizzare le fasi seguenti per verificare le firme tramite lo strumento `GnuPG`.
I AWS CLI file del pacchetto di installazione sono firmati crittograficamente utilizzando firme PGP. `.zip` Se i file sono in qualche modo danneggiati o alterati, questa verifica non va a buon fine e l’installazione deve essere arrestata.
1. Scarica e installa il comando `gpg` utilizzando il programma di gestione dei pacchetti. Per ulteriori informazioni su `GnuPG`, consulta il [sito Web GnuPG](https://www.gnupg.org/).
1. Per creare il file della chiave pubblica, crea un file di testo e incolla il testo seguente.
```
-----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-----
```
Per riferimento, di seguito sono riportati i dettagli della chiave pubblica.
```
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. Importa la chiave AWS CLI pubblica con il seguente comando, sostituendola *public-key-file-name* con il nome del file della chiave pubblica che hai creato.
```
$ 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. [Scarica il file della AWS CLI firma per il pacchetto scaricato all'indirizzo https://awscli.amazonaws.com /awscli.tar.gz.sig.](https://awscli.amazonaws.com/awscli.tar.gz.sig) Il percorso e il nome sono identici a quelli del file tarball corrispondente, ma con estensione `.sig`. Salvare il file nello stesso percorso del file tarball. In alternativa, utilizzare il seguente blocco di comandi:
```
$ curl awscliv2.sig https://awscli.amazonaws.com/ -o awscli.tar.gz.sig
```
1. Verifica la firma, passando entrambi i nomi file `.sig` e `.zip` scaricati come parametri del comando `gpg`.
```
$ gpg --verify awscliv2.sig awscli.tar.gz
```
L’output visualizzato dovrebbe essere simile al seguente:
```
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
```
**Importante**
L’avviso nell’output è previsto e non indica un problema. Si verifica perché non esiste una catena di fiducia tra la tua chiave PGP personale (se ne hai una) e la chiave PGP. AWS CLI Per ulteriori informazioni, consulta [Web of trust](https://wikipedia.org/wiki/Web_of_trust).
1. È disponibile un ambiente in grado di eseguire file generati da [GNU Autotools](https://www.gnu.org/software/automake/faq/autotools-faq.html) come `configure` e `Makefile`. Questi file sono ampiamente portabili nelle piattaforme POSIX.
------
#### [ Linux and macOS ]
Se Autotools non è installato nell’ambiente o è necessario aggiornarlo, seguire le istruzioni di installazione disponibili in [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) o [Basic Installation](https://www.gnu.org/savannah-checkouts/gnu/automake/manual/automake.html#Basic-Installation) nella *Documentazione di GNU*.
------
#### [ Windows PowerShell ]
**avvertimento**
Se si utilizza un ambiente Windows, è consigliabile utilizzare i programmi di installazione predefiniti. Per le istruzioni di installazione dei programmi di installazione predefiniti, consulta [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md).
Poiché Windows non è dotato di una shell compatibile con POSIX, è necessario installare software aggiuntivo per installare il codice sorgente. AWS CLI [MSYS2](https://www.msys2.org/)fornisce una raccolta di strumenti e librerie per aiutare a creare e installare software Windows, in particolare per lo scripting basato su POSIX utilizzato da Autotools.
1. Installa. MSYS2 Per informazioni sull'installazione e l'uso MSYS2, consulta le [istruzioni di installazione e utilizzo](https://www.msys2.org/) nella *MSYS2 Documentazione*.
1. Apri il MSYS2 terminale e installa gli autotools usando il seguente comando.
```
$ pacman -S autotools
```
**Nota**
Quando si utilizzano gli esempi di codice di configurazione, compilazione e installazione riportati in questa guida per Windows, si presuppone il percorso di MSYS2 installazione predefinito di`C:\msys64\usr\bin\bash`. Quando chiami MSYS2 inside of PowerShell utilizzerai il seguente formato, con il comando bash tra virgolette:
```
PS C:\> C:\msys64\usr\bin\bash -lc "command example"
```
Il seguente comando di esempio chiama il comando `./configure`.
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure"
```
------
1. È installato un interprete Python 3.8 o versioni successive. La versione minima di Python richiesta segue le stesse tempistiche della politica di supporto [Python](https://aws.amazon.com/blogs/developer/python-support-policy-updates-for-aws-sdks-and-tools/) ufficiale per and Tools. AWS SDKs Un interprete è supportato solo 6 mesi dopo la sua data. end-of-support
1. **(Facoltativo)** Installare tutte le dipendenze della libreria Python di compilazione e runtime di AWS CLI. Il comando `./configure` informa l’utente se mancano delle dipendenze e come installarle.
È possibile installare e utilizzare automaticamente queste dipendenze tramite la configurazione, consulta [Download delle dipendenze](#source-getting-started-install-config-dependencies) per ulteriori informazioni.
## Fase 2: Configurazione dell'installazione del codice sorgente AWS CLI
La configurazione per la creazione e l'installazione di AWS CLI viene specificata utilizzando lo `configure` script. Per la documentazione di tutte le opzioni di configurazione, eseguire lo script `configure` con l’opzione `--help`:
------
#### [ Linux and macOS ]
```
$ ./configure --help
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure --help"
```
------
**Topics**
+ [Posizione di installazione](#source-getting-started-install-config-location)
+ [Interprete Python](#source-getting-started-install-config-interpreter)
+ [Download delle dipendenze](#source-getting-started-install-config-dependencies)
+ [Tipo di installazione](#source-getting-started-install-config-type)
### Posizione di installazione
L'installazione sorgente di AWS CLI utilizza due directory configurabili per installare: AWS CLI
+ `libdir`- Directory principale in cui AWS CLI verrà installato. Il percorso di AWS CLI installazione è`/aws-cli`. Il valore `libdir` predefinito per Linux e macOS è `/usr/local/lib`, pertanto la directory di installazione predefinita è `/usr/local/lib/aws-cli`.
+ `bindir`- Directory in cui sono installati AWS CLI gli eseguibili. Il percorso predefinito è `/usr/local/bin`.
Le seguenti opzioni `configure` controllano le directory utilizzate:
+ `--prefix`: imposta il prefisso di directory da utilizzare per l’installazione. Il valore predefinito per Linux e macOS è `/usr/local`.
+ `--libdir`: imposta la `libdir` da utilizzare per l’installazione di AWS CLI. Il valore predefinito è `/lib`. Se entrambi `--libdir` e `--prefix` non sono specificati, l’impostazione predefinita per Linux e macOS è `/usr/local/lib/`.
+ `--bindir`- Imposta `bindir` da utilizzare per l'installazione di AWS CLI `aws` ed `aws_completer` eseguibili. Il valore predefinito è `/bin`. Se entrambi `bindir` e `--prefix` non sono specificati, l’impostazione predefinita per Linux e macOS è `/usr/local/bin/`.
------
#### [ Linux and macOS ]
Il seguente comando di esempio utilizza l’opzione `--prefix` per eseguire un’installazione utente locale di AWS CLI. Questo comando installa AWS CLI in `$HOME/.local/lib/aws-cli` e gli eseguibili in: `$HOME/.local/bin`
```
$ ./configure --prefix=$HOME/.local
```
Il seguente comando di esempio utilizza l’opzione `--libdir` per installare AWS CLI come applicazione aggiuntiva nella directory `/opt`. Questo comando installa AWS CLI at `/opt/aws-cli` e gli eseguibili nella posizione predefinita di. `/usr/local/bin`
```
$ ./configure --libdir=/opt
```
------
#### [ Windows PowerShell ]
Il seguente comando di esempio utilizza l’opzione `--prefix` per eseguire un’installazione utente locale di AWS CLI. Questo comando installa AWS CLI in `$HOME/.local/lib/aws-cli` e gli eseguibili in: `$HOME/.local/bin`
```
$ C:\msys64\usr\bin\bash -lc "./configure --prefix='C:\Program Files\AWSCLI'"
```
Il seguente comando di esempio utilizza l’opzione `--libdir` per installare AWS CLI come applicazione aggiuntiva nella directory `/opt`. Questo comando installa il file at. AWS CLI `C:\Program Files\AWSCLI\opt\aws-cli`
------
### Interprete Python
**Nota**
Si consiglia vivamente di specificare l’interprete Python durante l’installazione per Windows.
Lo `./configure` script seleziona automaticamente un interprete Python 3.8 o successivo installato da utilizzare nella creazione e nell'esecuzione AWS CLI della macro using the Autoconf. [https://www.gnu.org/software/automake/manual/html_node/Python.html](https://www.gnu.org/software/automake/manual/html_node/Python.html)
L’interprete Python da utilizzare può essere impostato in modo esplicito utilizzando la variabile di ambiente `PYTHON` durante l’esecuzione dello 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"
```
------
### Download delle dipendenze
Per impostazione predefinita, è necessario che tutte le dipendenze di build e runtime di siano già installate nel AWS CLI sistema. Sono incluse le dipendenze della libreria Python. Tutte le dipendenze vengono controllate durante l’esecuzione dello script `configure` e se nel sistema mancano delle dipendenze Python, lo script `configure` genera errori.
Il seguente codice di esempio genera errori quando nel sistema mancano le dipendenze:
------
#### [ 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."
```
------
Per installare automaticamente le dipendenze Python richieste, utilizzare l’opzione `--with-download-deps`. Quando si utilizza questo flag, il processo di compilazione esegue le seguenti operazioni:
+ Salta il controllo delle dipendenze della libreria Python.
+ Configura le impostazioni per scaricare tutte le dipendenze Python richieste e utilizzare **solo** le dipendenze scaricate per compilare AWS CLI durante la compilazione di `make`.
Il seguente comando configure di esempio utilizza l’opzione `--with-download-deps` per scaricare e utilizzare le dipendenze Python:
------
#### [ Linux and macOS ]
```
$ ./configure --with-download-deps
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "./configure --with-download-deps"
```
------
### Tipo di installazione
Il processo di installazione dall’origine supporta i seguenti tipi di installazione:
+ `system-sandbox`- **(Impostazione predefinita)** Crea un ambiente virtuale Python isolato, lo installa AWS CLI nell'ambiente virtuale e collega simbolicamente al `aws_completer` file eseguibile nell'ambiente virtuale. `aws` Questa installazione di AWS CLI dipende direttamente dall'interprete Python selezionato per il suo runtime.
Questo è un meccanismo di installazione leggero per installarlo su un sistema e segue le migliori pratiche di Python eseguendo il sandboxing dell'installazione in un ambiente virtuale. AWS CLI Questa installazione è destinata ai clienti che desiderano installare il file AWS CLI dal codice sorgente nel modo più semplice possibile con l'installazione abbinata all'installazione di Python.
+ `portable-exe`- Lo blocca AWS CLI in un eseguibile autonomo che può essere distribuito in ambienti con architetture simili. Questo è lo stesso processo utilizzato per generare gli eseguibili ufficiali predefiniti di AWS CLI. `portable-exe` blocca in una copia dell’interprete Python scelto nel passaggio `configure` da utilizzare per il runtime di AWS CLI. Questo consente di spostarlo su altri computer che potrebbero non avere un interprete Python.
Questo tipo di compilazione è utile perché è possibile assicurarsi che l’installazione di AWS CLI non sia abbinata alla versione di Python installata nell’ambiente e distribuire una compilazione su altri sistemi in cui potrebbe non essere installato Python. Ciò consente di controllare le dipendenze e la sicurezza degli eseguibili utilizzati. AWS CLI
Per configurare il tipo di installazione, utilizzare l’opzione `--with-install-type` e specificare il valore `portable-exe` o `system-sandbox`.
Il seguente comando `./configure` di esempio specifica il valore `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"
```
------
## Fase 3: Creazione del AWS CLI
Usa il `make` comando per crearlo AWS CLI usando le tue impostazioni di configurazione:
------
#### [ Linux and macOS ]
```
$ make
```
------
#### [ Windows PowerShell ]
```
PS C:\> C:\msys64\usr\bin\bash -lc "make"
```
------
**Nota**
Un ambiente virtuale viene creato nella directory di compilazione utilizzando il modulo Python [https://docs.python.org/3/library/venv.html](https://docs.python.org/3/library/venv.html). L’ambiente virtuale viene avviato con una [versione di pip fornita nella libreria standard Python](https://docs.python.org/3/library/ensurepip.html).
Le dipendenze della libreria Python vengono copiate. A seconda se il flag `--with-download-deps` è stato specificato nel comando `configure`, questo passaggio esegue una delle seguenti operazioni:
`--with-download-deps` **è** specificato. Le dipendenze Python eseguono l’installazione pip. Sono incluse `wheel`, `setuptools` e tutte le dipendenze di runtime AWS CLI . Se si sta compilando `portable-exe`, viene installato `pyinstaller`. Questi requisiti sono tutti specificati nei file di blocco generati da [https://github.com/jazzband/pip-tools](https://github.com/jazzband/pip-tools).
`--with-download-deps` **non è** specificato. Le librerie Python del pacchetto del sito dell’interprete Python più eventuali script (ad esempio `pyinstaller`) vengono copiati nell’ambiente virtuale utilizzato per la compilazione.
Viene eseguito `pip install` direttamente sulla AWS CLI codebase per eseguire una compilazione offline e nell'albero e l'installazione di AWS CLI nell'ambiente virtuale di compilazione. [Questa installazione utilizza i flag pip [--no-build-isolation , [in-tree-build --use-feature=](https://pip.pypa.io/en/stable/cli/pip_install/#local-project-installs), --](https://pip.pypa.io/en/stable/cli/pip_install/#cmdoption-no-build-isolation) e. 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)
**(Facoltativo)** Se `--install-type` è impostato su `portable-exe` nel comando `configure`, viene compilato un eseguibile standalone utilizzando [https://www.pyinstaller.org/](https://www.pyinstaller.org/).
## Fase 4: Installazione di AWS CLI
Il `make install` comando installa il build AWS CLI nella posizione configurata sul sistema.
------
#### [ Linux and macOS ]
Il seguente esempio di comando installa le AWS CLI impostazioni di configurazione e compilazione:
```
$ make install
```
------
#### [ Windows PowerShell ]
Il seguente esempio di comando installa le impostazioni AWS CLI using your configuration and build, quindi aggiunge una variabile di ambiente con il percorso per: AWS CLI
```
PS C:\> C:\msys64\usr\bin\bash -lc " make install "
PS C:\> $Env:PATH +=";C:\Program Files\AWSCLI\bin\"
```
------
La regola `make install` supporta la variabile [https://www.gnu.org/software/make/manual/html_node/DESTDIR.html#DESTDIR](https://www.gnu.org/software/make/manual/html_node/DESTDIR.html#DESTDIR). Quando è specificata, questa variabile imposta per il percorso specificato il prefisso del percorso di installazione già configurato durante l’installazione di AWS CLI. Per impostazione predefinita, non è impostato alcun valore per questa variabile.
------
#### [ Linux and macOS ]
Il seguente codice di esempio utilizza un flag `--prefix=/usr/local` per configurare una posizione di installazione, quindi modifica tale destinazione utilizzando `DESTDIR=/tmp/stage` per il comando `make install`. Questi comandi determinano l'installazione AWS CLI in `/tmp/stage/usr/local/lib/aws-cli` e i relativi eseguibili si trovano in. `/tmp/stage/usr/local/bin`
```
$ ./configure --prefix=/usr/local
$ make
$ make DESTDIR=/tmp/stage install
```
------
#### [ Windows PowerShell ]
Il seguente codice di esempio utilizza un flag `--prefix=\awscli` per configurare una posizione di installazione, quindi modifica tale destinazione utilizzando `DESTDIR=C:\Program Files` per il comando `make install`. Questi comandi comportano l'installazione AWS CLI in`C:\Program Files\awscli`.
```
$ ./configure --prefix=\awscli
$ make
$ make DESTDIR='C:\Program Files' install
```
------
**Nota**
Sposta uno dei seguenti elementi nella directory di installazione configurata:
Se il tipo di installazione è `system-sandbox`, sposta l’ambiente virtuale compilato.
Se il tipo di installazione è `portable-exe`, sposta l’eseguibile standalone compilato.
Crea collegamenti simbolici per gli eseguibili `aws` e `aws_completer` nella directory bin configurata.
## Fase 5: Verifica dell'installazione AWS CLI
Conferma l' AWS CLI avvenuta installazione utilizzando il seguente comando:
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Se il comando `aws` non viene riconosciuto, potrebbe essere necessario riavviare il terminale per aggiornare i nuovi collegamenti simbolici. Se riscontrate altri problemi dopo l'installazione o la disinstallazione di AWS CLI, consultate le procedure comuni [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md) per la risoluzione dei problemi
## Esempi di flussi di lavoro
Questa sezione fornisce alcuni esempi di flussi di lavoro di base per l’installazione dall’origine.
### Installazione di base per Linux e macOS
L'esempio seguente è un flusso di lavoro di installazione di base in cui AWS CLI viene installato nella posizione predefinita di`/usr/local/lib/aws-cli`.
```
$ cd path/to/cli/respository/
$ ./configure
$ make
$ make install
```
### Installazione automatizzata per Windows
**Nota**
È necessario eseguire l'esecuzione PowerShell come amministratore per utilizzare questo flusso di lavoro.
MSYS2 può essere utilizzato in modo automatizzato in un'impostazione CI, vedere [Utilizzo MSYS2 in CI](https://www.msys2.org/docs/ci/) nella *MSYS2 documentazione*.
------
#### [ Downloaded Tarball ]
Scaricare il file `awscli.tar.gz`, estrarre e installare AWS CLI. Quando si utilizzano i comandi seguenti, sostituire i percorsi seguenti:
+ `C:\msys64\usr\bin\bash`con la posizione del MSYS2 percorso.
+ `.\awscli-2.x.x\` con il nome della cartella `awscli.tar.gz` estratta.
+ `PYTHON='C:\path\to\python.exe'` con il percorso Python locale.
Il seguente esempio di codice automatizza la creazione e l'installazione di AWS CLI from PowerShell MSYS2 using e specifica quale installazione locale di Python usare:
```
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 ]
Scaricare il file `awscli.tar.gz`, estrarre e installare AWS CLI. Quando si utilizzano i comandi seguenti, sostituire i percorsi seguenti:
+ `C:\msys64\usr\bin\bash`con la posizione del percorso. MSYS2
+ `C:path\to\cli\repository\`con il percorso del [AWS CLI repository](https://github.com/aws/aws-cli) clonato da. *GitHub* *Per maggiori informazioni, consulta [Fork a repo nei Documenti](https://docs.github.com/en/get-started/quickstart/fork-a-repo) GitHub *
+ `PYTHON='C:\path\to\python.exe'` con il percorso Python locale.
Il seguente esempio di codice automatizza la creazione e l'installazione di AWS CLI from PowerShell MSYS2 using e specifica quale installazione locale di Python usare:
```
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
```
------
### Container Alpine Linux
Di seguito è riportato un esempio di Dockerfile che può essere utilizzato per ottenere un’installazione funzionante di AWS CLI in un container Alpine Linux come [alternativa ai file binari predefiniti per Alpine](https://github.com/aws/aws-cli/issues/4685). Quando usate questo esempio, sostituite *AWSCLI\$1VERSION* con il numero di versione desiderato AWS CLI :
```
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"]
```
Questa immagine viene creata e AWS CLI richiamata da un contenitore simile a quello creato su 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 dimensione finale di questa immagine è inferiore alla dimensione dell'immagine AWS CLI Docker ufficiale. Per informazioni sull’immagine Docker ufficiale, consulta [Esecuzione delle immagini ufficiali di Amazon ECR Public o Docker per AWS CLI](getting-started-docker.md).
## Risoluzione degli errori di AWS CLI installazione e disinstallazione
Per i passaggi della risoluzione dei problemi di installazione, consulta [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md) per le procedure più comuni. Per le procedure di risoluzione dei problemi più importanti, consulta [Errori di comando non trovato](cli-chap-troubleshooting.md#tshoot-install-not-found), [Il comando `aws --version` restituisce una versione diversa da quella installata](cli-chap-troubleshooting.md#tshoot-install-wrong-version) e [Il comando "`aws --version`" restituisce una versione dopo la disinstallazione di AWS CLI](cli-chap-troubleshooting.md#tshoot-uninstall-1).
Per eventuali problemi non descritti nelle guide alla risoluzione dei problemi, cerca i problemi con l'`source-distribution`etichetta nel [AWS CLI Repository](https://github.com/aws/aws-cli/labels/source-distribution) su *GitHub*. Se nessun problema esistente riguarda i tuoi errori, [crea un nuovo problema](https://github.com/aws/aws-cli/issues/new?assignees=&labels=source-distribution%2Cneeds-triage&template=source-distribution.yml&title=%28short+issue+description%29) per ricevere assistenza dai AWS CLI manutentori.
## Fasi successive
Dopo aver installato il AWS CLI, è necessario eseguire un. [Configurazione del AWS CLI](getting-started-quickstart.md)