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à.
# Specificare dei valori di parametro nella AWS CLI
Molti parametri utilizzati in AWS Command Line Interface (AWS CLI) sono semplici valori stringa o numerici, ad esempio il nome della coppia di chiavi `my-key-pair` nell’esempio del comando `aws ec2 create-key-pair` seguente.
```
$ aws ec2 create-key-pair --key-name my-key-pair
```
La formattazione del comando può variare tra i terminali. Ad esempio, la maggior parte dei terminali distingue tra maiuscole e minuscole, ma Powershell non fa distinzione tra maiuscole e minuscole. Ciò significa che i due esempi di comandi seguenti produrrebbero risultati diversi per i terminali con distinzione tra maiuscole e minuscole in quanto visualizzano `MyFile*.txt` e `myfile*.txt` come parametri **diversi**.
Tuttavia, PowerShell potrebbe elaborare queste richieste allo stesso modo in cui le vedono `MyFile*.txt` e `myfile*.txt` con gli **stessi** parametri. Il comando di esempio seguente dimostra questi parametri che utilizzano il comando `aws s3 cp`:
```
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "MyFile*.txt"
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "myfile*.txt"
```
Per ulteriori informazioni sulla mancanza di distinzione tra maiuscole e minuscole di PowerShell, consulta [about\$1Case-Sensitivity](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_case-sensitivity) nella *documentazione di PowerShell*.
A volte è necessario utilizzare virgolette o caratteri letterali attorno a stringhe che includono caratteri speciali o di spazio. Le regole relative a questa formattazione possono variare anche tra i terminali. Per ulteriori informazioni sull'utilizzo di virgolette attorno a parametri complessi, consulta [Utilizzo di virgolette e valori letterali con stringhe in AWS CLI](cli-usage-parameters-quoting-strings.md).
Questi argomenti riguardano le regole di formattazione dei terminali più comuni. Se riscontri dei problemi con il riconoscimento dei valori dei parametri da parte del terminale, assicurati di consultare gli argomenti di questa sezione e di consultare anche la documentazione del terminale per le relative regole di sintassi specifiche.
**Topics**
+ [Tipi di parametri comuni in AWS CLI](cli-usage-parameters-types.md)
+ [Utilizzo di virgolette e valori letterali con stringhe in AWS CLI](cli-usage-parameters-quoting-strings.md)
+ [Caricamento di un parametro da un file nel AWS CLI](cli-usage-parameters-file.md)
+ [AWS CLI scheletri e file di input nel AWS CLI](cli-usage-skeleton.md)
+ [Utilizzo della sintassi abbreviata in AWS CLI](cli-usage-shorthand.md)
# Tipi di parametri comuni in AWS CLI
Questa sezione descrive alcuni tipi di parametri comuni e il formato tipico richiesto.
In caso di problemi con la formattazione di un parametro per un comando specifico, consulta la guida digitando **help** dopo il nome del comando. L’aiuto per ogni sottocomando include il nome e la descrizione di un’opzione. Il tipo di parametro dell’opzione è elencato tra parentesi. Per ulteriori informazioni sulla visualizzazione della guida, consulta [Accesso all'aiuto e alle risorse per AWS CLI](cli-usage-help.md).
**Topics**
+ [Stringa](#parameter-type-string)
+ [Time stamp](#parameter-type-timestamp)
+ [List](#parameter-type-list)
+ [Booleano](#parameter-type-boolean)
+ [Numero intero](#parameter-type-integer)
+ [Binary / blob (oggetto binario di grandi dimensioni) e blob in streaming](#parameter-type-blobs)
+ [Eseguire la mappatura](#parameter-type-map)
+ [Documento](#parameter-type-document)
## Stringa
I parametri stringa possono contenere caratteri alfanumerici, simboli e spazi vuoti del set di caratteri [ASCII](https://wikipedia.org/wiki/ASCII). Le stringhe che contengono spazi vuoti devono essere racchiuse tra virgolette. Ti consigliamo di non utilizzare simboli o spazi bianchi diversi dal carattere di spazio standard e di osservare le [regole di citazione](cli-usage-parameters-quoting-strings.md) del tuo terminale per evitare risultati imprevisti.
Alcuni parametri di stringa accettano i dati binari da un file. Consulta [File binari](cli-usage-parameters-file.md#cli-usage-parameters-file-binary) per un esempio.
## Time stamp
I timestamp sono formattati in base allo standard [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html). Questi sono spesso indicati come parametri “`DateTime`” o “`Date`”.
```
$ aws ec2 describe-spot-price-history --start-time 2014-10-13T19:00:00Z
```
I formati accettabili includono:
+ *YYYY*- *MM* - *DD* T*hh*:*mm*: *ss.sss**TZD (UTC)*, ad esempio, 2014-10-01T 20:30:00.000 Z
+ *YYYY*- *MM* - *DD* T::, ad esempio, 2014-10-01T 12:30:00.000-08:00 *hh* *mm* *ss.sss* *TZD (with offset)*
+ *YYYY**MM*- -*DD*, ad esempio, 2014-10-01
+ Tempo Unix in secondi, ad esempio 1412195400. A volte, viene chiamato [epoca Unix (Unix epoch)](https://wikipedia.org/wiki/Unix_time) e rappresenta il numero di secondi dalla mezzanotte del 1 gennaio 1970 UTC.
Per impostazione predefinita, la AWS CLI versione 2 traduce tutti i DateTime valori di ***risposta*** nel formato ISO 8601.
È possibile impostare il formato del timestamp utilizzando l’impostazione del file `cli\$1timestamp\$1format`.
## List
Una o più stringhe separate da spazi. Se uno degli elementi della stringa contiene uno spazio, devi racchiuderlo tra virgolette. Osserva le [regole di citazione](cli-usage-parameters-quoting-strings.md) del tuo terminale per evitare risultati imprevisti.
```
$ aws ec2 describe-spot-price-history --instance-types m1.xlarge m1.medium
```
## Booleano
Flag binario che attiva o disattiva un’opzione. Ad esempio, `ec2 describe-spot-price-history` ha un parametro `--dry-run` booleano che, quando specificato, consente di convalidare la query con il servizio anche senza eseguire la query.
```
$ aws ec2 describe-spot-price-history --dry-run
```
L'output indica se il formato del comando è valido. Questo comando include anche una versione `--no-dry-run` del parametro, che puoi utilizzare per indicare esplicitamente che il comando deve essere eseguito normalmente, anche se non è necessario includerlo poiché questa è l'impostazione predefinita.
## Numero intero
Numero intero senza firma.
```
$ aws ec2 describe-spot-price-history --max-items 5
```
## Binary / blob (oggetto binario di grandi dimensioni) e blob in streaming
In AWS CLI, è possibile passare un valore binario come stringa direttamente sulla riga di comando. Esistono due tipi di blob:
+ [Blob](#parameter-type-blob)
+ [Blob di streaming](#parameter-type-streaming-blob)
### Blob
Per passare un valore a un parametro con tipo `fileb://`, è necessario specificare un percorso di un file locale che contiene i dati binari utilizzando il prefisso `blob`. I file a cui si fa riferimento utilizzando il prefisso `fileb://` vengono sempre trattati come binario non codificato. Il percorso specificato viene interpretato come relativo alla directory di lavoro. Ad esempio, il parametro `--plaintext` per `aws kms encrypt` è un blob.
```
$ aws kms encrypt \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--plaintext fileb://ExamplePlaintextFile \
--output text \
--query CiphertextBlob | base64 \
--decode > ExampleEncryptedFile
```
**Nota**
Per la compatibilità con le versioni precedenti, puoi utilizzare il prefisso `file://`. Esistono due formati utilizzati in base all’impostazione del file `cli\$1binary\$1format` o all’opzione della riga di comando `--cli-binary-format`:
Impostazione predefinita per la AWS CLI versione 2. Se il valore dell’impostazione è `base64`, i file a cui si fa riferimento utilizzando il prefisso `file://` vengono trattati come testo con codifica Base64.
Impostazione predefinita per la AWS CLI versione 1. Se il valore dell’impostazione è `raw-in-base64-out`, i file a cui si fa riferimento utilizzando il prefisso `file://` vengono letti come testo e quindi la AWS CLI tenta di codificarli in codice binario.
Per ulteriori informazioni, consulta l’impostazione del file `cli\$1binary\$1format` o l’opzione della riga di comando `--cli-binary-format`.
### Blob di streaming
I blob di streaming, ad esempio `aws cloudsearchdomain upload-documents` non utilizza prefissi. Invece, i parametri dello streaming blob vengono formattati utilizzando il percorso diretto del file. L’esempio seguente utilizza il percorso diretto del file `document-batch.json` per il comando `aws cloudsearchdomain upload-documents`:
```
$ aws cloudsearchdomain upload-documents \
--endpoint-url https://doc-my-domain.us-west-1.cloudsearch.amazonaws.com \
--content-type application/json \
--documents document-batch.json
```
## Eseguire la mappatura
Un set di coppie chiave-valore specificato in formato JSON o utilizzando la [sintassi abbreviata](cli-usage-shorthand.md) dell'interfaccia a riga di comando (CLI). L’esempio JSON seguente legge un elemento da una tabella Amazon DynamoDB denominata *my-table* con un parametro mappa, `--key`. Il parametro specifica la chiave primaria denominata *id* con un valore numerico *1* in una struttura JSON nidificata.
Per un utilizzo JSON più avanzato in una riga di comando, prendi in considerazione l’utilizzo di un processore JSON a riga di comando, ad esempio `jq`, per creare stringhe JSON. Per ulteriori informazioni su`jq`, consulta il [repository jq](http://stedolan.github.io/jq/) su. *GitHub*
```
$ aws dynamodb get-item --table-name my-table --key '{"id": {"N":"1"}}'
{
"Item": {
"name": {
"S": "John"
},
"id": {
"N": "1"
}
}
}
```
## Documento
**Nota**
La [sintassi abbreviata](cli-usage-shorthand.md) non è compatibile con i tipi di documento.
I tipi di documento vengono utilizzati per inviare dati senza dover incorporare JSON nelle stringhe. Il tipo di documento consente ai servizi di fornire schemi arbitrari per l’utilizzo di tipi di dati più flessibili.
Ciò consente di inviare dati JSON senza la necessità di eseguire l’escape dei valori. Ad esempio, invece di utilizzare il seguente input JSON con escape:
```
{"document": "{\"key\":true}"}
```
Puoi utilizzare il seguente tipo di documento:
```
{"document": {"key": true}}
```
### I valori validi per i tipi di documento
A causa della natura flessibile dei tipi di documento, esistono più tipi di valori validi. I valori validi includono quanto segue:
**Stringa**
```
--option '"value"'
```
**Numero**
```
--option 123
--option 123.456
```
**Booleano**
```
--option true
```
**Null**
```
--option null
```
**Array**
```
--option '["value1", "value2", "value3"]'
--option '["value", 1, true, null, ["key1", 2.34], {"key2": "value2"}]'
```
**Oggetto**
```
--option '{"key": "value"}'
--option '{"key1": "value1", "key2": 123, "key3": true, "key4": null, "key5": ["value3", "value4"], "key6": {"value5": "value6"}'
```
# Utilizzo di virgolette e valori letterali con stringhe in AWS CLI
Esistono principalmente due modi in cui vengono utilizzate le virgolette singole e doppie nella AWS CLI.
+ [Utilizzo delle virgolette attorno a stringhe che contengono spazi bianchi](#cli-usage-parameters-quoting-strings-around)
+ [Utilizzo delle virgolette all’interno delle stringhe](#cli-usage-parameters-quoting-strings-containing)
## Utilizzo delle virgolette attorno a stringhe che contengono spazi bianchi
I nomi dei parametri e i relativi valori sono separati da spazi sulla riga di comando. Se un valore di stringa contiene uno spazio incorporato, è necessario racchiudere l'intera stringa tra virgolette per evitare che lo spazio venga interpretato erroneamente come divisore tra il valore e il nome del parametro successivo. AWS CLI Il tipo di virgolette utilizzato dipende dal sistema operativo su cui è in esecuzione. AWS CLI
------
#### [ Linux and macOS ]
Utilizzo di virgolette singole `' '`
```
$ aws ec2 create-key-pair --key-name 'my key pair'
```
Per ulteriori informazioni sull’utilizzo delle virgolette, consulta la documentazione per l’utente della shell che preferisci.
------
#### [ PowerShell ]
**Virgolette singole (scelta consigliata)**
Le virgolette singole `' '` sono chiamate stringhe `verbatim`. La stringa viene passata al comando esattamente mentre viene digitata, il che significa che PowerShell le variabili non verranno trasmesse.
```
PS C:\> aws ec2 create-key-pair --key-name 'my key pair'
```
**Virgolette doppie**
Le virgolette doppie `" "` sono chiamate stringhe `expandable`. Le variabili possono essere trasmesse nelle stringhe espandibili.
```
PS C:\> aws ec2 create-key-pair --key-name "my key pair"
```
Per ulteriori informazioni sull'utilizzo delle virgolette, vedere [Informazioni sulle regole di quotazione](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) in *Microsoft PowerShell Docs*.
------
#### [ Windows command prompt ]
Utilizzo delle virgolette doppie `" "`.
```
C:\> aws ec2 create-key-pair --key-name "my key pair"
```
------
Facoltativamente, è possibile separare il nome del parametro dal valore con un segno di uguale (`=`) invece di uno spazio. In genere è necessario solo se il valore del parametro inizia con un trattino.
```
$ aws ec2 delete-key-pair --key-name=-mykey
```
## Utilizzo delle virgolette all’interno delle stringhe
Le stringhe potrebbero contenere virgolette e la shell potrebbe richiedere le virgolette di escape perché funzionino correttamente. Uno dei tipi di valore di parametro comuni è una stringa JSON. Questa operazione è complessa poiché include spazi e virgolette doppie `" "` attorno al nome e al valore di ogni elemento nella struttura JSON. Il modo in cui si immettono parametri in formato JSON alla riga di comando varia a seconda del sistema operativo.
Per un utilizzo più avanzato del codice JSON su una riga di comando, prendi in considerazione l’utilizzo di un processore JSON a riga di comando, ad esempio `jq`, per creare stringhe JSON. Per ulteriori informazioni su`jq`, consulta il repository [jq](http://stedolan.github.io/jq/) su. *GitHub*
------
#### [ Linux and macOS ]
Affinché Linux e macOS interpretino le stringhe, usa letteralmente le virgolette singole `' '` per racchiudere la struttura dei dati JSON, come nell’esempio seguente. Non è necessario utilizzare caratteri di escape per le virgolette doppie incorporate nella stringa JSON, poiché vengono trattate letteralmente. Poiché il codice JSON è racchiuso tra virgolette singole, sarà necessario eliminare tutte le virgolette singole nella stringa, in genere utilizzando una barra rovesciata prima delle virgolette singole `\'`.
```
$ aws ec2 run-instances \
--image-id ami-12345678 \
--block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]'
```
Per ulteriori informazioni sull’utilizzo delle virgolette, consulta la documentazione per l’utente della shell che preferisci.
------
#### [ PowerShell ]
Utilizzo di virgolette singole `' '` o doppie `" "`.
**Virgolette singole (scelta consigliata)**
Le virgolette singole `' '` sono chiamate stringhe `verbatim`. La stringa viene passata al comando esattamente mentre viene digitata, il che significa che PowerShell le variabili non verranno trasmesse.
Poiché le strutture di dati JSON includono virgolette doppie, suggeriamo di racchiuderle tra virgolette **singole** `' '`. Se si utilizzano virgolette **singole**, non è necessario eseguire l’escape delle virgolette **doppie** incorporate nella stringa JSON. Tuttavia, è necessario eseguire l’escape per ogni **singola** virgoletta inserendo un segno di spunta ``` all’interno della struttura JSON.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]'
```
**Virgolette doppie**
Le virgolette doppie `" "` sono chiamate stringhe `expandable`. Le variabili possono essere trasmesse nelle stringhe espandibili.
Se si utilizzano le virgolette **doppie**, non è necessario eseguire l’escape delle virgolette **singole** incorporate nella stringa JSON. Tuttavia, è necessario eseguire l’escape per ogni **virgoletta doppia** con un segno di spunta ``` all’interno della struttura JSON, come nell’esempio seguente.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings "[{`"DeviceName`":`"/dev/sdb`",`"Ebs`":{`"VolumeSize`":20,`"DeleteOnTermination`":false,`"VolumeType`":`"standard`"}}]"
```
Per ulteriori informazioni sull'utilizzo delle virgolette, vedere [Informazioni sulle regole di quotazione](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) in *Microsoft PowerShell Docs*.
**avvertimento**
Prima di PowerShell inviare un comando a AWS CLI, determina se il comando viene interpretato utilizzando regole tipiche PowerShell o di `CommandLineToArgvW` citazione. Quando PowerShell i processi vengono utilizzati`CommandLineToArgvW`, è necessario escludere i caratteri con una barra `\` rovesciata.
*Per ulteriori informazioni su `CommandLineToArgvW` in PowerShell, vedi [What's up with the strange treatment of virgolette and backslashes di CommandLineToArgv W](https://devblogs.microsoft.com/oldnewthing/20100917-00/?p=12833) in *Microsoft DevBlogs*, [Everyone cita gli argomenti della riga di comando nel modo sbagliato](https://docs.microsoft.com/en-us/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way) nel *Microsoft Docs Blog* e la funzione [CommandLineToArgvW in](https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-commandlinetoargvw#remarks) Microsoft Docs.*
**Virgolette singole**
Le virgolette singole `' '` sono chiamate stringhe `verbatim`. La stringa viene passata al comando esattamente mentre viene digitata, il che significa che PowerShell le variabili non verranno trasmesse. Esegui l’escape dei caratteri con una barra rovesciata `\`.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings '[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]'
```
**Virgolette doppie**
Le virgolette doppie `" "` sono chiamate stringhe `expandable`. Le variabili possono essere trasmesse nelle stringhe `expandable`. Per le stringhe con virgolette doppie è necessario uscire due volte utilizzando *`\$1* per ogni virgoletta invece di usare solo un backtick. Il carattere di apice evita la barra rovesciata, e quindi la barra rovesciata viene utilizzata come carattere di escape per il processo `CommandLineToArgvW`.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings "[{`\"DeviceName`\":`\"/dev/sdb`\",`\"Ebs`\":{`\"VolumeSize`\":20,`\"DeleteOnTermination`\":false,`\"VolumeType`\":`\"standard`\"}}]"
```
**Blobs (scelta consigliata)**
Per aggirare le regole di PowerShell citazione per l'immissione di dati JSON, usa Blobs per passare i dati JSON direttamente a. AWS CLI Per ulteriori informazioni sui Blob, consulta [Blob](cli-usage-parameters-types.md#parameter-type-blob).
------
#### [ Windows command prompt ]
Il prompt dei comandi di Windows richiede le virgolette doppie `" "` per racchiudere la struttura di dati JSON. Inoltre, per impedire al processore di comandi di interpretare erroneamente le virgolette doppie incorporate nel JSON, è necessario anche evitare (inserendo un carattere barra rovesciata `\`) l’uso di virgolette doppie `"` all’interno della struttura dati JSON stessa, come nell’esempio seguente.
```
C:\> aws ec2 run-instances ^
--image-id ami-12345678 ^
--block-device-mappings "[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]"
```
Soltanto le virgolette doppie più esterne non richiedono il carattere di escape.
------
# Caricamento di un parametro da un file nel AWS CLI
Alcuni parametri prevedono nomi di file come argomenti, dai quali vengono AWS CLI caricati i dati. Altri parametri consentono di specificare il valore del parametro come testo digitato sulla riga di comando o letto da un file. Indipendentemente dal fatto che un file sia obbligatorio o facoltativo, è necessario codificarlo correttamente in modo che AWS CLI possano comprenderlo. La codifica del file deve corrispondere alle impostazioni locali predefinite del sistema di lettura. È possibile determinarle usando il metodo Python `locale.getpreferredencoding()`.
Questo metodo serve per caricare un file per un singolo parametro. Per informazioni sul caricamento di più parametri con un singolo file, consulta[AWS CLI scheletri e file di input nel AWS CLI](cli-usage-skeleton.md).
**Nota**
Per impostazione predefinita, Windows PowerShell emette il testo come UTF-16, il che è in conflitto con la codifica UTF-8 utilizzata dai file JSON e da molti sistemi Linux. Si consiglia di utilizzarlo `-Encoding ascii` con i PowerShell `Out-File` comandi per assicurarsi che siano in grado di leggere il file risultante. AWS CLI
**Topics**
+ [Come caricare un parametro da un file](#cli-usage-parameters-file-how)
+ [File binari](#cli-usage-parameters-file-binary)
+ [Caricamento di un file come valore di sintassi abbreviata](#cli-usage-parameters-file-shorthand)
## Come caricare un parametro da un file
In alcuni casi, ad esempio quando il parametro è una stringa JSON complessa, è utile caricare il valore di un parametro da un file anziché provare a digitarlo come valore di parametro della riga di comando. Per specificare un file che contiene il valore, specifica un URL di file nel formato seguente:
```
file://complete/path/to/file
```
+ I primi due caratteri di barra" /" fanno parte della specifica. Se il percorso richiesto inizia con "/", il risultato conterrà tre caratteri di barra: `file:///folder/file`.
+ L'URL fornisce il percorso del file con il contenuto del parametro effettivo.
+ Quando utilizzi dei file con spazi o caratteri speciali, segui le [regole di escape e di utilizzo delle virgolette](cli-usage-parameters-quoting-strings.md) del tuo terminale.
I percorsi di file specificati nei seguenti esempi vengono interpretati come relativi alla directory di lavoro corrente.
------
#### [ Linux or macOS ]
```
// Read from a file in the current directory
$ aws ec2 describe-instances --filters file://filter.json
// Read from a file in /tmp
$ aws ec2 describe-instances --filters file:///tmp/filter.json
// Read from a file with a filename with whitespaces
$ aws ec2 describe-instances --filters 'file://filter content.json'
```
------
#### [ Windows command prompt ]
```
// Read from a file in C:\temp
C:\> aws ec2 describe-instances --filters file://C:\temp\filter.json
// Read from a file with a filename with whitespaces
C:\> aws ec2 describe-instances --filters "file://C:\temp\filter content.json"
```
------
L'opzione del prefisso `file://` supporta le espansioni in stile Unix, tra cui "`~/`", "`./`" e "`../`". In Windows l'espressione "`~/`" si espande alla directory utente, archiviata nella variabile di ambiente `%USERPROFILE%`. Ad esempio, in Windows 10 in genere è presente una directory utente in `%USERPROFILE%`.
Nei documenti JSON incorporati come valore di un altro documento JSON deve essere comunque inserito il carattere di escape.
```
$ aws sqs create-queue --queue-name my-queue --attributes file://attributes.json
```
**attributes.json**
```
{
"RedrivePolicy": "{\"deadLetterTargetArn\":\"arn:aws:sqs:us-west-2:0123456789012:deadletter\", \"maxReceiveCount\":\"5\"}"
}
```
## File binari
Per i comandi che richiedono dati binari come parametro, è necessario specificare che i dati sono contenuto binario mediante il prefisso `fileb://`. I comandi che accettano i dati binari includono:
+ Parametro `--user-data` **`aws ec2 run-instances:`**.
+ Parametro `--sse-customer-key` **`aws s3api put-object:`**.
+ Parametro `--ciphertext-blob` **`aws kms decrypt:`**.
Nell’esempio seguente viene generata una chiave AES binaria da 256 bit mediante uno strumento a riga di comando Linux che vien poi fornita ad Amazon S3 per crittografare un file caricato sul lato server.
```
$ dd if=/dev/urandom bs=1 count=32 > sse.key
32+0 records in
32+0 records out
32 bytes (32 B) copied, 0.000164441 s, 195 kB/s
$ aws s3api put-object \
--bucket amzn-s3-demo-bucket \
--key test.txt \
--body test.txt \
--sse-customer-key fileb://sse.key \
--sse-customer-algorithm AES256
{
"SSECustomerKeyMD5": "iVg8oWa8sy714+FjtesrJg==",
"SSECustomerAlgorithm": "AES256",
"ETag": "\"a6118e84b76cf98bf04bbe14b6045c6c\""
}
```
Per un altro esempio che fa riferimento a un file contenente parametri in formato JSON più complessi, consulta [Collegamento di una policy IAM gestita a un utente](cli-services-iam.md#cli-services-iam-policy).
## Caricamento di un file come valore di sintassi abbreviata
Quando si utilizza una sintassi abbreviata in cui un valore è grande o complesso, è spesso più semplice caricarlo in un file come valore. Per caricare un file come valore di sintassi abbreviata, la formattazione cambierà leggermente. Invece di `key=value`, utilizzerai l’operatore `@=` al posto dell’operatore `=`. `@=` significa per la AWS CLI che il valore deve essere letto come un percorso di file e non come una stringa. L’esempio seguente mostra una coppia chiave-valore che carica un file per il relativo valore.
------
#### [ Linux or macOS ]
```
--option key@=file://template.txt
```
------
#### [ Windows ]
```
--option "key1@=file://template.txt"
```
------
L’esempio seguente mostra il caricamento di un file di certificato per il comando `aws rolesanywhere create-trust-anchor`.
```
$ aws rolesanywhere create-trust-anchor --name TrustAnchor \
--source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \
--enabled
```
Per ulteriori informazioni sulla sintassi abbreviata, consulta [Utilizzo della sintassi abbreviata in AWS CLI](cli-usage-shorthand.md).
# AWS CLI scheletri e file di input nel AWS CLI
La maggior parte dei AWS CLI comandi accetta l'importazione di input di parametri da un file. Questi modelli possono essere generati utilizzando l’opzione `generate-cli-skeleton` e quindi importati utilizzando i parametri `--cli-input-json` e `--cli-input-yaml`.
**Topics**
+ [Informazioni sugli AWS CLI scheletri e sui file di input](#cli-usage-skeleton-about)
+ [Generazione e importazione di uno skeleton di comandi](#cli-usage-skeleton-generate)
+ [Combinazione di file di input e parametri della riga di comando](#cli-usage-skeleton-combine)
## Informazioni sugli AWS CLI scheletri e sui file di input
La maggior parte dei comandi AWS Command Line Interface (AWS CLI) supporta la possibilità di accettare input di parametri da un file utilizzando il `--cli-input-yaml` parametro `--cli-input-json` and s.
Questi stessi comandi utilizzano il parametro `--generate-cli-skeleton` per generare un file in formato JSON o YAML con tutti i parametri che può essere modificato e compilato. Quindi puoi eseguire il comando con il parametro `--cli-input-json` o `--cli-input-yaml` e scegliere il file compilato.
**Importante**
AWS CLI I comandi personalizzati, ad esempio i [command](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html), non supportano né i `--cli-input-yaml` parametri `--generate-cli-skeleton` or `--cli-input-json` né quelli descritti in questo argomento. Per verificare se un comando specifico supporta questi parametri, esegui il [`help`comando relativo al comando](cli-usage-help.md#cli-usage-help-command) che desideri utilizzare o consulta la guida di riferimento per la per la [AWS CLI versione 2](https://docs.aws.amazon.com/cli/latest/reference/index.html).
Il comando `--generate-cli-skeleton` genera e visualizza un modello di parametri che è possibile personalizzare e utilizzare come input per un comando. Il modello generato include tutti i parametri supportati dal comando.
Il parametro `--generate-cli-skeleton` accetta uno dei seguenti valori:
+ `input` - Il modello generato include tutti i parametri di input formattati come JSON. Si tratta del valore di default.
+ `yaml-input` - Il modello generato include tutti i parametri di input formattati come YAML.
+ `output` - Il modello generato include tutti i parametri di output formattati come JSON. Al momento non è possibile richiedere i parametri di output come YAML.
Poiché AWS CLI è essenzialmente un «wrapper» attorno all'API del servizio, il file skeleton si aspetta che tu faccia riferimento a tutti i parametri tramite i nomi dei parametri API sottostanti. Probabilmente è diverso dal nome del parametro. AWS CLI Ad esempio, un AWS CLI parametro denominato `user-name` potrebbe essere mappato al parametro API del AWS servizio denominato `UserName` (notate le maiuscole alterate e il trattino mancante). Ti consigliamo di utilizzare l'opzione `--generate-cli-skeleton` per generare il modello con i nomi di parametro "corretti" per evitare errori. Puoi fare riferimento alla Guida di riferimento delle API per il servizio per visualizzare i nomi dei parametri previsti. Puoi eliminare dal modello tutti i parametri che non sono obbligatori e per i quali non desideri fornire un valore.
Ad esempio, se esegui questo comando, viene generato il modello di parametri per il comando **run-instances** di Amazon Elastic Compute Cloud (Amazon EC2).
------
#### [ JSON ]
Nell'esempio seguente viene illustrato come generare un modello formattato in JSON utilizzando il valore predefinito (`input`) per il parametro `--generate-cli-skeleton`.
```
$ aws ec2 run-instances --generate-cli-skeleton
```
```
{
"DryRun": true,
"ImageId": "",
"MinCount": 0,
"MaxCount": 0,
"KeyName": "",
"SecurityGroups": [
""
],
"SecurityGroupIds": [
""
],
"UserData": "",
"InstanceType": "",
"Placement": {
"AvailabilityZone": "",
"GroupName": "",
"Tenancy": ""
},
"KernelId": "",
"RamdiskId": "",
"BlockDeviceMappings": [
{
"VirtualName": "",
"DeviceName": "",
"Ebs": {
"SnapshotId": "",
"VolumeSize": 0,
"DeleteOnTermination": true,
"VolumeType": "",
"Iops": 0,
"Encrypted": true
},
"NoDevice": ""
}
],
"Monitoring": {
"Enabled": true
},
"SubnetId": "",
"DisableApiTermination": true,
"InstanceInitiatedShutdownBehavior": "",
"PrivateIpAddress": "",
"ClientToken": "",
"AdditionalInfo": "",
"NetworkInterfaces": [
{
"NetworkInterfaceId": "",
"DeviceIndex": 0,
"SubnetId": "",
"Description": "",
"PrivateIpAddress": "",
"Groups": [
""
],
"DeleteOnTermination": true,
"PrivateIpAddresses": [
{
"PrivateIpAddress": "",
"Primary": true
}
],
"SecondaryPrivateIpAddressCount": 0,
"AssociatePublicIpAddress": true
}
],
"IamInstanceProfile": {
"Arn": "",
"Name": ""
},
"EbsOptimized": true
}
```
------
#### [ YAML ]
Nell'esempio seguente viene illustrato come generare un modello formattato in YAML utilizzando il valore `yaml-input` per il parametro `--generate-cli-skeleton`.
```
$ aws ec2 run-instances --generate-cli-skeleton yaml-input
```
```
BlockDeviceMappings: # The block device mapping entries.
- DeviceName: '' # The device name (for example, /dev/sdh or xvdh).
VirtualName: '' # The virtual device name (ephemeralN).
Ebs: # Parameters used to automatically set up Amazon EBS volumes when the instance is launched.
DeleteOnTermination: true # Indicates whether the EBS volume is deleted on instance termination.
Iops: 0 # The number of I/O operations per second (IOPS) that the volume supports.
SnapshotId: '' # The ID of the snapshot.
VolumeSize: 0 # The size of the volume, in GiB.
VolumeType: st1 # The volume type. Valid values are: standard, io1, gp2, sc1, st1.
Encrypted: true # Indicates whether the encryption state of an EBS volume is changed while being restored from a backing snapshot.
KmsKeyId: '' # Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed KMS key under which the EBS volume is encrypted.
NoDevice: '' # Suppresses the specified device included in the block device mapping of the AMI.
ImageId: '' # The ID of the AMI.
InstanceType: c4.4xlarge # The instance type. Valid values are: t1.micro, t2.nano, t2.micro, t2.small, t2.medium, t2.large, t2.xlarge, t2.2xlarge, t3.nano, t3.micro, t3.small, t3.medium, t3.large, t3.xlarge, t3.2xlarge, t3a.nano, t3a.micro, t3a.small, t3a.medium, t3a.large, t3a.xlarge, t3a.2xlarge, m1.small, m1.medium, m1.large, m1.xlarge, m3.medium, m3.large, m3.xlarge, m3.2xlarge, m4.large, m4.xlarge, m4.2xlarge, m4.4xlarge, m4.10xlarge, m4.16xlarge, m2.xlarge, m2.2xlarge, m2.4xlarge, cr1.8xlarge, r3.large, r3.xlarge, r3.2xlarge, r3.4xlarge, r3.8xlarge, r4.large, r4.xlarge, r4.2xlarge, r4.4xlarge, r4.8xlarge, r4.16xlarge, r5.large, r5.xlarge, r5.2xlarge, r5.4xlarge, r5.8xlarge, r5.12xlarge, r5.16xlarge, r5.24xlarge, r5.metal, r5a.large, r5a.xlarge, r5a.2xlarge, r5a.4xlarge, r5a.8xlarge, r5a.12xlarge, r5a.16xlarge, r5a.24xlarge, r5d.large, r5d.xlarge, r5d.2xlarge, r5d.4xlarge, r5d.8xlarge, r5d.12xlarge, r5d.16xlarge, r5d.24xlarge, r5d.metal, r5ad.large, r5ad.xlarge, r5ad.2xlarge, r5ad.4xlarge, r5ad.8xlarge, r5ad.12xlarge, r5ad.16xlarge, r5ad.24xlarge, x1.16xlarge, x1.32xlarge, x1e.xlarge, x1e.2xlarge, x1e.4xlarge, x1e.8xlarge, x1e.16xlarge, x1e.32xlarge, i2.xlarge, i2.2xlarge, i2.4xlarge, i2.8xlarge, i3.large, i3.xlarge, i3.2xlarge, i3.4xlarge, i3.8xlarge, i3.16xlarge, i3.metal, i3en.large, i3en.xlarge, i3en.2xlarge, i3en.3xlarge, i3en.6xlarge, i3en.12xlarge, i3en.24xlarge, i3en.metal, hi1.4xlarge, hs1.8xlarge, c1.medium, c1.xlarge, c3.large, c3.xlarge, c3.2xlarge, c3.4xlarge, c3.8xlarge, c4.large, c4.xlarge, c4.2xlarge, c4.4xlarge, c4.8xlarge, c5.large, c5.xlarge, c5.2xlarge, c5.4xlarge, c5.9xlarge, c5.12xlarge, c5.18xlarge, c5.24xlarge, c5.metal, c5d.large, c5d.xlarge, c5d.2xlarge, c5d.4xlarge, c5d.9xlarge, c5d.18xlarge, c5n.large, c5n.xlarge, c5n.2xlarge, c5n.4xlarge, c5n.9xlarge, c5n.18xlarge, cc1.4xlarge, cc2.8xlarge, g2.2xlarge, g2.8xlarge, g3.4xlarge, g3.8xlarge, g3.16xlarge, g3s.xlarge, g4dn.xlarge, g4dn.2xlarge, g4dn.4xlarge, g4dn.8xlarge, g4dn.12xlarge, g4dn.16xlarge, cg1.4xlarge, p2.xlarge, p2.8xlarge, p2.16xlarge, p3.2xlarge, p3.8xlarge, p3.16xlarge, p3dn.24xlarge, d2.xlarge, d2.2xlarge, d2.4xlarge, d2.8xlarge, f1.2xlarge, f1.4xlarge, f1.16xlarge, m5.large, m5.xlarge, m5.2xlarge, m5.4xlarge, m5.8xlarge, m5.12xlarge, m5.16xlarge, m5.24xlarge, m5.metal, m5a.large, m5a.xlarge, m5a.2xlarge, m5a.4xlarge, m5a.8xlarge, m5a.12xlarge, m5a.16xlarge, m5a.24xlarge, m5d.large, m5d.xlarge, m5d.2xlarge, m5d.4xlarge, m5d.8xlarge, m5d.12xlarge, m5d.16xlarge, m5d.24xlarge, m5d.metal, m5ad.large, m5ad.xlarge, m5ad.2xlarge, m5ad.4xlarge, m5ad.8xlarge, m5ad.12xlarge, m5ad.16xlarge, m5ad.24xlarge, h1.2xlarge, h1.4xlarge, h1.8xlarge, h1.16xlarge, z1d.large, z1d.xlarge, z1d.2xlarge, z1d.3xlarge, z1d.6xlarge, z1d.12xlarge, z1d.metal, u-6tb1.metal, u-9tb1.metal, u-12tb1.metal, u-18tb1.metal, u-24tb1.metal, a1.medium, a1.large, a1.xlarge, a1.2xlarge, a1.4xlarge, a1.metal, m5dn.large, m5dn.xlarge, m5dn.2xlarge, m5dn.4xlarge, m5dn.8xlarge, m5dn.12xlarge, m5dn.16xlarge, m5dn.24xlarge, m5n.large, m5n.xlarge, m5n.2xlarge, m5n.4xlarge, m5n.8xlarge, m5n.12xlarge, m5n.16xlarge, m5n.24xlarge, r5dn.large, r5dn.xlarge, r5dn.2xlarge, r5dn.4xlarge, r5dn.8xlarge, r5dn.12xlarge, r5dn.16xlarge, r5dn.24xlarge, r5n.large, r5n.xlarge, r5n.2xlarge, r5n.4xlarge, r5n.8xlarge, r5n.12xlarge, r5n.16xlarge, r5n.24xlarge.
Ipv6AddressCount: 0 # [EC2-VPC] The number of IPv6 addresses to associate with the primary network interface.
Ipv6Addresses: # [EC2-VPC] The IPv6 addresses from the range of the subnet to associate with the primary network interface.
- Ipv6Address: '' # The IPv6 address.
KernelId: '' # The ID of the kernel.
KeyName: '' # The name of the key pair.
MaxCount: 0 # [REQUIRED] The maximum number of instances to launch.
MinCount: 0 # [REQUIRED] The minimum number of instances to launch.
Monitoring: # Specifies whether detailed monitoring is enabled for the instance.
Enabled: true # [REQUIRED] Indicates whether detailed monitoring is enabled.
Placement: # The placement for the instance.
AvailabilityZone: '' # The Availability Zone of the instance.
Affinity: '' # The affinity setting for the instance on the Dedicated Host.
GroupName: '' # The name of the placement group the instance is in.
PartitionNumber: 0 # The number of the partition the instance is in.
HostId: '' # The ID of the Dedicated Host on which the instance resides.
Tenancy: dedicated # The tenancy of the instance (if the instance is running in a VPC). Valid values are: default, dedicated, host.
SpreadDomain: '' # Reserved for future use.
RamdiskId: '' # The ID of the RAM disk to select.
SecurityGroupIds: # The IDs of the security groups.
- ''
SecurityGroups: # [default VPC] The names of the security groups.
- ''
SubnetId: '' # [EC2-VPC] The ID of the subnet to launch the instance into.
UserData: '' # The user data to make available to the instance.
AdditionalInfo: '' # Reserved.
ClientToken: '' # Unique, case-sensitive identifier you provide to ensure the idempotency of the request.
DisableApiTermination: true # If you set this parameter to true, you can't terminate the instance using the Amazon EC2 console, CLI, or API; otherwise, you can.
DryRun: true # Checks whether you have the required permissions for the action, without actually making the request, and provides an error response.
EbsOptimized: true # Indicates whether the instance is optimized for Amazon EBS I/O.
IamInstanceProfile: # The IAM instance profile.
Arn: '' # The Amazon Resource Name (ARN) of the instance profile.
Name: '' # The name of the instance profile.
InstanceInitiatedShutdownBehavior: stop # Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown). Valid values are: stop, terminate.
NetworkInterfaces: # The network interfaces to associate with the instance.
- AssociatePublicIpAddress: true # Indicates whether to assign a public IPv4 address to an instance you launch in a VPC.
DeleteOnTermination: true # If set to true, the interface is deleted when the instance is terminated.
Description: '' # The description of the network interface.
DeviceIndex: 0 # The position of the network interface in the attachment order.
Groups: # The IDs of the security groups for the network interface.
- ''
Ipv6AddressCount: 0 # A number of IPv6 addresses to assign to the network interface.
Ipv6Addresses: # One or more IPv6 addresses to assign to the network interface.
- Ipv6Address: '' # The IPv6 address.
NetworkInterfaceId: '' # The ID of the network interface.
PrivateIpAddress: '' # The private IPv4 address of the network interface.
PrivateIpAddresses: # One or more private IPv4 addresses to assign to the network interface.
- Primary: true # Indicates whether the private IPv4 address is the primary private IPv4 address.
PrivateIpAddress: '' # The private IPv4 addresses.
SecondaryPrivateIpAddressCount: 0 # The number of secondary private IPv4 addresses.
SubnetId: '' # The ID of the subnet associated with the network interface.
InterfaceType: '' # The type of network interface.
PrivateIpAddress: '' # [EC2-VPC] The primary IPv4 address.
ElasticGpuSpecification: # An elastic GPU to associate with the instance.
- Type: '' # [REQUIRED] The type of Elastic Graphics accelerator.
ElasticInferenceAccelerators: # An elastic inference accelerator to associate with the instance.
- Type: '' # [REQUIRED] The type of elastic inference accelerator.
TagSpecifications: # The tags to apply to the resources during launch.
- ResourceType: network-interface # The type of resource to tag. Valid values are: client-vpn-endpoint, customer-gateway, dedicated-host, dhcp-options, elastic-ip, fleet, fpga-image, host-reservation, image, instance, internet-gateway, launch-template, natgateway, network-acl, network-interface, reserved-instances, route-table, security-group, snapshot, spot-instances-request, subnet, traffic-mirror-filter, traffic-mirror-session, traffic-mirror-target, transit-gateway, transit-gateway-attachment, transit-gateway-route-table, volume, vpc, vpc-peering-connection, vpn-connection, vpn-gateway.
Tags: # The tags to apply to the resource.
- Key: '' # The key of the tag.
Value: '' # The value of the tag.
LaunchTemplate: # The launch template to use to launch the instances.
LaunchTemplateId: '' # The ID of the launch template.
LaunchTemplateName: '' # The name of the launch template.
Version: '' # The version number of the launch template.
InstanceMarketOptions: # The market (purchasing) option for the instances.
MarketType: spot # The market type. Valid values are: spot.
SpotOptions: # The options for Spot Instances.
MaxPrice: '' # The maximum hourly price you're willing to pay for the Spot Instances.
SpotInstanceType: one-time # The Spot Instance request type. Valid values are: one-time, persistent.
BlockDurationMinutes: 0 # The required duration for the Spot Instances (also known as Spot blocks), in minutes.
ValidUntil: 1970-01-01 00:00:00 # The end date of the request.
InstanceInterruptionBehavior: terminate # The behavior when a Spot Instance is interrupted. Valid values are: hibernate, stop, terminate.
CreditSpecification: # The credit option for CPU usage of the T2 or T3 instance.
CpuCredits: '' # [REQUIRED] The credit option for CPU usage of a T2 or T3 instance.
CpuOptions: # The CPU options for the instance.
CoreCount: 0 # The number of CPU cores for the instance.
ThreadsPerCore: 0 # The number of threads per CPU core.
CapacityReservationSpecification: # Information about the Capacity Reservation targeting option.
CapacityReservationPreference: none # Indicates the instance's Capacity Reservation preferences. Valid values are: open, none.
CapacityReservationTarget: # Information about the target Capacity Reservation.
CapacityReservationId: '' # The ID of the Capacity Reservation.
HibernationOptions: # Indicates whether an instance is enabled for hibernation.
Configured: true # If you set this parameter to true, your instance is enabled for hibernation.
LicenseSpecifications: # The license configurations.
- LicenseConfigurationArn: '' # The Amazon Resource Name (ARN) of the license configuration.
```
------
## Generazione e importazione di uno skeleton di comandi
**Per generare e utilizzare un file scheletro dei parametri**
1. Eseguire il comando con il parametro `--generate-cli-skeleton` per produrre JSON o YAML e indirizzare l’output a un file per salvarlo.
------
#### [ JSON ]
```
$ aws ec2 run-instances --generate-cli-skeleton input > ec2runinst.json
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --generate-cli-skeleton yaml-input > ec2runinst.yaml
```
------
1. Apri il file scheletro dei parametri nell'editor di testo e rimuovi qualsiasi parametro non necessario. Ad esempio, è possibile eliminare il modello fino al seguente. Conferma che il file sia ancora nel formato JSON o YAML valido dopo aver rimosso gli elementi non necessari.
------
#### [ JSON ]
```
{
"DryRun": true,
"ImageId": "",
"KeyName": "",
"SecurityGroups": [
""
],
"InstanceType": "",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: true
ImageId: ''
KeyName: ''
SecurityGroups:
- ''
InstanceType:
Monitoring:
Enabled: true
```
------
In questo esempio, il parametro `DryRun` viene lasciato impostato su `true` per utilizzare la funzionalità di test EC2. Questa funzione consente di testare in modo sicuro il comando senza creare o modificare effettivamente alcuna risorsa.
1. Compila i valori rimanenti con valori appropriati per il tuo scenario. In questo esempio, forniamo il tipo di istanza, il nome della chiave, il gruppo di sicurezza e l'identificatore dell'Amazon Machine Image (AMI) da utilizzare. Questo esempio presuppone l'impostazione predefinita. Regione AWS L’AMI `ami-dfc39aef` è un’immagine a 64 bit Amazon Linux ospitata nella Regione `us-west-2`. Se utilizzi un'altra regione, devi [trovare l'ID AMI corretto da utilizzare](https://aws.amazon.com/amazon-linux-ami/).
------
#### [ JSON ]
```
{
"DryRun": true,
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: true
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
1. Eseguire il comando con i parametri completati passando il file modello completato al parametro `--cli-input-json` o --`cli-input-yaml` utilizzando il prefisso `file://`. AWS CLI Interpreta il percorso in modo che sia relativo alla directory di lavoro corrente. L'esempio seguente AWS CLI cerca il file nella directory di lavoro corrente.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
L’errore in fase di test indica che la formattazione del JSON o YAML è corretta e i valori dei parametri sono validi. Se nell'output vengono segnalati altri problemi, correggerli e ripetere la fase precedente fino a quando non viene visualizzato il messaggio"`Request would have succeeded`".
1. Ora puoi impostare il parametro `DryRun` su `false` per disabilitare il test.
------
#### [ JSON ]
```
{
"DryRun": false,
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: false
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
1. Eseguire il comando, e `run-instances` avvia effettivamente un’istanza Amazon EC2 e visualizza tutte le informazioni generate dal lancio corretto. Il formato dell'output è controllato dal parametro `--output`, separatamente dal formato del modello di parametro di input.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json --output json
```
```
{
"OwnerId": "123456789012",
"ReservationId": "r-d94a2b1",
"Groups": [],
"Instances": [
...
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --output yaml
```
```
OwnerId: '123456789012'
ReservationId: 'r-d94a2b1',
Groups":
- ''
Instances:
...
```
------
## Combinazione di file di input e parametri della riga di comando
Un file di input può essere utilizzato per tutti i parametri o può essere combinato con i parametri specificati in AWS CLI. È possibile utilizzare questa funzionalità per le impostazioni che si riutilizzano frequentemente in un file di input, mantenendo le impostazioni individuali nel comando stesso.
Negli esempi seguenti `aws ec2 run-instances` combinano l’uso di un file di input e di parametri. Forniamo il tipo di istanza, il nome della chiave, il gruppo di sicurezza, l'identificatore dell'Amazon Machine Image (AMI) da utilizzare e assumiamo quello predefinito Regione AWS. L’AMI `ami-dfc39aef` è un’immagine a 64 bit Amazon Linux ospitata nella Regione `us-west-2`. Se utilizzi un'altra regione, devi [trovare l'ID AMI corretto da utilizzare](https://aws.amazon.com/amazon-linux-ami/).
------
#### [ JSON ]
Contenuto del file JSON:
```
{
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
Contenuto del file YAML:
```
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
L’esempio seguente utilizza il file di input in combinazione con il parametro `--dry-run` per eseguire una prova del comando per confermare se si dispone delle autorizzazioni richieste e se il file è stato compilato con valori validi.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json --dry-run
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --dry-run
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
L’esempio seguente utilizza quindi lo stesso file di input, ma con il parametro `--no-dry-run` per eseguire il comando per intero.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json --no-dry-run --output json
```
```
{
"OwnerId": "123456789012",
"ReservationId": "r-d94a2b1",
"Groups": [],
"Instances": [
...
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --no-dry-run --output yaml
```
```
OwnerId: '123456789012'
ReservationId: 'r-d94a2b1',
Groups":
- ''
Instances:
...
```
------
# Utilizzo della sintassi abbreviata in AWS CLI
Il AWS Command Line Interface (AWS CLI) può accettare molti dei suoi parametri di opzione in formato JSON. Tuttavia, può essere noioso immettere lunghi elenchi o strutture JSON nella riga di comando. Per semplificare questa operazione, supporta AWS CLI anche una sintassi abbreviata che consente una rappresentazione più semplice dei parametri delle opzioni rispetto all'utilizzo del formato JSON completo.
**Topics**
+ [Parametri della struttura con coppie chiave-valore](#shorthand-structure-parameters)
+ [Caricamento di un file come valore di sintassi abbreviata](#shorthand-files)
+ [Utilizzo della sintassi abbreviata con AWS CLI](#shorthand-list-parameters)
## Parametri della struttura con coppie chiave-valore
La sintassi abbreviata di AWS CLI semplifica l'immissione di parametri piatti (strutture non annidate) da parte degli utenti. Il formato è un elenco separato da virgole di coppie chiave-valore. Assicurati di utilizzare le regole di [citazione](cli-usage-parameters-quoting-strings.md) e di escape appropriate per il tuo terminale poiché la sintassi abbreviata è costituita da stringhe.
------
#### [ Linux or macOS ]
```
--option key1=value1,key2=value2,key3=value3
```
È l’equivalente dell’esempio seguente in formato JSON.
```
--option '{"key1":"value1","key2":"value2","key3":"value3"}'
```
------
#### [ Windows ]
```
--option "key1=value1,key2=value2,key3=value3"
```
È l’equivalente dell’esempio seguente in formato JSON.
```
--option '{"key1":"value1","key2":"value2","key3":"value3"}'
```
------
Le coppie chiave-valore separate da virgole non devono contenere spazi vuoti. Di seguito è riportato un esempio del comando `update-table` di Amazon DynamoDB con l’opzione `--provisioned-throughput` specificata in formato abbreviato.
```
$ aws dynamodb update-table \
--provisioned-throughput ReadCapacityUnits=15,WriteCapacityUnits=10 \
--table-name MyDDBTable
```
È l'equivalente dell'esempio seguente in formato JSON.
```
$ aws dynamodb update-table \
--provisioned-throughput '{"ReadCapacityUnits":15,"WriteCapacityUnits":10}' \
--table-name MyDDBTable
```
## Caricamento di un file come valore di sintassi abbreviata
Quando un valore è grande o complesso, è spesso più facile caricarlo come valore. Per caricare un file come valore di sintassi abbreviata, la formattazione cambierà leggermente. Invece di `key=value`, utilizzerai l’operatore `@=` al posto dell’operatore `=`. `@=`Significa AWS CLI che il valore deve essere letto come un percorso di file e non come una stringa. Quando si caricano dei file in sintassi abbreviata, si applicano le normali [regole di formattazione dei file AWS CLI](cli-usage-parameters-file.md). L’esempio seguente mostra una coppia chiave-valore che carica un file per il relativo valore.
------
#### [ Linux or macOS ]
```
--option key@=file://template.txt
```
------
#### [ Windows ]
```
--option "key1@=file://template.txt"
```
------
L’esempio seguente mostra il caricamento di un file di certificato per il comando `aws rolesanywhere create-trust-anchor`.
```
$ aws rolesanywhere create-trust-anchor --name TrustAnchor \
--source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \
--enabled
```
## Utilizzo della sintassi abbreviata con AWS CLI
Puoi specificare i parametri di input in formato elenco in due modi: JSON o abbreviato. La sintassi abbreviata di AWS CLI è stata progettata per rendere più facile il trasferimento di elenchi di numeri, di stringhe o di strutture non nidificate.
Qui viene mostrato il formato di base,in cui i valori nell'elenco sono separati da un solo spazio.
```
--option value1 value2 value3
```
È l'equivalente dell'esempio seguente in formato JSON.
```
--option '[value1,value2,value3]'
```
Come accennato in precedenza, è possibile specificare un elenco di numeri, un elenco di stringhe o un elenco di strutture non nidificate in forato abbreviato. Di seguito viene riportato un esempio del comando `stop-instances` per Amazon Elastic Compute Cloud (Amazon EC2), dove il parametro di input (elenco di stringhe) per l’opzione `--instance-ids` viene specificato in formato abbreviato.
```
$ aws ec2 stop-instances \
--instance-ids i-1486157a i-1286157c i-ec3a7e87
```
È l'equivalente dell'esempio seguente in formato JSON.
```
$ aws ec2 stop-instances \
--instance-ids '["i-1486157a","i-1286157c","i-ec3a7e87"]'
```
L’esempio successivo mostra il comando `create-tags` di Amazon EC2 che utilizza un elenco di strutture non nidificate per l’opzione `--tags`. L'opzione `--resources` specifica l'ID dell'istanza da contrassegnare.
```
$ aws ec2 create-tags \
--resources i-1286157c \
--tags Key=My1stTag,Value=Value1 Key=My2ndTag,Value=Value2 Key=My3rdTag,Value=Value3
```
È l'equivalente dell'esempio seguente in formato JSON. Il parametro JSON viene scritto su più righe per maggiore leggibilità.
```
$ aws ec2 create-tags \
--resources i-1286157c \
--tags '[
{"Key": "My1stTag", "Value": "Value1"},
{"Key": "My2ndTag", "Value": "Value2"},
{"Key": "My3rdTag", "Value": "Value3"}
]'
```