Come scegliere il formato di output Formato di output JSON Il formato YAML dell'output Formato di output dello stream YAML Formato di output di testo Formato di output di tabella

Imposta il formato AWS CLI di output

Questo argomento descrive i diversi formati di output per AWS Command Line Interface (AWS CLI). AWS CLISupporta i seguenti formati di output:

json— L'output è formattato come stringa JSON.
yaml— L'output è formattato come stringa YAML.
yaml-stream— L'output viene trasmesso in streaming e formattato come 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. Questo può essere utile per passare l'output a un elaboratore di testi, ad esempiogrep, sed o. awk
table— L'output viene formattato come 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'outputopzione in un profilo denominato nel config file: l'esempio seguente imposta il formato di output predefinito su. text
```
[default]
output=text
```
Utilizzo della variabile di AWS_DEFAULT_OUTPUT ambiente: l'output seguente imposta il formato dei comandi in questa sessione della riga di comando fino alla modifica della variabile o al termine della sessione. table L'utilizzo di questa variabile di ambiente sostituisce il valore impostato nel file config.
```
$ export AWS_DEFAULT_OUTPUT="table"
```
Utilizzo dell'--outputopzione sulla riga di comando: l'esempio seguente imposta l'output di questo solo comando sujson. 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 modifica il funzionamento dell'--queryopzione:

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, il che può generare un output aggiuntivo inaspettato. Per filtrare ulteriormente l'output, puoi utilizzare altri strumenti da riga di comando come head otail.
Se si specifica --output json --output yaml, o --output yaml-stream l'output viene completamente elaborato come un'unica struttura nativa prima dell'applicazione del --query filtro. AWS CLIEsegue 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 AWS 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. È possibile effettuare il download 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 dello stream YAML

Il yaml-stream formato 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 scaricarli 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 yaml-stream output associato all'utilizzo del --page-size parametro per impaginare 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. 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 AWS Management Console.

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, la rappresentazione JSON di un'istanza Amazon EC2 basata su Linux potrebbe contenere elementi che non sono 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 può essere utile anche in. text 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 AWS CLI Uscita del filtro.


$ 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

Output del comando di controllo

Paginazione