**Questa documentazione è valida AWS CLI solo per la versione 1.** Abbiamo annunciato l' end-of-supportimminente rilascio della AWS CLI versione 1. Ti consigliamo di migrare alla AWS CLI versione 2. [Per date, dettagli aggiuntivi e informazioni su come effettuare la migrazione, consulta l'annuncio.](https://aws.amazon.com/blogs/developer/cli-v1-maintenance-mode-announcement/) Per la documentazione relativa alla versione 2 di AWS CLI, consulta la [Guida per l'utente della versione 2](https://docs.aws.amazon.com/cli/latest/userguide/). 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à. # 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 Alcuni servizi prevedono l'[impaginazione](cli-usage-pagination.md) lato server per i dati 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) + [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/). + **[`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. ## 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`,, 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" } ] } ``` ## 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 | +--------------+--------------+--------------+-----+ ``` # 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. ## 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 2 della [guida AWS CLI di riferimento](https://docs.aws.amazon.com/cli/v1/reference/). ### 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. # 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/v1/reference/ses/create-receipt-filter.html) e [ce](https://docs.aws.amazon.com/cli/v1/reference/ce/get-cost-and-usage.html). + `--filters` come [ec2](https://docs.aws.amazon.com/cli/v1/reference/ec2/describe-volumes.html), [autoscaling](https://docs.aws.amazon.com/cli/v1/reference/autoscaling/describe-tags.html) e [rds](https://docs.aws.amazon.com/cli/v1/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/v1/reference/dynamodb/scan.html](https://docs.aws.amazon.com/cli/v1/reference/dynamodb/scan.html). [https://docs.aws.amazon.com/cli/v1/reference/](https://docs.aws.amazon.com/cli/v1/reference/) ## 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`,, 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** ``` [].{