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 Formato di output disattivato

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: 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 in cui si utilizzano 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.
off— 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, 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 è 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 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/.

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 servizi e strumenti che emettono o utilizzano stringhe in formato YAML, ad esempio con il supporto per i modelli in formato YAML. CloudFormation

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. yqPuoi scaricarlo nel GitHubrepository 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 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. 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 comegrep, e sedawk, 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 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'textoutput 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.


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

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

Formato di output dell'errore