Auswählen des Ausgabeformats JSON-Ausgabeformat YAML-Ausgabeformat YAML-Stream-Ausgabeformat Textausgabeformat Tabellenausgabeformat

Festlegen des AWS CLI-Ausgabeformats

In diesem Thema werden die verschiedenen Ausgabeformate für AWS Command Line Interface (AWS CLI) enthalten. AWS CLI unterstützt die folgenden Ausgabeformate:

json –Die Ausgabe erfolgt im JSON-Format.
yaml –Die Ausgabe erfolgt im YAML-Format.
yaml-stream – Die Ausgabe erfolgt im YAML-Format und wird so auch gestreamt. Streaming ermöglicht eine schnellere Handhabung großer Datentypen.
text – Die Ausgabe wird als mehrere Zeilen mit tabulatorgetrennten Zeichenfolgenwerten formatiert. Dies kann nützlich sein, um die Ausgabe an einen Textprozessor wie grep, sed oder awk zu übergeben.
table – Die Ausgabe erfolgt in Form einer Tabelle mit den Zeichen +|-, um die Zellenrahmen zu bilden. Normalerweise wird die Information in einem benutzerfreundlichen Format wiedergegeben, das viel einfacher zu lesen ist als die anderen, jedoch programmatisch nicht so nützlich ist.

Auswählen des Ausgabeformats

Wie im Thema Konfiguration erläutert, gibt es drei verschiedene Methoden, das Ausgabeformat anzugeben:

Verwenden der Option output in einem benannten Profil in der config-Datei – Im folgenden Beispiel wird das Standardausgabeformat auf text festgelegt.
```
[default]
output=text
```
Verwenden der Umgebungsvariablen AWS_DEFAULT_OUTPUT – Die folgende Ausgabe legt das Format für die Befehle in dieser Befehlszeilensitzung auf table fest, bis die Variable geändert wird oder die Sitzung endet. Diese Umgebungsvariable überschreibt alle Werte, die in der Datei config festgelegt sind.
```
$ export AWS_DEFAULT_OUTPUT="table"
```
Verwenden der Option --output in der Befehlszeile – Im folgenden Beispiel wird nur die Ausgabe dieses einen Befehls auf json gesetzt. Mit dieser Option für den Befehl werden alle aktuell festgelegten Umgebungsvariablen überschrieben oder der Wert in der Datei config.
```
$ aws swf list-domains --registration-status REGISTERED --output json
```

Wichtig

Der von Ihnen angegebene Ausgabetyp ändert die Funktionsweise der Option --query:

Wenn Sie --output text angeben, wird die Ausgabe paginiert, bevor der --query-Filter angewendet wird, und die AWS CLI führt die Abfrage einmal auf jeder Seite der Ausgabe aus. Aus diesem Grund enthält die Abfrage das erste passende Element auf jeder Seite, was zu unerwarteten zusätzlichen Ausgaben führen kann. Um die Ausgabe zusätzlich zu filtern, können Sie andere Befehlszeilentools wie head oder tail verwenden.
Wenn Sie --output json, --output yaml oder --output yaml-stream angeben, wird die Ausgabe vollständig als einzelne, native Struktur verarbeitet, bevor der --query-Filter angewendet wird. Die AWS CLI führt die Abfrage nur einmal für die gesamte Struktur aus, wodurch ein gefiltertes Ergebnis erzeugt wird, das dann ausgegeben wird.

JSON-Ausgabeformat

JSON ist das Standardausgabeformat der AWS CLI. Die meisten Programmiersprachen können JSON-Zeichenfolgen mit integrierten Funktionen oder öffentlich verfügbaren Bibliotheken problemlos dekodieren. Sie können die JSON-Ausgabe mit der Option --query auf leistungsstarke Weise kombinieren, um die AWS CLI-JSON-formatierte Ausgabe zu filtern und zu formatieren.

Für eine erweiterte Filterung, die Sie möglicherweise mit --query nicht durchführen können, können Sie jq, einen Befehlszeilen-JSON-Prozessor, in Betracht ziehen. Sie können dies unter http://stedolan.github.io/jq/ herunterladen und finden hier auch die offizielle praktische Anleitung.

Nachfolgend finden Sie ein Beispiel für eine JSON-Ausgabe.


$ 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"
        }
    ]
}

YAML-Ausgabeformat

YAML ist eine gute Wahl für die programmgesteuert Behandlung der Ausgabe mit Services und Tools, die YAML-formatierte Zeichenfolgen ausgeben oder verwenden, wie etwa AWS CloudFormation mit seinem Support für YAML-formatierte Vorlagen.

Für eine erweiterte Filterung, die Sie möglicherweise mit --query nicht durchführen können, können Sie yq, einen Befehlszeilen-YAML-Prozessor, in Betracht ziehen. Sie können ihn herunterladen. Die Dokumentation finden Sie unter yq-Repository auf GitHub.

Es folgt ein Beispiel für die YAML-Ausgabe.


$ 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

YAML-Stream-Ausgabeformat

Das Format yaml-stream nutzt das YAML-Format und bietet gleichzeitig eine reaktionsschnellere/schnellere Anzeige großer Datensätze durch das Streamen der Daten an Sie. Sie können YAML-Daten anzeigen und verwenden, bevor die gesamte Abfrage heruntergeladen wird.

Es folgt ein Beispiel für die yaml-stream-Ausgabe.


$ 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

Im Folgenden sehen Sie ein Beispiel für die yaml-stream-Ausgabe in Verbindung mit der Verwendung des --page-size-Parameters zum Paginieren des gestreamten YAML-Inhalts.


$ 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

Textausgabeformat

Das text-Format strukturiert die AWS CLI-Ausgabe in durch Tabstopps getrennte Zeilen. Es funktioniert gut mit traditionellen Unix-Textverarbeitungs-Tools wie grep, sed und awk sowie mit der Textverarbeitung von PowerShell.

Das text-Ausgabeformat entspricht der unten gezeigten grundlegenden Struktur. Die Spalten werden alphabetisch nach dem entsprechenden Schlüsselnamen der zugrunde liegende JSON-Objekte sortiert.


IDENTIFIER  sorted-column1 sorted-column2
IDENTIFIER2 sorted-column1 sorted-column2

Es folgt ein Beispiel für die text-Ausgabe. Jedes Feld ist durch einen Tabulator getrennt von den anderen, mit einem zusätzlichen Tabulator, wenn ein leeres Feld vorhanden ist.


$ 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

Die vierte Spalte ist das PasswordLastUsed-Feld und ist für die letzten beiden Einträge leer, da sich diese Benutzer nie bei der AWS Management Console anmelden.

Wichtig

Wir empfehlen dringend, dass Sie, wenn Sie eine text-Ausgabe angeben, immer die Option --query verwenden, um ein konsistentes Verhalten zu gewährleisten.

Der Grund hierfür ist, dass das Textformat Ausgabespalten alphabetisch nach dem Schlüsselnamen des zugrunde liegenden JSON-Objekts sortiert, das vom AWS-Service zurückgegeben wird. Ähnliche Ressourcen verwenden möglicherweise andere Schlüsselnamen. Beispiel: Die JSON-Darstellung einer Linux-basierten Amazon-EC2-Instance kann ggf. Elemente haben, die in der JSON-Darstellung einer Windows-Instance nicht vorhanden sind, oder umgekehrt. In zukünftigen Aktualisierungen können auch Schlüssel-Wert-Elemente zu Ressourcen hinzugefügt oder aus diesen entfernt werden, wodurch sich die Spaltensortierung ändert. In diesem Fall erweitert --query die Funktionalität der text-Ausgabe, um eine vollständige Kontrolle über das Ausgabeformat zu ermöglichen.

Im folgenden Beispiel gibt der Befehl an, welche Elemente angezeigt werden sollen. definiert die Reihenfolge der Spalten über die Listennotation [key1, key2, ...]. Auf diese Weise können Sie sich vollständig darauf verlassen, dass immer die richtigen Schlüsselwerte in der erwarteten Spalte zu sehen sind. Des Weiteren gibt die AWS CLI als Wert für nicht vorhandene Schlüssel None aus.


$ 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

Das folgende Beispiel zeigt, wie Sie grep und awk mit der text-Ausgabe des Befehls aws ec2 describe-instances verwenden können. Durch den ersten Befehl erhalten Sie die Availability Zone, den aktuellen Status und die Instance-ID der einzelnen Instances als text-Ausgabe angezeigt. Der zweite Befehl verarbeitet die Ausgabe so, dass nur die Instance-IDs der Instances angezeigt werden, die in der Availability Zone us-west-2a ausgeführt werden.


$ 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

Das folgende Beispiel geht noch einen Schritt weiter und zeigt nicht nur, wie Sie die Ausgabe filtern, sondern auch, wie Sie die Ausgabe verwenden, um sich ändernde Instance-Typen für angehaltene Instances zu automatisieren.


$ 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

Die text-Ausgabe kann auch in PowerShell nützlich sein. Da die Spalten in der text-Ausgabe tabulatorgetrennt sind, können Sie die Ausgabe problemlos in ein Array aufteilen, indem Sie das `t-Trennzeichen von PowerShell verwenden. Mit dem folgenden Befehl bekommen Sie den Wert der dritten Spalte (InstanceId) angezeigt, wenn die erste Spalte (AvailabilityZone) mit der Zeichenfolge us-west-2a übereinstimmt.


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

Beachten Sie: Obwohl das vorherige Beispiel zeigt, wie der --query-Parameter verwendet wird, um die zugrunde liegenden JSON-Objekte zu analysieren und die gewünschte Spalte zu extrahieren, verfügt PowerShell über eine eigene Funktion zur Verarbeitung von JSON, wenn plattformübergreifende Kompatibilität nicht gegeben sein muss. Anstatt die Ausgabe als Text zu behandeln, wie für die meisten Befehls-Shells erforderlich, ermöglicht PowerShell die Verwendung des ConvertFrom-JSON-Cmdlets zur Erstellung eines hierarchisch strukturierten Objekts. Sie können dann direkt von diesem Objekt aus auf das gewünschte Element zugreifen.


(aws ec2 describe-instances --output json | ConvertFrom-Json).Reservations.Instances.InstanceId

Tipp

Wenn Sie Text ausgeben und die Ausgabe mithilfe des Parameters --query zu einem einzelnen Feld filtern, besteht die Ausgabe aus einer einzelnen Zeile mit Tabulator-getrennten Werten. Um jeden Wert auf eine separate Zeile zu bekommen, können Sie das Ausgabefeld in Klammern setzen, wie in den folgenden Beispielen gezeigt.

Tabulatorgetrennte, einzeilige Ausgabe:


$ aws iam list-groups-for-user --user-name susan  --output text --query "Groups[].GroupName"


HRDepartment    Developers      SpreadsheetUsers  LocalAdmins

Jeder Wert auf einer eigenen Zeile durch Setzen von [GroupName] in Klammern:


$ aws iam list-groups-for-user --user-name susan  --output text --query "Groups[].[GroupName]"


HRDepartment
Developers
SpreadsheetUsers
LocalAdmins

Tabellenausgabeformat

Das table-Format produziert lesbare Darstellungen der komplexen AWS CLI-Ausgabe in Tabellenform.


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

Sie können die --query-Option mit dem table-Format kombinieren, um eine Gruppe von Elementen zu erhalten, die vorab aus der unformatierten Ausgabe ausgewählt wurden. Beachten Sie die Ausgabeunterschiede in Wörterbuch- und Listennotation: Im ersten Beispiel werden die Spaltennamen alphabetisch sortiert und im zweiten Beispiel werden die unbenannten Spalten nach der Definition des Benutzers geordnet. Weitere Informationen zur Option --query finden Sie unter AWS CLI-Filterausgabe.


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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Steuern der Befehlsausgabe

Paginierung