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à.
# Nozioni di base su AWS CLI
Questo capitolo fornisce le fasi per iniziare con la versione 2 della AWS Command Line Interface (AWS CLI) e fornisce collegamenti alle istruzioni pertinenti.
1. **[Completa tutti i prerequisiti](getting-started-prereqs.md)** - Per accedere ai servizi AWS con la AWS CLI, sono necessari almeno un Account AWS e le credenziali IAM. Per aumentare la sicurezza del tuo AWS, ti consigliamo vivamente di non utilizzare le credenziali di accesso associate al tuo account root. È necessario creare un utente con il privilegio minimo per fornire le credenziali di accesso alle attività in cui verranno eseguite in AWS.
1. Installa o accedi a AWS CLI utilizzando uno dei seguenti metodi:
+ **(Consigliato)** [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md).
+ [Installazione delle versioni precedenti della AWS CLI versione 2](getting-started-version.md). L’installazione di una versione specifica viene utilizzata principalmente se il team allinea i propri strumenti a una versione specifica.
+ [Compilazione e installazione del file AWS CLI dal codice sorgente](getting-started-source-install.md). La creazione della AWS CLI da un codice sorgente GitHub è un metodo più approfondito utilizzato principalmente dai clienti che lavorano su piattaforme che non supportiamo direttamente con i nostri programmi di installazione predefiniti.
+ [Esecuzione delle immagini ufficiali di Amazon ECR Public o Docker per AWS CLI](getting-started-docker.md).
+ Accedi alla versione 2 della AWS CLI nella console AWS dal tuo browser utilizzando AWS CloudShell. Per ulteriori informazioni, consulta la [Guida per l'utente AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/).
1. [Dopo aver avuto accesso alla AWS CLI, configurala con le tue credenziali IAM per il primo utilizzo](getting-started-quickstart.md).
**Risoluzione dei problemi relativi all’installazione o alla configurazione**
In caso di problemi dopo l’installazione, la disinstallazione o la configurazione della AWS CLI, consulta la procedura [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md) per la risoluzione dei problemi.
**Topics**
+ [Prerequisiti per utilizzare la AWS CLI versione 2](getting-started-prereqs.md)
+ [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md)
+ [Installazione delle versioni precedenti della AWS CLI versione 2](getting-started-version.md)
+ [Compilazione e installazione del file AWS CLI dal codice sorgente](getting-started-source-install.md)
+ [Esecuzione delle immagini ufficiali di Amazon ECR Public o Docker per AWS CLI](getting-started-docker.md)
+ [Configurazione del AWS CLI](getting-started-quickstart.md)
# Prerequisiti per utilizzare la AWS CLI versione 2
Per accedere ai AWS servizi con AWS CLI, è necessario disporre di credenziali IAM o IAM Identity Center. Account AWS Quando si eseguono AWS CLI i comandi, è AWS CLI necessario avere accesso a tali AWS credenziali. Per aumentare la sicurezza del tuo AWS account, ti consigliamo di utilizzare solo credenziali di breve durata quando usi utenti root o IAM. Dovresti creare un utente con i privilegi minimi per fornire le credenziali di accesso alle attività che eseguirai. AWS Per informazioni sulle best practice, consulta le [best practice di sicurezza](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-users-federation-idp) nella IAM User Guide.
**Topics**
+ [Creare un account amministrativo IAM o Centro identità IAM](#getting-started-prereqs-iam)
+ [Fasi successive](#getting-started-prereqs-next)
## Creare un account amministrativo IAM o Centro identità IAM
Prima di poter configurare AWS CLI, devi creare un account IAM o IAM Identity Center.
**Opzioni di creazione dell'account**
| Scegli un modo per gestire le tue credenziali | Per | Come creare un account | Come configurare l'accesso programmatico all'account |
| --- | --- | --- | --- |
| AWS Credenziali della console di gestione | Utilizza credenziali a breve termine corrispondenti all'utente root creato durante la configurazione iniziale dell'account, un utente IAM o un'identità federata del tuo provider di identità. | Apri la [https://portal.aws.amazon.com/billing/registrazione](https://portal.aws.amazon.com/billing/signup) e segui le istruzioni online. | Non sono necessari passaggi aggiuntivi. Per accedere al AWS CLI con il tuo AWS account, vedi [Accedi per lo sviluppo AWS locale utilizzando le credenziali della console](cli-configure-sign-in.md) |
| Centro identità IAM | Utilizza credenziali a breve termine per accedere ai AWS servizi. | Segui le istruzioni contenute nella Guida introduttiva di AWS IAM Identity Center User Guide. | Configura l'accesso programmatico configurando l'opzione da utilizzare nella Guida per l'utente di AWS IAM Identity Center. |
| AWS Identity and Access Management(Non consigliato) | Utilizza credenziali a lungo termine per accedere ai servizi. AWS | Segui le istruzioni contenute in Create an for emergency access nella IAM User Guide. | Configura l'accesso programmatico tramite Gestisci le chiavi di accesso per gli utenti nella Guida per l'utente IAM. |
## Fasi successive
Dopo aver creato le credenziali Account AWS e IAM, per utilizzarle AWS CLI puoi effettuare una delle seguenti operazioni:
+ [Installa l'ultima versione](getting-started-install.md) della AWS CLI versione 2 sul tuo computer.
+ [Installa una](getting-started-version.md) AWS CLI versione precedente della versione 2 sul tuo computer.
+ Accedi alla AWS CLI versione 2 dal tuo computer [utilizzando un'immagine Docker](getting-started-docker.md).
+ Accedi alla AWS CLI versione 2 nella AWS console dal tuo browser utilizzando AWS CloudShell. Per ulteriori informazioni, consulta la [Guida per l'utente AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/).
# Installazione o aggiornamento alla versione più recente di AWS CLI
Questo argomento descrive come installare o aggiornare 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
Per installare una versione precedente di AWS CLI, vedere. [Installazione delle versioni precedenti della AWS CLI versione 2](getting-started-version.md) Per le istruzioni di disinstallazione, consulta [Disinstallazione della AWS CLI versione 2](uninstall.md).
**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**
+ [AWS CLI istruzioni per l'installazione e l'aggiornamento](#getting-started-install-instructions)
+ [Risoluzione degli errori di AWS CLI installazione e disinstallazione](#install-tshoot)
+ [Fasi successive](#install-next-steps)
## AWS CLI istruzioni per l'installazione e l'aggiornamento
Per le istruzioni di installazione, espandere la sezione relativa al sistema operativo in uso.
### Linux
#### Requisiti di installazione e aggiornamento
+ È necessario estrarre o decomprimere il pacchetto scaricato. Se il sistema operativo non dispone del comando `unzip` integrato, utilizza un comando equivalente.
+ Gli AWS CLI usi `glibc``groff`, e`less`. Questi sono inclusi per impostazione predefinita nella maggior parte delle principali distribuzioni di Linux.
+ Supportiamo le versioni AWS CLI a 64 bit delle distribuzioni recenti di CentOS, Fedora, Ubuntu, Amazon Linux 1, Amazon Linux 2, Amazon Linux 2023 e Linux ARM.
+ Poiché AWS non mantiene altri repository di terze parti`snap`, non possiamo garantire che contengano l'ultima versione di. AWS CLI
#### Installa o aggiorna il AWS CLI
**avvertimento**
Se è la prima volta che esegui un aggiornamento su Amazon Linux, per installare la versione più recente di AWS CLI, devi disinstallare la `yum` versione preinstallata utilizzando il seguente comando:
```
$ sudo yum remove awscli
```
Dopo aver rimosso l'`yum`installazione di, segui le istruzioni di installazione di Linux riportate di seguito. AWS CLI
È possibile installarlo AWS CLI utilizzando uno dei seguenti metodi:
+ **Il programma di installazione da riga di comando** è una buona opzione per il controllo delle versioni, in quanto consente di specificare la versione da installare. Questa opzione non si aggiorna automaticamente e ogni volta che si esegue l’aggiornamento è necessario scaricare un nuovo programma di installazione per sostituire la versione precedente.
+ **Il `snap` pacchetto ufficialmente supportato** è una buona opzione per fare in modo che la versione più recente dei pacchetti AWS CLI as snap si aggiorni sempre automaticamente. Non esiste un supporto integrato per la selezione delle versioni secondarie di AWS CLI e pertanto non è un metodo di installazione ottimale se il team deve bloccare le versioni.
------
#### [ Command line installer - Linux x86 (64-bit) ]
Per aggiornare l'installazione corrente di AWS CLI, scarica un nuovo programma di installazione ogni volta che esegui l'aggiornamento per sovrascrivere le versioni precedenti. Segui questi passaggi dalla riga di comando per installarlo AWS CLI su Linux.
Di seguito sono riportati i passaggi di installazione rapida, in un singolo gruppo da copiare e incollare, i quali forniscono un’installazione di base. Per istruzioni dettagliate, consulta i passaggi a seguire.
**Nota**
**(Facoltativo)** Il seguente blocco di comandi scarica e installa il file AWS CLI senza prima verificare l'integrità del download. Per verificare l’integrità del download, utilizza le istruzioni dettagliate riportate di seguito.
**Come installare** AWS CLI, eseguire i comandi riportati di seguito.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
**Per aggiornare l’installazione corrente** della AWS CLI, aggiungere il collegamento simbolico esistente e le informazioni sul programma di installazione per costruire il comando `install` utilizzando i parametri `--bin-dir`, `--install-dir` e `--update`. Il seguente blocco di comandi utilizza un collegamento simbolico di esempio di una posizione del */usr/local/bin* programma di installazione di */usr/local/aws-cli* per installare AWS CLI localmente il file per l'utente corrente.
```
$ 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
```
**Istruzioni dettagliate per l’installazione**
1. Scaricare il file di installazione in uno dei seguenti modi:
+ **Utilizzare il comando `curl`**: l’opzione `-o` specifica il nome del file in cui viene scritto il pacchetto scaricato. Le opzioni sul seguente comando di esempio determinano la scrittura del file scaricato nella directory corrente con il nome locale `awscliv2.zip`.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
```
+ **Scaricare dall’URL**: per scaricare il programma di installazione con il browser, utilizzare il seguente URL: [https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip](https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip)
1. **(Facoltativo) Verificare l’integrità del file zip scaricato**
Se si è scelto di scaricare manualmente il pacchetto di AWS CLI installazione `.zip` nei passaggi precedenti, è possibile utilizzare i passaggi seguenti per verificare le firme utilizzando lo strumento. `GnuPG`
I `.zip` file del pacchetto di AWS CLI installazione sono firmati crittograficamente utilizzando firme PGP. 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: 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. 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 che hai scaricato. Il percorso e il nome sono identici a quelli del file `.zip` a cui corrisponde, ma con estensione `.sig`. Negli esempi seguenti, viene salvato nella cartella corrente come un file denominato `awscliv2.sig`.
**Per la versione più recente di AWS CLI,** usa il seguente blocco di comandi:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip.sig
```
1. Verifica la firma, passando entrambi i nomi file `.sig` e `.zip` scaricati come parametri del comando `gpg`.
```
$ gpg --verify awscliv2.sig awscliv2.zip
```
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 AWS CLI PGP. Per ulteriori informazioni, consulta [Web of trust](https://en.wikipedia.org/wiki/Web_of_trust).
1. Decomprimi il programma di installazione. Se la distribuzione Linux non dispone di un comando `unzip` integrato, usa un comando equivalente per la decompressione. Il comando di esempio seguente decomprime il pacchetto e crea una directory denominata `aws` sotto la directory corrente.
```
$ unzip awscliv2.zip
```
**Nota**
Quando si esegue l’aggiornamento da una versione precedente, il comando `unzip` richiede di sostituire i file esistenti. Per ignorare questi prompt, ad esempio con l’automazione degli script, utilizzare il flag di aggiornamento `-u` per `unzip`. Questo flag aggiorna automaticamente i file esistenti e ne crea di nuovi in base alle necessità.
```
$ unzip -u awscliv2.zip
```
1. Esegui il programma di installazione. Il comando di installazione utilizza un file denominato `install` nella `aws` directory appena decompressa. Per impostazione predefinita, i file vengono tutti installati in `/usr/local/aws-cli` e viene creato un collegamento simbolico in `/usr/local/bin`. Il comando include `sudo` per concedere autorizzazioni in scrittura a tali directory.
```
$ sudo ./aws/install
```
Puoi eseguire l’installazione senza `sudo` se specifichi le directory per le quali disponi già di autorizzazioni in scrittura. Usa le seguenti istruzioni per il comando `install` per specificare il percorso di installazione:
+ Assicurati che i percorsi forniti ai parametri `-i` e `-b` non contengano nomi di volume o directory contenenti caratteri di spazio o altri caratteri di spazio vuoto. Se c’è uno spazio, l’installazione non riesce.
+ `--install-dir` o `-i`: questa opzione specifica la directory in cui vengono copiati tutti i file.
Il valore predefinito è `/usr/local/aws-cli`.
+ `--bin-dir` o `-b`: questa opzione specifica che il programma `aws` principale nella directory di installazione è collegato simbolicamente al file `aws` nel percorso specificato. È necessario disporre delle autorizzazioni di scrittura nella directory specificata. La creazione di un collegamento simbolico a una directory già presente nel percorso elimina la necessità di aggiungere la directory di installazione alla variabile `$PATH` dell’utente.
Il valore predefinito è `/usr/local/bin`.
```
$ ./aws/install -i /usr/local/aws-cli -b /usr/local/bin
```
**Nota**
Per aggiornare l'installazione corrente di AWS CLI, aggiungete il collegamento simbolico esistente e le informazioni sull'installatore per costruire il comando con il parametro. `install` `--update`
```
$ sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
Per individuare il collegamento simbolico e la directory di installazione esistenti, utilizza i seguenti passaggi:
Usa il comando `which` per individuare il collegamento simbolico. Questo ti fornisce il percorso da utilizzare con il parametro `--bin-dir`.
```
$ which aws
/usr/local/bin/aws
```
Usa il comando `ls` per individuare la directory a cui punta il collegamento simbolico. Questo ti fornisce il percorso da utilizzare con il parametro `--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. Conferma l’installazione con il seguente comando.
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Se il comando `aws` non viene trovato, potrebbe essere necessario riavviare il terminale o seguire la procedura di risoluzione dei problemi riportata in [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Command line - Linux ARM ]
Per aggiornare l'installazione corrente di AWS CLI, scaricate un nuovo programma di installazione ogni volta che effettuate l'aggiornamento per sovrascrivere le versioni precedenti. Segui questi passaggi dalla riga di comando per installarlo AWS CLI su Linux.
Di seguito sono riportati i passaggi di installazione rapida, in un singolo gruppo da copiare e incollare, i quali forniscono un’installazione di base. Per istruzioni dettagliate, consulta i passaggi a seguire.
**Nota**
**(Facoltativo)** Il seguente blocco di comandi scarica e installa il file AWS CLI senza prima verificare l'integrità del download. Per verificare l’integrità del download, utilizza le istruzioni dettagliate riportate di seguito.
**Per installare** AWS CLI, esegui i seguenti comandi.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
**Per aggiornare l’installazione corrente** della AWS CLI, aggiungere il collegamento simbolico esistente e le informazioni sul programma di installazione per costruire il comando `install` utilizzando i parametri `--bin-dir`, `--install-dir` e `--update`. Il seguente blocco di comandi utilizza un collegamento simbolico di esempio */usr/local/bin* e la posizione del programma di installazione di. */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
```
**Istruzioni dettagliate per l’installazione**
1. Scaricare il file di installazione in uno dei seguenti modi:
+ **Utilizzare il comando `curl`**: l’opzione `-o` specifica il nome del file in cui viene scritto il pacchetto scaricato. Le opzioni sul seguente comando di esempio determinano la scrittura del file scaricato nella directory corrente con il nome locale `awscliv2.zip`.
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o "awscliv2.zip"
```
+ **Scaricare dall’URL**: per scaricare il programma di installazione con il browser, utilizzare il seguente URL: [https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip](https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip)
1. **(Facoltativo) Verificare l’integrità del file zip scaricato**
Se si è scelto di scaricare manualmente il pacchetto di AWS CLI installazione `.zip` nei passaggi precedenti, è possibile utilizzare i passaggi seguenti per verificare le firme utilizzando lo strumento. `GnuPG`
I `.zip` file del pacchetto di AWS CLI installazione sono firmati crittograficamente utilizzando firme PGP. 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: 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. 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 che hai scaricato. Il percorso e il nome sono identici a quelli del file `.zip` a cui corrisponde, ma con estensione `.sig`. Negli esempi seguenti, viene salvato nella cartella corrente come un file denominato `awscliv2.sig`.
**Per la versione più recente di AWS CLI,** usa il seguente blocco di comandi:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip.sig
```
1. Verifica la firma, passando entrambi i nomi file `.sig` e `.zip` scaricati come parametri del comando `gpg`.
```
$ gpg --verify awscliv2.sig awscliv2.zip
```
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 AWS CLI PGP. Per ulteriori informazioni, consulta [Web of trust](https://en.wikipedia.org/wiki/Web_of_trust).
1. Decomprimi il programma di installazione. Se la distribuzione Linux non dispone di un comando `unzip` integrato, usa un comando equivalente per la decompressione. Il comando di esempio seguente decomprime il pacchetto e crea una directory denominata `aws` sotto la directory corrente.
```
$ unzip awscliv2.zip
```
**Nota**
Quando si esegue l’aggiornamento da una versione precedente, il comando `unzip` richiede di sostituire i file esistenti. Per ignorare questi prompt, ad esempio con l’automazione degli script, utilizzare il flag di aggiornamento `-u` per `unzip`. Questo flag aggiorna automaticamente i file esistenti e ne crea di nuovi in base alle necessità.
```
$ unzip -u awscliv2.zip
```
1. Esegui il programma di installazione. Il comando di installazione utilizza un file denominato `install` nella `aws` directory appena decompressa. Per impostazione predefinita, i file vengono tutti installati in `/usr/local/aws-cli` e viene creato un collegamento simbolico in `/usr/local/bin`. Il comando include `sudo` per concedere autorizzazioni in scrittura a tali directory.
```
$ sudo ./aws/install
```
Puoi eseguire l’installazione senza `sudo` se specifichi le directory per le quali disponi già di autorizzazioni in scrittura. Usa le seguenti istruzioni per il comando `install` per specificare il percorso di installazione:
+ Assicurati che i percorsi forniti ai parametri `-i` e `-b` non contengano nomi di volume o directory contenenti caratteri di spazio o altri caratteri di spazio vuoto. Se c’è uno spazio, l’installazione non riesce.
+ `--install-dir` o `-i`: questa opzione specifica la directory in cui vengono copiati tutti i file.
Il valore predefinito è `/usr/local/aws-cli`.
+ `--bin-dir` o `-b`: questa opzione specifica che il programma `aws` principale nella directory di installazione è collegato simbolicamente al file `aws` nel percorso specificato. È necessario disporre delle autorizzazioni di scrittura nella directory specificata. La creazione di un collegamento simbolico a una directory già presente nel percorso elimina la necessità di aggiungere la directory di installazione alla variabile `$PATH` dell’utente.
Il valore predefinito è `/usr/local/bin`.
```
$ ./aws/install -i /usr/local/aws-cli -b /usr/local/bin
```
**Nota**
Per aggiornare l'installazione corrente di AWS CLI, aggiungete il collegamento simbolico esistente e le informazioni sull'installatore per costruire il comando con il parametro. `install` `--update`
```
$ sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
Per individuare il collegamento simbolico e la directory di installazione esistenti, utilizza i seguenti passaggi:
Usa il comando `which` per individuare il collegamento simbolico. Questo ti fornisce il percorso da utilizzare con il parametro `--bin-dir`.
```
$ which aws
/usr/local/bin/aws
```
Usa il comando `ls` per individuare la directory a cui punta il collegamento simbolico. Questo ti fornisce il percorso da utilizzare con il parametro `--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. Conferma l’installazione con il seguente comando.
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Se il comando `aws` non viene trovato, potrebbe essere necessario riavviare il terminale o seguire la procedura di risoluzione dei problemi riportata in [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Snap package ]
Forniamo una versione ufficiale AWS supportata di. AWS CLI `snap` Se desideri avere sempre l'ultima versione AWS CLI installata sul tuo sistema, un pacchetto snap te la fornisce mentre si aggiorna automaticamente. Non esiste un supporto integrato per la selezione delle versioni secondarie di AWS CLI e quindi non è un metodo di installazione ottimale se il team deve bloccare le versioni. Per installare una versione secondaria specifica di AWS CLI, è consigliabile utilizzare il programma di installazione da riga di comando.
1. Se la piattaforma Linux non include l’installazione di `snap`, installare `snap` sulla piattaforma.
1. Per informazioni sull’installazione di `snap`, consulta [Installing the daemon](https://snapcraft.io/docs/installing-snapd) nella *Documentazione di Snap*.
1. Potrebbe essere necessario riavviare il sistema in modo che le variabili `PATH` vengano aggiornate correttamente. Se si riscontrano problemi di installazione, seguire i passaggi riportati in [Fix common issues](https://snapcraft.io/docs/fix-common-issues) nella *Documentazione di Snap*.
1. Per verificare che `snap` sia installato correttamente, eseguire il comando seguente.
```
$ snap version
```
1. Eseguire il comando `snap install` seguente per AWS CLI.
```
$ snap install aws-cli --classic
```
A seconda delle autorizzazioni, potrebbe essere necessario aggiungere `sudo` al comando.
```
$ sudo snap install aws-cli --classic
```
**Nota**
Per visualizzare l'archivio snap di AWS CLI, comprese `snap` le istruzioni aggiuntive, consulta la [https://snapcraft.io/aws-cli](https://snapcraft.io/aws-cli)pagina del sito Web di *Canonical* Snapcraft.
1. Verifica che sia installato correttamente. AWS CLI
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Se si verifica un errore, consulta [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
------
### macOS
#### Requisiti di installazione e aggiornamento
+ Supportiamo AWS CLI le versioni macOS 11 e successive. Per ulteriori informazioni, consulta [gli aggiornamenti delle politiche di supporto di macOS per la versione AWS CLI 2 sul blog AWS](https://aws.amazon.com/blogs/developer/macos-support-policy-updates-for-the-aws-cli-v2/) *Developer* Tools.
+ Poiché AWS non gestisce repository di terze parti, non possiamo garantire che contengano la versione più recente di. AWS CLI
**Matrice di supporto della versione macOS**
| AWS CLI versione | Versione macOS supportata |
| --- | --- |
| 2.21.0 (attuale) | 11\$1 |
| 2.17.0 - 2.20.0 | 10.15\$1 |
| 2.0.0 - 2.16.12 | 10.14 e versioni precedenti |
#### Installa o aggiorna il AWS CLI
Se si esegue l'aggiornamento alla versione più recente, utilizzare lo stesso metodo di installazione utilizzato nella versione corrente. Puoi installarlo AWS CLI su macOS nei seguenti modi.
------
#### [ GUI installer ]
I passaggi seguenti mostrano come installare la versione più recente di AWS CLI utilizzando l'interfaccia utente macOS standard e il browser.
1. Nel browser, scaricare il file `pkg` macOS: [https://awscli.amazonaws.com/AWSCLIV2.pkg](https://awscli.amazonaws.com/AWSCLIV2.pkg)
1. Esegui il file scaricato e segui le istruzioni visualizzate. Puoi scegliere di installarlo AWS CLI nei seguenti modi:
+ **Per tutti gli utenti sul computer (richiede `sudo`)**
+ È possibile installare in qualsiasi cartella o scegliere la cartella predefinita consigliata `/usr/local/aws-cli`.
+ Il programma di installazione crea automaticamente un collegamento simbolico `/usr/local/bin/aws` che collega il programma principale nella cartella di installazione scelta.
+ **Solo per l’utente corrente (non richiede `sudo`)**
+ È possibile installare in qualsiasi cartella per cui si dispone dell’autorizzazione in scrittura.
+ A causa delle autorizzazioni utente standard, al termine del programma di installazione, è necessario creare manualmente un file di collegamento simbolico nel proprio `$PATH` che punta ai programmi `aws` e `aws_completer` utilizzando i seguenti comandi al prompt dei comandi. La posizione predefinita per un collegamento simbolico è`/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
```
Se non sono disponibili le autorizzazioni di scrittura per la cartella, potrebbe essere necessario utilizzare `sudo` nel comando. L’esempio seguente utilizza `sudo` con la posizione predefinita per un collegamento simbolico in `/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
```
**Nota**
È possibile visualizzare i log di debug dell’installazione premendo **CMD\$1L** in qualsiasi momento nel programma di installazione. Si aprirà un riquadro di log che consente di filtrare e salvare il log. Il file di log viene salvato automaticamente in `/var/log/install.log`.
1. Per verificare che la shell possa trovare ed eseguire il comando `aws` in `$PATH`, utilizza i seguenti comandi.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Se il comando `aws` non viene trovato, potrebbe essere necessario riavviare il terminale o seguire la procedura di risoluzione dei problemi riportata in [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Command line installer - All users ]
Se disponi delle autorizzazioni `sudo`, è possibile effettuare l'installazione di AWS CLI per tutti gli utenti sul computer. Forniamo le fasi in un gruppo facile da copiare e incollare. Consulta le descrizioni di ogni riga nelle fasi seguenti.
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
$ sudo installer -pkg AWSCLIV2.pkg -target /
```
**Istruzioni dettagliate per l’installazione**
1. Scarica il file utilizzando il comando `curl`. L’opzione `-o` specifica il nome del file su cui viene scritto il pacchetto scaricato. In questo esempio, il file viene scritto in `AWSCLIV2.pkg` nella cartella corrente.
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
```
1. Esegui il programma `installer` macOS standard, specificando come origine il file `.pkg` scaricato. Utilizza il parametro `-pkg` per specificare il nome del pacchetto da installare e il parametro `-target /` per indicare l’unità in cui installare il pacchetto. I file vengono installati in `/usr/local/aws-cli` e viene creato automaticamente un collegamento simbolico in `/usr/local/bin`. È necessario includere `sudo` nel comando per concedere autorizzazioni di scrittura a queste cartelle.
```
$ sudo installer -pkg ./AWSCLIV2.pkg -target /
```
Al termine dell’installazione, i log di debug vengono scritti in `/var/log/install.log`.
1. Per verificare che la shell possa trovare ed eseguire il comando `aws` in `$PATH`, utilizza i seguenti comandi.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Se il comando `aws` non viene trovato, potrebbe essere necessario riavviare il terminale o seguire la procedura di risoluzione dei problemi riportata in [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Command line - Current user ]
1. Per specificare in quale cartella AWS CLI è installato, è necessario creare un file XML con qualsiasi nome di file. Questo file è in formato XML, simile al seguente esempio. Lasciate tutti i valori come mostrati, tranne per la necessità di sostituire il percorso */Users/myusername* nella riga 9 con il percorso della cartella in cui desiderate che venga AWS CLI installato. *La cartella deve già esistere o il comando non riesce.* L'esempio XML seguente, denominato*choices.xml*, specifica il programma di installazione da installare AWS CLI nella cartella`/Users/myusername`, dove viene creata una cartella denominata. `aws-cli`
```
choiceAttribute
customLocation
attributeSetting
/Users/myusername
choiceIdentifier
default
```
1. Scarica il programma di installazione `pkg` utilizzando il comando `curl`. L’opzione `-o` specifica il nome del file su cui viene scritto il pacchetto scaricato. In questo esempio, il file viene scritto in `AWSCLIV2.pkg` nella cartella corrente.
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2.pkg" -o "AWSCLIV2.pkg"
```
1. Esegui il programma `installer` macOS standard con le seguenti opzioni:
+ Specifica il nome del pacchetto da installare utilizzando il parametro `-pkg`.
+ Specifica un’installazione *solo per l’utente corrente* impostando il parametro `-target` su `CurrentUserHomeDirectory`.
+ Specifica il percorso (relativo della cartella corrente) e il nome del file XML creato nel parametro `-applyChoiceChangesXML`.
L'esempio seguente installa il file AWS CLI nella cartella. `/Users/myusername/aws-cli`
```
$ installer -pkg AWSCLIV2.pkg \
-target CurrentUserHomeDirectory \
-applyChoiceChangesXML choices.xml
```
1. Poiché le autorizzazioni utente standard in genere non consentono la scrittura nelle cartelle in `$PATH`, il programma di installazione in questa modalità non tenta di aggiungere i collegamenti simbolici ai programmi `aws` e `aws_completer`. AWS CLI Per il corretto funzionamento, è necessario creare manualmente i collegamenti simbolici al termine dell'installazione. Se la `$PATH` include una cartella in cui è possibile scrivere, e si specifica questa cartella come percorso di destinazione, è possibile eseguire il comando seguente senza `sudo`. Se non si dispone di una cartella scrivibile in `$PATH`, è necessario utilizzare `sudo` per le autorizzazioni per scrivere nella cartella di destinazione specificata. La posizione predefinita di un collegamento simbolico è `/usr/local/bin/`. Sostituire `folder/installed` con il percorso dell’installazione di 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
```
Al termine dell’installazione, i log di debug vengono scritti in `/var/log/install.log`.
1. Per verificare che la shell possa trovare ed eseguire il comando `aws` in `$PATH`, utilizza i seguenti comandi.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Se il comando `aws` non viene trovato, potrebbe essere necessario riavviare il terminale o seguire la procedura di risoluzione dei problemi riportata in [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
------
### Windows
#### Requisiti di installazione e aggiornamento
+ Sono supportate le versioni AWS CLI di Windows a 64 bit supportate da Microsoft.
+ Diritti di amministratore per installare il software
#### Installa o aggiorna il AWS CLI
Per aggiornare l'installazione corrente di AWS CLI Windows, scarica un nuovo programma di installazione ogni volta che esegui l'aggiornamento per sovrascrivere le versioni precedenti. AWS CLI viene aggiornato regolarmente. Per vedere quando è stata rilasciata l'ultima versione, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. *GitHub*
1. Scarica ed esegui il programma di installazione AWS CLI MSI per Windows (64 bit):
[https://awscli.amazonaws.com/AWSCLIV2.msi](https://awscli.amazonaws.com/AWSCLIV2.msi)
In alternativa, è possibile eseguire il comando `msiexec` per eseguire il programma di installazione MSI.
```
C:\> msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2.msi
```
Per i vari parametri utilizzabili con `msiexec`, consulta [msiexec](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/msiexec) nel sito web *Microsoft Docs*. Ad esempio, è possibile utilizzare il flag `/qn` per eseguire un’installazione senza l’intervento dell’utente.
```
C:\> msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2.msi /qn
```
1. Per confermare l’installazione, apri il menu **Start**, ricerca `cmd` per aprire una finestra dei prompt dei comandi e, al prompt dei comandi, utilizza il comando `aws --version`.
```
C:\> aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Se Windows non riesce a trovare il programma, potrebbe essere necessario chiudere e riaprire la finestra del prompt dei comandi per aggiornare il percorso oppure seguire la procedura di risoluzione dei problemi riportata in [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
## Risoluzione degli errori di AWS CLI installazione e disinstallazione
Se riscontri problemi dopo l'installazione o la disinstallazione di AWS CLI, consulta la procedura [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md) per la risoluzione dei problemi. 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).
## Fasi successive
Dopo aver installato correttamente AWS CLI, puoi eliminare in sicurezza i file di installazione scaricati. Dopo aver completato i passaggi [Prerequisiti per utilizzare la AWS CLI versione 2](getting-started-prereqs.md) e aver installato il AWS CLI, è necessario eseguire un[Configurazione del AWS CLI](getting-started-quickstart.md).
# Installazione delle versioni precedenti della AWS CLI versione 2
Questo argomento descrive come installare le versioni precedenti della AWS Command Line Interface versione 2 (AWS CLI) sui sistemi operativi supportati. Per informazioni sulle versioni della AWS CLI versione 2, consultate il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. GitHub
AWS CLI istruzioni per l'installazione della versione 2:
## Linux
### Requisiti di installazione
+ Sai quale versione della AWS CLI versione 2 desideri installare. Per un elenco delle versioni, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. *GitHub*
+ È necessario estrarre o decomprimere il pacchetto scaricato. Se il sistema operativo non dispone del comando `unzip` integrato, utilizza un comando equivalente.
+ La AWS CLI versione 2 utilizza `glibc``groff`, e. `less` Questi sono inclusi per impostazione predefinita nella maggior parte delle principali distribuzioni di Linux.
+ Supportiamo la AWS CLI versione 2 nelle versioni a 64 bit delle distribuzioni recenti di CentOS, Fedora, Ubuntu, Amazon Linux 1, Amazon Linux 2 e Linux ARM.
+ Poiché AWS non gestisce repository di terze parti, non possiamo garantire che contengano la versione più recente di. AWS CLI
### Istruzioni di installazione
Segui questi passaggi dalla riga di comando per installarlo AWS CLI su Linux.
Le fasi vengono fornite in un unico gruppo facile da copiare e incollare a seconda se si utilizza Linux a 64 bit o Linux ARM. Consulta le descrizioni di ogni riga nelle fasi seguenti.
------
#### [ Linux x86 (64-bit) ]
**Nota**
**(Facoltativo)** Il seguente blocco di comandi scarica e installa il file AWS CLI senza prima verificare l'integrità del download. Per verificare l’integrità del download, utilizza le istruzioni dettagliate riportate di seguito.
Per un elenco delle versioni, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. *GitHub*
**Per installare** AWS CLI, esegui i seguenti comandi.
Per specificare una versione, aggiungi un trattino e il numero di versione al nome del file. In questo esempio, il nome del file per la versione *2.0.30* `awscli-exe-linux-x86_64-2.0.30.zip` risulterebbe nel seguente comando:
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
**Per aggiornare l’installazione corrente** della AWS CLI, aggiungere il collegamento simbolico esistente e le informazioni sul programma di installazione per costruire il comando `install` utilizzando i parametri `--bin-dir`, `--install-dir` e `--update`. Il seguente blocco di comandi utilizza un collegamento simbolico di esempio */usr/local/bin* e la posizione del programma di installazione di. */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 ]
**Nota**
**(Facoltativo)** Il seguente blocco di comandi scarica e installa il file AWS CLI senza prima verificare l'integrità del download. Per verificare l’integrità del download, utilizza le istruzioni dettagliate riportate di seguito.
Per un elenco delle versioni, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. *GitHub*
**Per installare** AWS CLI, esegui i seguenti comandi.
Per specificare una versione, aggiungi un trattino e il numero di versione al nome del file. In questo esempio, il nome del file per la versione *2.0.30* `awscli-exe-linux-aarch64-2.0.30.zip` risulterebbe nel seguente comando:
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```
**Per aggiornare l’installazione corrente** della AWS CLI, aggiungere il collegamento simbolico esistente e le informazioni sul programma di installazione per costruire il comando `install` utilizzando i parametri `--bin-dir`, `--install-dir` e `--update`. Il seguente blocco di comandi utilizza un collegamento simbolico di esempio */usr/local/bin* e la posizione del programma di installazione di. */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. Scaricare il file di installazione in uno dei seguenti modi:
------
#### [ Linux x86 (64-bit) ]
+ **Utilizzare il comando `curl`**: l’opzione `-o` specifica il nome del file in cui viene scritto il pacchetto scaricato. Le opzioni sul seguente comando di esempio determinano la scrittura del file scaricato nella directory corrente con il nome locale `awscliv2.zip`.
Per specificare una versione, aggiungi un trattino e il numero di versione al nome del file. In questo esempio, il nome del file per la versione *2.0.30* `awscli-exe-linux-x86_64-2.0.30.zip` risulterebbe nel seguente comando:
```
$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip" -o "awscliv2.zip"
```
Per un elenco delle versioni, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. *GitHub*
+ **Download dall’URL** –
Nel tuo browser, scarica la versione specifica di AWS CLI aggiungendo un trattino e il numero di versione al nome del file.
```
https://awscli.amazonaws.com/awscli-exe-linux-x86_64-version.number.zip
```
Per questo esempio, il nome del file per la versione *2.0.30* sarebbe awscli-exe-linux-x 86\$164-2.0.30.zip e otterrebbe il seguente link: [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 ]
+ **Utilizzare il comando `curl`**: l’opzione `-o` specifica il nome del file in cui viene scritto il pacchetto scaricato. Le opzioni sul seguente comando di esempio determinano la scrittura del file scaricato nella directory corrente con il nome locale `awscliv2.zip`.
Per specificare una versione, aggiungi un trattino e il numero di versione al nome del file. In questo esempio, il nome del file per la versione risulterebbe nel seguente comando: *2.0.30* `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
```
+ **Download dall’URL** –
Nel browser, scaricate la versione specifica di AWS CLI aggiungendo un trattino e il numero di versione al nome del file.
```
https://awscli.amazonaws.com/awscli-exe-linux-aarch64-version.number.zip
```
In questo esempio, il nome del file per la versione *2.0.30* `awscli-exe-linux-aarch64-2.0.30.zip` risulterebbe nel seguente collegamento: [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. **(Facoltativo) Verificare l’integrità del file zip scaricato**
Se hai scelto di scaricare manualmente il pacchetto di AWS CLI installazione `.zip` nei passaggi precedenti, puoi utilizzare i passaggi seguenti per verificare le firme utilizzando lo strumento. `GnuPG`
I `.zip` file del pacchetto di AWS CLI installazione sono firmati crittograficamente utilizzando firme PGP. 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 che hai scaricato. Il percorso e il nome sono identici a quelli del file `.zip` a cui corrisponde, ma con estensione `.sig`. Negli esempi seguenti, viene salvato nella cartella corrente come un file denominato `awscliv2.sig`.
------
#### [ Linux x86 (64-bit) ]
**Per la versione più recente di AWS CLI,** usa il seguente blocco di comandi:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip.sig
```
**Per una versione specifica di AWS CLI,** aggiungi un trattino e il numero di versione al nome del file. In questo esempio, il nome del file per la versione *2.0.30* `awscli-exe-linux-x86_64-2.0.30.zip.sig` risulterebbe nel seguente comando:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip.sig
```
Per un elenco delle versioni, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. *GitHub*
------
#### [ Linux ARM ]
**Per la versione più recente di AWS CLI, usa il** seguente blocco di comandi:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip.sig
```
**Per una versione specifica di AWS CLI,** aggiungi un trattino e il numero di versione al nome del file. In questo esempio, il nome del file per la versione *2.0.30* `awscli-exe-linux-aarch64-2.0.30.zip.sig` risulterebbe nel seguente comando:
```
$ curl -o awscliv2.sig https://awscli.amazonaws.com/awscli-exe-linux-aarch64-2.0.30.zip.sig
```
Per un elenco delle versioni, consulta il [Changelog della AWS CLI versione 2](https://github.com/aws/aws-cli/blob/v2/CHANGELOG.rst?plain=1) su. *GitHub*
------
1. Verifica la firma, passando entrambi i nomi file `.sig` e `.zip` scaricati come parametri del comando `gpg`.
```
$ gpg --verify awscliv2.sig awscliv2.zip
```
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://en.wikipedia.org/wiki/Web_of_trust).
1. Decomprimi il programma di installazione. Se la distribuzione Linux non dispone di un comando `unzip` integrato, usa un comando equivalente per la decompressione. Il comando di esempio seguente decomprime il pacchetto e crea una directory denominata `aws` sotto la directory corrente.
```
$ unzip awscliv2.zip
```
1. Esegui il programma di installazione. Il comando di installazione utilizza un file denominato `install` nella `aws` directory appena decompressa. Per impostazione predefinita, i file vengono tutti installati in `/usr/local/aws-cli` e viene creato un collegamento simbolico in `/usr/local/bin`. Il comando include `sudo` per concedere autorizzazioni in scrittura a tali directory.
```
$ sudo ./aws/install
```
Puoi eseguire l’installazione senza `sudo` se specifichi le directory per le quali disponi già di autorizzazioni in scrittura. Usa le seguenti istruzioni per il comando `install` per specificare il percorso di installazione:
+ Assicurati che i percorsi forniti ai parametri `-i` e `-b` non contengano nomi di volume o directory contenenti caratteri di spazio o altri caratteri di spazio vuoto. Se c’è uno spazio, l’installazione non riesce.
+ `--install-dir` o `-i`: questa opzione specifica la directory in cui vengono copiati tutti i file.
Il valore predefinito è `/usr/local/aws-cli`.
+ `--bin-dir` o `-b`: questa opzione specifica che il programma `aws` principale nella directory di installazione è collegato simbolicamente al file `aws` nel percorso specificato. È necessario disporre delle autorizzazioni di scrittura nella directory specificata. La creazione di un collegamento simbolico a una directory già presente nel percorso elimina la necessità di aggiungere la directory di installazione alla variabile `$PATH` dell’utente.
Il valore predefinito è `/usr/local/bin`.
```
$ ./aws/install -i /usr/local/aws-cli -b /usr/local/bin
```
**Nota**
Per aggiornare l'installazione corrente della AWS CLI versione 2 a una versione più recente, aggiungete il collegamento simbolico e le informazioni di installazione esistenti per creare il comando con il parametro. `install` `--update`
```
$ sudo ./aws/install --bin-dir /usr/local/bin --install-dir /usr/local/aws-cli --update
```
Per individuare il collegamento simbolico e la directory di installazione esistenti, utilizza i seguenti passaggi:
Usa il comando `which` per individuare il collegamento simbolico. Questo ti fornisce il percorso da utilizzare con il parametro `--bin-dir`.
```
$ which aws
/usr/local/bin/aws
```
Usa il comando `ls` per individuare la directory a cui punta il collegamento simbolico. Questo ti fornisce il percorso da utilizzare con il parametro `--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. Conferma l’installazione con il seguente comando.
```
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Linux/5.10.205-195.807.amzn2.x86_64
```
Se il comando `aws` non viene trovato, potrebbe essere necessario riavviare il terminale o seguire la procedura di risoluzione dei problemi riportata in [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
## macOS
### Requisiti di installazione
+ Sai quale versione della AWS CLI versione 2 desideri installare. Per un elenco delle versioni, consulta il [Changelog della AWS CLI versione 2](https://github.com/aws/aws-cli/blob/v2/CHANGELOG.rst?plain=1) su. *GitHub*
+ Supportiamo la AWS CLI versione 2 nelle versioni di macOS a 64 bit supportate da Apple.
+ Poiché AWS non gestisce repository di terze parti, non possiamo garantire che contengano la versione più recente di. AWS CLI
### Istruzioni di installazione
Puoi installare la AWS CLI versione 2 su macOS nei seguenti modi.
------
#### [ GUI installer ]
Le fasi seguenti mostrano come installare o aggiornare la versione più recente della AWS CLI versione 2 utilizzando l’interfaccia utente standard di macOS e il browser. Se si esegue l’aggiornamento alla versione più recente, utilizza lo stesso metodo di installazione impiegato per la versione corrente.
1. Nel browser, scarica la versione specifica di AWS CLI aggiungendo un trattino e il numero di versione al nome del file.
```
https://awscli.amazonaws.com/AWSCLIV2-version.number.pkg
```
Per questo esempio, il nome del file per la versione *2.0.30* `AWSCLIV2-2.0.30.pkg` risulterebbe nel seguente link:. [https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg](https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg)
1. Esegui il file scaricato e segui le istruzioni visualizzate. Puoi scegliere di installare la AWS CLI versione 2 nei seguenti modi:
+ **Per tutti gli utenti sul computer (richiede `sudo`)**
+ È possibile installare in qualsiasi cartella o scegliere la cartella predefinita consigliata `/usr/local/aws-cli`.
+ Il programma di installazione crea automaticamente un collegamento simbolico `/usr/local/bin/aws` che collega il programma principale nella cartella di installazione scelta.
+ **Solo per l’utente corrente (non richiede `sudo`)**
+ È possibile installare in qualsiasi cartella per cui si dispone dell’autorizzazione in scrittura.
+ A causa delle autorizzazioni utente standard, al termine del programma di installazione, è necessario creare manualmente un file di collegamento simbolico nel proprio `$PATH` che punta ai programmi `aws` e `aws_completer` utilizzando i seguenti comandi al prompt dei comandi. Se `$PATH` include una cartella in cui è possibile scrivere, eseguire il comando seguente senza `sudo` se si specifica tale cartella come percorso di destinazione. Se non si dispone di una cartella scrivibile nel `$PATH`, è necessario utilizzare `sudo` nei comandi per ottenere le autorizzazioni per scrivere nella cartella di destinazione specificata. La posizione predefinita di un collegamento simbolico è `/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
```
**Nota**
È possibile visualizzare i log di debug dell’installazione premendo **CMD\$1L** in qualsiasi momento nel programma di installazione. Si aprirà un riquadro di log che consente di filtrare e salvare il log. Il file di log viene salvato automaticamente in `/var/log/install.log`.
1. Per verificare che la shell possa trovare ed eseguire il comando `aws` in `$PATH`, utilizza i seguenti comandi.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Se il comando `aws` non viene trovato, potrebbe essere necessario riavviare il terminale o seguire la procedura di risoluzione dei problemi riportata in [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Command line installer - All users ]
Se disponi `sudo` delle autorizzazioni, puoi installare la AWS CLI versione 2 per tutti gli utenti del computer. Forniamo le fasi in un gruppo facile da copiare e incollare. Consulta le descrizioni di ogni riga nelle fasi seguenti.
Per una versione specifica di AWS CLI, aggiungi un trattino e il numero di versione al nome del file. In questo esempio, il nome del file per la versione *2.0.30* `AWSCLIV2-2.0.30.pkg` risulterebbe nel seguente comando:
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg" -o "AWSCLIV2.pkg"
$ sudo installer -pkg AWSCLIV2.pkg -target /
```
1. Scarica il file utilizzando il comando `curl`. L’opzione `-o` specifica il nome del file su cui viene scritto il pacchetto scaricato. In questo esempio, il file viene scritto in `AWSCLIV2.pkg` nella cartella corrente.
Per una versione specifica di AWS CLI, aggiungi un trattino e il numero di versione al nome del file. In questo esempio, il nome del file per la versione *2.0.30* `AWSCLIV2-2.0.30.pkg` risulterebbe nel seguente comando:
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg" -o "AWSCLIV2.pkg"
```
Per un elenco delle versioni, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. *GitHub*
1. Esegui il programma `installer` macOS standard, specificando come origine il file `.pkg` scaricato. Utilizza il parametro `-pkg` per specificare il nome del pacchetto da installare e il parametro `-target /` per indicare l’unità in cui installare il pacchetto. I file vengono installati in `/usr/local/aws-cli` e viene creato automaticamente un collegamento simbolico in `/usr/local/bin`. È necessario includere `sudo` nel comando per concedere autorizzazioni di scrittura a queste cartelle.
```
$ sudo installer -pkg ./AWSCLIV2.pkg -target /
```
Al termine dell’installazione, i log di debug vengono scritti in `/var/log/install.log`.
1. Per verificare che la shell possa trovare ed eseguire il comando `aws` in `$PATH`, utilizza i seguenti comandi.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Se il comando `aws` non viene trovato, potrebbe essere necessario riavviare il terminale o seguire la procedura di risoluzione dei problemi riportata in [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
------
#### [ Command line - Current user ]
1. Per specificare in quale cartella AWS CLI è installato, è necessario creare un file XML. Questo file è in formato XML, simile al seguente esempio. Lasciate tutti i valori come mostrati, tranne per il fatto che dovete sostituire il percorso */Users/myusername* nella riga 9 con il percorso della cartella in cui desiderate installare la AWS CLI versione 2. *La cartella deve già esistere o il comando non riesce.* Questo esempio XML specifica che il programma di installazione installa il AWS CLI nella cartella`/Users/myusername`, dove crea una cartella denominata. `aws-cli`
```
choiceAttribute
customLocation
attributeSetting
/Users/myusername
choiceIdentifier
default
```
1. Scarica il programma di installazione `pkg` utilizzando il comando `curl`. L’opzione `-o` specifica il nome del file su cui viene scritto il pacchetto scaricato. In questo esempio, il file viene scritto in `AWSCLIV2.pkg` nella cartella corrente.
Per la versione specifica di AWS CLI, aggiungi un trattino e il numero di versione al nome del file. In questo esempio, il nome del file per la versione *2.0.30* `AWSCLIV2-2.0.30.pkg` risulterebbe nel seguente comando:
```
$ curl "https://awscli.amazonaws.com/AWSCLIV2-2.0.30.pkg" -o "AWSCLIV2.pkg"
```
Per un elenco delle versioni, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. *GitHub*
1. Esegui il programma `installer` macOS standard con le seguenti opzioni:
+ Specifica il nome del pacchetto da installare utilizzando il parametro `-pkg`.
+ Specifica un’installazione *solo per l’utente corrente* impostando il parametro `-target` su `CurrentUserHomeDirectory`.
+ Specifica il percorso (relativo della cartella corrente) e il nome del file XML creato nel parametro `-applyChoiceChangesXML`.
L'esempio seguente installa il file AWS CLI nella cartella. `/Users/myusername/aws-cli`
```
$ installer -pkg AWSCLIV2.pkg \
-target CurrentUserHomeDirectory \
-applyChoiceChangesXML choices.xml
```
1. Poiché le autorizzazioni utente standard in genere non consentono la scrittura nelle cartelle in `$PATH`, il programma di installazione in questa modalità non tenta di aggiungere i collegamenti simbolici ai programmi `aws` e `aws_completer`. AWS CLI Per il corretto funzionamento, è necessario creare manualmente i collegamenti simbolici al termine dell'installazione. Se la `$PATH` include una cartella in cui è possibile scrivere, e si specifica questa cartella come percorso di destinazione, è possibile eseguire il comando seguente senza `sudo`. Se non si dispone di una cartella scrivibile in `$PATH`, è necessario utilizzare `sudo` per le autorizzazioni per scrivere nella cartella di destinazione specificata. La posizione predefinita di un collegamento simbolico è `/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
```
Al termine dell’installazione, i log di debug vengono scritti in `/var/log/install.log`.
1. Per verificare che la shell possa trovare ed eseguire il comando `aws` in `$PATH`, utilizza i seguenti comandi.
```
$ which aws
/usr/local/bin/aws
$ aws --version
aws-cli/2.27.41 Python/3.11.6 Darwin/23.3.0
```
Se il comando `aws` non viene trovato, potrebbe essere necessario riavviare il terminale o seguire la procedura di risoluzione dei problemi riportata in [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
------
## Windows
### Requisiti di installazione
+ Sai quale versione della AWS CLI versione 2 desideri installare. Per un elenco delle versioni, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. *GitHub*
+ Sono supportate le versioni AWS CLI di Windows a 64 bit supportate da Microsoft.
+ Diritti di amministratore per installare il software
### Istruzioni di installazione
Per aggiornare l'installazione corrente della AWS CLI versione 2 su Windows, scarica un nuovo programma di installazione ogni volta che esegui l'aggiornamento per sovrascrivere le versioni precedenti. AWS CLI viene aggiornato regolarmente. Per vedere quando è stata rilasciata l'ultima versione, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. *GitHub*
1. Scarica ed esegui il programma di installazione AWS CLI MSI per Windows (64 bit) in uno dei seguenti modi:
+ **Scaricamento ed esecuzione del programma di installazione MSI:** per creare il link per il download di una versione specifica di AWS CLI, aggiungi un trattino e il numero di versione al nome del file.
```
https://awscli.amazonaws.com/AWSCLIV2-version.number.msi
```
Per questo esempio, il nome del file per la versione *2.0.30* risulterebbe nel seguente collegamento:. `AWSCLIV2-2.0.30.msi` [https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi](https://awscli.amazonaws.com/AWSCLIV2-2.0.30.msi)
+ **Uso del comando msiexec:** in alternativa, è possibile utilizzare il programma di installazione MSI aggiungendo il link al comando `msiexec`. Per una versione specifica di AWS CLI, aggiungi un trattino e il numero di versione al nome del file.
```
C:\> msiexec.exe /i https://awscli.amazonaws.com/AWSCLIV2-version.number.msi
```
In questo esempio, il nome del file per la versione *2.0.30* `AWSCLIV2-2.0.30.msi` risulterebbe nel seguente collegamento. [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
```
Per i vari parametri utilizzabili con `msiexec`, consulta [msiexec](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/msiexec) nel sito web *Microsoft Docs*.
Per un elenco delle versioni, consulta il [Changelog della AWS CLI versione 2](https://raw.githubusercontent.com/aws/aws-cli/v2/CHANGELOG.rst) su. *GitHub*
1. Per confermare l’installazione, apri il menu **Start**, ricerca `cmd` per aprire una finestra dei prompt dei comandi e, al prompt dei comandi, utilizza il comando `aws --version`.
```
C:\> aws --version
aws-cli/2.27.41 Python/3.11.6 Windows/10 exe/AMD64 prompt/off
```
Se Windows non riesce a trovare il programma, potrebbe essere necessario chiudere e riaprire la finestra del prompt dei comandi per aggiornare il percorso oppure seguire la procedura di risoluzione dei problemi riportata in [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md).
## Risoluzione degli errori di AWS CLI installazione e disinstallazione
Se riscontri problemi dopo l'installazione o la disinstallazione di AWS CLI, consulta la procedura [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md) per la risoluzione dei problemi. 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).
## Fasi successive
Dopo aver completato i passaggi descritti in [Prerequisiti per utilizzare la AWS CLI versione 2](getting-started-prereqs.md) e aver installato la AWS CLI, è necessario eseguire la configurazione come indicato in [Configurazione del AWS CLI](getting-started-quickstart.md).
# 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)
# Esecuzione delle immagini ufficiali di Amazon ECR Public o Docker per AWS CLI
Questo argomento descrive come eseguire, controllare la versione e configurare la AWS CLI versione 2 su Docker utilizzando l'immagine ufficiale di Amazon Elastic Container Registry Public (Amazon ECR Public) o Docker Hub. Per ulteriori informazioni su come utilizzare Docker, consulta la [documentazione di Docker](https://docs.docker.com/).
Le immagini ufficiali forniscono isolamento, portabilità e sicurezza che supportano e gestiscono AWS direttamente. Ciò consente di utilizzare la AWS CLI versione 2 in un ambiente basato su container senza dover gestire personalmente l'installazione.
**Topics**
+ [Prerequisiti](#cliv2-docker-prereq)
+ [Decidere tra Amazon ECR Public e Docker Hub](#cliv2-docker-versus)
+ [Esegui le immagini della AWS CLI versione ufficiale 2](#cliv2-docker-install)
+ [Note sulle interfacce e sulla retrocompatibilità delle immagini ufficiali](#cliv2-docker-install-notes)
+ [Utilizzo di versioni e tag specifici](#cliv2-docker-upgrade)
+ [Aggiornamento all’ultima immagine ufficiale](#cliv2-docker-update)
+ [Condivisione di file host, credenziali, variabili d’ambiente e configurazione](#cliv2-docker-share-files)
+ [Abbreviazione del comando di esecuzione Docker](#cliv2-docker-aliases)
## Prerequisiti
È necessario che Docker sia installato. Per istruzioni sull'installazione, consulta il [sito Web Docker](https://docs.docker.com/install/).
Per verificare l'installazione di Docker, eseguire il comando seguente e confermare l'esistenza di output.
```
$ docker --version
Docker version 19.03.1
```
## Decidere tra Amazon ECR Public e Docker Hub
Ti consigliamo di utilizzare Amazon ECR Public over Docker Hub per le AWS CLI immagini. Docker Hub prevede limiti di velocità più rigorosi per i consumatori pubblici, causando eventualmente problemi di limitazione (della larghezza di banda della rete). Inoltre, Amazon ECR Public replica le immagini in più di una Regione per fornire una solida disponibilità e gestire i problemi di interruzione della Regione.
Per ulteriori informazioni sui limiti di frequenza di Docker Hub, consulta [Informazioni sulla limitazione della frequenza di Docker Hub](https://www.docker.com/increase-rate-limits/) nel sito web di *Docker*.
## Esegui le immagini della AWS CLI versione ufficiale 2
La prima volta che si utilizza il comando `docker run`, l’immagine più recente viene scaricata sul computer. Ogni successivo utilizzo del comando `docker run` viene eseguito dalla copia locale.
Per eseguire le immagini Docker della AWS CLI versione 2, usa il `docker run` comando.
------
#### [ Amazon ECR Public ]
[L'immagine pubblica di Amazon ECR AWS CLI versione 2 ufficiale è ospitata su Amazon ECR Public nel `aws-cli/aws-cli` repository.](https://gallery.ecr.aws/aws-cli/aws-cli)
```
$ docker run --rm -it public.ecr.aws/aws-cli/aws-cli command
```
------
#### [ Docker Hub ]
L'immagine Docker della AWS CLI versione ufficiale 2 è ospitata su Docker Hub nel repository. `amazon/aws-cli`
```
$ docker run --rm -it amazon/aws-cli command
```
------
Ecco come funziona il comando:
+ `docker run --rm -it repository/name` - L’equivalente dell’eseguibile `aws`. Ogni volta che esegui questo comando, Docker rende operativo un container dell’immagine scaricata ed esegue il comando `aws`. Per impostazione predefinita, l'immagine utilizza la versione più recente della AWS CLI versione 2.
Ad esempio, per chiamare il comando `aws --version` nel Docker, eseguire quanto segue.
------
#### [ 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` - Specifica di eseguire la pulizia del container dopo l’uscita del comando.
+ `-it` - Specifica di aprire uno pseudo-TTY con `stdin`. Ciò consente di fornire input alla AWS CLI versione 2 mentre è in esecuzione in un contenitore, ad esempio utilizzando i `aws help` comandi `aws configure` and. Se scegli se omettere `-it`, considera quanto segue:
+ Se stai eseguendo degli script, `-it` non è necessario.
+ Se riscontri degli errori con gli script, l’omissione della `-it` dalla chiamata Docker potrebbe risolvere il problema.
+ Se stai cercando di reindirizzare l’output, la `-it` potrebbe causare degli errori e l’omissione della `-it` dalla chiamata Docker potrebbe risolvere il problema. Se desideri mantenere il flag `-it`, ma desideri comunque reindirizzare l’output, la disattivazione del [pager lato client](cli-usage-pagination.md#cli-usage-pagination-clientside) utilizzato dalla AWS CLI per impostazione predefinita dovrebbe risolvere il problema.
Per ulteriori informazioni sul comando `docker run`, consulta la [Guida di riferimento di Docker](https://docs.docker.com/engine/reference/run/).
## Note sulle interfacce e sulla retrocompatibilità delle immagini ufficiali
+ L’unico strumento supportato sull’immagine è la AWS CLI. Solo l’eseguibile `aws` non dovrebbe mai essere eseguito direttamente. Ad esempio, anche se `less` `groff` sono installati in modo esplicito sull'immagine, non devono essere eseguiti direttamente all'esterno di un AWS CLI comando.
+ La directory di lavoro di `/aws` è controllata dall’utente. L'immagine non verrà scritta in questa directory, a meno che l'utente non richieda istruzioni sull'esecuzione di un AWS CLI comando.
+ Non ci sono garanzie di compatibilità con le versioni precedenti quando si fa affidamento sul tag più recente. Per garantire la compatibilità con le versioni precedenti, è necessario aggiungere un tag specifico ``, in quanto tali tag sono immutabili e verranno inseriti una sola volta.
## Utilizzo di versioni e tag specifici
L'immagine ufficiale della AWS CLI versione 2 ha più versioni che è possibile utilizzare, a partire dalla versione`2.0.6`. Per eseguire una versione specifica della AWS CLI versione 2, aggiungi il tag appropriato al tuo `docker run` comando. La prima volta che utilizzi il comando `docker run` con un tag, l’ultima immagine Docker per quel tag viene scaricata nel computer. Ogni successivo utilizzo del comando `docker run` con quel tag viene eseguito dalla copia locale.
È possibile utilizzare due tipi di tag:
+ `latest`— Definisce l'ultima versione della AWS CLI versione 2 per l'immagine. Suggeriamo di utilizzare il tag `latest` se desideri l’ultima versione della AWS CLI versione 2. Tuttavia, non ci sono garanzie di compatibilità con le versioni precedenti quando si fa affidamento su questo tag. Il tag `latest` viene utilizzato per impostazione predefinita nel comando `docker run`. Per utilizzare esplicitamente il tag `latest`, aggiungere il tag al nome dell'immagine del container.
------
#### [ 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
```
------
+ ``— Definisce una versione specifica della AWS CLI versione 2 per l'immagine. Se prevedi di utilizzare un'immagine ufficiale in produzione, ti consigliamo di utilizzare una versione specifica della AWS CLI versione 2 per garantire la compatibilità con le versioni precedenti. Ad esempio, per eseguire la versione `2.0.6`, aggiungere la versione al nome dell’immagine del container.
------
#### [ 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
```
------
## Aggiornamento all’ultima immagine ufficiale
Poiché l’immagine più recente viene scaricata nel computer solo la prima volta che si utilizza il comando `docker run`, è necessario estrarre manualmente un’immagine aggiornata. Per eseguire manualmente l'aggiornamento alla versione più recente, ti consigliamo di estrarre l'immagine `latest` con tag. Estraendo l’immagine viene scaricata la versione più recente sul computer.
------
#### [ Amazon ECR Public ]
```
$ docker pull public.ecr.aws/aws-cli/aws-cli:latest
```
------
#### [ Docker Hub ]
```
$ docker pull amazon/aws-cli:latest
```
------
## Condivisione di file host, credenziali, variabili d’ambiente e configurazione
Poiché la AWS CLI versione 2 viene eseguita in un contenitore, per impostazione predefinita la CLI non può accedere al file system host, che include configurazione e credenziali. Per condividere il file system host, le credenziali e la configurazione nel container, montare la directory `~/.aws` del sistema host sul container `/root/.aws` con il flag `-v` per il comando `docker run`. Ciò consente alla AWS CLI versione 2 in esecuzione nel contenitore di individuare le informazioni sul file host.
------
#### [ Amazon ECR Public ]
**Linux e macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws public.ecr.aws/aws-cli/aws-cli command
```
**Prompt dei comandi di 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 e macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws amazon/aws-cli command
```
**Prompt dei comandi di 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
```
------
Per ulteriori informazioni sul flag `-v` e sul montaggio, consulta la [Guida di riferimento Docker](https://docs.docker.com/storage/volumes/).
**Nota**
Per informazioni sui file `config` e `credentials`, consulta [Impostazioni dei file di configurazione e credenziali in AWS CLI](cli-configure-files.md).
### Esempio 1: fornire credenziali e configurazione
In questo esempio, vengono fornite le credenziali host e la configurazione durante l’esecuzione del comando `s3 ls` per elencare i bucket in Amazon Simple Storage Service (Amazon S3). Gli esempi seguenti utilizzano la posizione predefinita per AWS CLI le credenziali e i file di configurazione, per utilizzare una posizione diversa, modificano il percorso del file.
------
#### [ Amazon ECR Public ]
**Linux e 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
```
**Prompt dei comandi di 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 e macOS**
```
$ docker run --rm -it -v ~/.aws:/root/.aws amazon/aws-cli s3 ls
2020-03-25 00:30:48 aws-cli-docker-demo
```
**Prompt dei comandi di 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
```
------
È possibile chiamare variabili di ambiente di sistema specifiche utilizzando il flag `-e`. Per utilizzare una variabile di ambiente, chiamala per nome.
------
#### [ Amazon ECR Public ]
**Linux e 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
```
**Prompt dei comandi di 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 e 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
```
**Prompt dei comandi di 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
```
------
### Esempio 2: download di un file Amazon S3 nel sistema host
Per alcuni comandi della AWS CLI versione 2, è possibile leggere file dal sistema host nel contenitore o scrivere file dal contenitore al sistema host.
Questo esempio illustra come scaricare l'oggetto `S3` `s3://aws-cli-docker-demo/hello` nel file system locale montando la directory di lavoro corrente nella directory `/aws` del container. Scaricando l'oggetto `hello` nella directory `/aws` del container, il file viene salvato anche nella directory di lavoro corrente del sistema host.
------
#### [ Amazon ECR Public ]
**Linux e 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
```
**Prompt dei comandi di 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 e 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
```
**Prompt dei comandi di 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 .
```
------
Per verificare che il file scaricato esista nel file system locale, eseguire quanto segue.
**Linux e macOS**
```
$ cat hello
Hello from Docker!
```
**Windows PowerShell**
```
$ type hello
Hello from Docker!
```
### Esempio 3: utilizzo della variabile di AWS\$1PROFILE ambiente
È possibile chiamare variabili di ambiente di sistema specifiche utilizzando il flag `-e`. Chiama ogni variabile di ambiente che desideri utilizzare. In questo esempio, forniamo le credenziali dell'host, la configurazione e la variabile di *AWS\$1PROFILE* ambiente durante l'esecuzione del `s3 ls` comando per elencare i bucket in Amazon Simple Storage Service (Amazon S3).
------
#### [ Amazon ECR Public ]
**Linux e 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
```
**Prompt dei comandi di 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 e 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
```
**Prompt dei comandi di 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
```
------
## Abbreviazione del comando di esecuzione Docker
Per abbreviare il comando `docker run`, suggeriamo di utilizzare la capacità del sistema operativo per creare un [https://www.linux.com/topic/desktop/understanding-linux-links/](https://www.linux.com/topic/desktop/understanding-linux-links/) (collegamento simbolico) o un [https://www.linux.com/topic/desktop/aliases-diy-shell-commands/](https://www.linux.com/topic/desktop/aliases-diy-shell-commands/) in Linux e macOS o [https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/doskey](https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/doskey) in Windows. Per impostare l'alias `aws`, è possibile eseguire uno dei seguenti comandi.
+ Per l'accesso di base ai comandi `aws`, eseguire le seguenti operazioni.
------
#### [ Amazon ECR Public ]
**Linux e macOS**
```
$ alias aws='docker run --rm -it public.ecr.aws/aws-cli/aws-cli'
```
**Prompt dei comandi di 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 e macOS**
```
$ alias aws='docker run --rm -it amazon/aws-cli'
```
**Prompt dei comandi di 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
```
------
+ Per accedere al file system host e alle impostazioni di configurazione quando si utilizzano i comandi `aws` eseguire le seguenti operazioni.
------
#### [ Amazon ECR Public ]
**Linux e macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws public.ecr.aws/aws-cli/aws-cli'
```
**Prompt dei comandi di 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 e macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws amazon/aws-cli'
```
**Prompt dei comandi di 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
```
------
+ Per assegnare una versione specifica da utilizzare nell'alias `aws`, aggiungere il tag di versione.
------
#### [ Amazon ECR Public ]
**Linux e macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws public.ecr.aws/aws-cli/aws-cli:2.0.6'
```
**Prompt dei comandi di 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 e macOS**
```
$ alias aws='docker run --rm -it -v ~/.aws:/root/.aws -v $(pwd):/aws amazon/aws-cli:2.0.6'
```
**Prompt dei comandi di 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
```
------
Dopo aver impostato l'alias, puoi eseguire la AWS CLI versione 2 dall'interno di un contenitore come se fosse installata sul tuo sistema host.
```
$ aws --version
aws-cli/2.27.41 Python/3.7.3 Linux/4.9.184-linuxkit botocore/2.4.5dev10
```
# Configurazione del AWS CLI
Questo argomento spiega come configurare rapidamente le impostazioni di base utilizzate da AWS Command Line Interface (AWS CLI) per interagire AWS. Queste includono le credenziali di sicurezza, il formato di output predefinito e la AWS regione predefinita.
**Topics**
+ [Raccogliere le informazioni sulle credenziali per l’accesso programmatico](#getting-started-prereqs-keys)
+ [Configurazione di nuove configurazioni e credenziali](#getting-started-quickstart-new)
+ [Utilizzo di file di configurazione e credenziali esistenti](#getting-started-quickstart-existing)
## Raccogliere le informazioni sulle credenziali per l’accesso programmatico
Avrai bisogno dell'accesso programmatico se desideri interagire con l' AWS esterno di. Console di gestione AWS Per istruzioni di autenticazione e credenziali, scegli una delle seguenti opzioni:
****
| Tipo di autenticazione | Scopo | Istruzioni |
| --- | --- | --- |
| AWS Credenziali della console di gestione | **(Consigliato)** Utilizza credenziali a breve termine accedendo alla AWS CLI con le credenziali della console. Consigliato se utilizzi root, utenti IAM o federazione con IAM per l'accesso all'account AWS | [Accedi per lo sviluppo AWS locale utilizzando le credenziali della console](cli-configure-sign-in.md) |
| Credenziali a breve termine per gli utenti della forza lavoro del Centro identità IAM | Utilizza credenziali a breve termine per un utente della forza lavoro di IAM Identity Center.Le best practice di sicurezza sono da utilizzare AWS Organizations con IAM Identity Center. Combina credenziali a breve termine con una directory utente, ad esempio la directory integrata del Centro identità IAM o di Active Directory. | [Configurazione dell'autenticazione IAM Identity Center con AWS CLI](cli-configure-sso.md) |
| Credenziali a breve termine per utenti IAM | Utilizza le credenziali a breve termine degli utenti IAM, che sono più sicure delle credenziali a lungo termine. Se le tue credenziali sono compromesse, è previsto un periodo di tempo limitato in cui possono essere utilizzate prima della scadenza. | [Autenticazione con credenziali a breve termine per AWS CLI](cli-authentication-short-term.md) |
| Utenti IAM o del Centro identità IAM su un’istanza Amazon EC2. | Utilizza i metadati dell’istanza Amazon EC2 per richiedere delle credenziali temporanee utilizzando il ruolo assegnato all’istanza Amazon EC2. | [Utilizzo dei metadati delle istanze Amazon EC2 come credenziali nel AWS CLI](cli-configure-metadata.md) |
| Assumere ruoli per le autorizzazioni | Associa un altro metodo di credenziali e assumi un ruolo per l’accesso temporaneo a cui l’utente dei Servizi AWS potrebbe non avere accesso. | [Utilizzo di un ruolo IAM in AWS CLI](cli-configure-role.md) |
| Credenziali a lungo termine per utenti IAM | (Non raccomandato) Utilizzare credenziali a lungo termine, che non hanno scadenza. | [Autenticazione tramite credenziali utente IAM per AWS CLI](cli-authentication-user.md) |
| Archiviazione esterna degli utenti della forza lavoro IAM o del Centro identità IAM | (Non raccomandato) Associare un altro metodo di credenziali ma archiviare i valori delle credenziali in una posizione esterna alla AWS CLI. Questo metodo è sicuro solo quanto la posizione esterna in cui sono archiviate le credenziali. | [Acquisizione di credenziali con un processo esterno in AWS CLI](cli-configure-sourcing-external.md) |
## Configurazione di nuove configurazioni e credenziali
AWS CLI Memorizza le informazioni sulla configurazione e sulle credenziali in un *profilo* (una raccolta di impostazioni) nei `config` file `credentials` and.
**Topics**
+ [Configurazione tramite comandi AWS CLI](#getting-started-quickstart-new-command)
+ [Modifica manuale delle credenziali e dei file di configurazione](#getting-started-quickstart-new-file)
Gli esempi seguenti utilizzano valori di esempio per ciascuno dei metodi di autenticazione. Sostituire i valori di esempio con i propri.
### Configurazione tramite comandi AWS CLI
Per uso generale, i comandi `aws configure sso` o `aws configure` nel terminale preferito sono il modo più veloce per configurare l’installazione della AWS CLI . In base al metodo di credenziale che preferisci, ti AWS CLI verranno richieste le informazioni pertinenti. Per impostazione predefinita, le informazioni in questo profilo vengono utilizzate quando si esegue un AWS CLI comando che non specifica esplicitamente un profilo da utilizzare.
Per ulteriori informazioni sui file `credentials` e `config`, consulta [Impostazioni dei file di configurazione e credenziali in AWS CLI](cli-configure-files.md).
------
#### [ Console sessions as short-term credentials ]
Questo esempio consente di utilizzare le credenziali della console esistenti con il `aws login` comando. Questo metodo di accesso può essere utilizzato con credenziali root create durante la configurazione iniziale dell'account, con un utente IAM o con un'identità federata del provider di identità. Per ulteriori informazioni, consulta [Accesso per lo sviluppo AWS locale utilizzando le credenziali della 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) ]
Questo esempio riguarda l' AWS IAM Identity Center utilizzo della `aws configure sso` procedura guidata. Per ulteriori informazioni, consulta [Configurazione dell'autenticazione IAM Identity Center con 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) ]
Questo esempio riguarda il metodo precedente di AWS IAM Identity Center utilizzo della `aws configure sso` procedura guidata. Per utilizzare l’SSO precedente, lascia vuoto il nome della sessione. Per ulteriori informazioni, consulta [Configurazione dell'autenticazione IAM Identity Center con 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 ]
Questo esempio riguarda le credenziali a breve termine di AWS Identity and Access Management. Dopo aver utilizzato la procedura guidata aws configure per impostare i valori iniziali, il comando `aws configure set` assegna l’ultimo valore necessario. Per ulteriori informazioni, consulta [Autenticazione con credenziali a breve termine per 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 ]
Questo esempio serve per assumere un ruolo IAM. I profili che utilizzano i ruoli IAM estraggono le credenziali da un altro profilo e quindi applicano le autorizzazioni dei ruoli IAM. Negli esempi seguenti, `default` è il profilo di origine per le credenziali e `user1` prende in prestito le stesse credenziali per poi assumere un nuovo ruolo. Non esiste una procedura guidata per questo processo, pertanto ogni valore viene impostato utilizzando il comando `aws configure set`. Per ulteriori informazioni, consulta [Utilizzo di un ruolo IAM in 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 ]
Questo esempio riguarda le credenziali ottenute dai metadati dell’istanza Amazon EC2 di hosting. Non esiste una procedura guidata per questo processo, pertanto ogni valore viene impostato utilizzando il comando `aws configure set`. Per ulteriori informazioni, consulta [Utilizzo dei metadati delle istanze Amazon EC2 come credenziali nel 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 ]
**avvertimento**
Per evitare rischi per la sicurezza, non utilizzare gli utenti IAM per l’autenticazione quando sviluppi software creato ad hoc o lavori con dati reali. Utilizza invece la federazione con un provider di identità come [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
Questo esempio riguarda le credenziali a lungo termine di AWS Identity and Access Management. Per ulteriori informazioni, consulta [Autenticazione tramite credenziali utente IAM per 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
```
------
Per informazioni più dettagliate sui metodi di autenticazione e credenziali, consulta [Credenziali di autenticazione e accesso per AWS CLI](cli-chap-authentication.md).
### Modifica manuale delle credenziali e dei file di configurazione
Quando copi e incolli le informazioni, ti suggeriamo di modificare manualmente il file `config` e `credentials`. In base al metodo di credenziali preferito, i file vengono configurati in modo diverso.
I file vengono memorizzati nella home directory all’interno della cartella `.aws`. La posizione della home directory varia in base al sistema operativo, ma viene definita utilizzando le variabili di ambiente `%UserProfile%` in Windows e `$HOME` o `~` (tilde) nei sistemi basati su Unix. Per ulteriori informazioni su dove sono memorizzate queste impostazioni, consulta [Dove vengono archiviate le impostazioni di configurazione?](cli-configure-files.md#cli-configure-files-where).
Gli esempi seguenti mostrano un profilo `default` e un profilo denominato `user1` e utilizzano valori di esempio. Sostituire i valori di esempio con i propri. Per ulteriori informazioni sui file `credentials` e `config`, consulta [Impostazioni dei file di configurazione e credenziali in AWS CLI](cli-configure-files.md).
------
#### [ IAM Identity Center (SSO) ]
Questo esempio è per AWS IAM Identity Center. Per ulteriori informazioni, consulta [Configurazione dell'autenticazione IAM Identity Center con AWS CLI](cli-configure-sso.md).
**File di credenziali**
Il file `credentials` non viene utilizzato per questo metodo di autenticazione.
**File di configurazione**
```
[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) ]
Questo esempio riguarda il metodo legacy di AWS IAM Identity Center. Per ulteriori informazioni, consulta [Configurazione dell'autenticazione IAM Identity Center con AWS CLI](cli-configure-sso.md).
**File di credenziali**
Il file `credentials` non viene utilizzato per questo metodo di autenticazione.
**File di configurazione**
```
[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 ]
Questo esempio riguarda le credenziali a breve termine di AWS Identity and Access Management. Per ulteriori informazioni, consulta [Autenticazione con credenziali a breve termine per AWS CLI](cli-authentication-short-term.md).
**File di credenziali**
```
[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
```
**File di configurazione**
```
[default]
region=us-west-2
output=json
[profile user1]
region=us-east-1
output=text
```
------
#### [ IAM role ]
Questo esempio serve per assumere un ruolo IAM. I profili che utilizzano i ruoli IAM estraggono le credenziali da un altro profilo e quindi applicano le autorizzazioni dei ruoli IAM. Negli esempi seguenti, `default` è il profilo di origine per le credenziali e `user1` prende in prestito le stesse credenziali per poi assumere un nuovo ruolo. Per ulteriori informazioni, consulta [Utilizzo di un ruolo IAM in AWS CLI](cli-configure-role.md).
**File di credenziali**
Il file `credentials` dipende dall’autenticazione utilizzata dal profilo di origine. Nell’esempio seguente, il profilo di origine utilizza credenziali a breve termine.
```
[default]
aws_access_key_id=ASIAIOSFODNN7EXAMPLE
aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
aws_session_token = IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZ2luX2IQoJb3JpZVERYLONGSTRINGEXAMPLE
```
**File di configurazione**
```
[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 ]
Questo esempio riguarda le credenziali ottenute dai metadati dell’istanza Amazon EC2 di hosting. Per ulteriori informazioni, consulta [Utilizzo dei metadati delle istanze Amazon EC2 come credenziali nel AWS CLI](cli-configure-metadata.md).
**File di credenziali**
Il file `credentials` non viene utilizzato per questo metodo di autenticazione.
**File di configurazione**
```
[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 ]
**avvertimento**
Per evitare rischi per la sicurezza, non utilizzare gli utenti IAM per l’autenticazione quando sviluppi software creato ad hoc o lavori con dati reali. Utilizza invece la federazione con un provider di identità come [AWS IAM Identity Center](https://docs.aws.amazon.com/singlesignon/latest/userguide/what-is.html).
Questo esempio riguarda le credenziali a lungo termine di AWS Identity and Access Management. Per ulteriori informazioni, consulta [Autenticazione tramite credenziali utente IAM per AWS CLI](cli-authentication-user.md).
**File di credenziali**
```
[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
```
**File di configurazione**
```
[default]
region=us-west-2
output=json
[profile user1]
region=us-east-1
output=text
```
------
Per informazioni più dettagliate sui metodi di autenticazione e credenziali, consulta [Credenziali di autenticazione e accesso per AWS CLI](cli-chap-authentication.md).
## Utilizzo di file di configurazione e credenziali esistenti
Se disponi di file di configurazione e credenziali esistenti, questi possono essere utilizzati per AWS CLI.
Per utilizzare i file `credentials` e `config`, spostali nella cartella denominata `.aws` nella tua home directory. La posizione della home directory varia in base al sistema operativo, ma viene definita utilizzando le variabili di ambiente `%UserProfile%` in Windows e `$HOME` o `~` (tilde) nei sistemi basati su Unix.
Puoi specificare una posizione non predefinita per i file `config` e `credentials` impostando le variabili di ambiente `AWS_CONFIG_FILE` e `AWS_SHARED_CREDENTIALS_FILE` su un altro percorso locale. Per informazioni dettagliate, vedi [Configurazione delle variabili di ambiente per AWS CLI](cli-configure-envvars.md).
Per informazioni più dettagliate sui file di configurazione e credenziali, consulta [Impostazioni dei file di configurazione e credenziali in AWS CLI](cli-configure-files.md).