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à.
# Utilizzo di AWS CLI
Questa sezione fornisce una panoramica completa dell’uso generale, delle funzionalità comuni e delle opzioni disponibili in AWS Command Line Interface (AWS CLI), oltre ai dettagli trattati nella sezione Configurazione di [Utilizzo degli endpoint in AWS CLI](cli-configure-endpoints.md).
Questa guida approfondisce gli aspetti fondamentali della scrittura dei comandi della AWS CLI, incluse la struttura di base, la formattazione e le funzionalità di filtraggio. A partire da questi elementi fondamentali, è possibile creare comandi che indirizzano con precisione le risorse e le azioni necessarie, senza bisogno di navigare su complesse console basate sul web.
Inoltre, questo evidenzia il contenuto della guida e la documentazione disponibili per AWS CLI. Dalla guida della riga di comando integrata alla [AWS CLI version 2 reference guide](https://docs.aws.amazon.com/cli/latest/reference/) completa, avrai accesso alle informazioni per aiutarti a esplorare le caratteristiche e le funzionalità della AWS CLI.
Per esempi e casi d’uso specifici della Servizio AWS, consulta [Esempio per la AWS CLI](cli-chap-code-examples.md) o la [AWS CLI version 2 reference guide](https://docs.aws.amazon.com/cli/latest/reference/). Questa documentazione fornisce informazioni specifiche sui comandi e mostra degli esempi su come sfruttare la AWS CLI per vari Servizi AWS.
**Nota**
Per impostazione predefinita, la AWS CLI invia le richieste ai Servizi AWS utilizzando l’HTTPS sulla porta TCP 443. Per utilizzare la AWS CLI correttamente, devi essere in grado di eseguire connessioni in uscita su questa porta.
**Topics**
+ [Accesso all'aiuto e alle risorse per AWS CLI](cli-usage-help.md)
+ [Struttura di comando in AWS CLI](cli-usage-commandstructure.md)
+ [Specificare dei valori di parametro nella AWS CLI](cli-usage-parameters.md)
+ [Attivazione e utilizzo dei prompt dei comandi in AWS CLI](cli-usage-parameters-prompting.md)
+ [Controllo dell'output dei comandi in AWS CLI](cli-usage-output.md)
+ [Codici restituiti dalla riga di comando in AWS CLI](cli-usage-returncodes.md)
+ [Utilizzo di procedure guidate personalizzate per eseguire comandi interattivi in AWS CLI](cli-usage-wizard.md)
+ [Creazione e utilizzo di alias in AWS CLI](cli-usage-alias.md)
+ [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md)
# Accesso all'aiuto e alle risorse per AWS CLI
Questo argomento descrive come accedere ai contenuti di aiuto per AWS Command Line Interface (AWS CLI).
**Topics**
+ [Il comando AWS CLI help integrato](#cli-usage-help-command)
+ [AWS CLI guida di riferimento](#cli-reference)
+ [Documentazione API](#api-reference)
+ [Risoluzione degli errori](#help-tshoot)
+ [Aiuto aggiuntivo](#help-additional)
## Il comando AWS CLI help integrato
È possibile ottenere assistenza con qualsiasi comando quando si utilizza il comando AWS Command Line Interface (AWS CLI). Per farlo, basta digitare `help` al termine del nome di un comando.
Ad esempio, il comando seguente mostra la guida per le AWS CLI opzioni generali e i comandi di primo livello disponibili.
```
$ aws help
```
Il comando seguente visualizza i comandi specifici di Amazon Elastic Compute Cloud (Amazon EC2) disponibili.
```
$ aws ec2 help
```
L’esempio seguente visualizza le informazioni dettagliate per l’operazione `DescribeInstances` di Amazon EC2. L'assistenza include le descrizioni dei parametri di input, i filtri disponibili e tutto ciò che è incluso nell'output. Include anche esempi che mostrano come digitare varianti comuni del comando.
```
$ aws ec2 describe-instances help
```
A partire dalla versione `2.31.0` La visualizzazione del comando `help` è configurata dall’impostazione `cli_help_output` e presenta i seguenti valori:
+ **(impostazione predefinita)** `terminal` ‐ Apre la pagina man nel terminale.
+ `browser` ‐ Apre la pagina man come file HTML locale nel browser predefinito. Viene stampato un avviso sul terminale quando viene aperto il browser predefinito e un messaggio di errore se AWS CLI non è possibile aprire il browser.
+ `url`‐ Stampa l'URL della Guida AWS CLI di riferimento online per la versione di AWS CLI cui hai installato. Le impostazioni per la paginazione lato client, come la variabile di `AWS_PAGER` ambiente, vengono rispettate.
Il contenuto della Guida per ciascun comando è suddiviso in sei sezioni:
Name
Nome del comando.
```
NAME
describe-instances -
```
Description
Descrizione dell'operazione API richiamata dal comando.
```
DESCRIPTION
Describes one or more of your instances.
If you specify one or more instance IDs, Amazon EC2 returns information
for those instances. If you do not specify instance IDs, Amazon EC2
returns information for all relevant instances. If you specify an
instance ID that is not valid, an error is returned. If you specify an
instance that you do not own, it is not included in the returned
results.
...
```
Riepilogo
Sintassi di base per l'utilizzo del comando e delle relative opzioni. Le opzioni tra parentesi quadre sono facoltative, hanno un valore predefinito oppure hanno un'opzione che può essere utilizzata in alternativa.
```
SYNOPSIS
describe-instances
[--dry-run | --no-dry-run]
[--instance-ids ]
[--filters ]
[--cli-input-json ]
[--starting-token ]
[--page-size ]
[--max-items ]
[--generate-cli-skeleton]
```
Ad esempio, `describe-instances` ha un comportamento predefinito che descrive ***tutte le*** istanze nell'account corrente e nella regione. AWS Puoi specificare, a tua discrezione, un elenco di `instance-ids` per descrivere una o più istanze. `dry-run` è un flag booleano opzionale che non utilizza un valore. Per usare un flag booleano specifica il valore mostrato, in questo caso `--dry-run` o `--no-dry-run`. Anche `--generate-cli-skeleton` non utilizza un valore. Se per l'utilizzo di un'opzione sono previste condizioni, queste sono descritte nella sezione `OPTIONS` o mostrate negli esempi.
Opzioni
Descrizione di ogni singola opzione mostrata nella sinossi.
```
OPTIONS
--dry-run | --no-dry-run (boolean)
Checks whether you have the required permissions for the action,
without actually making the request, and provides an error response.
If you have the required permissions, the error response is DryRun-
Operation . Otherwise, it is UnauthorizedOperation .
--instance-ids (list)
One or more instance IDs.
Default: Describes all your instances.
...
```
Esempi
Esempi che mostrano l'utilizzo del comando e delle relative opzioni. Se non è disponibile alcun esempio per un comando o un caso d'uso di cui hai bisogno, richiedine uno utilizzando il link di feedback in questa pagina o nel riferimento al AWS CLI comando nella pagina di aiuto del comando.
```
EXAMPLES
To describe an Amazon EC2 instance
Command:
aws ec2 describe-instances --instance-ids i-5203422c
To describe all instances with the instance type m1.small
Command:
aws ec2 describe-instances --filters "Name=instance-type,Values=m1.small"
To describe all instances with an Owner tag
Command:
aws ec2 describe-instances --filters "Name=tag-key,Values=Owner"
...
```
Output
Descrizioni di ciascuno dei campi e dei tipi di dati inclusi nella risposta di AWS.
Per `describe-instances`, l'output è un elenco di oggetti prenotazione, ciascuno dei quali contiene diversi campi e oggetti che includono informazioni sulle istanze a essi associate. Queste informazioni provengono dalla [documentazione API per il tipo di dati di prenotazione](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_Reservation.html) utilizzato da Amazon EC2.
```
OUTPUT
Reservations -> (list)
One or more reservations.
(structure)
Describes a reservation.
ReservationId -> (string)
The ID of the reservation.
OwnerId -> (string)
The ID of the AWS account that owns the reservation.
RequesterId -> (string)
The ID of the requester that launched the instances on your
behalf (for example, AWS Management Console or Auto Scaling).
Groups -> (list)
One or more security groups.
(structure)
Describes a security group.
GroupName -> (string)
The name of the security group.
GroupId -> (string)
The ID of the security group.
Instances -> (list)
One or more instances.
(structure)
Describes an instance.
InstanceId -> (string)
The ID of the instance.
ImageId -> (string)
The ID of the AMI used to launch the instance.
State -> (structure)
The current state of the instance.
Code -> (integer)
The low byte represents the state. The high byte
is an opaque internal value and should be ignored.
...
```
Quando AWS CLI esegue il rendering dell'output in JSON, diventa una matrice di oggetti di prenotazione, simile all'esempio seguente.
```
{
"Reservations": [
{
"OwnerId": "012345678901",
"ReservationId": "r-4c58f8a0",
"Groups": [],
"RequesterId": "012345678901",
"Instances": [
{
"Monitoring": {
"State": "disabled"
},
"PublicDnsName": "ec2-52-74-16-12.us-west-2.compute.amazonaws.com",
"State": {
"Code": 16,
"Name": "running"
},
...
```
Ogni oggetto prenotazione contiene campi che descrivono la prenotazione e una serie di oggetti istanza, ognuno con specifici campi (ad esempio, `PublicDnsName`) e oggetti (ad esempio, `State`) che lo descrivono.
**Utenti Windows**
Puoi *eseguire il piping* (\$1) dell'output del comando help su `more` per visualizzare il file della guida una pagina alla volta. Premete la barra spaziatrice o **PgDn**per visualizzare altre parti del documento e **q** per uscire.
```
C:\> aws ec2 describe-instances help | more
```
## AWS CLI guida di riferimento
I file della guida contengono collegamenti che non possono essere visualizzati o esplorati dalla riga di comando. È possibile visualizzare e interagire con questi collegamenti utilizzando la guida di di [riferimento AWS CLI versione 2)](https://docs.aws.amazon.com/cli/latest/reference/index.html). Il riferimento contiene anche il contenuto della guida per tutti AWS CLI i comandi. Le descrizioni sono presentate in modo da semplificare la navigazione e la visualizzazione su dispositivi mobili, tablet o schermi del desktop.
## Documentazione API
Tutti i comandi in AWS CLI corrispondono alle richieste effettuate all'API pubblica di un AWS servizio. Ogni servizio con un’API pubblica include un riferimento API, disponibile nella home page del servizio nel [sito web della documentazione AWS](https://docs.aws.amazon.com/). Il contenuto di un riferimento API varia in base al modo in cui è costruita l'API e al protocollo utilizzato. Di solito, un riferimento API contiene informazioni dettagliate sulle operazioni supportate dall'API, sui dati inviati da e verso il servizio ed su eventuali condizioni di errore riportate dal servizio.
**Sezioni della documentazione API**
+ **Operazioni**: informazioni dettagliate su ogni operazione e sui relativi parametri (inclusi i limiti di lunghezza o di contenuto e i valori predefiniti). Vengono elencati gli errori che possono verificarsi per questa operazione. Ogni operazione corrisponde a un sottocomando in. AWS CLI
+ **Tipi di dati**: informazioni dettagliate sulle strutture che un comando potrebbe richiedere come parametro o restituire in risposta a una richiesta.
+ **Parametri comuni**: informazioni dettagliate sui parametri condivisi da tutte le operazioni per il servizio.
+ **Errori comuni**: informazioni dettagliate sugli errori che possono essere restituiti da qualsiasi operazione del servizio.
Il nome e la disponibilità di ogni sezione possono variare a seconda del servizio.
**Specifico del servizio CLIs**
Alcuni servizi dispongono di una CLI separata che risale a prima della creazione di una CLI singola AWS CLI per funzionare con tutti i servizi. Questi servizi specifici CLIs dispongono di una documentazione separata collegata alla pagina della documentazione del servizio. La documentazione relativa ai servizi specifici CLIs non si applica a. AWS CLI
## Risoluzione degli errori
Per informazioni sulla diagnosi e la correzione degli AWS CLI errori, vedere. [Risoluzione degli errori relativi a AWS CLI](cli-chap-troubleshooting.md)
## Aiuto aggiuntivo
Per ulteriore assistenza con i tuoi AWS CLI problemi, visita la [AWS CLI community](https://github.com/aws/aws-cli/issues) su *GitHub*.
# Struttura di comando in AWS CLI
Questo argomento illustra come è strutturato il comando AWS Command Line Interface (AWS CLI) e come utilizzare i comandi wait.
**Topics**
+ [Struttura di comando](#cli-usage-commandstructure-structure.title)
+ [Comandi wait](#cli-usage-commandstructure-wait)
## Struttura di comando
La AWS CLI utilizza una struttura in più parti nella riga di comando che deve essere specificata in questo ordine:
1. La chiamata di base al programma `aws`.
1. Il *comando* di livello superiore, che in genere corrisponde a un servizio AWS supportato dall'AWS CLI.
1. Il *sottocomando* che specifica l'operazione da eseguire.
1. Le opzioni o i parametri della AWS CLI generali necessari per l’operazione. Possono essere specificati in qualsiasi ordine, purché seguano le prime tre parti. Se un parametro esclusivo viene specificato più volte, si applica solo l'*ultimo valore*.
```
$ aws [options and parameters]
```
I parametri possono utilizzare vari tipi di valori di input, ad esempio numeri, stringhe, elenchi, mappe e strutture JSON. Quanto supportato dipende dal comando e dal sottocomando specificati.
### Esempi
**Amazon S3**
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
```
Per ulteriori informazioni sull’utilizzo dei comandi Amazon S3, consulta [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html) in *AWS CLI Command Reference*.
**AWS CloudFormation**
Il seguente esempio del comando [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-change-set.html) modifica il nome dello stack in *my-change-set*.
```
$ aws cloudformation create-change-set --stack-name my-stack --change-set-name my-change-set
```
Per ulteriori informazioni sui comandi AWS CloudFormation, consulta [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/index.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/index.html) in *AWS CLI Command Reference*.
## Comandi wait
Alcuni servizi AWS dispongono dei comandi `wait`. Qualsiasi comando che utilizza `aws wait` in genere attende il completamento di un comando prima di passare alla fase successiva. Ciò è particolarmente utile per i comandi multiparte o gli script, poiché è possibile utilizzare un comando wait per evitare di passare alle fasi successive se il comando wait ha esito negativo.
La AWS CLI utilizza una struttura in più parti nella riga di comando per il comando `wait` che deve essere specificata in questo ordine:
1. La chiamata di base al programma `aws`.
1. Il *comando* di livello superiore, che in genere corrisponde a un servizio AWS supportato dall'AWS CLI.
1. Il comando `wait`.
1. Il *sottocomando* che specifica l'operazione da eseguire.
1. Le opzioni o i parametri dell'interfaccia a riga di comando necessari per l'operazione. Possono essere specificati in qualsiasi ordine, purché seguano le prime tre parti. Se un parametro esclusivo viene specificato più volte, si applica solo l'*ultimo valore*.
```
$ aws wait [options and parameters]
```
I parametri possono utilizzare vari tipi di valori di input, ad esempio numeri, stringhe, elenchi, mappe e strutture JSON. Quanto supportato dipende dal comando e dal sottocomando specificati.
**Nota**
Non tutti i servizi AWS supportano i comandi `wait`. Consulta la [AWS CLI version 2 reference guide](https://docs.aws.amazon.com/cli/latest/reference/index.html) per verificare se il tuo servizio supporta i comandi `wait`.
### Esempi
**AWS CloudFormation**
I seguenti esempi di comandi [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html) si interrompono e riprendono solo dopo aver confermato che il set di modifiche *my-change-set* nello stack *my-stack* è pronto per l’esecuzione.
```
$ aws cloudformation wait change-set-create-complete --stack-name my-stack --change-set-name my-change-set
```
Per ulteriori informazioni sui comandi AWS CloudFormation `wait`, consulta [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html) in *AWS CLI Command Reference*.
**AWS CodeDeploy**
I seguenti esempi di comando [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html) si mettono in pausa finché l’implementazione *d-A1B2C3111* viene completata correttamente.
```
$ aws deploy wait deployment-successful --deployment-id d-A1B2C3111
```
Per ulteriori informazioni sui comandi AWS CodeDeploy `wait`, consulta [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html) in *AWS CLI Command Reference*.
# 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"}
]'
```
# Attivazione e utilizzo dei prompt dei comandi in AWS CLI
È possibile fare in modo che la AWS CLI versione 2 richieda comandi, parametri e risorse quando si esegue un comando. `aws`
**Topics**
+ [Come funziona](#cli-usage-auto-prompt-about)
+ [Funzionalità di prompt automatico](#cli-usage-auto-prompt-features)
+ [Modalità di prompt automatico](#cli-usage-auto-prompt-modes)
+ [Configurare il prompt automatico](#cli-usage-auto-prompt-configure)
## Come funziona
Se abilitato, il prompt automatico consente di utilizzare il tasto **INVIO** per completare un comando immesso parzialmente. Dopo aver premuto il tasto **INVIO**, vengono suggeriti comandi, parametri e risorse in base a ciò che si continua a digitare. I suggerimenti elencano il nome del comando, del parametro o della risorsa a sinistra e una descrizione a destra. Per selezionare e utilizzare un suggerimento, utilizza i tasti freccia per evidenziare una riga, quindi premi il tasto **SPAZIO**. Dopo aver immesso il comando, premi **INVIO** per utilizzare il comando. L’esempio seguente mostra l’aspetto di un elenco suggerito dal prompt automatico.
```
$ aws
> aws a
accessanalyzer Access Analyzer
acm AWS Certificate Manager
acm-pca AWS Certificate Manager Private Certificate Authority
alexaforbusiness Alexa For Business
amplify AWS Amplify
```
## Funzionalità di prompt automatico
Il prompt automatico contiene le seguenti utili funzionalità:
**Pannello della documentazione**
Fornisce la documentazione di aiuto per il comando corrente. Per aprire la documentazione, premi il tasto **F3**.
**Completamento dei comandi**
Suggerisce i comandi `aws` da utilizzare. Per visualizzare un elenco, inserisci parzialmente il comando. L’esempio seguente è la ricerca di un servizio che inizia con la lettera `a`.
```
$ aws
> aws a
accessanalyzer Access Analyzer
acm AWS Certificate Manager
acm-pca AWS Certificate Manager Private Certificate Authority
alexaforbusiness Alexa For Business
amplify AWS Amplify
```
**Completamento dei parametri**
Dopo aver digitato un comando, il prompt automatico inizia a suggerire i parametri. Le descrizioni dei parametri includono il tipo di valore e una descrizione del parametro. I parametri obbligatori vengono elencati per primi e sono etichettati come obbligatori. L’esempio seguente mostra l’elenco di parametri con prompt automatico per `aws dynamodb describe-table`.
```
$ aws dynamodb describe-table
> aws dynamodb describe-table
--table-name (required) [string] The name of the table to describe.
--cli-input-json [string] Reads arguments from the JSON string provided. The JSON string follows the format provide...
--cli-input-yaml [string] Reads arguments from the YAML string provided. The YAML string follows the format provide...
--generate-cli-skeleton [string] Prints a JSON skeleton to standard output without sending an API request. If provided wit...
```
**Completamento delle risorse**
Il prompt automatico effettua chiamate API AWS utilizzando le proprietà delle risorse AWS disponibili per suggerire i valori delle risorse. Ciò consente al prompt automatico di suggerire possibili risorse di tua proprietà quando inserisci i parametri. Nell’esempio seguente, il prompt automatico elenca i nomi delle tabelle durante la compilazione del parametro `--table-name` per il comando `aws dynamodb describe-table`.
```
$ aws dynamodb describe-table
> aws dynamodb describe-table --table-name
Table1
Table2
Table3
```
**Completamento abbreviato**
Per i parametri che utilizzano una sintassi abbreviata, il prompt automatico suggerisce i valori da utilizzare. Nell’esempio seguente, il prompt automatico elenca i valori di sintassi abbreviata per il parametro `--placement` nel comando `aws ec2 run-instances`.
```
$ aws ec2 run-instances
> aws ec2 run-instances --placement
AvailabilityZone= [string] The Availability Zone of the instance. If not specified, an Availability Zone wil...
Affinity= [string] The affinity setting for the instance on the Dedicated Host. This parameter is no...
GroupName= [string] The name of the placement group the instance is in.
PartitionNumber= [integer] The number of the partition the instance is in. Valid only if the placement grou...
```
**Completamento del file**
Durante la compilazione dei parametri nei comandi `aws`, il completamento automatico suggerisce i nomi di file locali dopo aver usato il prefisso `file://` o `fileb://`. Nell’esempio seguente, il prompt automatico suggerisce i file locali dopo aver immesso `--item file://` per il comando `aws ec2 run-instances`.
```
$ aws ec2 run-instances
> aws ec2 run-instances --item file://
item1.txt
file1.json
file2.json
```
**Completamento della Regione**
Quando si utilizza il parametro globale `--region`, il prompt automatico elenca le possibili Regioni tra cui scegliere. Nell’esempio seguente, il prompt automatico suggerisce le Regioni in ordine alfabetico dopo aver immesso `--region` per il comando `aws dynamodb list-tables`.
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --region
af-south-1
ap-east-1
ap-northeast-1
ap-northeast-2
```
**Completamento del profilo**
Quando si utilizza il parametro globale `--profile`, il prompt automatico elenca i profili. Nell’esempio seguente, il prompt automatico suggerisce i profili dopo aver immesso `--profile` per il comando `aws dynamodb list-tables`.
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --profile
profile1
profile2
profile3
```
**Ricerche fuzzy**
Comandi e valori completi che contengono un set di caratteri specifico. Nell’esempio seguente, il prompt automatico suggerisce le Regioni che contengono `eu` dopo aver immesso `--region eu` per il comando `aws dynamodb list-tables`.
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --region west
eu-west-1
eu-west-2
eu-west-3
us-west-1
```
**Cronologia**
Per visualizzare ed eseguire i comandi utilizzati in precedenza in modalità prompt automatico, premere **CTRL \$1 R**. La cronologia elenca i comandi precedenti che è possibile selezionare utilizzando i tasti freccia. Nell’esempio seguente, viene visualizzata la cronologia della modalità di prompt automatico.
```
$ aws
> aws
dynamodb list-tables
s3 ls
```
## Modalità di prompt automatico
Il prompt automatico per la AWS CLI versione 2 dispone di 2 modalità che possono essere configurate:
+ **Modalità completa:** utilizza il prompt automatico ogni volta che tenti di eseguire un comando `aws`, sia che lo si richiami manualmente utilizzando il parametro `--cli-auto-prompt` sia che venga abilitato in modo permanente. Include il dover premere **INVIO** dopo un comando completo o incompleto.
+ **Modalità parziale:** utilizza il prompt automatico se un comando è incompleto o non può essere eseguito a causa di errori di convalida lato client. Questa modalità è particolarmente utile se sono disponibili script e runbook preesistenti o per ricevere un prompt automatico solo per i comandi che non si conoscono piuttosto che per ogni comando.
## Configurare il prompt automatico
Per configurare il prompt automatico puoi utilizzare i seguenti metodi in ordine di precedenza:
+ **Opzioni della riga di comando** abilitano o disabilitano il prompt automatico per un singolo comando. Utilizza `--cli-auto-prompt` per chiamare il prompt automatico e `--no-cli-auto-prompt` per disabilitare il prompt automatico.
+ Le **variabili di ambiente** utilizzano la variabile `aws\$1cli\$1auto\$1prompt`.
+ I **file di configurazione condivisi** utilizzano l’impostazione `cli\$1auto\$1prompt`.
# Controllo dell'output dei comandi in AWS CLI
In questa sezione vengono descritti i diversi modi per controllare l’output dall’ AWS Command Line Interface (AWS CLI). La personalizzazione dell' AWS CLI output del terminale può migliorare la leggibilità, semplificare l'automazione degli script e facilitare la navigazione tra set di dati più grandi.
AWS CLI Supporta diversi [formati di output](cli-usage-output-format.md), tra cui, [`json`[`text`](cli-usage-output-format.md#text-output)](cli-usage-output-format.md#json-output), [`yaml`](cli-usage-output-format.md#yaml-output)e. [`off`[`table`](cli-usage-output-format.md#table-output)](cli-usage-output-format.md#off-output) Alcuni servizi prevedono l'[impaginazione](cli-usage-pagination.md) lato server per i dati e AWS CLI forniscono le proprie funzionalità lato client per opzioni di impaginazione aggiuntive.
Infine, AWS CLI dispone di filtri sia lato [server che lato client che è possibile utilizzare singolarmente o insieme per filtrare l'output.](cli-usage-filter.md) AWS CLI
**Topics**
+ [Output sensibili](#cli-usage-output-sensitive)
+ [Opzioni di output lato server o lato client](#cli-usage-output-server-client)
+ [Impostazione del formato di output in AWS CLI](cli-usage-output-format.md)
+ [Output di errore strutturato nel AWS CLI](cli-usage-error-format.md)
+ [Utilizzo delle opzioni di impaginazione in AWS CLI](cli-usage-pagination.md)
+ [Uscita di filtraggio nel AWS CLI](cli-usage-filter.md)
## Output sensibili
Alcune operazioni di AWS CLI potrebbero restituire informazioni che potrebbero essere considerate riservate, incluse le informazioni provenienti da variabili di ambiente. L’esposizione di queste informazioni potrebbe rappresentare un rischio per la sicurezza in determinati scenari; ad esempio, le informazioni potrebbero essere incluse nei log di integrazione e implementazione continua (CI/CD). È quindi importante verificare quando includere tali output nei log e sopprimerli quando non sono necessari.
Per ulteriori informazioni sulla protezione dei dati sensibili, consulta [Protezione dei dati nel AWS CLI](data-protection.md).
Prendi in considerazione le seguenti best practice:
+ Prendi in considerazione la possibilità di recuperare a livello di codice i tuoi segreti da un archivio di segreti, ad esempio Gestione dei segreti AWS.
+ Effettua una revisione dei contenuti dei log di compilazione per assicurarti che non contengano informazioni riservate. Prendi in considerazione approcci come il piping `/dev/null` o l'acquisizione dell'output come bash o PowerShell variabile per sopprimere gli output dei comandi.
Quello che segue è un esempio di bash per reindirizzare l’output, ma non gli errori, a `/dev/null`:
```
$ aws s3 ls > /dev/null
```
Per informazioni specifiche sulla soppressione dell’output per il terminale, consulta la documentazione per l’utente del terminale che utilizzi.
+ Prendi in considerazione l’accesso ai tuoi log e definisci l’accesso in modo appropriato per il tuo caso d’uso.
## Opzioni di output lato server o lato client
AWS CLI Dispone di filtri sia lato [server che lato client che puoi usare singolarmente o insieme per filtrare l'output](cli-usage-filter.md). AWS CLI Il filtraggio lato server viene elaborato per primo e restituisce l’output per il filtraggio lato client. Il filtraggio lato server è supportato dall’API del servizio. Il filtraggio lato client è supportato dal client che utilizza il parametro. AWS CLI `--query`
Le opzioni **di output lato server** sono funzionalità supportate direttamente dall'API. Servizio AWS Tutti i dati filtrati o paginati non vengono inviati al client, eventualmente accelerando i tempi di risposta HTTP e migliorando la larghezza di banda per set di dati più grandi.
Le opzioni di output **lato client** sono funzionalità create da AWS CLI. Tutti i dati vengono inviati al client, quindi vengono visualizzati i AWS CLI filtri o le pagine del contenuto. Le operazioni lato client non consentono di risparmiare sulla velocità o sulla larghezza di banda per set di dati più grandi.
Quando le opzioni lato server e lato client vengono utilizzate insieme, le operazioni lato server vengono prima completate e poi inviate al client per le operazioni lato client. In questo modo si sfruttano i potenziali risparmi di velocità e larghezza di banda delle opzioni lato server, utilizzando al contempo le funzionalità aggiuntive della AWS CLI per ottenere l’output desiderato.
# Impostazione del formato di output in AWS CLI
Questo argomento descrive i diversi formati di output per AWS Command Line Interface (AWS CLI). La AWS CLI supporta i seguenti formati di output:
+ **[`json`](#json-output)**: l’output è formattato come una stringa [JSON](https://json.org/).
+ **[`yaml`](#yaml-output)**: l’output è formattato come una stringa [YAML](https://yaml.org/).
+ **[`yaml-stream`](#yaml-stream-output)**: l’output viene inviato in streaming e formattato come una stringa [YAML](https://yaml.org/). Lo streaming consente una gestione più rapida di tipi di dati di grandi dimensioni.
+ **[`text`](#text-output)**: l’output è formattato come più righe di valori di stringa separati da tabulazioni. Questa formattazione può essere utile per passare l’output a un elaboratore di testi, ad esempio `grep`, `sed` o `awk`.
+ **[`table`](#table-output)**: l’output è formattato come una tabella in cui si utilizzano i caratteri \$1\$1- per formare i bordi delle celle. In genere presenta le informazioni in un formato comprensibile molto più semplice da leggere rispetto ad altri, ma non altrettanto utile a livello programmatico.
+ **[`off`](#off-output)**— L'output sopprime tutto l'output dei comandi su stdout. Ciò è utile negli script e nelle CI/CD pipeline di automazione in cui è sufficiente controllare il codice di uscita del comando senza elaborare l'output.
## Come scegliere il formato di output
Come illustrato nell'argomento relativo alla [configurazione](cli-chap-configure.md), puoi specificare il formato di output in tre modi diversi:
+ **Utilizzo dell’opzione `output` in un profilo denominato nel file `config`**: l’esempio seguente imposta il formato di output predefinito su `text`.
```
[default]
output=text
```
+ **Utilizzo della variabile d’ambiente `AWS_DEFAULT_OUTPUT`**: l’output seguente imposta il formato su `table` per i comandi di questa sessione dalla riga di comando fino a quando la variabile viene modificata o la sessione termina. L'utilizzo di questa variabile di ambiente sostituisce il valore impostato nel file `config`.
```
$ export AWS_DEFAULT_OUTPUT="table"
```
+ **Utilizzo dell’opzione `--output` sulla riga di comando**: l’esempio seguente imposta l’output di un solo comando su `json`. L'utilizzo di questa opzione con il comando sostituisce eventuali variabili di ambiente attualmente impostate o il valore nel file `config`.
```
$ aws swf list-domains --registration-status REGISTERED --output json
```
**Importante**
Il tipo di output specificato influenza il funzionamento dell’opzione `--query`.
Se si specifica`--output text`, l'output viene impaginato *prima dell'*applicazione del `--query` filtro e la query AWS CLI viene eseguita una volta su *ogni pagina* dell'output. Per questo motivo, la query include il primo elemento corrispondente in ogni pagina, eventualmente generando un output aggiuntivo inaspettato. È inoltre possibile utilizzare altri strumenti a riga di comando, ad esempio `head` o `tail` per filtrare ulteriormente l’output.
Se si specifica `--output json`, `--output yaml` o `--output yaml-stream`, l’output viene completamente elaborato come una struttura singola nativa prima dell’applicazione del filtro `--query`. AWS CLI Esegue la query solo una volta sull'intera struttura, producendo un risultato filtrato che viene quindi emesso.
## Formato di output JSON
[JSON](https://json.org) è il formato di output predefinito dell' AWS CLI. La maggior parte dei linguaggi di programmazione può decodificare facilmente le stringhe JSON utilizzando funzioni integrate o con librerie disponibili pubblicamente. Puoi combinare l'output JSON con l'[opzione --query](cli-usage-filter.md) in modi efficaci per filtrare e formattare l' AWS CLI output in formato JSON.
Per un filtro più avanzato che potrebbe non essere eseguibile con `--query`, è possibile prendere in considerazione `jq`, un processore JSON a riga di comando. Il tutorial ufficiale è disponibile per il download all'indirizzo [http://stedolan.github.io/jq/](http://stedolan.github.io/jq/).
Di seguito è riportato un esempio di output JSON:
```
$ aws iam list-users --output json
```
```
{
"Users": [
{
"Path": "/",
"UserName": "Admin",
"UserId": "AIDA1111111111EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/Admin",
"CreateDate": "2014-10-16T16:03:09+00:00",
"PasswordLastUsed": "2016-06-03T18:37:29+00:00"
},
{
"Path": "/backup/",
"UserName": "backup-user",
"UserId": "AIDA2222222222EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/backup/backup-user",
"CreateDate": "2019-09-17T19:30:40+00:00"
},
{
"Path": "/",
"UserName": "cli-user",
"UserId": "AIDA3333333333EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/cli-user",
"CreateDate": "2019-09-17T19:11:39+00:00"
}
]
}
```
## Il formato YAML dell'output
[YAML](https://yaml.org) [è una buona scelta per gestire l'output a livello di codice con servizi e strumenti che emettono o utilizzano stringhe in formato YAML, ad esempio con il supporto per i modelli in formato [YAML](https://yaml.org). CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-formats.html)
Per un filtro più avanzato che potrebbe non essere possibile eseguire con `--query`, è possibile prendere in considerazione `yq`, un processore YAML della riga di comando. `yq`Puoi [scaricarlo](https://github.com/mikefarah/yq) nel *GitHub*repository yq su.
Segue un esempio di output YAML.
```
$ aws iam list-users --output yaml
```
```
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
## Formato di output dei flussi YAML
Il formato `yaml-stream` sfrutta il formato [YAML](https://yaml.org) fornendo al contempo una visualizzazione più reattiva/veloce di set di dati di grandi dimensioni mediante lo streaming dei dati. È possibile iniziare a visualizzare e utilizzare i dati YAML prima del download dell’intera query.
Per un filtro più avanzato che potrebbe non essere possibile eseguire con `--query`, è possibile prendere in considerazione `yq`, un processore YAML della riga di comando. Puoi scaricarlo dal `yq` repository [yq su](https://github.com/mikefarah/yq). *GitHub*
Segue un esempio di output `yaml-stream`.
```
$ aws iam list-users --output yaml-stream
```
```
- IsTruncated: false
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
Di seguito è riportato un esempio di output `yaml-stream` combinato con l’utilizzo del parametro `--page-size` per paginare il contenuto YAML in streaming.
```
$ aws iam list-users --output yaml-stream --page-size 2
```
```
- IsTruncated: true
Marker: ab1234cdef5ghi67jk8lmo9p/q012rs3t445uv6789w0x1y2z/345a6b78c9d00/1efgh234ij56klmno78pqrstu90vwxyx
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- IsTruncated: false
Users:
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
## Formato di output di testo
Il `text` formato organizza l' AWS CLI output in righe delimitate da tabulazioni. Funziona bene con gli strumenti di testo Unix tradizionali come`grep`, e `sed``awk`, e con l'elaborazione del testo eseguita da. PowerShell
Il formato di output `text` segue la struttura di base riportata di seguito. Le colonne sono disposte in ordine alfabetico in base ai nomi di chiave corrispondenti dell'oggetto JSON sottostante.
```
IDENTIFIER sorted-column1 sorted-column2
IDENTIFIER2 sorted-column1 sorted-column2
```
Segue un esempio di output `text`. Ogni campo è una scheda separata dalle altre, con una scheda aggiuntiva dove c'è un campo vuoto.
```
$ aws iam list-users --output text
```
```
USERS arn:aws:iam::123456789012:user/Admin 2014-10-16T16:03:09+00:00 2016-06-03T18:37:29+00:00 / AIDA1111111111EXAMPLE Admin
USERS arn:aws:iam::123456789012:user/backup/backup-user 2019-09-17T19:30:40+00:00 /backup/ AIDA2222222222EXAMPLE backup-user
USERS arn:aws:iam::123456789012:user/cli-user 2019-09-17T19:11:39+00:00 / AIDA3333333333EXAMPLE cli-user
```
La quarta colonna è il campo `PasswordLastUsed` ed è vuota per le ultime due voci perché gli utenti non accedono mai alla Console di gestione AWS.
**Importante**
*Se specifichi l'output `text`, ti consigliamo di utilizzare sempre l'opzione [`--query`](cli-usage-filter.md) per garantire un comportamento coerente*.
Questo perché il formato di testo ordina alfabeticamente le colonne di output in base al nome chiave dell'oggetto JSON sottostante restituito dal AWS servizio e risorse simili potrebbero non avere gli stessi nomi di chiave. Ad esempio, una rappresentazione JSON di un’istanza Amazon EC2 basata su Linux potrebbe contenere elementi non presenti nella rappresentazione JSON di un’istanza basata su Windows o viceversa. Inoltre, negli aggiornamenti futuri delle risorse potrebbero essere aggiunti o eliminati elementi chiave-valore che modificano l'ordinamento della colonna. In questa situazione `--query` potenzia la funzionalità dell'output di testo `text` per consentire il controllo completo sul formato dell'output.
Nell'esempio seguente, il comando specifica gli elementi da visualizzare e *definisce l'ordinamento* delle colonne con la notazione elenco `[key1, key2, ...]`. In questo modo gli utenti hanno la certezza che i valori chiave siano visualizzati sempre nella colonna prevista. Infine, notate come gli AWS CLI output `None` siano il valore di chiavi che non esistono.
```
$ aws iam list-users --output text --query 'Users[*].[UserName,Arn,CreateDate,PasswordLastUsed,UserId]'
```
```
Admin arn:aws:iam::123456789012:user/Admin 2014-10-16T16:03:09+00:00 2016-06-03T18:37:29+00:00 AIDA1111111111EXAMPLE
backup-user arn:aws:iam::123456789012:user/backup-user 2019-09-17T19:30:40+00:00 None AIDA2222222222EXAMPLE
cli-user arn:aws:iam::123456789012:user/cli-backup 2019-09-17T19:11:39+00:00 None AIDA3333333333EXAMPLE
```
L'esempio seguente mostra in che modo utilizzare `grep` e `awk` con l'output `text` dal comando `aws ec2 describe-instances`. Il primo comando visualizza la zona di disponibilità, lo stato corrente e l'ID istanza di ogni istanza nell'output `text`. Il secondo comando elabora l'output per visualizzare solo l'istanza IDs di tutte le istanze in esecuzione nella zona di `us-west-2a` disponibilità.
```
$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text
```
```
us-west-2a running i-4b41a37c
us-west-2a stopped i-a071c394
us-west-2b stopped i-97a217a0
us-west-2a running i-3045b007
us-west-2a running i-6fc67758
```
```
$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text | grep us-west-2a | grep running | awk '{print $3}'
```
```
i-4b41a37c
i-3045b007
i-6fc67758
```
L'esempio seguente fa un passo in più e mostra non solo come filtrare l'output, ma anche come utilizzarlo per automatizzare la modifica dei tipi di istanza per ogni istanza arrestata.
```
$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[State.Name, InstanceId]' --output text |
> grep stopped |
> awk '{print $2}' |
> while read line;
> do aws ec2 modify-instance-attribute --instance-id $line --instance-type '{"Value": "m1.medium"}';
> done
```
L'`text`output può essere utile anche in PowerShell. Poiché le colonne in `text` output sono delimitate da tabulazioni, puoi facilmente dividere l'output in un array utilizzando il PowerShell ``t` delimitatore. Il comando seguente mostra il valore della terza colonna (`InstanceId`) se la prima colonna (`AvailabilityZone`) corrisponde alla stringa `us-west-2a`.
```
PS C:\>aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text |
%{if ($_.split("`t")[0] -match "us-west-2a") { $_.split("`t")[2]; } }
```
```
-4b41a37c
i-a071c394
i-3045b007
i-6fc67758
```
Nota che, sebbene l'esempio precedente mostri come utilizzare il `--query` parametro per analizzare gli oggetti JSON sottostanti ed estrarre la colonna desiderata, PowerShell ha la sua capacità di gestire JSON, se la compatibilità multipiattaforma non è un problema. Invece di gestire l'output come testo, come richiede la maggior parte delle shell di comando, consente di utilizzare il PowerShell `ConvertFrom-JSON` cmdlet per produrre un oggetto strutturato gerarchicamente. È quindi possibile accedere direttamente al membro desiderato da tale oggetto.
```
(aws ec2 describe-instances --output json | ConvertFrom-Json).Reservations.Instances.InstanceId
```
**Suggerimento**
Se l'output è di testo e si filtra l'output in un unico campo utilizzando il parametro `--query`, l'output è una singola riga di valori separati da tabulazione. Per ottenere ogni valore su una riga separata, puoi inserire il campo di output tra parentesi, come mostrato negli esempi seguenti:
Output a riga singola, separato da tabulazione:
```
$ aws iam list-groups-for-user --user-name susan --output text --query "Groups[].GroupName"
```
```
HRDepartment Developers SpreadsheetUsers LocalAdmins
```
Ogni valore nella propria riga inserendo `[GroupName]` tra parentesi:
```
$ aws iam list-groups-for-user --user-name susan --output text --query "Groups[].[GroupName]"
```
```
HRDepartment
Developers
SpreadsheetUsers
LocalAdmins
```
## Formato di output di tabella
Il formato `table` produce rappresentazioni leggibili degli output complessi di AWS CLI in formato tabulare.
```
$ aws iam list-users --output table
```
```
-----------------------------------------------------------------------------------------------------------------------------------------------------------------
| ListUsers |
+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
|| Users ||
|+----------------------------------------------------+---------------------------+---------------------------+----------+-----------------------+-------------+|
|| Arn | CreateDate | PasswordLastUsed | Path | UserId | UserName ||
|+----------------------------------------------------+---------------------------+---------------------------+----------+-----------------------+-------------+|
|| arn:aws:iam::123456789012:user/Admin | 2014-10-16T16:03:09+00:00 | 2016-06-03T18:37:29+00:00 | / | AIDA1111111111EXAMPLE | Admin ||
|| arn:aws:iam::123456789012:user/backup/backup-user | 2019-09-17T19:30:40+00:00 | | /backup/ | AIDA2222222222EXAMPLE | backup-user ||
|| arn:aws:iam::123456789012:user/cli-user | 2019-09-17T19:11:39+00:00 | | / | AIDA3333333333EXAMPLE | cli-user ||
+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
Puoi combinare l'opzione `--query` con il formato `table` per visualizzare un set di elementi preselezionati dall'output non elaborato. Osserva le differenze di output nelle notazioni dizionario ed elenco: nel primo esempio, i nomi delle colonne sono in ordine alfabetico, mentre nel secondo esempio le colonne senza nome sono ordinate in base a quanto definito dall'utente. Per ulteriori informazioni sull'opzione `--query`, consulta [Uscita di filtraggio nel AWS CLI](cli-usage-filter.md).
```
$ aws ec2 describe-volumes --query 'Volumes[*].{ID:VolumeId,InstanceId:Attachments[0].InstanceId,AZ:AvailabilityZone,Size:Size}' --output table
```
```
------------------------------------------------------
| DescribeVolumes |
+------------+----------------+--------------+-------+
| AZ | ID | InstanceId | Size |
+------------+----------------+--------------+-------+
| us-west-2a| vol-e11a5288 | i-a071c394 | 30 |
| us-west-2a| vol-2e410a47 | i-4b41a37c | 8 |
+------------+----------------+--------------+-------+
```
```
$ aws ec2 describe-volumes --query 'Volumes[*].[VolumeId,Attachments[0].InstanceId,AvailabilityZone,Size]' --output table
```
```
----------------------------------------------------
| DescribeVolumes |
+--------------+--------------+--------------+-----+
| vol-e11a5288| i-a071c394 | us-west-2a | 30 |
| vol-2e410a47| i-4b41a37c | us-west-2a | 8 |
+--------------+--------------+--------------+-----+
```
## Formato di output disattivato
Il `off` formato sopprime tutto l'output dei comandi su stdout. Ciò è utile negli script e nelle CI/CD pipeline di automazione in cui è sufficiente controllare il codice di uscita del comando senza elaborare l'output. I messaggi di errore vengono ancora visualizzati su stderr.
L'esempio seguente mostra come il `off` formato sopprime l'output riuscito. È possibile controllare il codice di uscita per determinare l'esito positivo:
```
$ aws s3api list-buckets --output off
$ echo $?
0
```
Ciò è particolarmente utile negli script di shell in cui si desidera verificare l'esistenza di una risorsa senza acquisire l'output:
```
#!/bin/bash
if aws s3api head-bucket --bucket my-bucket --output off 2>/dev/null; then
echo "Bucket exists"
else
echo "Bucket does not exist"
fi
```
**Nota**
Il `off` formato sopprime solo lo stdout. Gli errori vengono ancora scritti su stderr.
# Output di errore strutturato nel AWS CLI
Questo argomento descrive i formati di output di errore strutturati per AWS Command Line Interface (AWS CLI). La CLI scrive errori su stderr e supporta i seguenti formati:
+ **[`enhanced`](#cli-error-format-enhanced)**(impostazione predefinita): messaggio di errore con dettagli aggiuntivi visualizzati in linea. Utilizzare per il debug leggibile dall'uomo.
+ **[`json`](#cli-error-format-json)**[— L'output è formattato come una stringa JSON con tutti i campi di errore.](https://json.org/) Utilizzare per l'automazione e lo scripting.
+ **[`yaml`](#cli-error-format-yaml)**— L'output è formattato come una stringa [YAML](https://yaml.org/) con tutti i campi di errore. Utilizzare per l'automazione e lo scripting.
+ **[`text`](#cli-error-format-text)**— Formatta gli errori utilizzando il formattatore di testo. Utilizzatelo per una scansione visiva rapida.
+ **[`table`](#cli-error-format-table)**— Formatta gli errori utilizzando il formattatore di tabelle. Utilizzare per una scansione visiva rapida.
+ **[`legacy`](#cli-error-format-legacy)**— Formato di errore originale senza dettagli strutturati. Utilizzare per la compatibilità con le versioni precedenti.
## Configurazione del formato di errore
È possibile configurare il formato dell'errore utilizzando uno dei seguenti metodi:
contrassegno della riga di comando
```
$ aws --cli-error-format json
```
File di configurazione () `~/.aws/config`
```
[default]
cli_error_format = json
```
Variabile di ambiente
```
$ export AWS_CLI_ERROR_FORMAT=yaml
```
## Formati di output di errore
Le seguenti sezioni descrivono ogni formato:
### Formato avanzato (impostazione predefinita)
Il formato avanzato visualizza messaggi di errore con dettagli aggiuntivi in linea per valori semplici. Per strutture complesse, il formato suggerisce di utilizzare JSON o YAML.
**Esempio: configurazione della regione mancante**
```
aws: [ERROR]: An error occurred (NoRegion): You must specify a region. You can also configure your region by running "aws configure".
```
**Esempio: funzione Lambda inesistente con campi aggiuntivi**
```
aws: [ERROR]: An error occurred (ResourceNotFoundException) when calling the GetFunction operation: Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345
Additional error details:
Type: User
```
La sezione «Dettagli aggiuntivi sull'errore» mostra solo i campi definiti nel modello di forma dell'errore del servizio. I campi non modellati della risposta all'errore non vengono visualizzati.
**Esempio: campi di errore complessi**
```
An error occurred (TransactionCanceledException) when calling the TransactWriteItems operation: Transaction cancelled, please refer cancellation reasons for specific reasons [ConditionalCheckFailed, None]
Additional error details:
CancellationReasons:
Use "--cli-error-format json" or another error format to see the full details.
```
### Formato JSON
Il formato JSON fornisce una rappresentazione strutturata con tutti i campi di errore.
**Esempio: configurazione della regione mancante**
```
{
"Code": "NoRegion",
"Message": "You must specify a region. You can also configure your region by running \"aws configure\"."
}
```
**Esempio: funzione Lambda inesistente**
```
{
"Code": "ResourceNotFoundException",
"Message": "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345",
"Type": "User"
}
```
### Formato YAML
Il formato YAML fornisce una rappresentazione strutturata con tutti i campi di errore.
**Esempio: configurazione della regione mancante**
```
Code: NoRegion
Message: You must specify a region. You can also configure your region by running "aws configure".
```
**Esempio: funzione Lambda inesistente**
```
Code: ResourceNotFoundException
Message: "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345"
Type: User
```
### Formato testo
Il formato di testo utilizza lo stesso formattatore utilizzato per l'output del comando riuscito.
**Esempio: funzione Lambda inesistente**
```
ResourceNotFoundException Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345 User
```
### Formato della tabella
Il formato della tabella utilizza lo stesso formattatore utilizzato per l'output del comando corretto.
**Esempio: funzione Lambda inesistente**
```
------------------------------------------------------------------------------------------------------------------------------------|
| error |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
| Code | Message | Type |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
| ResourceNotFoundException | Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345 | User |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
```
### Formato precedente
Il formato legacy fornisce il formato di errore originale senza dettagli strutturati. Questo formato non include il prefisso «An error occurred (ErrorCode):» per le eccezioni CLI.
**Esempio: configurazione della regione mancante**
```
aws: [ERROR]: You must specify a region. You can also configure your region by running "aws configure".
```
**Esempio: funzione Lambda inesistente**
```
An error occurred (ResourceNotFoundException) when calling the GetFunction operation: Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345
```
**Nota**
Gli errori ora includono costantemente il `aws: [ERROR]:` prefisso per le eccezioni CLI. Le versioni precedenti non sempre includevano questo prefisso.
Le seguenti eccezioni utilizzano sempre il formato precedente indipendentemente dal formato di errore configurato:
`UnknownArgumentError`— Visualizza le informazioni sull'utilizzo
Interruzioni da tastiera () `KeyboardInterrupt`
## Esempio completo
L'esempio seguente mostra un comando con formattazione di errore JSON:
```
$ aws lambda get-function \
--function-name nonexistent-function-12345 \
--cli-error-format json
```
Output (stderr):
```
{
"Code": "ResourceNotFoundException",
"Message": "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345",
"Type": "User"
}
```
Il `Type` campo è un membro di errore modellato definito nella forma di errore del servizio Lambda. Solo i campi definiti nel modello di errore del servizio sono inclusi nell'output di errore strutturato.
# Utilizzo delle opzioni di impaginazione in AWS CLI
Questo argomento descrive i diversi modi per impaginare l'output di AWS Command Line Interface ()AWS CLI.
Esistono principalmente due modi per controllare la paginazione dalla AWS CLI.
+ [Utilizzo dei parametri di paginazione lato server.](#cli-usage-pagination-serverside)
+ [Utilizzo del programma di paging lato client di output predefinito](#cli-usage-pagination-clientside).
I parametri di paginazione lato server elaborano e qualsiasi output viene inviato alla paginazione lato client.
## Paginazione lato server
Per la maggior parte dei comandi che restituiscono un ampio elenco di elementi, AWS CLI dispone di diverse opzioni lato server per controllare il numero di elementi inclusi nell'output quando AWS CLI chiama l'API di un servizio per compilare l'elenco. L'impaginazione lato server in AWS CLI è abilitata dall'API del AWS servizio, pertanto queste opzioni funzionano solo se l'API del servizio le abilita.
**Topics**
+ [--no-paginate](#cli-usage-pagination-nopaginate)
+ [--page-size](#cli-usage-pagination-pagesize)
+ [--max-items](#cli-usage-pagination-maxitems)
+ [--starting-token](#cli-usage-pagination-startingtoken)
Per impostazione predefinita, AWS CLI utilizza una dimensione di pagina determinata dal singolo servizio e recupera tutti gli elementi disponibili. Ad esempio, Amazon S3 ha una dimensione di pagina predefinita di 1000. Se esegui `aws s3api list-objects` in un bucket che contiene 3500 oggetti, la AWS CLI effettua automaticamente quattro chiamate a Amazon S3, gestendo la logica di paginazione specifica del servizio in background e restituendo tutti i 3500 oggetti nell’output finale.
Per informazioni sull'impaginazione lato server di uno specifico comando, consultate la guida di riferimento [AWS CLI versione](https://docs.aws.amazon.com/cli/latest/reference/index.html) 2 della .
### Come utilizzare il parametro --no-paginate
L’opzione `--no-paginate` disabilita i token di paginazione seguenti sul lato client. Quando si utilizza un comando, per impostazione predefinita effettua AWS CLI automaticamente più chiamate per restituire tutti i risultati possibili per creare l'impaginazione. Una chiamata per ogni pagina. La disattivazione dell'impaginazione comporta l' AWS CLI unica chiamata una volta per la prima pagina dei risultati del comando.
Ad esempio, se esegui `aws s3api list-objects` su un bucket Amazon S3 che contiene 3.500 oggetti, effettua AWS CLI solo la prima chiamata ad Amazon S3, restituendo solo i primi 1.000 oggetti nell'output finale.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--no-paginate
{
"Contents": [
...
```
### Come utilizzare il parametro --page-size
Se vengono rilevati errori quando esegui i comandi dell’elenco per un numero elevato di risorse, le dimensioni di pagina predefinite potrebbero essere eccessive. Ciò può far sì che le chiamate ai AWS servizi superino il tempo massimo consentito e generare un errore di «timeout». È possibile utilizzare l'`--page-size`opzione per specificare che si AWS CLI richiede un numero inferiore di elementi per ogni chiamata al AWS servizio. Continua AWS CLI a recuperare l'elenco completo, ma esegue un numero maggiore di chiamate API di servizio in background e recupera un numero inferiore di elementi a ogni chiamata. In questo modo, le chiamate individuali hanno una migliore possibilità di completamento prima della scadenza. La modifica delle dimensioni della pagina non pregiudica l'output, ma solo il numero di chiamate API che deve essere effettuato per generare l'output.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--page-size 100
{
"Contents": [
...
```
### Come utilizzare il parametro --max-items
Per includere nell' AWS CLI output un numero inferiore di elementi alla volta, utilizzate l'`--max-items`opzione. The AWS CLI still gestisce l'impaginazione con il servizio come descritto in precedenza, ma stampa solo il numero di elementi alla volta specificato.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--max-items 100
{
"NextToken": "eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxfQ==",
"Contents": [
...
```
### Come utilizzare il parametro --starting-token
Se l'output del numero di elementi (`--max-items`) è inferiore rispetto al numero totale di elementi restituito dalle chiamate API sottostanti, l'output include `NextToken`, che può essere trasferito a un comando successivo per recuperare il set di elementi successivo. L'esempio seguente mostra come usare il valore `NextToken` restituito dall'esempio precedente e consente di recuperare il secondo centinaio di elementi.
**Nota**
Il parametro `--starting-token` non può essere null o vuoto. Se il comando precedente non restituisce un valore `NextToken`, non esistono altre voci da restituire e non dovrai richiamare di nuovo il comando.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--max-items 100 \
--starting-token eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxfQ==
{
"Contents": [
...
```
Il AWS servizio specificato potrebbe non restituire gli articoli nello stesso ordine ogni volta che si chiama. Se si specificano valori diversi per `--page-size` e `--max-items`, puoi ottenere risultati imprevisti con elementi mancanti o duplicati. Per evitarlo, utilizza lo stesso numero per `--page-size` e `--max-items` per sincronizzare la paginazione della AWS CLI con quella del servizio sottostante. Puoi anche recuperare l'intero elenco ed eseguire tutte le operazioni di paginazione necessarie in locale.
## Pager lato client
AWS CLI la versione 2 prevede l'uso di un programma pager sul lato client per l'output. Per impostazione predefinita, questa caratteristica restituisce tutto l'output attraverso il programma pager predefinito del sistema operativo.
In ordine di precedenza, puoi specificare il pager di output nei seguenti modi:
+ Utilizzando l’impostazione `cli_pager` nel file `config` nel profilo di `default` o denominato.
+ Utilizzando la variabile di ambiente `AWS_PAGER`.
+ Utilizzando la variabile di ambiente `PAGER`.
In ordine di precedenza, è possibile disabilitare qualsiasi utilizzo di un programma di paging esterno nei seguenti modi:
+ Utilizza l’opzione della riga di comando `--no-cli-pager` per disabilitare il pager per l’utilizzo di un singolo comando.
+ Imposta la configurazione `cli_pager` o la variabile `AWS_PAGER` su una stringa vuota.
**Topics**
+ [cli\$1pager](#cli-usage-pagination-clipager)
+ [AWS\$1PAGER](#cli-usage-pagination-awspager)
+ [--no-cli-pager](#cli-usage-pagination-noclipager)
+ [Flag del pager](#cli-usage-pagination-flags)
### Come utilizzare l’impostazione cli\$1pager
Puoi salvare le impostazioni di configurazione e le credenziali utilizzate di frequente nei file gestiti da AWS CLI. Le impostazioni nel profilo del nome hanno la precedenza sulle impostazioni del profilo di `default`. Per ulteriori informazioni sulle impostazioni di configurazione, consulta [Impostazioni dei file di configurazione e credenziali in AWS CLI](cli-configure-files.md).
L’esempio seguente imposta il pager di output predefinito sul programma `less`.
```
[default]
cli_pager=less
```
L'esempio seguente configura l'impostazione predefinita per disabilitare l'uso di un pager.
```
[default]
cli_pager=
```
### Come impostare la variabile di ambiente AWS\$1PAGER
L’esempio seguente imposta il pager di output predefinito sul programma `less`. Per ulteriori informazioni sulle variabili di ambiente, consulta [Configurazione delle variabili di ambiente per AWS CLI](cli-configure-envvars.md).
------
#### [ Linux and macOS ]
```
$ export AWS_PAGER="less"
```
------
#### [ Windows ]
```
C:\> setx AWS_PAGER "less"
```
------
### Come usare l'no-cli-pager opzione --
Per disabilitare l’uso di un pager su un singolo comando, utilizza l’opzione `--no-cli-pager`. Per ulteriori informazioni, sulle opzioni della riga di comando, consulta [Opzioni della riga di comando in AWS CLI](cli-configure-options.md).
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--no-cli-pager
{
"Contents": [
...
```
### Come utilizzare i flag del pager
È possibile specificare i flag da utilizzare automaticamente con il programma di paging. I flag dipendono dal programma di paging utilizzato. Gli esempi seguenti riguardano le impostazioni predefinite tipiche di `less` e `more`.
------
#### [ Linux and macOS ]
Se non si specifica diversamente, il pager utilizzato per impostazione predefinita dalla AWS CLI versione 2 è`less`. Se la variabile di `LESS` ambiente non è impostata, la AWS CLI versione 2 utilizza i `FRX` flag. È possibile combinare i flag specificandoli durante l'impostazione del cercapersone. AWS CLI
Nell’esempio seguente viene utilizzato il flag `S`. Questo flag si combina quindi con i flag `FRX` predefiniti per creare un flag `FRXS`.
```
$ export AWS_PAGER="less -S"
```
Se non desideri nessuno di questi flag `FRX`, puoi annullarli. L’esempio seguente nega il flag `F` per creare un flag `RX` finale.
```
$ export AWS_PAGER="less -+F"
```
*Per ulteriori informazioni sui flag `less`, consulta [less](http://manpages.org/less/1#options) su manpages.org*.
------
#### [ Windows ]
Se non specificate diversamente, il pager utilizzato per impostazione predefinita dalla AWS CLI versione 2 non prevede flag aggiuntivi`more`.
Nell’esempio seguente viene utilizzato il parametro `/c`.
```
C:\> setx AWS_PAGER "more /c"
```
Per ulteriori informazioni sui flag `more`, consulta `[more](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/more)` su *Microsoft Docs*.
------
# Uscita di filtraggio nel AWS CLI
AWS Command Line Interface (AWS CLI) dispone di filtri sia sul lato server che sul lato client che è possibile utilizzare singolarmente o insieme per filtrare l'output. AWS CLI Il filtraggio lato server viene elaborato per primo e restituisce l’output per il filtraggio lato client.
+ Il filtraggio lato server è supportato dall’API e di solito lo si implementa con un parametro `--filter`. Il servizio restituisce solo risultati corrispondenti che possono velocizzare i tempi di risposta HTTP per set di dati di grandi dimensioni.
+ Il filtraggio lato client è supportato dal client che utilizza il parametro. AWS CLI `--query` Questo parametro ha funzionalità che il filtraggio lato server potrebbe non avere.
**Topics**
+ [Filtro lato server](#cli-usage-filter-server-side)
+ [Filtro lato client](#cli-usage-filter-client-side)
+ [Combinazione di filtri lato server e lato client](#cli-usage-filter-combining)
+ [Risorse aggiuntive](#cli-usage-filter-resources)
## Filtro lato server
Il filtraggio lato server in AWS CLI è fornito dall'API del servizio. AWS Il servizio AWS restituisce solo i record nella risposta HTTP che corrispondono al filtro, il che può velocizzare i tempi di risposta HTTP per set di dati di grandi dimensioni. Poiché il filtraggio lato server è definito dall’API del servizio, i nomi e le funzioni dei parametri variano tra i servizi. Alcuni nomi di parametri comuni utilizzati per il filtraggio sono:
+ `--filter` come [ses](https://docs.aws.amazon.com/cli/latest/reference/ses/create-receipt-filter.html) e [ce](https://docs.aws.amazon.com/cli/latest/reference/ce/get-cost-and-usage.html).
+ `--filters` come [ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-volumes.html), [autoscaling](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/describe-tags.html) e [rds](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html).
+ Nomi che iniziano con la parola `filter`, ad esempio `--filter-expression` per il comando [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/scan.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/scan.html).
## Filtro lato client
AWS CLI Fornisce funzionalità di filtraggio lato client basate su JSON integrate con il parametro. `--query` Il parametro `--query` è uno strumento potente che puoi utilizzare per personalizzare il contenuto e lo stile del tuo output. Il parametro `--query` prende la risposta HTTP che arriva dal server e filtra i risultati prima di visualizzarli. Poiché l’intera risposta HTTP viene inviata al client prima del filtraggio, il filtraggio lato client può essere più lento del filtraggio lato server per set di dati di grandi dimensioni.
L'interrogazione utilizza la [JMESPath sintassi per creare espressioni](https://jmespath.org/) per filtrare l'output. *Per imparare la JMESPath sintassi, consulta il [Tutorial](https://jmespath.org/tutorial.html) sul sito web. JMESPath *
**Importante**
Il tipo di output specificato influenza il funzionamento dell’opzione `--query`:
Se lo specificate`--output text`, l'output viene impaginato *prima dell'*applicazione del `--query` filtro e quindi AWS CLI esegue la query una volta su *ogni pagina* dell'output. Per questo motivo, la query include il primo elemento corrispondente in ogni pagina, eventualmente generando un output aggiuntivo inaspettato. È inoltre possibile utilizzare altri strumenti a riga di comando, ad esempio `head` o `tail` per filtrare ulteriormente l’output.
Se si specifica `--output json`, `--output yaml` o `--output yaml-stream`, l’output viene completamente elaborato come una struttura singola nativa prima dell’applicazione del filtro `--query`. AWS CLI Esegue la query solo una volta sull'intera struttura, producendo un risultato filtrato che viene quindi emesso.
**Topics**
+ [Prima di iniziare](#cli-usage-filter-client-side-output)
+ [Identificatori](#cli-usage-filter-client-side-identifiers)
+ [Selezione da un elenco](#cli-usage-filter-client-side-select-list)
+ [Filtrare i dati nidificati](#cli-usage-filter-client-side-nested)
+ [Appiattimento dei risultati](#cli-usage-filter-client-side-specific-flattening)
+ [Filtro per valori specifici](#cli-usage-filter-client-side-specific-values)
+ [Espressioni con reindirizzamento](#cli-usage-filter-client-side-pipe)
+ [Filtraggio in base a molteplici identificatori](#cli-usage-filter-client-side-miltiselect-list)
+ [Aggiunta di etichette ai valori degli identificatori](#cli-usage-filter-client-side-multiselect-hash)
+ [Funzioni](#cli-usage-filter-client-side-functions)
+ [Esempi avanzati di `--query`](#cli-usage-filter-client-side-advanced)
### Prima di iniziare
**Nota**
Questi esempi di espressioni di filtro sono scritti per shell di base in stile Linux. Quando usi questi esempi, assicurati di utilizzare le regole di quotazione corrette per la shell del terminale. Il modo in cui il terminale interpreta i tuoi input può modificare notevolmente ciò che viene inviato alla AWS CLI. Il modo in cui il terminale legge le virgolette singole `'`, le virgolette doppie `"` o le virgolette inverse ``` può cambiare il modo in cui viene letto il contenuto.
Per ulteriori informazioni, consulta [Utilizzo di virgolette e valori letterali con stringhe in AWS CLI](cli-usage-parameters-quoting-strings.md).
Il seguente output JSON mostra un esempio di ciò che può produrre il parametro `--query`. L’output illustra tre volumi Amazon EBS collegati a istanze Amazon EC2 separate.
#### Output di esempio
```
$ aws ec2 describe-volumes
{
"Volumes": [
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
}
```
### Identificatori
Gli identificatori sono le etichette per i valori di output. Quando crei dei filtri, utilizzi gli identificatori per restringere i risultati delle query. Nel seguente esempio di output, tutti gli identificatori come `Volumes`, `AvailabilityZone` e `AttachTime` sono evidenziati.
```
$ aws ec2 describe-volumes
{
"Volumes": [
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
}
```
*Per ulteriori informazioni, vedere [Identificatori](https://jmespath.org/specification.html#identifiers ) sul sito Web. JMESPath *
### Selezione da un elenco
Un elenco o una matrice è un identificatore seguito da una parentesi quadra “`[`” come `Volumes` e `Attachments` in [Prima di iniziare](#cli-usage-filter-client-side-output).
**Sintassi**
```
[ ]
```
Per filtrare tutto l’output di un array, puoi utilizzare la notazione con caratteri jolly. Le espressioni [con caratteri jolly](http://jmespath.org/specification.html#wildcard-expressions) sono espressioni utilizzate per restituire elementi utilizzando la notazione `*`.
L’esempio seguente esegue una query su tutti i contenuti di `Volumes`.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
```
Per visualizzare un volume specifico nell’array per indice, chiami l’indice dell’array. Ad esempio, il primo elemento dell’array `Volumes` presenta un indice pari a 0, che appare nella query `Volumes[0]`. *Per ulteriori informazioni sugli indici degli array, consultate le [espressioni di indice sul sito Web](http://jmespath.org/specification.html#index-expressions). JMESPath*
```
$ aws ec2 describe-volumes \
--query 'Volumes[0]'
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
}
```
Per visualizzare un intervallo specifico di volumi per indice, utilizza `slice` con la seguente sintassi, dove **start** è l’indice iniziale dell’array, **stop** è l’indice in cui il filtro interrompe l’elaborazione e **step** è l’intervallo di salto.
**Sintassi**
```
[::]
```
Se uno di questi valori viene omesso dall’espressione slice, vengono utilizzati i seguenti valori predefiniti:
+ Start - Il primo indice dell’elenco, 0.
+ Stop - L’ultimo indice dell’elenco.
+ Step - Non viene saltato nessun elemento, il valore è quindi 1.
Per restituire solo i primi due volumi, utilizza un valore di Start pari a 0, un valore di Stop pari a 2 e un valore di Step pari a 1, come illustrato nell’esempio seguente.
```
$ aws ec2 describe-volumes \
--query 'Volumes[0:2:1]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
}
]
```
Poiché questo esempio contiene valori predefiniti, puoi abbreviare il comando slice da `Volumes[0:2:1]` a `Volumes[:2]`.
L’esempio seguente omette i valori predefiniti e restituisce un volume ogni due dell’intero array.
```
$ aws ec2 describe-volumes \
--query 'Volumes[::2]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
```
Inoltre, i passaggi possono utilizzare numeri negativi per filtrare in ordine inverso un array, come mostrato nell’esempio seguente.
```
$ aws ec2 describe-volumes \
--query 'Volumes[::-2]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
}
]
```
*Per ulteriori informazioni, consultate [Slices](https://jmespath.org/specification.html#slices) sul JMESPath sito Web.*
### Filtrare i dati nidificati
Per restringere il filtraggio dei `Volumes[*]` in caso di valori nidificati, utilizza le sottoespressioni aggiungendo un punto e i criteri di filtro.
**Sintassi**
```
.
```
L’esempio seguente visualizza tutte le informazioni `Attachments` per tutti i volumi.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments'
[
[
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
[
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
[
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
]
]
```
Per filtrare ulteriormente i valori nidificati, aggiungi l’espressione per ogni identificatore nidificato. L’esempio seguente elenca gli `State` per tutti i `Volumes`.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[*].State'
[
[
"attached"
],
[
"attached"
],
[
"attached"
]
]
```
### Appiattimento dei risultati
Per ulteriori informazioni, consulta [SubExpressions](https://jmespath.org/specification.html#subexpressions)il *JMESPathsito Web*.
È possibile appiattire i risultati del comando `Volumes[*].Attachments[*].State` rimuovendo la notazione con caratteri jolly risultante dalla query `Volumes[*].Attachments[].State`. L’appiattimento spesso è utile per migliorare la leggibilità dei risultati.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].State'
[
"attached",
"attached",
"attached"
]
```
*Per ulteriori informazioni, vedere [Flatten sul sito](https://jmespath.org/specification.html#flatten) Web. JMESPath *
### Filtro per valori specifici
Per filtrare valori specifici in un elenco, utilizza un’espressione di filtro come illustrato nella sintassi seguente.
**Sintassi**
```
? ]
```
I comparatori di espressioni includono `==`, `!=`, `<`, `<=`, `>` e `>=`. L’esempio seguente filtra i `VolumeIds` per tutti i `Volumes` in un `Attached``State`.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[?State==`attached`].VolumeId'
[
[
"vol-e11a5288"
],
[
"vol-2e410a47"
],
[
"vol-a1b3c7nd"
]
]
```
Questo risultato può quindi essere appiattito, ottenendo l’esempio seguente.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[?State==`attached`].VolumeId[]'
[
"vol-e11a5288",
"vol-2e410a47",
"vol-a1b3c7nd"
]
```
L’esempio seguente filtra i `VolumeIds` di tutti i `Volumes` che hanno una dimensione inferiore a 20.
```
$ aws ec2 describe-volumes \
--query 'Volumes[?Size < `20`].VolumeId'
[
"vol-2e410a47",
"vol-a1b3c7nd"
]
```
*Per ulteriori informazioni, consulta [Filter Expressions](https://jmespath.org/specification.html#filterexpressions) sul JMESPath sito Web.*
### Espressioni con reindirizzamento
È possibile reindirizzare i risultati di un filtro a un nuovo elenco e quindi filtrare il risultato con un’altra espressione utilizzando la sintassi seguente:
**Sintassi**
```
| ]
```
L’esempio seguente prende i risultati del filtro dell’espressione `Volumes[*].Attachments[].InstanceId` e restituisce il primo risultato nell’array.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].InstanceId | [0]'
"i-a071c394"
```
Questo esempio esegue questa operazione creando innanzitutto l’array dalla seguente espressione.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].InstanceId'
"i-a071c394",
"i-4b41a37c",
"i-1jd73kv8"
```
In seguito restituisce il primo elemento di tale array.
```
"i-a071c394"
```
Per ulteriori informazioni, consulta [Pipe Expressions](https://jmespath.org/specification.html#pipe-expressions) sul *JMESPathsito Web*.
### Filtraggio in base a molteplici identificatori
Per filtrare più identificatori, utilizza un elenco a selezione multipla con la seguente sintassi:
**Sintassi**
```
[].[, ]
```
Nell’esempio seguente, `VolumeId` e `VolumeType` vengono filtrati nell’elenco `Volumes` risultante dalla seguente espressione.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType]'
[
[
"vol-e11a5288",
"standard"
],
[
"vol-2e410a47",
"standard"
],
[
"vol-a1b3c7nd",
"standard"
]
]
```
Per aggiungere dati annidati all’elenco, aggiungi un altro elenco a selezione multipla. L’esempio seguente amplia l’esempio precedente filtrando anche per `InstanceId` e `State` nell’elenco nidificato `Attachments`. I risultati sono illustrati di seguito.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType, Attachments[].[InstanceId, State]]'
[
[
"vol-e11a5288",
"standard",
[
[
"i-a071c394",
"attached"
]
]
],
[
"vol-2e410a47",
"standard",
[
[
"i-4b41a37c",
"attached"
]
]
],
[
"vol-a1b3c7nd",
"standard",
[
[
"i-1jd73kv8",
"attached"
]
]
]
]
```
Per renderli più leggibili, appiattisci l’espressione come mostrato nell’esempio seguente.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType, Attachments[].[InstanceId, State][]][]'
[
"vol-e11a5288",
"standard",
[
"i-a071c394",
"attached"
],
"vol-2e410a47",
"standard",
[
"i-4b41a37c",
"attached"
],
"vol-a1b3c7nd",
"standard",
[
"i-1jd73kv8",
"attached"
]
]
```
*Per ulteriori informazioni, consultate l'[elenco Multiselect sul sito Web](https://jmespath.org/specification.html#multiselectlist). JMESPath *
### Aggiunta di etichette ai valori degli identificatori
Per facilitare la lettura di questo output, utilizza un hash a selezione multipla con la seguente sintassi.
**Sintassi**
```
[].{