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à.
# Esempi di comandi guidati per la AWS CLI
AWS Command Line Interface (AWS CLI) è uno strumento open source che consente di interagire con un’ampia gamma di Servizi AWS utilizzando i comandi nella shell a riga di comando. Questa sezione fornisce esempi guidati che mostrano come sfruttare la AWS CLI per accedere ad alcuni dei Servizi AWS. Ciò include alcuni comandi della AWS CLI personalizzati, come i comandi `aws s3` di alto livello. Questi esempi di comandi illustrano le azioni comuni utilizzate per alcuni Servizi AWS e forniscono risorse aggiuntive per ulteriori informazioni.
Per utenti AWS esperti o alle prime armi con la AWS CLI, questi esempi guidati rappresentano una risorsa per semplificare le operazioni AWS.
Per un riferimento completo a tutti i comandi disponibili per ciascun Servizio AWS, consulta la [AWS CLI version 2 reference guide](https://docs.aws.amazon.com/cli/latest/reference/index.html). Inoltre, puoi utilizzare la [guida integrata nella riga di comando](cli-usage-help.md) per esplorare l’array di Servizi AWS, i comandi, le opzioni e le funzionalità della AWS CLI.
Per altri esempi di comandi non disponibili in questa sezione, consulta la sezione [AWS CLI esempi di comandi](cli_code_examples.md). Questi sono esempi di comandi open source disponibili anche nella [AWS CLI version 2 reference guide](https://docs.aws.amazon.com/cli/latest/reference/index.html). Gli esempi dei comandi sono ospitati nel repository della [AWS CLI](https://github.com/aws/aws-cli/tree/develop/awscli/examples) su *GitHub*.
Per gli esempi di script Bash open source, consulta [AWS CLI con esempi di codice di script Bash](bash_code_examples.md). Gli esempi di script Bash sono ospitati nel [repository degli esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples) su *GitHub*.
**Topics**
+ [DynamoDB](cli-services-dynamodb.md)
+ [Amazon EC2](cli-services-ec2.md)
+ [Amazon Glacier](cli-services-glacier.md)
+ [IAM](cli-services-iam.md)
+ [Amazon S3](cli-services-s3.md)
+ [Amazon SNS](cli-services-sns.md)
# Utilizzo di Amazon DynamoDB nella AWS CLI
AWS Command Line Interface (AWS CLI) fornisce supporto per tutti i servizi di database AWS, tra cui Amazon DynamoDB. Puoi utilizzare la AWS CLI per operazioni ad hoc, quali la creazione di tabelle. È possibile utilizzarla anche per incorporare operazioni DynamoDB all’interno di script di utilità.
Per ulteriori informazioni sull’utilizzo della AWS CLI con DynamoDB, consulta ```[dynamodb](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html)` in *AWS CLI Command Reference*.
Per elencare i comandi della AWS CLI per DynamoDB, utilizza il comando seguente.
```
$ aws dynamodb help
```
**Topics**
+ [Prerequisiti](#cli-services-dynamodb-prereqs)
+ [Creazione e utilizzo di tabelle DynamoDB](#cli-services-dynamodb-using)
+ [Utilizzo di DynamoDB locale](#cli-services-dynamodb-local)
+ [Risorse](#cli-services-dynamodb-resources)
## Prerequisiti
Per eseguire i comandi `dynamodb`, è necessario:
+ Istalla e configura la AWS CLI. Per ulteriori informazioni, consultare [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md) e [Credenziali di autenticazione e accesso per AWS CLI](cli-chap-authentication.md).
## Creazione e utilizzo di tabelle DynamoDB
Il formato a riga di comando consiste in un nome di comando DynamoDB seguito dai parametri per tale comando. L'AWS CLI supporta la [sintassi abbreviata](cli-usage-shorthand.md) della CLI per i valori dei parametri, oltre a JSON completo.
L'esempio seguente crea una tabella denominata `MusicCollection`.
```
$ aws dynamodb create-table \
--table-name MusicCollection \
--attribute-definitions AttributeName=Artist,AttributeType=S AttributeName=SongTitle,AttributeType=S \
--key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \
--provisioned-throughput ReadCapacityUnits=1,WriteCapacityUnits=1
```
Puoi aggiungere nuove righe alla tabella con comandi simili a quelli mostrati nell'esempio seguente. In questi esempi viene utilizzata una combinazione di sintassi abbreviata e JSON.
```
$ aws dynamodb put-item \
--table-name MusicCollection \
--item '{
"Artist": {"S": "No One You Know"},
"SongTitle": {"S": "Call Me Today"} ,
"AlbumTitle": {"S": "Somewhat Famous"}
}' \
--return-consumed-capacity TOTAL
{
"ConsumedCapacity": {
"CapacityUnits": 1.0,
"TableName": "MusicCollection"
}
}
```
```
$ aws dynamodb put-item \
--table-name MusicCollection \
--item '{
"Artist": {"S": "Acme Band"},
"SongTitle": {"S": "Happy Day"} ,
"AlbumTitle": {"S": "Songs About Life"}
}' \
--return-consumed-capacity TOTAL
{
"ConsumedCapacity": {
"CapacityUnits": 1.0,
"TableName": "MusicCollection"
}
}
```
Può essere difficile comporre un JSON valido in un comando su una sola riga. Per semplificare l'operazione, l'AWS CLI può leggere i file JSON. Considera ad esempio il seguente frammento JSON, che viene memorizzato in un file denominato `expression-attributes.json`.
```
{
":v1": {"S": "No One You Know"},
":v2": {"S": "Call Me Today"}
}
```
Puoi utilizzare questo file per inviare una richiesta `query` con l'AWS CLI. Nell'esempio seguente, il contenuto del file `expression-attributes.json` viene utilizzato come valore del parametro `--expression-attribute-values`.
```
$ aws dynamodb query --table-name MusicCollection \
--key-condition-expression "Artist = :v1 AND SongTitle = :v2" \
--expression-attribute-values file://expression-attributes.json
{
"Count": 1,
"Items": [
{
"AlbumTitle": {
"S": "Somewhat Famous"
},
"SongTitle": {
"S": "Call Me Today"
},
"Artist": {
"S": "No One You Know"
}
}
],
"ScannedCount": 1,
"ConsumedCapacity": null
}
```
## Utilizzo di DynamoDB locale
Oltre che con DynamoDB, puoi utilizzare la AWS CLI con DynamoDB locale. DynamoDB locale è un piccolo database e server lato client che imita il servizio DynamoDB. DynamoDB locale consente di scrivere applicazioni che utilizzano l’API DynamoDB senza effettivamente manipolare tabelle o dati nel servizio web DynamoDB. Tutte le operazioni API vengono invece reinstradate a un database locale. In questo modo è possibile salvare il throughput assegnato, lo storage dei dati e le tariffe per il trasferimento dei dati.
Per ulteriori informazioni su DynamoDB locale e su come utilizzarlo con la AWS CLI, consulta le seguenti sezioni della [Guida per sviluppatori di Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/):
+ [DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.DynamoDBLocal.html)
+ [Utilizzo della AWS CLI con DynamoDB locale](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.CLI.html#UsingWithDDBLocal)
## Risorse
**Riferimento alla AWS CLI:**
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/create-table.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/create-table.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/put-item.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/put-item.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/query.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/query.html)
**Riferimento al servizio**:
+ [DynamoDB locale](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.DynamoDBLocal.html) nella Guida per sviluppatori di Amazon DynamoDB
+ [Utilizzo della AWS CLI con DynamoDB locale](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tools.CLI.html#UsingWithDDBLocal) nella Guida per sviluppatori di Amazon DynamoDB
# Utilizzo di Amazon EC2 nella AWS CLI
| Un’introduzione ad Amazon Elastic Compute Cloud |
| --- |
| [](http://www.youtube.com/watch?v=https://www.youtube.com/embed/TsRBftzZsQo) |
Amazon Elastic Compute Cloud (Amazon EC2) fornisce ambienti di elaborazione virtuale altamente scalabili e flessibili. Amazon EC2 consente di effettuare il provisioning e di gestire server virtuali, noti come istanze Amazon EC2, per soddisfare un’ampia gamma di esigenze di elaborazione.
Le istanze di Amazon EC2 sono macchine virtuali che possono essere personalizzate con varie configurazioni di CPU, memoria, archiviazione e capacità di rete. Puoi scegliere tra una vasta gamma di tipi di istanze, che spaziano da opzioni leggere ed economiche a istanze potenti e ad alte prestazioni, a seconda dei requisiti dell’applicazione. Questa flessibilità consente di soddisfare le esigenze di elaborazione per ottimizzare le prestazioni e l’efficienza dei costi.
Inoltre, Amazon EC2 offre una suite di funzionalità che consente di gestire le risorse di elaborazione in modo efficace. Queste risorse includono la possibilità di avviare rapidamente nuove istanze, creare immagini di macchine (AMI) personalizzate per una rapida implementazione e aumentare o ridurre la capacità di calcolo in base alle esigenze.
Puoi accedere alle funzionalità di Amazon EC2 utilizzando AWS Command Line Interface (AWS CLI). Per elencare i comandi della AWS CLI per Amazon EC2, usa il comando seguente.
```
aws ec2 help
```
Prima di eseguire qualsiasi comando, imposta le tue credenziali di default. Per ulteriori informazioni, consulta [Configurazione delle impostazioni della AWS CLI.](cli-chap-configure.md).
Questo argomento mostra esempi di comandi della AWS CLI che eseguono operazioni comuni per Amazon EC2.
Per esempi di comandi della AWS CLI in formato lungo, consulta il [repository degli esempi di codice della AWS CLI](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli) su *GitHub*.
**Topics**
+ [Creazione, visualizzazione ed eliminazione di coppie di chiavi Amazon EC2 in AWS CLI](cli-services-ec2-keypairs.md)
+ [Creazione, configurazione ed eliminazione di gruppi di sicurezza Amazon EC2 nel AWS CLI](cli-services-ec2-sg.md)
+ [Avvio, elenco ed eliminazione di istanze Amazon EC2 nel AWS CLI](cli-services-ec2-instances.md)
+ [Modifica un tipo di istanza Amazon EC2 con uno script bash nel AWS CLI](cli-services-ec2-instance-type-script.md)
# Creazione, visualizzazione ed eliminazione di coppie di chiavi Amazon EC2 in AWS CLI
Puoi usare AWS Command Line Interface (AWS CLI) per creare, visualizzare ed eliminare le tue coppie di chiavi per Amazon Elastic Compute Cloud (Amazon EC2) Elastic Compute Cloud (Amazon EC2). Puoi utilizzare le coppie di chiavi per connetterti a un’istanza Amazon EC2. Puoi fornire la coppia di chiavi a EC2 quando crei l’istanza, quindi devi utilizzare questa coppia di chiavi per autenticarti quando ti connetti all’istanza.
**Nota**
Per ulteriori esempi di comandi, consulta la [riferimento.](https://docs.aws.amazon.com/cli/latest/reference/index.html)
**Topics**
+ [Prerequisiti](#cli-services-ec2-keypairs-prereqs)
+ [Creazione di una coppia di chiavi](#creating-a-key-pair)
+ [Visualizzazione della coppia di chiavi](#displaying-a-key-pair)
+ [Eliminazione della coppia di chiavi](#deleting-a-key-pair)
+ [Riferimenti](#cli-services-ec2-keypairs-references)
## Prerequisiti
Per eseguire i comandi `ec2`, è necessario:
+ Istalla e configura la AWS CLI. Per ulteriori informazioni, consultare [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md) e [Credenziali di autenticazione e accesso per AWS CLI](cli-chap-authentication.md).
+ Impostare le autorizzazioni IAM per consentire l’accesso ad Amazon EC2. Per ulteriori informazioni sulle autorizzazioni IAM per Amazon EC2, consulta [Policy IAM per Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) nella *Guida per l’utente di Amazon EC2*.
## Creazione di una coppia di chiavi
Per creare una coppia di chiavi, utilizza il comando `[aws ec2 create-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-key-pair.html)` con l’opzione `--query` e l’opzione `--output text` per indirizzare la chiave privata direttamente in un file.
```
$ aws ec2 create-key-pair --key-name MyKeyPair --query 'KeyMaterial' --output text > MyKeyPair.pem
```
Infatti PowerShell, il `> file` reindirizzamento è impostato per impostazione predefinita sulla codifica UTF-8, che non può essere utilizzata con alcuni client SSH. Pertanto, devi convertire l'output reindirizzandolo al comando `out-file` e impostando esplicitamente la codifica su `ascii`.
```
PS C:\>aws ec2 create-key-pair --key-name MyKeyPair --query 'KeyMaterial' --output text | out-file -encoding ascii -filepath MyKeyPair.pem
```
L'aspetto del file `MyKeyPair.pem` risultante è simile a quello riportato di seguito.
```
-----BEGIN RSA PRIVATE KEY-----
EXAMPLEKEYKCAQEAy7WZhaDsrA1W3mRlQtvhwyORRX8gnxgDAfRt/gx42kWXsT4rXE/b5CpSgie/
vBoU7jLxx92pNHoFnByP+Dc21eyyz6CvjTmWA0JwfWiW5/akH7iO5dSrvC7dQkW2duV5QuUdE0QW
Z/aNxMniGQE6XAgfwlnXVBwrerrQo+ZWQeqiUwwMkuEbLeJFLhMCvYURpUMSC1oehm449ilx9X1F
G50TCFeOzfl8dqqCP6GzbPaIjiU19xX/azOR9V+tpUOzEL+wmXnZt3/nHPQ5xvD2OJH67km6SuPW
oPzev/D8V+x4+bHthfSjR9Y7DvQFjfBVwHXigBdtZcU2/wei8D/HYwIDAQABAoIBAGZ1kaEvnrqu
/uler7vgIn5m7lN5LKw4hJLAIW6tUT/fzvtcHK0SkbQCQXuriHmQ2MQyJX/0kn2NfjLV/ufGxbL1
mb5qwMGUnEpJaZD6QSSs3kICLwWUYUiGfc0uiSbmJoap/GTLU0W5Mfcv36PaBUNy5p53V6G7hXb2
bahyWyJNfjLe4M86yd2YK3V2CmK+X/BOsShnJ36+hjrXPPWmV3N9zEmCdJjA+K15DYmhm/tJWSD9
81oGk9TopEp7CkIfatEATyyZiVqoRq6k64iuM9JkA3OzdXzMQexXVJ1TLZVEH0E7bhlY9d8O1ozR
oQs/FiZNAx2iijCWyv0lpjE73+kCgYEA9mZtyhkHkFDpwrSM1APaL8oNAbbjwEy7Z5Mqfql+lIp1
YkriL0DbLXlvRAH+yHPRit2hHOjtUNZh4Axv+cpg09qbUI3+43eEy24B7G/Uh+GTfbjsXsOxQx/x
p9otyVwc7hsQ5TA5PZb+mvkJ5OBEKzet9XcKwONBYELGhnEPe7cCgYEA06Vgov6YHleHui9kHuws
ayav0elc5zkxjF9nfHFJRry21R1trw2Vdpn+9g481URrpzWVOEihvm+xTtmaZlSp//lkq75XDwnU
WA8gkn6O3QE3fq2yN98BURsAKdJfJ5RL1HvGQvTe10HLYYXpJnEkHv+Unl2ajLivWUt5pbBrKbUC
gYBjbO+OZk0sCcpZ29sbzjYjpIddErySIyRX5gV2uNQwAjLdp9PfN295yQ+BxMBXiIycWVQiw0bH
oMo7yykABY7Ozd5wQewBQ4AdSlWSX4nGDtsiFxWiI5sKuAAeOCbTosy1s8w8fxoJ5Tz1sdoxNeGs
Arq6Wv/G16zQuAE9zK9vvwKBgF+09VI/1wJBirsDGz9whVWfFPrTkJNvJZzYt69qezxlsjgFKshy
WBhd4xHZtmCqpBPlAymEjr/TOlbxyARmXMnIOWIAnNXMGB4KGSyl1mzSVAoQ+fqR+cJ3d0dyPl1j
jjb0Ed/NY8frlNDxAVHE8BSkdsx2f6ELEyBKJSRr9snRAoGAMrTwYneXzvTskF/S5Fyu0iOegLDa
NWUH38v/nDCgEpIXD5Hn3qAEcju1IjmbwlvtW+nY2jVhv7UGd8MjwUTNGItdb6nsYqM2asrnF3qS
VRkAKKKYeGjkpUfVTrW0YFjXkfcrR/V+QFL5OndHAKJXjW7a4ejJLncTzmZSpYzwApc=
-----END RSA PRIVATE KEY-----
```
***La tua chiave privata non è archiviata AWS e può essere recuperata solo al momento della creazione.*** Non puoi recuperarla successivamente. Se perdi la chiave privata, invece, devi creare una nuova coppia di chiavi.
Se ti connetti all'istanza da un computer Linux, consigliamo di utilizzare il comando seguente per impostare le autorizzazioni del file della chiave privata in modo da essere l'unico a poterlo leggere.
```
$ chmod 400 MyKeyPair.pem
```
## Visualizzazione della coppia di chiavi
Dalla coppia di chiavi viene generata un’impronta che può essere utilizzata per verificare che la chiave privata che si trova sul tuo computer locale corrisponda alla chiave pubblica archiviata in AWS.
L'impronta digitale è un SHA1 hash ricavato da una copia codificata in DER della chiave privata. Questo valore viene acquisito al momento della creazione della coppia di chiavi e memorizzato AWS con la chiave pubblica. Puoi visualizzare l'impronta digitale nella console Amazon EC2 o AWS CLI eseguendo il comando. `[aws ec2 describe-key-pairs](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-key-pairs.html)`
L'esempio seguente mostra l'impronta per `MyKeyPair`.
```
$ aws ec2 describe-key-pairs --key-name MyKeyPair
{
"KeyPairs": [
{
"KeyName": "MyKeyPair",
"KeyFingerprint": "1f:51:ae:28:bf:89:e9:d8:1f:25:5d:37:2d:7d:b8:ca:9f:f5:f1:6f"
}
]
}
```
Per ulteriori informazioni sulle chiavi e sulle impronte, consulta [Coppie di chiavi Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) nella *Guida per l’utente di Amazon EC2*.
## Eliminazione della coppia di chiavi
Per eliminare una coppia di chiavi, esegui il comando `[aws ec2 delete-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-key-pair.html)`, sostituendo *`MyKeyPair`* con il nome della coppia da eliminare.
```
$ aws ec2 delete-key-pair --key-name MyKeyPair
```
## Riferimenti
**AWS CLI riferimento:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/index.html)`
+ `[aws ec2 create-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-key-pair.html)`
+ `[aws ec2 delete-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-key-pair.html)`
+ `[aws ec2 describe-key-pairs](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-key-pairs.html)`
**Altri riferimenti:**
+ [Amazon Elastic Compute Cloud Documentation](https://docs.aws.amazon.com/ec2/)
+ Per visualizzare e contribuire all' AWS SDK e agli esempi di AWS CLI codice, consulta il [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/) su. *GitHub*
# Creazione, configurazione ed eliminazione di gruppi di sicurezza Amazon EC2 nel AWS CLI
Puoi creare un gruppo di sicurezza per le istanze Amazon Elastic Compute Cloud (Amazon EC2) che essenzialmente funziona come un firewall, con regole che determinano il traffico di rete a cui è consentito l’ingresso e l’uscita.
Utilizzate il AWS Command Line Interface (AWS CLI) per creare un gruppo di sicurezza, aggiungere regole ai gruppi di sicurezza esistenti ed eliminare i gruppi di sicurezza.
**Nota**
Per ulteriori esempi di comandi, consultate la [di riferimento](https://docs.aws.amazon.com/cli/latest/reference/index.html).
**Topics**
+ [Prerequisiti](#cli-services-ec2-sg-prereqs)
+ [Creare un gruppo di sicurezza](#creating-a-security-group)
+ [Aggiunta di regole al gruppo di sicurezza](#configuring-a-security-group)
+ [Eliminazione del gruppo di sicurezza:](#deleting-a-security-group)
+ [Riferimenti](#cli-services-ec2-sg-references)
## Prerequisiti
Per eseguire i comandi `ec2`, è necessario:
+ Istalla e configura la AWS CLI. Per ulteriori informazioni, consultare [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md) e [Credenziali di autenticazione e accesso per AWS CLI](cli-chap-authentication.md).
+ Impostare le autorizzazioni IAM per consentire l’accesso ad Amazon EC2. Per ulteriori informazioni sulle autorizzazioni IAM per Amazon EC2, consulta [Policy IAM per Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) nella *Guida per l’utente di Amazon EC2*.
## Creare un gruppo di sicurezza
È possibile creare gruppi di sicurezza associati a cloud privati virtuali (VPCs).
Nell’esempio seguente `[aws ec2 create-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-security-group.html)` mostra come creare un gruppo di sicurezza per un VPC specificato.
```
$ aws ec2 create-security-group --group-name my-sg --description "My security group" --vpc-id vpc-1a2b3c4d
{
"GroupId": "sg-903004f8"
}
```
Per visualizzare le informazioni iniziali per un gruppo di sicurezza, esegui il comando `[aws ec2 describe-security-groups](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-security-groups.html)`. Puoi fare riferimento a un gruppo di sicurezza EC2-VPC solo utilizzando il relativo `vpc-id`, non il nome.
```
$ aws ec2 describe-security-groups --group-ids sg-903004f8
{
"SecurityGroups": [
{
"IpPermissionsEgress": [
{
"IpProtocol": "-1",
"IpRanges": [
{
"CidrIp": "0.0.0.0/0"
}
],
"UserIdGroupPairs": []
}
],
"Description": "My security group"
"IpPermissions": [],
"GroupName": "my-sg",
"VpcId": "vpc-1a2b3c4d",
"OwnerId": "123456789012",
"GroupId": "sg-903004f8"
}
]
}
```
## Aggiunta di regole al gruppo di sicurezza
Quando esegui un’istanza Amazon EC2, devi abilitare le regole nel gruppo di sicurezza per consentire il traffico di rete in entrata per il tuo strumento di connessione all’immagine.
Ad esempio, se avvii un'istanza di Windows, in genere devi aggiungere una regola per consentire il traffico in entrata sulla porta TCP 3389 per supportare Remote Desktop Protocol (RDP). Se avvii un'istanza di Linux, in genere devi aggiungere una regola per consentire il traffico in entrata sulla porta TCP 22 per supportare le connessioni SSH.
Utilizza il comando `[aws ec2 authorize-security-group-ingress](https://docs.aws.amazon.com/cli/latest/reference/ec2/authorize-security-group-ingress.html)` per aggiungere una regola al gruppo di sicurezza. Un parametro obbligatorio di questo comando è l'indirizzo IP pubblico del computer o la rete (sotto forma di intervallo di indirizzi) a cui è collegato il computer, in notazione [CIDR](https://wikipedia.org/wiki/Classless_Inter-Domain_Routing).
**Nota**
Forniamo il servizio seguente, [https://checkip.global.api.aws/](https://checkip.global.api.aws/), per consentire di determinare l’indirizzo IP pubblico. Per trovare altri servizi che possono aiutarti a identificare il tuo indirizzo IP, utilizza il browser per cercare "*qual è il indirizzo IP*". Se ti connetti tramite un ISP o da dietro un firewall utilizzando un indirizzo IP dinamico (tramite un gateway NAT da una rete privata), l'indirizzo può cambiare periodicamente. In questo caso, devi scoprire l'intervallo di indirizzi IP utilizzato dai computer client.
L’esempio seguente mostra come aggiungere una regola per il protocollo RDP (porta TCP 3389) a un gruppo di sicurezza EC2-VPC con ID `sg-903004f8` utilizzando il tuo indirizzo IP.
Per iniziare, trova il tuo indirizzo IP.
```
$ curl https://checkip.amazonaws.com
x.x.x.x
```
Puoi quindi aggiungere l’indirizzo IP al tuo gruppo di sicurezza eseguendo il comando `[aws ec2 authorize-security-group-ingress](https://docs.aws.amazon.com/cli/latest/reference/ec2/authorize-security-group-ingress.html)`.
```
$ aws ec2 authorize-security-group-ingress --group-id sg-903004f8 --protocol tcp --port 3389 --cidr x.x.x.x/x
```
Il comando seguente aggiunge un'altra regola per abilitare l'autenticazione SSH nelle istanze dello stesso gruppo di sicurezza.
```
$ aws ec2 authorize-security-group-ingress --group-id sg-903004f8 --protocol tcp --port 22 --cidr x.x.x.x/x
```
Per visualizzare le modifiche al gruppo di sicurezza, esegui il comando `[aws ec2 describe-security-groups](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-security-groups.html)`.
```
$ aws ec2 describe-security-groups --group-ids sg-903004f8
{
"SecurityGroups": [
{
"IpPermissionsEgress": [
{
"IpProtocol": "-1",
"IpRanges": [
{
"CidrIp": "0.0.0.0/0"
}
],
"UserIdGroupPairs": []
}
],
"Description": "My security group"
"IpPermissions": [
{
"ToPort": 22,
"IpProtocol": "tcp",
"IpRanges": [
{
"CidrIp": "x.x.x.x/x"
}
]
"UserIdGroupPairs": [],
"FromPort": 22
}
],
"GroupName": "my-sg",
"OwnerId": "123456789012",
"GroupId": "sg-903004f8"
}
]
}
```
## Eliminazione del gruppo di sicurezza:
Per eliminare un gruppo di sicurezza, utilizza il comando `[aws ec2 delete-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-security-group.html)`.
**Nota**
Non puoi eliminare un gruppo di sicurezza se è attualmente collegato a un ambiente.
Il comando di esempio seguente elimina un gruppo di sicurezza EC2-VPC.
```
$ aws ec2 delete-security-group --group-id sg-903004f8
```
## Riferimenti
**AWS CLI riferimento:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/index.html)`
+ `[aws ec2 authorize-security-group-ingress](https://docs.aws.amazon.com/cli/latest/reference/ec2/authorize-security-group-ingress.html)`
+ `[aws ec2 create-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-security-group.html)`
+ `[aws ec2 delete-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-security-group.html)`
+ `[aws ec2 describe-security-groups](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-security-groups.html)`
**Altri riferimenti:**
+ [Amazon Elastic Compute Cloud Documentation](https://docs.aws.amazon.com/ec2/)
+ Per visualizzare e contribuire all' AWS SDK e agli esempi di AWS CLI codice, consulta il [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/) su. *GitHub*
# Avvio, elenco ed eliminazione di istanze Amazon EC2 nel AWS CLI
Puoi utilizzare AWS Command Line Interface (AWS CLI) per avviare, elencare ed eliminare le istanze di Amazon Elastic Compute Cloud (Amazon EC2). Se avvii un'istanza che non rientra nel piano AWS gratuito, ti verrà fatturata una volta avviata l'istanza e ti verrà addebitato il tempo in cui l'istanza è in esecuzione, anche se rimane inattiva.
**Nota**
Per ulteriori esempi di comandi, consulta la [riferimento.](https://docs.aws.amazon.com/cli/latest/reference/index.html)
**Topics**
+ [Prerequisiti](#cli-services-ec2-instances-prereqs)
+ [Lancio dell'istanza](#launching-instances)
+ [Aggiunta di un dispositivo a blocchi all'istanza](#block-device-mapping)
+ [Aggiunta di un tag all'istanza](#tagging-instances)
+ [Connessione all’istanza](#connecting-to-instances)
+ [Elencazione delle istanze](#listing-instances)
+ [Eliminare l'istanza](#terminating-instances)
+ [Riferimenti](#cli-services-ec2-instances-references)
## Prerequisiti
Per eseguire i comandi della `ec2` descritti in questo argomento, è necessario:
+ Istalla e configura la AWS CLI. Per ulteriori informazioni, consultare [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md) e [Credenziali di autenticazione e accesso per AWS CLI](cli-chap-authentication.md).
+ Impostare le autorizzazioni IAM per consentire l’accesso ad Amazon EC2. Per ulteriori informazioni sulle autorizzazioni IAM per Amazon EC2, consulta [Policy IAM per Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-policies-for-amazon-ec2.html) nella *Guida per l’utente di Amazon EC2*.
+ Creare una [coppia di chiavi](cli-services-ec2-keypairs.md) e un [gruppo di sicurezza](cli-services-ec2-sg.md).
+ Seleziona un’Amazon Machine Image (AMI) e prendi nota dell’ID AMI. Per ulteriori informazioni, consulta [Come trovare un’AMI appropriata](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html) nella *Guida per l’utente di EC2*.
## Lancio dell'istanza
Per avviare un’istanza Amazon EC2 con l’AMI selezionata, utilizza il comando `[aws ec2 run-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html)`. Puoi avviare l’istanza in un cloud privato virtuale (VPC).
Inizialmente l'istanza viene visualizzata in stato `pending`, ma dopo pochi minuti passa allo stato `running`.
L'esempio seguente mostra come avviare un'istanza `t2.micro` nella sottorete specificata di un VPC. Sostituisci i valori del parametro *italicized* con i tuoi valori.
```
$ aws ec2 run-instances --image-id ami-xxxxxxxx --count 1 --instance-type t2.micro --key-name MyKeyPair --security-group-ids sg-903004f8 --subnet-id subnet-6e7f829e
{
"OwnerId": "123456789012",
"ReservationId": "r-5875ca20",
"Groups": [
{
"GroupName": "my-sg",
"GroupId": "sg-903004f8"
}
],
"Instances": [
{
"Monitoring": {
"State": "disabled"
},
"PublicDnsName": null,
"Platform": "windows",
"State": {
"Code": 0,
"Name": "pending"
},
"EbsOptimized": false,
"LaunchTime": "2013-07-19T02:42:39.000Z",
"PrivateIpAddress": "10.0.1.114",
"ProductCodes": [],
"VpcId": "vpc-1a2b3c4d",
"InstanceId": "i-5203422c",
"ImageId": "ami-173d747e",
"PrivateDnsName": "ip-10-0-1-114.ec2.internal",
"KeyName": "MyKeyPair",
"SecurityGroups": [
{
"GroupName": "my-sg",
"GroupId": "sg-903004f8"
}
],
"ClientToken": null,
"SubnetId": "subnet-6e7f829e",
"InstanceType": "t2.micro",
"NetworkInterfaces": [
{
"Status": "in-use",
"SourceDestCheck": true,
"VpcId": "vpc-1a2b3c4d",
"Description": "Primary network interface",
"NetworkInterfaceId": "eni-a7edb1c9",
"PrivateIpAddresses": [
{
"PrivateDnsName": "ip-10-0-1-114.ec2.internal",
"Primary": true,
"PrivateIpAddress": "10.0.1.114"
}
],
"PrivateDnsName": "ip-10-0-1-114.ec2.internal",
"Attachment": {
"Status": "attached",
"DeviceIndex": 0,
"DeleteOnTermination": true,
"AttachmentId": "eni-attach-52193138",
"AttachTime": "2013-07-19T02:42:39.000Z"
},
"Groups": [
{
"GroupName": "my-sg",
"GroupId": "sg-903004f8"
}
],
"SubnetId": "subnet-6e7f829e",
"OwnerId": "123456789012",
"PrivateIpAddress": "10.0.1.114"
}
],
"SourceDestCheck": true,
"Placement": {
"Tenancy": "default",
"GroupName": null,
"AvailabilityZone": "us-west-2b"
},
"Hypervisor": "xen",
"BlockDeviceMappings": [
{
"DeviceName": "/dev/sda1",
"Ebs": {
"Status": "attached",
"DeleteOnTermination": true,
"VolumeId": "vol-877166c8",
"AttachTime": "2013-07-19T02:42:39.000Z"
}
}
],
"Architecture": "x86_64",
"StateReason": {
"Message": "pending",
"Code": "pending"
},
"RootDeviceName": "/dev/sda1",
"VirtualizationType": "hvm",
"RootDeviceType": "ebs",
"Tags": [
{
"Value": "MyInstance",
"Key": "Name"
}
],
"AmiLaunchIndex": 0
}
]
}
```
## Aggiunta di un dispositivo a blocchi all'istanza
A ogni istanza avviata è associato un volume dispositivo root. Puoi utilizzare una mappatura dei dispositivi a blocchi per specificare volumi di Amazon Elastic Block Store (Amazon EBS) aggiuntivi o i volumi di archivio dell’istanza da collegare a un’istanza quando viene avviata.
Per aggiungere un dispositivo a blocchi all'istanza, specifica l'opzione `--block-device-mappings` quando utilizzi `run-instances`.
Il parametro di esempio seguente esegue il provisioning di un volume Amazon EBS standard di 20 GB e lo mappa all’istanza utilizzando l’identificatore `/dev/sdf`.
```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdf\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false}}]"
```
L’esempio seguente aggiunge un volume Amazon EBS, mappato a `/dev/sdf`, basato su uno snapshot esistente. Una snapshot rappresenta un'immagine caricata sul volume per te. Quando specifichi una snapshot, non devi specificare una dimensione del volume perché sarà sufficiente a contenere la tua immagine. Tuttavia, se specifichi la dimensione, questa deve essere maggiore o uguale a quella della snapshot.
```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdf\",\"Ebs\":{\"SnapshotId\":\"snap-a1b2c3d4\"}}]"
```
L'esempio seguente aggiunge due volumi all'istanza. Il numero di volumi disponibili per l'istanza dipende dal tipo di istanza.
```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdf\",\"VirtualName\":\"ephemeral0\"},{\"DeviceName\":\"/dev/sdg\",\"VirtualName\":\"ephemeral1\"}]"
```
L'esempio seguente crea la mappatura (`/dev/sdj`), ma non esegue il provisioning di un volume per l'istanza.
```
--block-device-mappings "[{\"DeviceName\":\"/dev/sdj\",\"NoDevice\":\"\"}]"
```
Per ulteriori informazioni, consulta [Mappatura dei dispositivi a blocchi](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html) nella *Guida per l’utente di EC2*.
## Aggiunta di un tag all'istanza
Un tag è un'etichetta che si assegna a una AWS risorsa. Questo consente di aggiungere metadati alle risorse, che possono essere utilizzati per vari scopi. Per ulteriori informazioni, consulta [Tagging delle risorse](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) nella *Guida per l’utente di EC2*.
L’esempio seguente mostra come aggiungere un tag con il nome della chiave “`Name`“ e il valore “`MyInstance`“ all’istanza specificata, utilizzando il comando `[aws ec2 create-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-tags.html)`.
```
$ aws ec2 create-tags --resources i-5203422c --tags Key=Name,Value=MyInstance
```
## Connessione all’istanza
Mentre l'istanza è in esecuzione, puoi connetterti e utilizzarla esattamente come se si trovasse nel tuo computer. Per ulteriori informazioni, consulta [Connessione all’istanza Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-to-linux-instance.html) nella *Guida per l’utente di Amazon EC2*.
## Elencazione delle istanze
Puoi utilizzarlo AWS CLI per elencare le tue istanze e visualizzare le informazioni su di esse. Puoi creare un elenco di tutte le istanze oppure filtrare i risultati in base alle istanze che ti interessano.
Negli esempi seguenti viene illustrato come utilizzare il comando `[aws ec2 describe-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html)`.
Il comando seguente elenca tutte le tue istanze.
```
$ aws ec2 describe-instances
```
Il comando seguente filtra l'elenco visualizzando solo le istanze `t2.micro` e restituisce solo i valori `InstanceId` per ogni corrispondenza.
```
$ aws ec2 describe-instances --filters "Name=instance-type,Values=t2.micro" --query "Reservations[].Instances[].InstanceId"
[
"i-05e998023d9c69f9a"
]
```
Il comando seguente elenca qualsiasi istanza con il tag `Name=MyInstance`.
```
$ aws ec2 describe-instances --filters "Name=tag:Name,Values=MyInstance"
```
Il comando seguente elenca le istanze che sono state avviate utilizzando uno dei seguenti comandi AMIs:`ami-x0123456`,`ami-y0123456`, e. `ami-z0123456`
```
$ aws ec2 describe-instances --filters "Name=image-id,Values=ami-x0123456,ami-y0123456,ami-z0123456"
```
## Eliminare l'istanza
Puoi utilizzarlo AWS CLI per terminare (eliminare) un'istanza Amazon EC2 quando non è più necessaria.
**Importante**
**La terminazione di un’istanza è permanente e irreversibile.**
Dopo aver terminato un’istanza, non puoi più connetterti a essa e non puoi ripristinarla. Inoltre, tutti i volumi Amazon EBS collegati e configurati per essere eliminati in caso di terminazione vengono eliminati in modo definitivo e non possono essere recuperati. Tutti i dati archiviati nei volumi di archivio dell’istanza vengono persi in modo definitivo. Per ulteriori informazioni, consulta [Come funziona la chiusura dell'istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/how-ec2-instance-termination-works.html).
Prima di terminare un’istanza, assicurati di aver eseguito il backup di tutti i dati che devi mantenere dopo la terminazione sull’archivio persistente.
Appena lo stato dell'istanza cambia in `shutting-down` o `terminated`, vengono bloccati i rispettivi addebiti. Per riconnetterti a un'istanza in un secondo momento, utilizza [stop-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/stop-instances.html) invece di `terminate-instances`. Per ulteriori informazioni, consulta [Terminazione dell'istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html) nella *Guida per l'utente di Amazon EC2*.
L'esempio seguente mostra come eliminare un'istanza utilizzando il `[aws ec2 terminate-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/terminate-instances.html)` comando.
```
$ aws ec2 terminate-instances --instance-ids i-5203422c
{
"TerminatingInstances": [
{
"InstanceId": "i-5203422c",
"CurrentState": {
"Code": 32,
"Name": "shutting-down"
},
"PreviousState": {
"Code": 16,
"Name": "running"
}
}
]
}
```
## Riferimenti
**AWS CLI riferimento:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/index.html)`
+ `[aws ec2 create-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-tags.html)`
+ `[aws ec2 describe-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html)`
+ `[aws ec2 run-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html)`
+ `[aws ec2 terminate-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/terminate-instances.html)`
**Altri riferimenti:**
+ [Amazon Elastic Compute Cloud Documentation](https://docs.aws.amazon.com/ec2/)
+ Per visualizzare e contribuire all' AWS SDK e agli esempi di AWS CLI codice, consulta il [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/) su. *GitHub*
# Modifica un tipo di istanza Amazon EC2 con uno script bash nel AWS CLI
Questo esempio di script bash per Amazon EC2 modifica il tipo di istanza per un'istanza Amazon EC2 utilizzando (). AWS Command Line Interface AWS CLI Arresta l’istanza se è in esecuzione, cambia il tipo di istanza e quindi, se richiesto, riavvia l’istanza. Gli script di shell sono programmi progettati per l’esecuzione in un’interfaccia a riga di comando.
**Nota**
[Per ulteriori esempi di comandi, consulta la guida di AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/index.html)
**Topics**
+ [Prima di iniziare](#cli-services-ec2-instance-type-script-prereqs)
+ [Informazioni sull’esempio](#cli-services-ec2-instance-type-script-about)
+ [Parameters](#cli-services-ec2-instance-type-script-params)
+ [File](#cli-services-ec2-instance-type-script-files.title)
+ [Riferimenti](#cli-services-ec2-instance-type-script-references)
## Prima di iniziare
Prima di poter eseguire uno qualsiasi degli esempi seguenti, è necessario completare le seguenti operazioni.
+ Istalla e configura la AWS CLI. Per ulteriori informazioni, consultare [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md) e [Credenziali di autenticazione e accesso per AWS CLI](cli-chap-authentication.md).
+ Il profilo utilizzato deve disporre di autorizzazioni che consentano le AWS operazioni eseguite dagli esempi.
+ Un’istanza Amazon EC2 in esecuzione nell’account per il quale l’utente è autorizzato a interrompere e modificare. Se esegui lo script di test, avvia automaticamente un’istanza, verifica la modifica del tipo e quindi termina l’istanza.
+ Come procedura AWS consigliata, concedi a questo codice il privilegio minimo o solo le autorizzazioni necessarie per eseguire un'operazione. Per ulteriori informazioni sui ruoli IAM, consulta [Assegnare il privilegio minimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) nella *Guida per l’utente di AWS Identity and Access Management*.
+ Questo codice non è stato testato in tutte le AWS regioni. Alcuni AWS servizi sono disponibili solo in regioni specifiche. Per ulteriori informazioni, consulta [ Service Endpoints and Quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) nella *AWS General Reference Guide*.
+ L'esecuzione di questo codice può comportare addebiti sul tuo AWS account. È tua responsabilità assicurarti che tutte le risorse create da questo script vengano rimosse quando hai finito di utilizzarle.
## Informazioni sull’esempio
Questo esempio è scritto come una funzione nel file di script della shell `change_ec2_instance_type.sh` che è possibile `source` da un altro script o dalla riga di comando. Ogni file di script contiene commenti che descrivono ciascuna delle funzioni. Una volta che la funzione è in memoria, è possibile invocarla dalla riga di comando. Ad esempio, i seguenti comandi modificano il tipo dell’istanza specificata in `t2.nano`:
```
$ source ./change_ec2_instance_type.sh
$ ./change_ec2_instance_type -i *instance-id* -t new-type
```
Per gli esempi completi e i file di script scaricabili, consulta [Change Amazon EC2 Instance](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/ec2/change-ec2-instance-type) Type nel *Code Examples AWS Repository* su. *GitHub*
## Parameters
**-i** - *(stringa)* Specifica l’ID dell’istanza da modificare.
**-t** - *(stringa)* Specifica il tipo di istanza Amazon EC2 a cui passare.
**-r** - *(switch)* Per impostazione predefinita, non è impostato. Se `-r` è impostato, riavvia l’istanza dopo il cambio di tipo.
**-f** - *(switch)* Per impostazione predefinita, lo script richiede all’utente di confermare la chiusura dell’istanza prima di effettuare il passaggio. Se `-f` è impostata, la funzione non richiede all’utente di cambiare tipo prima di chiudere l’istanza
**-v** - *(switch)* Per impostazione predefinita, lo script funziona silenziosamente e visualizza l’output solo in caso di errore. Se `-v` è impostata, la funzione visualizza lo stato durante tutto il suo funzionamento.
## File
**`change_ec2_instance_type.sh`**
Il file di script principale contiene la funzione `change_ec2_instance_type()` che effettua le attività seguenti:
+ Verifica l’esistenza dell’istanza Amazon EC2 specificata.
+ A meno che `-f` non sia selezionata, avvisa l’utente prima di interrompere l’istanza.
+ Modifica il tipo di istanza
+ Se `-r` è impostata, riavvia l’istanza e conferma che l’istanza è in esecuzione
Visualizza il codice per on. `[change\$1ec2\$1instance\$1type.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/ec2/change-ec2-instance-type/change_ec2_instance_type.sh)` *GitHub*
**`test_change_ec2_instance_type.sh`**
Lo script del file `test_change_ec2_instance_type.sh` verifica i vari percorsi di codice per la funzione `change_ec2_instance_type`. Se tutte le fasi dello script di test sono state eseguite correttamente, lo script di test rimuove tutte le risorse che ha creato.
Puoi eseguire lo script di test con i parametri seguenti:
+ **-v** - *(switch)* Ogni test mostra uno pass/failure stato durante l'esecuzione. Per impostazione predefinita, i test vengono eseguiti silenziosamente e l'output include solo lo stato generale pass/failure finale.
+ **-i** - *(switch)* Lo script viene messo in pausa dopo ogni test per consentire all’utente di sfogliare i risultati intermedi di ogni fase. Consente di esaminare lo stato corrente dell’istanza tramite la console Amazon EC2. Lo script procede alla fase successiva dopo aver premuto *INVIO* al prompt.
Visualizza il codice per `[test\$1change\$1ec2\$1instance\$1type.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/ec2/change-ec2-instance-type/test_change_ec2_instance_type.sh)` on. *GitHub*
**`awsdocs_general.sh`**
Il file di script `awsdocs_general.sh` contiene funzioni generiche utilizzate negli esempi avanzati per la AWS CLI.
Visualizza il codice per `[awsdocs\$1general.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/ec2/change-ec2-instance-type/awsdocs_general.sh)` on *GitHub*.
## Riferimenti
**AWS CLI riferimento:**
+ `[aws ec2](https://docs.aws.amazon.com/cli/v1/reference/ec2/index.html)`
+ `[aws ec2 describe-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/describe-instances.html)`
+ `[aws ec2 modify-instance-attribute](https://docs.aws.amazon.com/cli/v1/reference/ec2/modify-instance-attribute.html)`
+ `[aws ec2 start-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/start-instances.html)`
+ `[aws ec2 stop-instances](https://docs.aws.amazon.com/cli/v1/reference/ec2/stop-instances.html)`
+ `[aws ec2 wait instance-running](https://docs.aws.amazon.com/cli/v1/reference/ec2/wait/instance-running.html)`
+ `[aws ec2 wait instance-stopped](https://docs.aws.amazon.com/cli/v1/reference/ec2/wait/instance-stopped.html)`
**Altri riferimenti:**
+ [Amazon Elastic Compute Cloud Documentation](https://docs.aws.amazon.com/ec2/)
+ Per visualizzare e contribuire all' AWS SDK e agli esempi di AWS CLI codice, consulta il [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/) su. *GitHub*
# Utilizzo di Amazon Glacier in AWS CLI
| Un'introduzione ad Amazon Glacier |
| --- |
| |
Questo argomento mostra esempi di AWS CLI comandi che eseguono attività comuni per Amazon Glacier. Gli esempi mostrano come utilizzare AWS CLI per caricare un file di grandi dimensioni su Amazon Glacier suddividendolo in parti più piccole e caricandole dalla riga di comando.
Puoi accedere alle funzionalità di Amazon Glacier utilizzando AWS Command Line Interface ().AWS CLI Per elencare i AWS CLI comandi per Amazon Glacier, usa il seguente comando.
```
aws glacier help
```
**Nota**
Per i riferimenti e ulteriori esempi sui comandi, consulta `[aws glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html)` in *AWS CLI Command Reference*.
**Topics**
+ [Prerequisiti](#cli-services-glacier-prereqs)
+ [Crea un vault Amazon Glacier](#cli-services-glacier-vault)
+ [Preparazione di un file per il caricamento](#cli-services-glacier-prep)
+ [Avvio di un caricamento in più parti e caricamento dei file](#cli-services-glacier-initiate)
+ [Completamento del caricamento](#cli-services-glacier-complete)
+ [Resources](#cli-services-glacier-resources)
## Prerequisiti
Per eseguire i comandi `glacier`, è necessario:
+ Istalla e configura la AWS CLI. Per ulteriori informazioni, consultare [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md) e [Credenziali di autenticazione e accesso per AWS CLI](cli-chap-authentication.md).
+ Questo tutorial utilizza diversi strumenti a riga di comando che in genere vengono preinstallati su sistemi operativi di tipo Unix, tra cui Linux e macOS. Gli utenti Windows possono utilizzare gli stessi strumenti installando [Cygwin](https://www.cygwin.com/) ed eseguendo i comandi dal terminale Cygwin. Le utilità e i comandi nativi di Windows che eseguono le stesse funzioni sono indicati, laddove disponibili.
## Crea un vault Amazon Glacier
Creazione di un insieme di credenziali con il comando `[create-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/create-vault.html)`.
```
$ aws glacier create-vault --account-id - --vault-name myvault
{
"location": "/123456789012/vaults/myvault"
}
```
**Nota**
Tutti i comandi Amazon Glacier richiedono un parametro ID account. Utilizza il trattino (`--account-id -`) per utilizzare l'account corrente.
## Preparazione di un file per il caricamento
Creazione di un file per il caricamento di prova. I seguenti comandi creano un file denominato *largefile* che contiene esattamente 3 MiB di dati casuali.
**Linux o macOS**
```
$ dd if=/dev/urandom of=largefile bs=3145728 count=1
1+0 records in
1+0 records out
3145728 bytes (3.1 MB) copied, 0.205813 s, 15.3 MB/s
```
`dd` è un'utilità che consente di copiare una serie di byte da un file di input a un file di output. L'esempio precedente usa il file del dispositivo di sistema `/dev/urandom` come origine dei dati casuali. `fsutil` esegue una funzione simile in Windows.
**Windows**
```
C:\> fsutil file createnew largefile 3145728
File C:\temp\largefile is created
```
Quindi, suddividi il file in blocchi da 1 MiB (1048576 byte) con un file splitter.
```
$ split -b 1048576 --verbose largefile chunk
creating file `chunkaa'
creating file `chunkab'
creating file `chunkac'
```
## Avvio di un caricamento in più parti e caricamento dei file
Crea un caricamento multiparte in Amazon Glacier utilizzando il comando. `[initiate-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html)`
```
$ aws glacier initiate-multipart-upload --account-id - --archive-description "multipart upload test" --part-size 1048576 --vault-name myvault
{
"uploadId": "19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ",
"location": "/123456789012/vaults/myvault/multipart-uploads/19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ"
}
```
Amazon Glacier richiede la dimensione di ogni parte in byte (1 MiB in questo esempio), il nome del vault e un ID account per configurare il caricamento multiparte. Al termine dell' AWS CLI operazione, emette un ID di caricamento. Salva l'ID in una variabile shell da utilizzare in futuro.
**Linux o macOS**
```
$ UPLOADID="19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ"
```
**Windows**
```
C:\> set UPLOADID="19gaRezEXAMPLES6Ry5YYdqthHOC_kGRCT03L9yetr220UmPtBYKk-OssZtLqyFu7sY1_lR7vgFuJV6NtcV5zpsJ"
```
Quindi, utilizza il comando `[upload-multipart-part](https://docs.aws.amazon.com/cli/latest/reference/glacier/upload-multipart-part.html)` per caricare singolarmente le tre parti.
```
$ aws glacier upload-multipart-part --upload-id $UPLOADID --body chunkaa --range 'bytes 0-1048575/*' --account-id - --vault-name myvault
{
"checksum": "e1f2a7cd6e047fa606fe2f0280350f69b9f8cfa602097a9a026360a7edc1f553"
}
$ aws glacier upload-multipart-part --upload-id $UPLOADID --body chunkab --range 'bytes 1048576-2097151/*' --account-id - --vault-name myvault
{
"checksum": "e1f2a7cd6e047fa606fe2f0280350f69b9f8cfa602097a9a026360a7edc1f553"
}
$ aws glacier upload-multipart-part --upload-id $UPLOADID --body chunkac --range 'bytes 2097152-3145727/*' --account-id - --vault-name myvault
{
"checksum": "e1f2a7cd6e047fa606fe2f0280350f69b9f8cfa602097a9a026360a7edc1f553"
}
```
**Nota**
L'esempio precedente utilizza il simbolo del dollaro (`$`) per fare riferimento ai contenuti della variabile della shell `UPLOADID` in Linux. Nella riga di comando di Windows, utilizza un segno di percentuale (%) su entrambe le estremità del nome di variabile (ad esempio, `%UPLOADID%`).
È necessario specificare l'intervallo di byte di ogni parte al momento del caricamento in modo che Amazon Glacier possa riassemblarla nell'ordine corretto. Ogni parte è 1048576 byte, pertanto la prima parte occupa i byte 0-1048575, la seconda i byte 1048576-2097151 e la terza i byte 2097152-3145727.
## Completamento del caricamento
Amazon Glacier richiede un tree hash del file originale per confermare che tutti i pezzi caricati siano rimasti intatti. AWS
Per calcolare una struttura hash, devi suddividere il file in parti da 1 MiB e calcolare un hash SHA-256 binario di ogni parte. Quindi si suddivide l'elenco di hash in coppie, si combinano i due hash binari in ciascuna coppia e si utilizzano gli hash risultanti. Ripeti il processo fino a esaurire tutti gli hash. Se il numero di hash è dispari a qualsiasi livello, promuovilo al livello successivo senza modificarlo.
La chiave per calcolare correttamente una struttura hash quando si usano le utility a riga di comando consiste nel memorizzare ogni hash in formato binario ed effettuare la conversione in esadecimale solo nell'ultima fase. Combinando ed eseguendo l'hashing della versione esadecimale di qualsiasi hash nella struttura si otterrà un risultato non corretto.
**Nota**
Gli utenti Windows possono utilizzare il comando `type` anziché `cat`. OpenSSL è disponibile per Windows all'indirizzo [OpenSSL.org](https://www.openssl.org/source/).
**Per calcolare una struttura hash**
1. Se non lo hai già fatto, suddividi il file originale in parti da 1 MiB.
```
$ split --bytes=1048576 --verbose largefile chunk
creating file `chunkaa'
creating file `chunkab'
creating file `chunkac'
```
1. Calcola e memorizza l'hash binario SHA-256 di ogni blocco.
```
$ openssl dgst -sha256 -binary chunkaa > hash1
$ openssl dgst -sha256 -binary chunkab > hash2
$ openssl dgst -sha256 -binary chunkac > hash3
```
1. Combina i primi due hash e utilizza l'hash binario del risultato.
```
$ cat hash1 hash2 > hash12
$ openssl dgst -sha256 -binary hash12 > hash12hash
```
1. Combina l'hash padre dei blocchi `aa` e `ab` con l'hash del blocco `ac` ed esegui l'hashing del risultato, questa volta con un output esadecimale. Memorizza il risultato in una variabile della shell.
```
$ cat hash12hash hash3 > hash123
$ openssl dgst -sha256 hash123
SHA256(hash123)= 9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67
$ TREEHASH=9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67
```
Infine, completa il caricamento con il comando `[complete-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html)`. Questo comando utilizza le dimensioni del file originale in byte, il valore hash nella struttura finale esadecimale, il tuo ID account e il nome dell'insieme di credenziali.
```
$ aws glacier complete-multipart-upload --checksum $TREEHASH --archive-size 3145728 --upload-id $UPLOADID --account-id - --vault-name myvault
{
"archiveId": "d3AbWhE0YE1m6f_fI1jPG82F8xzbMEEZmrAlLGAAONJAzo5QdP-N83MKqd96Unspoa5H5lItWX-sK8-QS0ZhwsyGiu9-R-kwWUyS1dSBlmgPPWkEbeFfqDSav053rU7FvVLHfRc6hg",
"checksum": "9628195fcdbcbbe76cdde932d4646fa7de5f219fb39823836d81f0cc0e18aa67",
"location": "/123456789012/vaults/myvault/archives/d3AbWhE0YE1m6f_fI1jPG82F8xzbMEEZmrAlLGAAONJAzo5QdP-N83MKqd96Unspoa5H5lItWX-sK8-QS0ZhwsyGiu9-R-kwWUyS1dSBlmgPPWkEbeFfqDSav053rU7FvVLHfRc6hg"
}
```
Puoi anche controllare lo stato del vault utilizzando il comando `[describe-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-vault.html)`.
```
$ aws glacier describe-vault --account-id - --vault-name myvault
{
"SizeInBytes": 3178496,
"VaultARN": "arn:aws:glacier:us-west-2:123456789012:vaults/myvault",
"LastInventoryDate": "2018-12-07T00:26:19.028Z",
"NumberOfArchives": 1,
"CreationDate": "2018-12-06T21:23:45.708Z",
"VaultName": "myvault"
}
```
**Nota**
Lo stato dell'insieme di credenziali viene aggiornato circa una volta al giorno. Per ulteriori informazioni, consulta l'argomento relativo all'[utilizzo di vault](https://docs.aws.amazon.com/amazonglacier/latest/dev/working-with-vaults.html).
Ora puoi rimuovere i file di blocco e hash creati in modo sicuro.
```
$ rm chunk* hash*
```
*Per ulteriori informazioni sui caricamenti in più parti, consulta [Uploading Large Archives in Parts and Computing Checksums nella](https://docs.aws.amazon.com/amazonglacier/latest/dev/uploading-archive-mpu.html) [Amazon Glacier Developer](https://docs.aws.amazon.com/amazonglacier/latest/dev/checksum-calculations.html) Guide.*
## Resources
**AWS CLI riferimento:**
+ `[aws glacier](https://docs.aws.amazon.com/cli/latest/reference/glacier/index.html)`
+ `[aws glacier complete-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/complete-multipart-upload.html)`
+ `[aws glacier create-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/create-vault.html)`
+ `[aws glacier describe-vault](https://docs.aws.amazon.com/cli/latest/reference/glacier/describe-vault.html)`
+ `[aws glacier initiate-multipart-upload](https://docs.aws.amazon.com/cli/latest/reference/glacier/initiate-multipart-upload.html)`
**Riferimento al servizio**:
+ [Guida per sviluppatori Amazon Glacier](https://docs.aws.amazon.com/amazonglacier/latest/dev/)
+ [Caricamento di archivi di grandi dimensioni in parti](https://docs.aws.amazon.com/amazonglacier/latest/dev/uploading-archive-mpu.html) nella *Amazon Glacier Developer Guide*
+ [Elaborazione dei checksum nella Guida per gli](https://docs.aws.amazon.com/amazonglacier/latest/dev/checksum-calculations.html) sviluppatori di Amazon *Glacier*
+ [Utilizzo di Vaults](https://docs.aws.amazon.com/amazonglacier/latest/dev/working-with-vaults.html) nella *Amazon Glacier Developer Guide*
# Utilizzo di IAM nella AWS CLI
| Introduzione ad AWS Identity and Access Management. |
| --- |
| |
Puoi accedere alle funzionalità di AWS Identity and Access Management (AWS Command Line Interface) utilizzando (AWS CLI). Per elencare i comandi della AWS CLI per IAM, utilizza il comando seguente.
```
aws iam help
```
Questo argomento mostra esempi di comandi della AWS CLI che eseguono operazioni comuni per IAM.
Prima di eseguire qualsiasi comando, imposta le tue credenziali di default. Per ulteriori informazioni, consulta [Configurazione delle impostazioni della AWS CLI.](cli-chap-configure.md).
Per ulteriori informazioni sul servizio IAM, consulta la [Guida per l'utente AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html).
**Topics**
+ [Creazione di gruppi e utenti IAM](#cli-services-iam-new-user-group)
+ [Collegamento di una policy IAM gestita a un utente](#cli-services-iam-policy)
+ [Impostazione di una password iniziale per un utente IAM](#cli-services-iam-set-pw)
+ [Creare una chiave di accesso per un utente IAM](#cli-services-iam-create-creds)
## Creazione di gruppi e utenti IAM
**Per creare un gruppo e aggiungervi un nuovo utente**
1. Utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/iam/create-group.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-group.html) per creare il gruppo.
```
$ aws iam create-group --group-name MyIamGroup
{
"Group": {
"GroupName": "MyIamGroup",
"CreateDate": "2018-12-14T03:03:52.834Z",
"GroupId": "AGPAJNUJ2W4IJVEXAMPLE",
"Arn": "arn:aws:iam::123456789012:group/MyIamGroup",
"Path": "/"
}
}
```
1. Utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/iam/create-user.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-user.html) per creare l'utente.
```
$ aws iam create-user --user-name MyUser
{
"User": {
"UserName": "MyUser",
"Path": "/",
"CreateDate": "2018-12-14T03:13:02.581Z",
"UserId": "AIDAJY2PE5XUZ4EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/MyUser"
}
}
```
1. Utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/iam/add-user-to-group.html](https://docs.aws.amazon.com/cli/latest/reference/iam/add-user-to-group.html) per aggiungere l'utente al gruppo.
```
$ aws iam add-user-to-group --user-name MyUser --group-name MyIamGroup
```
1. Per verificare che il gruppo `MyIamGroup` contenga `MyUser`, utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/iam/get-group.html](https://docs.aws.amazon.com/cli/latest/reference/iam/get-group.html).
```
$ aws iam get-group --group-name MyIamGroup
{
"Group": {
"GroupName": "MyIamGroup",
"CreateDate": "2018-12-14T03:03:52Z",
"GroupId": "AGPAJNUJ2W4IJVEXAMPLE",
"Arn": "arn:aws:iam::123456789012:group/MyIamGroup",
"Path": "/"
},
"Users": [
{
"UserName": "MyUser",
"Path": "/",
"CreateDate": "2018-12-14T03:13:02Z",
"UserId": "AIDAJY2PE5XUZ4EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/MyUser"
}
],
"IsTruncated": "false"
}
```
## Collegamento di una policy IAM gestita a un utente
La policy nell'esempio fornisce all'utente "Power User Access" (Accesso utenti avanzati).
**Per collegare una policy gestita IAM a un utente**
1. Determina l'Amazon Resource Name (ARN) della policy da allegare. Il comando seguente utilizza `list-policies` per trovare l'ARN del criterio con il nome `PowerUserAccess`. Quindi, archivia l'ARN in una variabile di ambiente.
```
$ export POLICYARN=$(aws iam list-policies --query 'Policies[?PolicyName==`PowerUserAccess`].{ARN:Arn}' --output text) ~
$ echo $POLICYARN
arn:aws:iam::aws:policy/PowerUserAccess
```
1. Per collegare la policy, utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html](https://docs.aws.amazon.com/cli/latest/reference/iam/attach-user-policy.html) e fai riferimento alla variabile di ambiente che contiene l'ARN della policy.
```
$ aws iam attach-user-policy --user-name MyUser --policy-arn $POLICYARN
```
1. Verifica che la policy sia collegata all'utente eseguendo il comando [https://docs.aws.amazon.com/cli/latest/reference/iam/list-attached-user-policies.html](https://docs.aws.amazon.com/cli/latest/reference/iam/list-attached-user-policies.html).
```
$ aws iam list-attached-user-policies --user-name MyUser
{
"AttachedPolicies": [
{
"PolicyName": "PowerUserAccess",
"PolicyArn": "arn:aws:iam::aws:policy/PowerUserAccess"
}
]
}
```
Per ulteriori informazioni, consulta la sezione relativa all'[accesso alle risorse di gestione](https://docs.aws.amazon.com/IAM/latest/UserGuide/policies-additional-resources.html). In questo argomento sono disponibili link a una panoramica di autorizzazioni e policy e a esempi di policy per l’accesso ad Amazon S3, Amazon EC2 e ad altri servizi.
## Impostazione di una password iniziale per un utente IAM
Il comando seguente utilizza `[create-login-profile](https://docs.aws.amazon.com/cli/latest/reference/iam/create-login-profile.html)` per impostare una password iniziale per l’utente specificato. Quando l'utente accede per la prima volta, deve modificare la password in qualcosa che solo l'utente conosce.
```
$ aws iam create-login-profile --user-name MyUser --password My!User1Login8P@ssword --password-reset-required
{
"LoginProfile": {
"UserName": "MyUser",
"CreateDate": "2018-12-14T17:27:18Z",
"PasswordResetRequired": true
}
}
```
Puoi utilizzare il comando `update-login-profile` per *cambiare* la password di un utente.
```
$ aws iam update-login-profile --user-name MyUser --password My!User1ADifferentP@ssword
```
## Creare una chiave di accesso per un utente IAM
Puoi utilizzare il comando [https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html](https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html) per creare una chiave di accesso per un utente. Una chiave di accesso è un set di credenziali di sicurezza costituito da un ID chiave di accesso e una chiave segreta.
Un utente può creare solo due chiavi di accesso alla volta. Se provi a creare un terzo set, il comando restituisce un errore `LimitExceeded`.
```
$ aws iam create-access-key --user-name MyUser
{
"AccessKey": {
"UserName": "MyUser",
"AccessKeyId": "AKIAIOSFODNN7EXAMPLE",
"Status": "Active",
"SecretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
"CreateDate": "2018-12-14T17:34:16Z"
}
}
```
Utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/iam/delete-access-key.html](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-access-key.html) per eliminare una chiave di accesso per un utente. Specifica la chiave di accesso da eliminare utilizzando l'ID chiave di accesso.
```
$ aws iam delete-access-key --user-name MyUser --access-key-id AKIAIOSFODNN7EXAMPLE
```
# Utilizzo di Amazon S3 nella AWS CLI
| Un’introduzione a Amazon Simple Storage Service (Amazon S3) |
| --- |
| |
Puoi accedere alle funzionalità di Amazon Simple Storage Service (Amazon S3) con AWS Command Line Interface (AWS CLI). Amazon S3 è un servizio di archiviazione di oggetti altamente scalabile e durevole. Amazon S3 è progettato per fornire una capacità di storage praticamente illimitata, una caratteristica che lo rende una soluzione ideale per un’ampia gamma di esigenze di archiviazione e gestione dei dati.
Amazon S3 consente di memorizzare e recuperare qualsiasi quantità di dati, da file di piccole dimensioni a set di dati di grandi dimensioni, sotto forma di oggetti. Ogni oggetto è archiviato in un container chiamato bucket, a cui è possibile accedere e che può essere gestito tramite la Console di gestione AWS o, in modo programmatico, tramite gli SDK AWS, gli strumenti e la AWS CLI.
Oltre allo storage di base, Amazon S3 offre anche una gamma di funzionalità tra cui gestione del ciclo di vita, controllo delle versioni, scalabilità e sicurezza. Queste funzionalità si integrano con altri Servizi AWS e ti consentono di creare soluzioni basate sul cloud che si adattano alle tue esigenze.
La AWS CLI offre due livelli di comandi per l’accesso ad Amazon S3:
+ **s3**: comandi di livello alto realizzati specificatamente per la AWS CLI che semplificano le operazioni di uso frequente, ad esempio la creazione, la modifica, l’eliminazione e la sincronizzazione di oggetti e bucket.
+ **s3api**: offre accesso diretto a tutte le operazioni API di Amazon S3, consentendo di eseguire operazioni avanzate.
**Topics**
+ [Utilizzo di comandi di alto livello (s3) in AWS CLI](cli-services-s3-commands.md)
+ [Utilizzo di comandi a livello di API (s3api) in AWS CLI](cli-services-s3-apicommands.md)
+ [Esempio di scripting per il ciclo di vita del bucket Amazon S3 nel AWS CLI](cli-services-s3-lifecycle-example.md)
# Utilizzo di comandi di alto livello (s3) in AWS CLI
Questo argomento descrive alcuni dei comandi che è possibile utilizzare per gestire i bucket e gli oggetti Amazon S3 utilizzando i comandi [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html) presenti nella AWS CLI. Per i comandi non trattati in questo argomento e per altri esempi di comandi, consulta i comandi [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html) nella *Guida di riferimento della AWS CLI *.
I comandi `aws s3` di alto livello semplificano la gestione degli oggetti Amazon S3. Questi comandi consentono di gestire i contenuti di Amazon S3 al suo interno e utilizzando le directory locali.
**Topics**
+ [Prerequisiti](#using-s3-commands-prereqs)
+ [Prima di iniziare](#using-s3-commands-before)
+ [Creazione di un bucket](#using-s3-commands-managing-buckets-creating)
+ [Elenca i bucket e gli oggetti](#using-s3-commands-listing-buckets)
+ [Eliminazione di bucket](#using-s3-commands-delete-buckets)
+ [Eliminazione di oggetti](#using-s3-commands-delete-objects)
+ [Sposta oggetti](#using-s3-commands-managing-objects-move)
+ [Copia oggetti](#using-s3-commands-managing-objects-copy)
+ [Oggetti sincronizzati](#using-s3-commands-managing-objects-sync)
+ [Opzioni utilizzate di frequente per i comandi S3](#using-s3-commands-managing-objects-param)
+ [Resources](#using-s3-commands-managing-buckets-references)
## Prerequisiti
Per eseguire i comandi `s3`, è necessario:
+ Istalla e configura la AWS CLI. Per ulteriori informazioni, consultare [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md) e [Credenziali di autenticazione e accesso per AWS CLI](cli-chap-authentication.md).
+ Il profilo utilizzato deve disporre di autorizzazioni che consentano le AWS operazioni eseguite dagli esempi.
+ Glossario dei termini di Amazon S3:
+ **Bucket**: cartella Amazon S3 di primo livello.
+ **Prefisso**: una cartella Amazon S3 in un bucket.
+ **Oggetto**: qualsiasi elemento ospitato in un bucket Amazon S3.
## Prima di iniziare
Questa sezione descrive alcune cose da tenere a mente prima di utilizzare i comandi `aws s3`.
### Caricamenti di oggetti di grandi dimensioni
Quando usi i comandi `aws s3` per caricare oggetti di grandi dimensioni in un bucket Amazon S3, AWS CLI esegue automaticamente un caricamento in più parti. Quando si utilizzano questi comandi `aws s3`, non è possibile riprendere un caricamento non riuscito.
Se il caricamento in più parti non riesce a causa di un timeout o se l'hai annullato manualmente in AWS CLI, AWS CLI interrompe il caricamento e pulisce tutti i file che sono stati creati. Questo processo può richiedere alcuni minuti.
Se il processo di caricamento in più parti o di pulizia viene annullato da un comando kill o da un errore di sistema, i file creati rimangono nel bucket Amazon S3.
### Proprietà e tag dei file nelle copie in più parti
Quando utilizzi la AWS CLI versione 1 dei comandi nello spazio dei `aws s3` nomi per copiare un file da una posizione del bucket Amazon S3 a un'altra posizione del bucket Amazon S3 e tale operazione [utilizza la copia multiparte](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CopyingObjctsMPUapi.html), nessuna proprietà del file dall'oggetto di origine viene copiata nell'oggetto di destinazione.
Per impostazione predefinita, i comandi della AWS CLI versione 2 nello spazio dei `s3` nomi che eseguono copie in più parti trasferiscono tutti i tag e il seguente set di proprietà dalla copia di origine a quella di destinazione: `content-type` `content-language``content-encoding`,`content-disposition`,,`cache-control`,`expires`, e`metadata`.
Ciò può comportare chiamate AWS API aggiuntive all'endpoint Amazon S3 che non sarebbero state effettuate se avessi utilizzato AWS CLI la versione 1. Questi possono includere: `HeadObject`, `GetObjectTagging` e `PutObjectTagging`.
Se devi modificare questo comportamento predefinito nei comandi della AWS CLI versione 2, usa il `--copy-props` parametro per specificare una delle seguenti opzioni:
+ **default** - Il valore predefinito. Specifica che la copia include tutti i tag collegati all’oggetto di origine e le proprietà racchiuse nel parametro `--metadata-directive` utilizzato per le copie non multipart: `content-type`, `content-language`, `content-encoding`, `content-disposition`, `cache-control`, `expires` e `metadata`.
+ **metadata-directive** - Specifica che la copia include solo le proprietà racchiuse nel parametro `--metadata-directive` utilizzato per le copie non multipart. Non copia alcun tag.
+ **none** - Specifica che la copia non include nessuna delle proprietà dell’oggetto di origine.
## Creazione di un bucket
Utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html) per creare un bucket. I nomi dei bucket devono essere univoci ***globalmente*** (univoci in tutto Amazon S3) e devono essere compatibili con DNS.
Possono includere lettere minuscole, numeri, trattini e punti. Possono iniziare e terminare solo con una lettera o un numero e non possono contenere un punto accanto a un trattino o a un altro periodo.
**Sintassi**
```
$ aws s3 mb [--options]
```
### Esempi di s3 mb
L’esempio seguente crea il bucket `s3://amzn-s3-demo-bucket`.
```
$ aws s3 mb s3://amzn-s3-demo-bucket
```
## Elenca i bucket e gli oggetti
Per elencare i bucket, le cartelle o gli oggetti, utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html). L’utilizzo del comando senza destinazione o opzioni elenca tutti i bucket.
**Sintassi**
```
$ aws s3 ls [--options]
```
Per alcune opzioni comuni da utilizzare con questo comando ed esempi, consulta [Opzioni utilizzate di frequente per i comandi S3](#using-s3-commands-managing-objects-param). Per un elenco completo delle opzioni disponibili, vedi [https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html) in *AWS CLI Command Reference*.
### Esempi di s3 ls
L’esempio seguente elenca tutti i tuoi bucket Amazon S3.
```
$ aws s3 ls
2018-12-11 17:08:50 amzn-s3-demo-bucket1
2018-12-14 14:55:44 amzn-s3-demo-bucket2
```
Il comando seguente elenca tutti gli oggetti e i prefissi inclusi in un bucket. In questo output di esempio, il prefisso `example/` ha un file denominato `MyFile1.txt`.
```
$ aws s3 ls s3://amzn-s3-demo-bucket
PRE example/
2018-12-04 19:05:48 3 MyFile1.txt
```
Puoi filtrare l’output per un determinato prefisso includendolo nel comando. Il comando seguente elenca gli oggetti in *bucket-name/example/* (ovvero gli oggetti *bucket-name* filtrati in base al prefisso*example/*).
```
$ aws s3 ls s3://amzn-s3-demo-bucket/example/
2018-12-06 18:59:32 3 MyFile1.txt
```
Per visualizzare solo i bucket e gli oggetti in una Regione specifica, utilizza le opzioni `--region`
```
$ aws s3 ls --region us-east-2
2018-12-06 18:59:32 3 MyFile1.txt
```
Se disponi di un ampio elenco di bucket e oggetti, puoi paginare i risultati utilizzando le opzioni `--max-items` o `--page-size`. L’opzione `--max-items` limita il numero totale di bucket e oggetti restituiti in una chiamata e l’opzione `--page-size` limita il numero di bucket e oggetti elencati in una pagina.
```
$ aws s3 ls --max-items 100 --page-size 10
```
Per ulteriori informazioni sulla paginazione, consulta [Come utilizzare il parametro --page-size](cli-usage-pagination.md#cli-usage-pagination-pagesize) e [Come utilizzare il parametro --max-items](cli-usage-pagination.md#cli-usage-pagination-maxitems).
## Eliminazione di bucket
Per eliminare un bucket, utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html).
**Sintassi**
```
$ aws s3 rb [--options]
```
### Esempi di s3 rb
L’esempio seguente rimuove il bucket `s3://amzn-s3-demo-bucket`.
```
$ aws s3 rb s3://amzn-s3-demo-bucket
```
Per default, perché l’operazione riesca il bucket deve essere vuoto. Per rimuovere un bucket non vuoto, è necessario includere l’opzione `--force`. Se utilizzi un bucket con versioni multiple che contiene oggetti precedentemente eliminati, ma mantenuti, questo comando *non* consentirà di rimuovere il bucket. Devi prima rimuovere tutti i contenuti.
Il seguente comando di esempio elimina tutti gli oggetti nel bucket ed elimina il bucket stesso.
```
$ aws s3 rb s3://amzn-s3-demo-bucket --force
```
## Eliminazione di oggetti
Per eliminare oggetti in un bucket o nella directory locale, usa il comando [https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html).
**Sintassi**
```
$ aws s3 rm [--options]
```
Per alcune opzioni comuni da utilizzare con questo comando ed esempi, consulta [Opzioni utilizzate di frequente per i comandi S3](#using-s3-commands-managing-objects-param). Per una lista completa di opzioni, consulta [https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) in *AWS CLI Command Reference*.
### Esempi di s3 rm
L’esempio seguente elimina `filename.txt` da `s3://amzn-s3-demo-bucket/example`.
```
$ aws s3 rm s3://amzn-s3-demo-bucket/example/filename.txt
```
L’esempio seguente elimina tutti gli oggetti da `s3://amzn-s3-demo-bucket/example` utilizzando l’opzione `--recursive`.
```
$ aws s3 rm s3://amzn-s3-demo-bucket/example --recursive
```
## Sposta oggetti
Usa il comando [https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html) per spostare oggetti da un bucket o da una directory locale. Il comando `s3 mv` copia l’oggetto o file di origine nella destinazione specificata, quindi elimina l’oggetto o il file di origine.
**Sintassi**
```
$ aws s3 mv [--options]
```
Per alcune opzioni comuni da utilizzare con questo comando ed esempi, consulta [Opzioni utilizzate di frequente per i comandi S3](#using-s3-commands-managing-objects-param). Per un elenco completo delle opzioni disponibili, vedi [https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html) in *AWS CLI Command Reference*.
**avvertimento**
Se utilizzi qualsiasi tipo di punto di accesso ARNs o alias del punto di accesso nella tua origine o URIs destinazione Amazon S3, devi prestare particolare attenzione che Amazon URIs S3 di origine e destinazione si risolvano in diversi bucket sottostanti. Se i bucket di origine e di destinazione sono gli stessi, il file o l’oggetto di origine può essere spostato su sé stesso, il che può comportare l’eliminazione accidentale del file o dell’oggetto di origine. Per verificare che i bucket di origine e di destinazione non siano gli stessi, utilizza il parametro `--validate-same-s3-paths` o imposta la variabile di ambiente ``AWS_CLI_S3_MV_VALIDATE_SAME_S3_PATHS`` su `true`.
### Esempi di s3 mv
L’esempio seguente sposta tutti gli oggetti da `s3://amzn-s3-demo-bucket/example` a `s3://amzn-s3-demo-bucket/`.
```
$ aws s3 mv s3://amzn-s3-demo-bucket/example s3://amzn-s3-demo-bucket/
```
L’esempio seguente sposta un file locale dalla directory di lavoro corrente nel bucket Amazon S3 con il comando `s3 mv`.
```
$ aws s3 mv filename.txt s3://amzn-s3-demo-bucket
```
L’esempio seguente sposta un file dal bucket Amazon S3 alla directory di lavoro corrente, dove `./` specifica la directory di lavoro corrente.
```
$ aws s3 mv s3://amzn-s3-demo-bucket/filename.txt ./
```
## Copia oggetti
Usa il comando [https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) per copiare oggetti da un bucket o da una directory locale.
**Sintassi**
```
$ aws s3 cp [--options]
```
È possibile utilizzare il parametro dash per l’invio in streaming di file su standard input (`stdin`) o standard output (`stdout`).
**avvertimento**
Se lo stai utilizzando PowerShell, la shell potrebbe alterare la codifica di un CRLF o aggiungere un CRLF all'input o all'output reindirizzato tramite piping o all'output reindirizzato.
Il comando `s3 cp` utilizza la seguente sintassi per caricare uno streaming di file da `stdin` a un bucket specificato.
**Sintassi**
```
$ aws s3 cp - [--options]
```
Il comando `s3 cp` utilizza la seguente sintassi per scaricare uno streaming di file Amazon S3 su `stdout`.
**Sintassi**
```
$ aws s3 cp [--options] -
```
Per alcune opzioni comuni da utilizzare con questo comando ed esempi, consulta [Opzioni utilizzate di frequente per i comandi S3](#using-s3-commands-managing-objects-param). Per la lista completa di opzioni, consulta [https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html) in *AWS CLI Command Reference*.
### Esempi di `s3 cp`
L’esempio seguente copia tutti gli oggetti da `s3://amzn-s3-demo-bucket/example` a `s3://amzn-s3-demo-bucket/`.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/example s3://amzn-s3-demo-bucket/
```
L’esempio seguente copia un file locale dalla directory di lavoro corrente nel bucket Amazon S3 con il comando `s3 cp`.
```
$ aws s3 cp filename.txt s3://amzn-s3-demo-bucket
```
L’esempio seguente copia un file dal bucket Amazon S3 nella directory di lavoro corrente, dove `./` specifica la directory di lavoro corrente.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/filename.txt ./
```
L’esempio seguente utilizza echo per trasmettere il testo “hello world” al file `s3://bucket-name/filename.txt`.
```
$ echo "hello world" | aws s3 cp - s3://amzn-s3-demo-bucket/filename.txt
```
L’esempio seguente trasmette il file `s3://amzn-s3-demo-bucket/filename.txt` a `stdout` e ne stampa il contenuto sulla console.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/filename.txt -
hello world
```
L’esempio seguente trasmette il contenuto di `s3://bucket-name/pre` a `stdout`, utilizza il comando `bzip2` per comprimere i file e carica il nuovo file compresso denominato `key.bz2` su `s3://bucket-name`.
```
$ aws s3 cp s3://amzn-s3-demo-bucket/pre - | bzip2 --best | aws s3 cp - s3://amzn-s3-demo-bucket/key.bz2
```
## Oggetti sincronizzati
Il comando [https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) sincronizza i contenuti di un bucket e una directory o i contenuti di due bucket. In genere, `s3 sync` copia i file o gli oggetti mancanti od obsoleti tra l’origine e la destinazione. Tuttavia, puoi anche utilizzare l’opzione `--delete` per rimuovere dalla destinazione i file o gli oggetti non presenti nell’origine.
**Sintassi**
```
$ aws s3 sync [--options]
```
Per alcune opzioni comuni da utilizzare con questo comando ed esempi, consulta [Opzioni utilizzate di frequente per i comandi S3](#using-s3-commands-managing-objects-param). Per una lista completa di opzioni, consulta [https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) in *AWS CLI Command Reference*.
### Esempi di s3 sync
L’esempio seguente sincronizza il contenuto di un prefisso Amazon S3 denominato *path* nel bucket denominato *amzn-s3-demo-bucket* con la directory di lavoro corrente.
`s3 sync` aggiorna tutti i file che hanno dimensioni diverse o un orario modificato rispetto ai file con lo stesso nome nella destinazione. L’output mostra le operazioni specifiche eseguite durante la sincronizzazione. Nota che l’operazione sincronizza ricorsivamente la sottodirectory `MySubdirectory` e il suo contenuto con `s3://amzn-s3-demo-bucket/path/MySubdirectory`.
```
$ aws s3 sync . s3://amzn-s3-demo-bucket/path
upload: MySubdirectory\MyFile3.txt to s3://amzn-s3-demo-bucket/path/MySubdirectory/MyFile3.txt
upload: MyFile2.txt to s3://amzn-s3-demo-bucket/path/MyFile2.txt
upload: MyFile1.txt to s3://amzn-s3-demo-bucket/path/MyFile1.txt
```
L’esempio seguente, che amplia quello precedente, mostra come utilizzare l’opzione `--delete`.
```
// Delete local file
$ rm ./MyFile1.txt
// Attempt sync without --delete option - nothing happens
$ aws s3 sync . s3://amzn-s3-demo-bucket/path
// Sync with deletion - object is deleted from bucket
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --delete
delete: s3://amzn-s3-demo-bucket/path/MyFile1.txt
// Delete object from bucket
$ aws s3 rm s3://amzn-s3-demo-bucket/path/MySubdirectory/MyFile3.txt
delete: s3://amzn-s3-demo-bucket/path/MySubdirectory/MyFile3.txt
// Sync with deletion - local file is deleted
$ aws s3 sync s3://amzn-s3-demo-bucket/path . --delete
delete: MySubdirectory\MyFile3.txt
// Sync with Infrequent Access storage class
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --storage-class STANDARD_IA
```
Quando si utilizza l’opzione `--delete`, le opzioni `--exclude` e `--include` possono filtrare file o oggetti da eliminare durante un’operazione `s3 sync`. In questo caso, la stringa di parametro deve specificare i file da escludere o includere per l’eliminazione nel contesto della directory o del bucket di destinazione. Di seguito viene riportato un esempio.
```
Assume local directory and s3://amzn-s3-demo-bucket/path currently in sync and each contains 3 files:
MyFile1.txt
MyFile2.rtf
MyFile88.txt
'''
// Sync with delete, excluding files that match a pattern. MyFile88.txt is deleted, while remote MyFile1.txt is not.
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --delete --exclude "path/MyFile?.txt"
delete: s3://amzn-s3-demo-bucket/path/MyFile88.txt
'''
// Sync with delete, excluding MyFile2.rtf - local file is NOT deleted
$ aws s3 sync s3://amzn-s3-demo-bucket/path . --delete --exclude "./MyFile2.rtf"
download: s3://amzn-s3-demo-bucket/path/MyFile1.txt to MyFile1.txt
'''
// Sync with delete, local copy of MyFile2.rtf is deleted
$ aws s3 sync s3://amzn-s3-demo-bucket/path . --delete
delete: MyFile2.rtf
```
## Opzioni utilizzate di frequente per i comandi S3
Le seguenti opzioni vengono utilizzate di frequente per i comandi descritti in questo argomento. [Per un elenco completo delle opzioni che è possibile utilizzare su un comando, consultate il comando specifico nella guida di riferimento alla versione 2 della .](https://docs.aws.amazon.com/cli/latest/reference/index.html)
**acl**
`s3 sync` e `s3 cp` possono utilizzare l’opzione `--acl`. Ciò consente di impostare le autorizzazioni di accesso per i file copiati su Amazon S3. L’opzione `--acl` accetta i valori `private`, `public-read` e `public-read-write`. Per maggiori informazioni, consulta [Canned ACL](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl) nella *Guida per l’utente di Amazon S3*.
```
$ aws s3 sync . s3://amzn-s3-demo-bucket/path --acl public-read
```
**exclude**
Quando usi il comando `s3 cp`, `s3 mv`, `s3 sync` o `s3 rm`, puoi filtrare i risultati utilizzando l’opzione `--exclude` o `--include`. L’opzione `--exclude` imposta le regole per escludere solo gli oggetti dal comando e le opzioni si applicano nell’ordine specificato. Questo viene mostrato nell’esempio seguente.
```
Local directory contains 3 files:
MyFile1.txt
MyFile2.rtf
MyFile88.txt
// Exclude all .txt files, resulting in only MyFile2.rtf being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --exclude "*.txt"
// Exclude all .txt files but include all files with the "MyFile*.txt" format, resulting in, MyFile1.txt, MyFile2.rtf, MyFile88.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --exclude "*.txt" --include "MyFile*.txt"
// Exclude all .txt files, but include all files with the "MyFile*.txt" format, but exclude all files with the "MyFile?.txt" format resulting in, MyFile2.rtf and MyFile88.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --exclude "*.txt" --include "MyFile*.txt" --exclude "MyFile?.txt"
```
**include**
Quando usi il comando `s3 cp`, `s3 mv`, `s3 sync` o `s3 rm`, puoi filtrare i risultati utilizzando l’opzione `--exclude` o `--include`. L’opzione `--include` imposta le regole per includere solo gli oggetti specificati nel comando e le opzioni si applicano nell’ordine specificato. Questo viene mostrato nell’esempio seguente.
```
Local directory contains 3 files:
MyFile1.txt
MyFile2.rtf
MyFile88.txt
// Include all .txt files, resulting in MyFile1.txt and MyFile88.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "*.txt"
// Include all .txt files but exclude all files with the "MyFile*.txt" format, resulting in no files being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "*.txt" --exclude "MyFile*.txt"
// Include all .txt files, but exclude all files with the "MyFile*.txt" format, but include all files with the "MyFile?.txt" format resulting in MyFile1.txt being copied
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "*.txt" --exclude "MyFile*.txt" --include "MyFile?.txt"
```
**grant**
I comandi `s3 cp`, `s3 mv` e `s3 sync` includono un’opzione `--grants` che può essere utilizzata per concedere autorizzazioni sull’oggetto a utenti o gruppi specificati. Imposta l’opzione `--grants` per un elenco di autorizzazioni utilizzando la sintassi seguente. Sostituisci `Permission`, `Grantee_Type` e `Grantee_ID` con il tuo valore.
**Sintassi**
```
--grants Permission=Grantee_Type=Grantee_ID
[Permission=Grantee_Type=Grantee_ID ...]
```
Ogni valore contiene i seguenti elementi:
+ *Permission*— Speciifica le autorizzazioni concesse. Può essere impostato su `read`, `readacl`, `writeacl` o `full`.
+ *Grantee\$1Type*— Specifica come identificare il beneficiario. Può essere impostato su `uri`, `emailaddress` o `id`.
+ *Grantee\$1ID*— Speciifica il beneficiario in base a. *Grantee\$1Type*
+ `uri` - L’URI del gruppo. Per ulteriori informazioni, consulta [Chi è l’assegnatario?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/ACLOverview.html#SpecifyingGrantee)
+ `emailaddress` - L’indirizzo e-mail dell’account.
+ `id` - L’ID canonico dell’account.
Per ulteriori informazioni sul controllo degli accessi di Amazon S3, consulta [Controllo degli accessi](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingAuthAccess.html).
L’esempio seguente copia un oggetto in un bucket. Concede le autorizzazioni `read` per l’oggetto a tutti e le autorizzazioni `full` (`read`, `readacl` e `writeacl`) all’account associato a `user@example.com`.
```
$ aws s3 cp file.txt s3://amzn-s3-demo-bucket/ --grants read=uri=http://acs.amazonaws.com/groups/global/AllUsers full=emailaddress=user@example.com
```
Puoi anche specificare una classe di archiviazione non predefinita (`REDUCED_REDUNDANCY` o `STANDARD_IA`) per gli oggetti caricati su Amazon S3. Per farlo, utilizza l’opzione `--storage-class`.
```
$ aws s3 cp file.txt s3://amzn-s3-demo-bucket/ --storage-class REDUCED_REDUNDANCY
```
**nessuna sovrascrittura**
I `s3 sync` comandi `s3 cp``s3 mv`, e includono un'`--no-overwrite`opzione che è possibile utilizzare per impedire la sovrascrittura di oggetti già esistenti nella destinazione.
L'esempio seguente copia un oggetto da un bucket nella directory locale solo se non esiste già nella directory locale.
```
$ aws s3 cp --no-overwrite s3://amzn-s3-demo-bucket/file.txt file.txt
```
L'esempio seguente copia in modo ricorsivo i file da una directory locale a un bucket. Copierà solo i file che non esistono già nel bucket.
```
$ aws s3 cp --recursive --no-overwrite /path/to/demo-files/ s3://amzn-s3-demo-bucket/demo-files/
```
L'esempio seguente sposta un oggetto da una directory locale a un bucket solo se non esiste già nella posizione di destinazione del bucket.
```
$ aws s3 mv --no-overwrite file.txt s3://amzn-s3-demo-bucket/file.txt
```
L'esempio seguente sincronizza i file da una directory locale a un bucket. Sincronizzerà solo i file che non esistono già nel bucket di destinazione.
```
$ aws s3 sync --no-overwrite /path/to/demo-files/ s3://amzn-s3-demo-bucket/demo-files/
```
**recursive**
Quando utilizzi questa opzione, il comando viene eseguito su tutti i file o gli oggetti nella directory o nel prefisso specificati. L’esempio seguente elimina `s3://amzn-s3-demo-bucket/path` e tutti i suoi contenuti.
```
$ aws s3 rm s3://amzn-s3-demo-bucket/path --recursive
```
## Resources
**AWS CLI riferimento:**
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html](https://docs.aws.amazon.com/cli/latest/reference/s3/cp.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html](https://docs.aws.amazon.com/cli/latest/reference/s3/mv.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rb.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html)
**Riferimento al servizio**:
+ [Utilizzo di bucket Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingBucket.html) nella *Guida per l’utente di Amazon S3*
+ [Utilizzo di oggetti Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingObjects.html) nella *Guida per l’utente di Amazon S3*
+ [Elenco gerarchico delle chiavi utilizzando un prefisso e un delimitatore](https://docs.aws.amazon.com//AmazonS3/latest/userguide/ListingKeysHierarchy.html) nella *Guida per l’utente di Amazon S3*
+ [https://docs.aws.amazon.com//AmazonS3/latest/userguide/LLAbortMPUnet.html](https://docs.aws.amazon.com//AmazonS3/latest/userguide/LLAbortMPUnet.html)
# Utilizzo di comandi a livello di API (s3api) in AWS CLI
I comandi a livello di API (contenuti nel set di `s3api` comandi) forniscono l'accesso diretto ad Amazon Simple Storage Service (Amazon APIs S3) e abilitano alcune operazioni che non sono esposte nei comandi di alto livello. `s3` Questi comandi sono equivalenti agli altri servizi AWS che forniscono l'accesso a livello di API alle funzionalità dei servizi. Per ulteriori informazioni sui comandi `s3`, consulta [Utilizzo di comandi di alto livello (s3) in AWS CLI](cli-services-s3-commands.md)
Questo argomento fornisce esempi che dimostrano come utilizzare i comandi di livello inferiore mappati ad Amazon S3. APIs Inoltre, puoi trovare esempi per ogni comando dell'API S3 nella `s3api` sezione della guida di riferimento, [versione](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html) 2.
**Topics**
+ [Prerequisiti](#cli-services-s3-apicommands-prereqs)
+ [Applicazione di una lista di controllo accessi (ACL) personalizzata](#cli-services-s3-apicommands-acls)
+ [Configurazione di una policy di registrazione](#cli-services-s3-apicommands-logpol)
+ [Resources](#cli-services-s3-apicommands-resources)
## Prerequisiti
Per eseguire i comandi `s3api`, è necessario:
+ Istalla e configura la AWS CLI. Per ulteriori informazioni, consultare [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md) e [Credenziali di autenticazione e accesso per AWS CLI](cli-chap-authentication.md).
+ Il profilo che utilizzi deve disporre di autorizzazioni che consentano le AWS operazioni eseguite dagli esempi.
+ Glossario dei termini di Amazon S3:
+ **Bucket**: cartella Amazon S3 di primo livello.
+ **Prefisso**: una cartella Amazon S3 in un bucket.
+ **Oggetto**: qualsiasi elemento ospitato in un bucket Amazon S3.
## Applicazione di una lista di controllo accessi (ACL) personalizzata
Con i comandi di alto livello, puoi utilizzare l'`--acl`opzione per applicare elenchi di controllo degli accessi predefiniti (ACLs) agli oggetti Amazon S3. Ma non puoi usare quel comando per impostare bucket-wide. ACLs Tuttavia, puoi farlo utilizzando il comando ```[put-bucket-acl](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-acl.html)` a livello di API.
L'esempio seguente mostra come concedere il controllo completo a due AWS utenti (*user1@example.com* e *user2@example.com*) e il permesso di lettura a tutti. L'identificatore per "tutti" proviene da un URI speciale passato come parametro.
```
$ aws s3api put-bucket-acl --bucket amzn-s3-demo-bucket --grant-full-control 'emailaddress="user1@example.com",emailaddress="user2@example.com"' --grant-read 'uri="http://acs.amazonaws.com/groups/global/AllUsers"'
```
Per dettagli su come costruire il ACLs, consulta [PUT Bucket acl](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTacl.html) nel riferimento all'API di *Amazon Simple Storage Service*. I comandi ACL `s3api` nell'interfaccia a riga di comando, come `put-bucket-acl`, utilizzano la stessa [notazione di argomento abbreviata](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-shorthand.html).
## Configurazione di una policy di registrazione
Il comando API `put-bucket-logging` configura una policy di registrazione di log dei bucket.
Nell'esempio seguente, *all' AWS utente user@example.com* viene concesso il pieno controllo sui file di registro e tutti gli utenti hanno accesso in lettura ad essi. Nota che il comando `put-bucket-acl` è richiesto anche per concedere al sistema di distribuzione dei log di Amazon S3 (specificato da un URI) le autorizzazioni necessarie per leggere e scrivere i log nel bucket.
```
$ aws s3api put-bucket-acl --bucket amzn-s3-demo-bucket --grant-read-acp 'URI="http://acs.amazonaws.com/groups/s3/LogDelivery"' --grant-write 'URI="http://acs.amazonaws.com/groups/s3/LogDelivery"'
$ aws s3api put-bucket-logging --bucket amzn-s3-demo-bucket --bucket-logging-status file://logging.json
```
Il file `logging.json` nel comando precedente ha il seguente contenuto.
```
{
"LoggingEnabled": {
"TargetBucket": "amzn-s3-demo-bucket",
"TargetPrefix": "amzn-s3-demo-bucketLogs/",
"TargetGrants": [
{
"Grantee": {
"Type": "AmazonCustomerByEmail",
"EmailAddress": "user@example.com"
},
"Permission": "FULL_CONTROL"
},
{
"Grantee": {
"Type": "Group",
"URI": "http://acs.amazonaws.com/groups/global/AllUsers"
},
"Permission": "READ"
}
]
}
}
```
## Resources
**AWS CLI riferimento:**
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-acl.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-acl.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-logging.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-bucket-logging.html)
**Riferimento al servizio**:
+ [Utilizzo di bucket Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingBucket.html) nella *Guida per l’utente di Amazon S3*
+ [Utilizzo di oggetti Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingObjects.html) nella *Guida per l’utente di Amazon S3*
+ [Elenco gerarchico delle chiavi utilizzando un prefisso e un delimitatore](https://docs.aws.amazon.com//AmazonS3/latest/userguide/ListingKeysHierarchy.html) nella *Guida per l’utente di Amazon S3*
+ [https://docs.aws.amazon.com//AmazonS3/latest/userguide/LLAbortMPUnet.html](https://docs.aws.amazon.com//AmazonS3/latest/userguide/LLAbortMPUnet.html)
# Esempio di scripting per il ciclo di vita del bucket Amazon S3 nel AWS CLI
Questo argomento utilizza un esempio di script Bash per le operazioni del ciclo di vita dei bucket Amazon S3 utilizzando AWS Command Line Interface (AWS CLI). Questo esempio di script utilizza il set di comandi [https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html). Gli script di shell sono programmi progettati per l’esecuzione in un’interfaccia a riga di comando.
**Topics**
+ [Prima di iniziare](#cli-services-s3-lifecycle-example-before)
+ [Informazioni sull’esempio](#cli-services-s3-lifecycle-example-about)
+ [File](#cli-services-s3-lifecycle-example-files)
+ [Riferimenti](#cli-services-s3-lifecycle-example-references)
## Prima di iniziare
Prima di poter eseguire uno qualsiasi degli esempi seguenti, è necessario completare le seguenti operazioni.
+ Istalla e configura la AWS CLI. Per ulteriori informazioni, consultare [Installazione o aggiornamento alla versione più recente di AWS CLI](getting-started-install.md) e [Credenziali di autenticazione e accesso per AWS CLI](cli-chap-authentication.md).
+ Il profilo che usi deve avere permessi che consentano le AWS operazioni eseguite dagli esempi.
+ Come procedura AWS consigliata, concedi a questo codice il privilegio minimo o solo le autorizzazioni necessarie per eseguire un'operazione. Per ulteriori informazioni, consulta [Assegnare il privilegio minimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) nella *Guida per l'utente di IAM*.
+ Questo codice non è stato testato in tutte le AWS regioni. Alcuni AWS servizi sono disponibili solo in regioni specifiche. Per ulteriori informazioni, consulta [ Service Endpoints and Quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) nella *AWS General Reference Guide*.
+ L'esecuzione di questo codice può comportare addebiti sul tuo AWS account. È tua responsabilità assicurarti che tutte le risorse create da questo script vengano rimosse quando hai finito di utilizzarle.
Il servizio Amazon S3 utilizza i termini seguenti:
+ Bucket: una cartella Amazon S3 di primo livello.
+ Prefisso: una cartella Amazon S3 in un bucket.
+ Oggetto: qualsiasi elemento ospitato in un bucket Amazon S3.
## Informazioni sull’esempio
Questo esempio dimostra come interagire con alcune delle operazioni di base di Amazon S3 utilizzando un set di funzioni nei file di script di shell. Le funzioni si trovano nel file di script di shell denominato `bucket-operations.sh`. È possibile richiamare queste funzioni in un altro file. Ogni file di script contiene commenti che descrivono ciascuna delle funzioni.
Per visualizzare i risultati intermedi di ogni fase, esegui lo script con un parametro `-i`. È possibile visualizzare lo stato attuale del bucket o il suo contenuto utilizzando la console Amazon S3. Lo script passa alla fase successiva solo quando premi **invio** al prompt.
*Per l'esempio completo e i file di script scaricabili, consulta [Amazon S3 Bucket Lifecycle](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations) Operations nel Code Examples Repository su.AWS *GitHub**
## File
L’esempio contiene i file seguenti:
**bucket-operations.sh**
Questo file di script principale può provenire da un altro file. Include funzioni in grado di eseguire le seguenti attività:
+ Creare un bucket e verificarne l’esistenza
+ Copiare un file dal computer locale in un bucket
+ Copiare un file da una posizione del bucket a un’altra posizione del bucket
+ Elenco dei contenuti di un bucket
+ Eliminazione di un file da un bucket
+ Eliminazione di un bucket
Visualizza il codice per on. `[bucket-operations.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations/bucket_operations.sh)` *GitHub*
**test-bucket-operations.sh**
Il file di script della shell `test-bucket-operations.sh` dimostra come chiamare le funzioni recuperando il file `bucket-operations.sh` e chiamando ciascuna delle funzioni. Dopo aver chiamato le funzioni, lo script di test rimuove tutte le risorse che ha creato.
Visualizza il codice per `[test-bucket-operations.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations/test_bucket_operations.sh)` on *GitHub*.
**awsdocs-general.sh**
Il file di script `awsdocs-general.sh` contiene funzioni generiche utilizzate negli esempi di codice avanzati per la AWS CLI.
Visualizza il codice per `[awsdocs-general.sh](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/aws-cli/bash-linux/s3/bucket-lifecycle-operations/awsdocs_general.sh)` on *GitHub*.
## Riferimenti
**AWS CLI riferimento:**
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/index.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/create-bucket.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/create-bucket.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/copy-object.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/copy-object.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-bucket.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-bucket.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-object.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/delete-object.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/head-bucket.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/head-bucket.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/list-objects.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/list-objects.html)
+ [https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html](https://docs.aws.amazon.com/cli/latest/reference/s3api/put-object.html)
**Altri riferimenti:**
+ [Utilizzo di bucket Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingBucket.html) nella *Guida per l’utente di Amazon S3*
+ [Utilizzo di oggetti Amazon S3](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingObjects.html) nella *Guida per l’utente di Amazon S3*
+ Per visualizzare e contribuire all' AWS SDK e agli esempi di AWS CLI codice, consulta il [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/) su. *GitHub*
# Accedere ad Amazon SNS in AWS CLI
Puoi accedere alle funzionalità di Amazon Simple Notification Service (Amazon SNS) tramite AWS Command Line Interface (AWS CLI). Per elencare i comandi della AWS CLI per Amazon SNS, utilizza il comando seguente.
```
aws sns help
```
Prima di eseguire qualsiasi comando, imposta le tue credenziali di default. Per ulteriori informazioni, consulta [Configurazione delle impostazioni della AWS CLI.](cli-chap-configure.md).
Questo argomento mostra esempi di comandi della AWS CLI che eseguono operazioni comuni per Amazon SNS.
**Topics**
+ [Creazione di un argomento](#cli-create-sns-topic)
+ [Sottoscrizione a un argomento](#cli-subscribe-sns-topic)
+ [Pubblicazione in un argomento](#cli-publish-sns-topic)
+ [Annullamento della sottoscrizione a un argomento](#cli-unsubscribe-sns-topic)
+ [Eliminazione di un argomento](#cli-delete-sns-topic)
## Creazione di un argomento
Per creare un argomento, utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/sns/create-topic.html](https://docs.aws.amazon.com/cli/latest/reference/sns/create-topic.html) e specifica il nome da assegnare all'argomento.
```
$ aws sns create-topic --name my-topic
{
"TopicArn": "arn:aws:sns:us-west-2:123456789012:my-topic"
}
```
Prendi nota del valore `TopicArn` della risposta, che utilizzerai in seguito per pubblicare un messaggio.
## Sottoscrizione a un argomento
Per sottoscrivere un argomento, utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/sns/subscribe.html](https://docs.aws.amazon.com/cli/latest/reference/sns/subscribe.html).
L'esempio seguente specifica il protocollo `email` e un indirizzo e-mail per `notification-endpoint`.
```
$ aws sns subscribe --topic-arn arn:aws:sns:us-west-2:123456789012:my-topic --protocol email --notification-endpoint saanvi@example.com
{
"SubscriptionArn": "pending confirmation"
}
```
AWS invia subito un'e-mail di conferma all'indirizzo specificato nel comando `subscribe`. Il testo dell'e-mail è il seguente.
```
You have chosen to subscribe to the topic:
arn:aws:sns:us-west-2:123456789012:my-topic
To confirm this subscription, click or visit the following link (If this was in error no action is necessary):
Confirm subscription
```
Quando il destinatario fa clic sul collegamento **Confirm subscription (Conferma sottoscrizione)**, il browser del destinatario visualizza un messaggio di notifica con informazioni simili alle seguenti.
```
Subscription confirmed!
You have subscribed saanvi@example.com to the topic:my-topic.
Your subscription's id is:
arn:aws:sns:us-west-2:123456789012:my-topic:1328f057-de93-4c15-512e-8bb22EXAMPLE
If it was not your intention to subscribe, click here to unsubscribe.
```
## Pubblicazione in un argomento
Per inviare un messaggio a tutti gli abbonati a un argomento, utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/sns/publish.html](https://docs.aws.amazon.com/cli/latest/reference/sns/publish.html).
L’esempio seguente invia il messaggio “Hello World\$1” a tutti gli abbonati dell’argomento specificato.
```
$ aws sns publish --topic-arn arn:aws:sns:us-west-2:123456789012:my-topic --message "Hello World!"
{
"MessageId": "4e41661d-5eec-5ddf-8dab-2c867EXAMPLE"
}
```
In questo esempio, la AWS invia un’e-mail con il testo “Hello World\$1” alla `saanvi@example.com`.
## Annullamento della sottoscrizione a un argomento
Per annullare l’abbonamento a un argomento e interrompere la ricezione dei messaggi pubblicati nell’argomento, utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/sns/unsubscribe.html](https://docs.aws.amazon.com/cli/latest/reference/sns/unsubscribe.html) e specifica l’ARN dell’argomento di cui si desidera annullare l’abbonamento.
```
$ aws sns unsubscribe --subscription-arn arn:aws:sns:us-west-2:123456789012:my-topic:1328f057-de93-4c15-512e-8bb22EXAMPLE
```
Per verificare il corretto annullamento della sottoscrizione, utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/sns/list-subscriptions.html](https://docs.aws.amazon.com/cli/latest/reference/sns/list-subscriptions.html) per confermare che l’ARN non appaia più nell’elenco.
```
$ aws sns list-subscriptions
```
## Eliminazione di un argomento
Per eliminare un argomento, è necessario eseguire il comando [https://docs.aws.amazon.com/cli/latest/reference/sns/delete-topic.html](https://docs.aws.amazon.com/cli/latest/reference/sns/delete-topic.html).
```
$ aws sns delete-topic --topic-arn arn:aws:sns:us-west-2:123456789012:my-topic
```
Per verificare che AWS abbia eliminato correttamente l’argomento, utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/sns/list-topics.html](https://docs.aws.amazon.com/cli/latest/reference/sns/list-topics.html) per confermare che l’argomento non appaia più nell’elenco.
```
$ aws sns list-topics
```