

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Einstellung des Ausgabeformats in der AWS CLI
<a name="cli-usage-output-format"></a>

In diesem Thema werden die verschiedenen Ausgabeformate für AWS Command Line Interface (AWS CLI) beschrieben. AWS CLI unterstützt die folgenden Ausgabeformate:
+ **[`json`](#json-output)** –Die Ausgabe erfolgt im [JSON](https://json.org/)-Format.
+  **[`yaml`](#yaml-output)** –Die Ausgabe erfolgt im [YAML](https://yaml.org/)-Format.
+ **[`yaml-stream`](#yaml-stream-output)** – Die Ausgabe erfolgt im [YAML](https://yaml.org/)-Format und wird so auch gestreamt. Streaming ermöglicht eine schnellere Handhabung großer Datentypen.
+ **[`text`](#text-output)** – 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`](#table-output)** – Die Ausgabe erfolgt in Form einer Tabelle mit den Zeichen \$1\$1-, 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.
+ **[`off`](#off-output)**— Die Ausgabe unterdrückt alle Befehlsausgaben an die Standardausgabe. Dies ist nützlich in Automatisierungsskripten und CI/CD Pipelines, bei denen Sie nur den Exit-Code des Befehls überprüfen müssen, ohne die Ausgabe zu verarbeiten.

## Auswählen des Ausgabeformats
<a name="cli-usage-output-format-how"></a>

Wie im Thema [Konfiguration](cli-chap-configure.md) 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 angeben`--output text`, wird die Ausgabe paginiert, *bevor* der `--query` Filter angewendet wird, und die Abfrage wird auf *jeder Seite* der Ausgabe einmal AWS CLI ausgeführt. 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. Der 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
<a name="json-output"></a>

[JSON](https://json.org) 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](cli-usage-filter.md) auf leistungsstarke Weise kombinieren, um die Ausgabe im AWS CLI JSON-Format 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/](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
<a name="yaml-output"></a>

[YAML](https://yaml.org) [ist eine gute Wahl für die programmgesteuerte Verarbeitung der Ausgabe mit Diensten und Tools, die Zeichenketten im YAML-Format ausgeben oder verarbeiten, z. B. aufgrund der Unterstützung für Vorlagen im [YAML-Format](https://yaml.org). CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-formats.html)

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 es im YQ-Repository unter herunterladen. `yq`*GitHub*](https://github.com/mikefarah/yq)

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
<a name="yaml-stream-output"></a>

Das Format `yaml-stream` nutzt das [YAML](https://yaml.org)-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. 

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 es `yq` im [YQ-Repository](https://github.com/mikefarah/yq) unter herunterladen. *GitHub*

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
<a name="text-output"></a>

Das `text` Format organisiert die AWS CLI Ausgabe in tabulatorgetrennten Zeilen. Es funktioniert gut mit herkömmlichen Unix-Textwerkzeugen wie`grep`, `sed``awk`, und und 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-Managementkonsole anmelden.

**Wichtig**  
*Wir empfehlen dringend, dass Sie, wenn Sie eine `text`-Ausgabe angeben, immer die Option [`--query`](cli-usage-filter.md) verwenden, um ein konsistentes Verhalten zu gewährleisten*.   
Das liegt daran, dass das Textformat die Ausgabespalten alphabetisch nach dem Schlüsselnamen des zugrunde liegenden JSON-Objekts sortiert, das vom AWS Dienst zurückgegeben wird, und ähnliche Ressourcen möglicherweise nicht dieselben Schlüsselnamen haben. 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. Beachten Sie schließlich, dass die AWS CLI Ausgaben `None` als Wert für Schlüssel ausgegeben werden, die nicht existieren.  

```
$ 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 diese Ausgabe so, dass nur die Instanz IDs aller laufenden Instances in der `us-west-2a` Availability Zone angezeigt wird.

```
$ 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 nützlich sein in PowerShell. Da die Spalten in der `text` Ausgabe durch Tabulatoren getrennt sind, können Sie die Ausgabe mithilfe des PowerShell Trennzeichens ``t` problemlos in ein Array aufteilen. 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, dass das vorherige Beispiel zwar zeigt, wie der `--query` Parameter verwendet wird, um die zugrunde liegenden JSON-Objekte zu analysieren und die gewünschte Spalte herauszuziehen, aber es PowerShell hat seine eigene Fähigkeit, mit JSON umzugehen, sofern die plattformübergreifende Kompatibilität kein Problem darstellt. Anstatt die Ausgabe als Text zu behandeln, wie es die meisten Befehls-Shells erfordern, PowerShell können Sie das `ConvertFrom-JSON` Cmdlet verwenden, um ein hierarchisch strukturiertes Objekt zu erzeugen. 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
<a name="table-output"></a>

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 [Ausgabe filtern in 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  |
+--------------+--------------+--------------+-----+
```

## Ausgabeformat deaktiviert
<a name="off-output"></a>

Das `off` Format unterdrückt die gesamte Befehlsausgabe an die Standardausgabe. Dies ist in Automatisierungsskripten und CI/CD Pipelines nützlich, bei denen Sie nur den Exit-Code des Befehls überprüfen müssen, ohne die Ausgabe zu verarbeiten. Fehlermeldungen werden weiterhin auf stderr angezeigt.

Das folgende Beispiel zeigt, wie das `off` Format eine erfolgreiche Ausgabe unterdrückt. Sie können den Exit-Code überprüfen, um festzustellen, ob der Vorgang erfolgreich war:

```
$ aws s3api list-buckets --output off
$ echo $?
0
```

Dies ist besonders nützlich in Shell-Skripten, bei denen Sie überprüfen möchten, ob eine Ressource existiert, ohne die Ausgabe zu erfassen:

```
#!/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
```

**Anmerkung**  
Das `off` Format unterdrückt nur stdout. Fehler werden immer noch auf stderr geschrieben.