Come scegliere il formato di output Formato di output JSON Il formato YAML dell'output Formato di output dei flussi YAML Formato di output di testo Formato di output di tabella

Impostazione del formato di output della 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: l’output è formattato come una stringa JSON.
yaml: l’output è formattato come una stringa YAML.
yaml-stream: l’output viene inviato in streaming e formattato come una stringa YAML. Lo streaming consente una gestione più rapida di tipi di dati di grandi dimensioni.
text: 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: l’output è formattato come una tabella utilizzando i caratteri +|- 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, 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 paginato prima dell'applicazione del filtro --query e l'AWS CLI esegue la query una volta in 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. La AWS CLI esegue la query solo una volta sull’intera struttura, producendo un risultato filtrato che viene quindi emesso.

Formato di output JSON

JSON è 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. È possibile combinare l'output JSON con l' opzione --query in modi potenti per filtrare e formattare l'output formattato JSON dell'AWS CLI.

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/.

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 è una buona scelta per gestire l'output a livello di codice con strumenti e servizi che emettono o consumano stringhe formattate YAML, ad esempio CloudFormation, con il supporto per modelli formattati YAML.

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 scaricare yq nel repository yq su GitHub.

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 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.

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 formato text organizza l'output dell'AWS CLI in righe delimitate da tabulazione. Il formato funziona in modo ottimale con gli strumenti di testo Unix tradizionali, ad esempio grep, sed e 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 per garantire un comportamento coerente.

Questo perché il formato di testo ordina alfabeticamente le colonne di output in base al nome della chiave dell'oggetto JSON sottostante restituito dal servizioAWS e risorse simili potrebbero non avere gli stessi nomi di chiavi. 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. Vediamo infine in che modo l'AWS CLI restituisce None come valore per le chiavi non esistenti.


$ 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 gli ID istanza di tutte le istanze in esecuzione nella zona di disponibilità us-west-2a.


$ 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'output text può essere utile anche in PowerShell. Poiché le colonne nell'output text sono delimitate da tabulazioni, è possibile suddividere facilmente l'output in un array utilizzando il delimitatore `t di PowerShell. 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 anche se l'esempio precedente mostra come utilizzare il parametro --query per analizzare gli oggetti JSON sottostanti ed estrarre la colonna desiderata, PowerShell ha la propria capacità di gestire JSON se la compatibilità multipiattaforma non costituisce un problema. Invece di gestire l'output come testo, come richiesto dalla maggior parte delle shell di comando, PowerShell consente di utilizzare il cmdlet ConvertFrom-JSON 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.


$ 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  |
+--------------+--------------+--------------+-----+

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Controllo dell’output dei comandi

Paginazione