**Diese Dokumentation bezieht sich AWS CLI nur auf Version 1 von.**
Wir haben die end-of-support bevorstehende AWS CLI Version 1 angekündigt. Wir empfehlen Ihnen, auf die AWS CLI Version 2 zu migrieren. Termine, zusätzliche Details und Informationen zur Migration finden Sie in der [Ankündigung](https://aws.amazon.com/blogs/developer/cli-v1-maintenance-mode-announcement/). Dokumentation zu Version 2 von finden Sie im [Benutzerhandbuch für Version 2. AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/)
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.
# Steuerung der Befehlsausgabe in der AWS CLI
In diesem Abschnitt werden die verschiedenen Möglichkeiten beschrieben, die Ausgabe von AWS Command Line Interface (AWS CLI) zu steuern. Durch das Anpassen der AWS CLI Ausgabe in Ihrem Terminal können Sie die Lesbarkeit verbessern, die Skriptautomatisierung optimieren und die Navigation durch größere Datensätze vereinfachen.
Einige Dienste verfügen über eine serverseitige [Paginierung](cli-usage-pagination.md) für ihre Daten zusätzliche Paginierungsoptionen.
Schließlich AWS CLI bietet der sowohl [serverseitige als auch clientseitige Filterung](cli-usage-filter.md), die Sie einzeln oder zusammen verwenden können, um Ihre Ausgabe zu filtern. AWS CLI
**Topics**
+ [Sensible Ausgabe](#cli-usage-output-sensitive)
+ [Serverseitige und clientseitige Ausgabeoptionen](#cli-usage-output-server-client)
+ [Einstellung des Ausgabeformats in der AWS CLI](cli-usage-output-format.md)
+ [Verwenden der Paginierungsoptionen in AWS CLI](cli-usage-pagination.md)
+ [Ausgabe filtern in AWS CLI](cli-usage-filter.md)
## Sensible Ausgabe
Einige Operationen von geben AWS CLI möglicherweise Informationen zurück, die als vertraulich angesehen werden könnten, einschließlich Informationen aus Umgebungsvariablen. Die Offenlegung dieser Informationen kann in bestimmten Szenarien ein Sicherheitsrisiko darstellen. Beispielsweise könnten die Informationen in CI/CD-Protokollen (Continuous Integration and Continuous Deployment) enthalten sein. Daher ist es wichtig, dass Sie überprüfen, wann Sie solche Ausgaben in Ihre Protokolle aufnehmen, und die Ausgabe unterdrücken, wenn sie nicht benötigt wird.
Weitere Informationen zum Schutz sensibler Daten finden Sie unter [Datenschutz in der AWS CLI](data-protection.md).
Bedenken Sie die folgenden bewährten Methoden:
+ Erwägen Sie, Ihre Secrets programmgesteuert aus einem Secret-Seicher abzurufen, z. B. AWS Secrets Manager
+ Überprüfen Sie den Inhalt Ihrer Build-Protokolle, um sicherzustellen, dass sie keine vertraulichen Informationen enthalten. Erwägen Sie Methoden wie die Weiterleitung an die Ausgabe `/dev/null` oder deren Erfassung als Bash oder PowerShell Variable, um Befehlsausgaben zu unterdrücken.
Im Folgenden finden Sie ein Bash-Beispiel für die Umleitung von Ausgaben, aber nicht von Fehlern, an `/dev/null`:
```
$ aws s3 ls > /dev/null
```
Einzelheiten zur Unterdrückung der Ausgabe für Ihr Terminal finden Sie in der Benutzerdokumentation des von Ihnen verwendeten Terminals.
+ Berücksichtigen Sie den Zugriff auf Ihre Protokolle und legen Sie den Umfang des Zugriffs gemäß Ihrem Anwendungsfall fest.
## Serverseitige und clientseitige Ausgabeoptionen
Der AWS CLI bietet sowohl [serverseitige als auch clientseitige Filterung](cli-usage-filter.md), die Sie einzeln oder zusammen verwenden können, um Ihre Ausgabe zu filtern. AWS CLI Die serverseitige Filterung wird zuerst verarbeitet und gibt Ihre Ausgabe für die clientseitige Filterung zurück. Die serverseitige Filterung wird von der Service-API unterstützt. Die clientseitige Filterung wird vom Client mithilfe des Parameters AWS CLI unterstützt. `--query`
**Serverseitige** Ausgabeoptionen sind Funktionen, die direkt von der API unterstützt werden. AWS-Service Alle gefilterten oder ausgelagerten Daten werden nicht an den Client gesendet, wodurch die HTTP-Antwortzeiten verkürzt und die Bandbreite für größere Datensätze verbessert werden können.
**Clientseitige** Ausgabeoptionen sind Features, die von der AWS CLI erstellt wurden. Alle Daten werden an den Client gesendet, dann die AWS CLI Filter oder Seiten, die den angezeigten Inhalt anzeigen. Bei clientseitigen Operationen werden bei größeren Datensätzen weder Geschwindigkeit noch Bandbreite eingespart.
Bei gemeinsamer Verwendung von serverseitigen und clientseitigen Optionen werden serverseitige Operationen zuerst abgeschlossen und dann für clientseitige Operationen an den Client gesendet. Dabei werden die potenziellen Geschwindigkeits- und Bandbreiteneinsparungen serverseitiger Optionen genutzt und gleichzeitig zusätzliche AWS CLI -Features verwendet, um die gewünschte Ausgabe zu erzielen.
# Einstellung des Ausgabeformats in der AWS CLI
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.
+ **[`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.
## Auswählen des Ausgabeformats
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`, 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
[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"
}
]
}
```
## Textausgabeformat
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
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 |
+--------------+--------------+--------------+-----+
```
# Verwenden der Paginierungsoptionen in AWS CLI
In diesem Thema werden die verschiedenen Möglichkeiten beschrieben, die Ausgabe von AWS Command Line Interface ()AWS CLI zu paginieren.
## Serverseitige Paginierung
Bei den meisten Befehlen, die eine umfangreiche Liste von Elementen zurückgeben, stehen mehrere serverseitige Optionen zur Verfügung, mit denen die Anzahl der in der Ausgabe enthaltenen Elemente gesteuert werden kann, wenn die AWS CLI API eines Dienstes zum Auffüllen der Liste aufgerufen wird. AWS CLI Die serverseitige Paginierung in der AWS CLI wird von der AWS Service-API aktiviert, daher funktionieren diese Optionen nur, wenn die Service-API sie aktiviert.
**Topics**
+ [--no-paginate](#cli-usage-pagination-nopaginate)
+ [--page-size](#cli-usage-pagination-pagesize)
+ [--max-items](#cli-usage-pagination-maxitems)
+ [--starting-token](#cli-usage-pagination-startingtoken)
Standardmäßig AWS CLI verwendet der eine Seitengröße, die vom jeweiligen Dienst bestimmt wird, und ruft alle verfügbaren Elemente ab. Amazon S3 hat beispielsweise eine Standardseitengröße von 1 000. Wenn Sie `aws s3api list-objects` auf einem Amazon-S3-Bucket ausführen, der 3 500 Objekte enthält, ruft die AWS CLI Amazon S3 automatisch vier Mal auf, verarbeitet die servicespezifische Paginierungslogik für Sie im Hintergrund und gibt alle 3 500 Objekte in der endgültigen Ausgabe zurück.
Informationen darüber, ob für einen bestimmten Befehl serverseitige Paginierung verfügbar ist, finden Sie im [AWS CLI Referenzhandbuch AWS CLI](https://docs.aws.amazon.com/cli/v1/reference/)
### So verwenden Sie den --no-paginate-Parameter
Die `--no-paginate`-Option deaktiviert folgende Paginierungs-Token auf der Client-Seite. Wenn Sie einen Befehl verwenden, führt der standardmäßig AWS CLI automatisch mehrere Aufrufe durch, um alle möglichen Ergebnisse zurückzugeben, um die Paginierung zu erstellen. Ein Aufruf für jede Seite. Beim Deaktivieren der Paginierung wird die erste Seite mit Befehlsergebnissen AWS CLI nur einmal aufgerufen.
Wenn Sie beispielsweise einen `aws s3api list-objects` Amazon S3-Bucket verwenden, der 3.500 Objekte enthält, ruft der Amazon S3 AWS CLI nur zum ersten Mal auf und gibt in der endgültigen Ausgabe nur die ersten 1.000 Objekte zurück.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--no-paginate
{
"Contents": [
...
```
### So verwenden Sie den –page-size-Parameter
Wenn beim Ausführen von Listenbefehlen für eine große Anzahl von Ressourcen Probleme auftreten, ist die Standardseitengröße möglicherweise zu hoch. Dies kann dazu führen, dass Aufrufe von AWS Diensten die maximal zulässige Zeit überschreiten und zu einem „Timeout“ -Fehler führen. Sie können die `--page-size` Option verwenden, um anzugeben, dass bei jedem Aufruf des AWS Dienstes eine geringere Anzahl von Elementen AWS CLI angefordert wird. Der ruft AWS CLI immer noch die vollständige Liste ab, führt jedoch eine größere Anzahl von Dienst-API-Aufrufen im Hintergrund aus und ruft bei jedem Aufruf eine kleinere Anzahl von Elementen ab. Dadurch ist es wahrscheinlicher, dass Aufrufe nicht zu einem Zeitüberschreitungsfehler führen. Das Ändern der Seitengröße hat keine Auswirkungen auf die Ausgabe. Es wirkt sich nur auf die Anzahl der API-Aufrufe aus, die erforderlich sind, um die Ausgabe zu generieren.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--page-size 100
{
"Contents": [
...
```
### So verwenden Sie den –max-items-Parameter
Verwenden Sie die Option, um weniger Elemente gleichzeitig in die AWS CLI Ausgabe aufzunehmen. `--max-items` Der verarbeitet die Seitennummerierung mit dem Service AWS CLI weiterhin wie zuvor beschrieben, druckt aber nur die Anzahl der Elemente gleichzeitig aus, die Sie angeben.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--max-items 100
{
"NextToken": "eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxfQ==",
"Contents": [
...
```
### So verwenden Sie den –starting-token-Parameter
Wenn die Anzahl der ausgegebenen Elemente (`--max-items`) geringer als die Gesamtanzahl der Elemente ist, die von den zugrunde liegenden API-Aufrufen zurückgeliefert werden, enthält die Ausgabe ein `NextToken`. Dieses können Sie in einem anschließenden Befehl zum Abrufen der nächsten Gruppe von Elementen übergeben. Im folgenden Beispiel wird gezeigt, wie Sie den Wert `NextToken` aus dem vorherigen Beispiel verwenden und die zweiten hundert Elemente abrufen.
**Anmerkung**
Der Parameter `--starting-token` kann nicht null oder leer sein. Wenn der vorherige Befehl keinen `NextToken`-Wert zurückgibt, können keine weiteren Elemente zurückgegeben werden und Sie müssen den Befehl nicht erneut aufrufen.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--max-items 100 \
--starting-token eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxfQ==
{
"Contents": [
...
```
Der angegebene AWS Dienst gibt möglicherweise nicht bei jedem Aufruf Elemente in derselben Reihenfolge zurück. Wenn Sie verschiedene Werte für `--page-size` und `--max-items` angeben, können Sie unerwartete Ergebnisse mit fehlenden oder doppelten Elementen bekommen. Um dies zu verhindern, verwenden Sie dieselbe Zahl für `--page-size` und `--max-items`, um die Paginierung der AWS CLI mit der Paginierung der zugrunde liegenden Services zu synchronisieren. Sie können auch die gesamte Liste abrufen und erforderliche Paginierungsvorgänge lokal durchführen.
# Ausgabe filtern in AWS CLI
The AWS Command Line Interface (AWS CLI) verfügt sowohl über serverseitige als auch clientseitige Filterung, die Sie einzeln oder zusammen verwenden können, um Ihre Ausgabe zu filtern. AWS CLI Die serverseitige Filterung wird zuerst verarbeitet und gibt Ihre Ausgabe für die clientseitige Filterung zurück.
+ Die serverseitige Filterung wird von der API unterstützt und Sie implementieren sie normalerweise mit einem `--filter` Parameter. Der Service gibt nur übereinstimmende Ergebnisse zurück, die HTTP-Antwortzeiten für große Datensätze beschleunigen können.
+ Die clientseitige Filterung wird vom Client mithilfe des Parameters AWS CLI unterstützt. `--query` Dieser Parameter verfügt über Funktionen, die die serverseitige Filterung möglicherweise nicht aufweist.
**Topics**
+ [Serverseitige Filterung](#cli-usage-filter-server-side)
+ [Clientseitige Filterung](#cli-usage-filter-client-side)
+ [Serverseitige und clientseitige Filterung kombinieren](#cli-usage-filter-combining)
+ [Weitere Ressourcen](#cli-usage-filter-resources)
## Serverseitige Filterung
Die serverseitige Filterung in AWS CLI wird von der AWS Service-API bereitgestellt. Der AWS -Service gibt nur die Datensätze in der HTTP-Antwort zurück, die Ihrem Filter entsprechen, was die HTTP-Antwortzeiten für große Datensätze beschleunigen kann. Da die serverseitige Filterung durch die Service-API definiert wird, variieren die Parameternamen und Funktionen zwischen den Services. Einige allgemeine Parameternamen, die zum Filtern verwendet werden, sind:
+ `--filter` wie beispielsweise [ses](https://docs.aws.amazon.com/cli/v1/reference/ses/create-receipt-filter.html) und [ce](https://docs.aws.amazon.com/cli/v1/reference/ce/get-cost-and-usage.html).
+ `--filters` wie beispielsweise [ec2](https://docs.aws.amazon.com/cli/v1/reference/ec2/describe-volumes.html), [autoscaling](https://docs.aws.amazon.com/cli/v1/reference/autoscaling/describe-tags.html) und [rds](https://docs.aws.amazon.com/cli/v1/reference/rds/describe-db-instances.html).
+ Namen, die mit dem Wort `filter` beginnen, zum Beispiel `--filter-expression` für den Befehl [https://docs.aws.amazon.com/cli/v1/reference/dynamodb/scan.html](https://docs.aws.amazon.com/cli/v1/reference/dynamodb/scan.html).
Informationen darüber, ob für einen bestimmten Befehl serverseitige Filterung und die Filterregeln gelten, finden Sie im [AWS CLI Referenzhandbuch AWS CLI](https://docs.aws.amazon.com/cli/v1/reference/)
## Clientseitige Filterung
Der AWS CLI bietet integrierte JSON-basierte clientseitige Filterfunktionen mit dem Parameter. `--query` Der Parameter `--query` ist ein leistungsstarkes Werkzeug, mit dem Sie den Inhalt und den Stil Ihrer Ausgabe anpassen können. Der Parameter `--query` nimmt die HTTP-Antwort, die vom Server zurückkommt und filtert die Ergebnisse, bevor sie angezeigt werden. Da die gesamte HTTP-Antwort vor dem Filtern an den Client gesendet wird, kann die clientseitige Filterung bei großen Datensätzen langsamer sein als die serverseitige Filterung.
Beim Abfragen wird [JMESPath Syntax](https://jmespath.org/) verwendet, um Ausdrücke zum Filtern Ihrer Ausgabe zu erstellen. Informationen zum Erlernen der JMESPath Syntax finden Sie im [Tutorial](https://jmespath.org/tutorial.html) auf der *JMESPath Website*.
**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`, 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.
**Topics**
+ [Bevor Sie beginnen](#cli-usage-filter-client-side-output)
+ [Bezeichner](#cli-usage-filter-client-side-identifiers)
+ [Auswählen aus einer Liste](#cli-usage-filter-client-side-select-list)
+ [Filtern verschachtelter Daten](#cli-usage-filter-client-side-nested)
+ [Abflachen der Ergebnisse](#cli-usage-filter-client-side-specific-flattening)
+ [Filtern nach bestimmten Werten](#cli-usage-filter-client-side-specific-values)
+ [Weiterleitungsausdruck](#cli-usage-filter-client-side-pipe)
+ [Filtern nach mehreren ID-Werten](#cli-usage-filter-client-side-miltiselect-list)
+ [Hinzufügen von Beschriftungen zu ID-Werten](#cli-usage-filter-client-side-multiselect-hash)
+ [Funktionen](#cli-usage-filter-client-side-functions)
+ [Fortschrittliche `--query`-Beispiele](#cli-usage-filter-client-side-advanced)
### Bevor Sie beginnen
**Anmerkung**
Diese Beispiele für Filterausdrücke sind für einfache Linux-ähnliche Shells geschrieben. Wenn Sie diese Beispiele verwenden, müssen Sie die richtigen Anführungsregeln für Ihre Terminal-Shell verwenden. Die Art und Weise, wie Ihr Terminal Ihre Eingaben interpretiert, kann erheblich beeinflussen, was an die AWS CLI gesendet wird. Wie Ihr Terminal einfache Anführungszeichen `'`, doppelte Anführungszeichen `"` oder Backticks ``` liest, kann die Art und Weise beeinflussen, wie Inhalte gelesen werden.
Weitere Informationen finden Sie unter [Verwenden von Anführungszeichen und Literalen mit Zeichenketten in AWS CLI](cli-usage-parameters-quoting-strings.md).
Die folgende JSON-Ausgabe zeigt ein Beispiel dafür, was der Parameter `--query` erzeugen kann. Die Ausgabe beschreibt drei Amazon-EBS-Volumes, die an separate Amazon-EC2-Instances angefügt sind.
#### Beispielausgabe
```
$ aws ec2 describe-volumes
{
"Volumes": [
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
}
```
### Bezeichner
IDs sind die Beschriftungen für Ausgabewerte. Beim Erstellen von Filtern verwenden Sie IDs, um die Abfrageergebnisse einzugrenzen. Im folgenden Ausgabebeispiel werden alle IDs wie `Volumes`, `AvailabilityZone` und`AttachTime` hervorgehoben.
```
$ aws ec2 describe-volumes
{
"Volumes": [
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
}
```
*Weitere Informationen finden Sie unter [Identifikatoren](https://jmespath.org/specification.html#identifiers ) auf der JMESPath Website.*
### Auswählen aus einer Liste
Eine Liste oder ein Array ist ein Bezeichner, auf den eine eckige Klammer „`[`“ folgt, wie `Volumes` und `Attachments` in [Bevor Sie beginnen](#cli-usage-filter-client-side-output).
**Syntax**
```
[ ]
```
Um durch die gesamte Ausgabe eines Arrays zu filtern, können Sie die Platzhalternotation verwenden. [Platzhalterausdrücke](http://jmespath.org/specification.html#wildcard-expressions) sind Ausdrücke, die verwendet werden, um Elemente unter Verwendung der `*`-Notation zurückzugeben.
Im folgenden Beispiel werden alle `Volumes`-Inhalte abgefragt.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
```
Um ein bestimmtes Volume im Array nach Index anzuzeigen, rufen Sie den Array-Index auf. Das erste Element im Array `Volumes` hat beispielsweise einen Index von 0, was zur Abfrage `Volumes[0]` führt. *Weitere Informationen zu Array-Indizes finden Sie auf der Website unter [Indexausdrücke](http://jmespath.org/specification.html#index-expressions). JMESPath*
```
$ aws ec2 describe-volumes \
--query 'Volumes[0]'
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
}
```
Um einen bestimmten Bereich von Volumes nach Index anzuzeigen, verwenden Sie `slice` mit der folgenden Syntax, wobei **Start** der Start-Array-Index ist, **Stopp** der Index ist, bei dem der Filter die Verarbeitung stoppt und **Schritt** das Sprungintervall ist.
**Syntax**
```
[::]
```
Wenn einer dieser Werte aus dem Slice-Ausdruck weggelassen wird, verwenden sie die folgenden Standardwerte:
+ Start – Der erste Index in der Liste, 0.
+ Stopp – Der letzte Index in der Liste.
+ Schritt – Kein Überspringen von Schritten, wobei der Wert 1 ist.
Um nur die ersten beiden Volumes zurückzugeben, verwenden Sie einen Startwert von 0, einen Stoppwert von 2 und einen Schrittwert von 1, wie im folgenden Beispiel gezeigt.
```
$ aws ec2 describe-volumes \
--query 'Volumes[0:2:1]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
}
]
```
Da dieses Beispiel Standardwerte enthält, können Sie das Slice von `Volumes[0:2:1]` auf `Volumes[:2]` kürzen.
Im folgenden Beispiel werden Standardwerte weggelassen und alle zwei Volumes im gesamten Array zurückgegeben.
```
$ aws ec2 describe-volumes \
--query 'Volumes[::2]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
```
Schritte können negative Zahlen auch verwenden, um in umgekehrter Reihenfolge eines Arrays zu filtern, wie im folgenden Beispiel gezeigt.
```
$ aws ec2 describe-volumes \
--query 'Volumes[::-2]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
}
]
```
Weitere Informationen finden Sie unter [Slices](https://jmespath.org/specification.html#slices) auf der *JMESPath Website*.
### Filtern verschachtelter Daten
Um die Filterung des `Volumes[*]` für verschachtelte Werte einzuschränken, verwenden Sie Unterausdrücke, indem Sie einen Punkt und Ihre Filterkriterien anhängen.
**Syntax**
```
.
```
Im folgenden Beispiel werden alle `Attachments`-Informationen für alle Volumes angezeigt.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments'
[
[
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
[
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
[
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
]
]
```
Um weiter in die verschachtelten Werte zu filtern, hängen Sie den Ausdruck für jede verschachtelte ID an. Das folgende Beispiel listet `State` für alle `Volumes` auf.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[*].State'
[
[
"attached"
],
[
"attached"
],
[
"attached"
]
]
```
### Abflachen der Ergebnisse
Weitere Informationen finden Sie [SubExpressions](https://jmespath.org/specification.html#subexpressions)auf der *JMESPathWebsite*.
Sie können die Ergebnisse für `Volumes[*].Attachments[*].State` reduzieren, indem Sie die Platzhalternotation entfernen, die zur Abfrage `Volumes[*].Attachments[].State` führt. Abflachung ist oft nützlich, um die Lesbarkeit der Ergebnisse zu verbessern.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].State'
[
"attached",
"attached",
"attached"
]
```
Weitere Informationen finden Sie unter [Flatten](https://jmespath.org/specification.html#flatten) auf der *JMESPath Website*.
### Filtern nach bestimmten Werten
Um nach bestimmten Werten in einer Liste zu filtern, verwenden Sie einen Filterausdruck, wie in der folgenden Syntax dargestellt.
**Syntax**
```
? ]
```
Ausdruckskomparatoren umfassen `==`, `!=`, `<`, `<=`, `>` und `>=`. Das folgende Beispiel filtert für die `VolumeIds` für alle `Volumes` in einem `Attached``State`.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[?State==`attached`].VolumeId'
[
[
"vol-e11a5288"
],
[
"vol-2e410a47"
],
[
"vol-a1b3c7nd"
]
]
```
Dies kann dann abgeflacht werden, was zu folgendem Beispiel führt.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[?State==`attached`].VolumeId[]'
[
"vol-e11a5288",
"vol-2e410a47",
"vol-a1b3c7nd"
]
```
Das folgende Beispiel filtert für die `VolumeIds` aller `Volumes`, die eine Größe kleiner als 20 haben.
```
$ aws ec2 describe-volumes \
--query 'Volumes[?Size < `20`].VolumeId'
[
"vol-2e410a47",
"vol-a1b3c7nd"
]
```
Weitere Informationen finden Sie auf der *JMESPathWebsite* unter [Filterausdrücke](https://jmespath.org/specification.html#filterexpressions).
### Weiterleitungsausdruck
Sie können Ergebnisse eines Filters über die Pipeline an eine neue Liste übergeben und das Ergebnis anschließend mithilfe der folgenden Syntax mit einem anderen Ausdruck filtern:
**Syntax**
```
| ]
```
Das folgende Beispiel nimmt die Filterergebnisse des Ausdrucks `Volumes[*].Attachments[].InstanceId` und gibt das erste Ergebnis im Array aus.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].InstanceId | [0]'
"i-a071c394"
```
In diesem Beispiel wird zuerst das Array aus dem folgenden Ausdruck erstellt.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].InstanceId'
"i-a071c394",
"i-4b41a37c",
"i-1jd73kv8"
```
Und dann gibt es das erste Element in diesem Array zurück.
```
"i-a071c394"
```
Weitere Informationen finden Sie unter [Pipe Expressions](https://jmespath.org/specification.html#pipe-expressions) auf der *JMESPathWebsite*.
### Filtern nach mehreren ID-Werten
Um nach mehreren IDs zu filtern, verwenden Sie eine Multi-Auswahl-Liste mithilfe der folgenden Syntax:
**Syntax**
```
[].[, ]
```
Im folgenden Beispiel werden `VolumeId` und `VolumeType` in der Liste `Volumes` gefiltert, was zu folgendem Ausdruck führt.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType]'
[
[
"vol-e11a5288",
"standard"
],
[
"vol-2e410a47",
"standard"
],
[
"vol-a1b3c7nd",
"standard"
]
]
```
Um verschachtelte Daten zur Liste hinzuzufügen, fügen Sie eine weitere Multi-Auswahl-Liste hinzu. Das folgende Beispiel erweitert das vorherige Beispiel, indem auch nach `InstanceId` und `State` in der verschachtelten Liste `Attachments` gefiltert wird. Daraus ergibt sich der folgende Ausdruck.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType, Attachments[].[InstanceId, State]]'
[
[
"vol-e11a5288",
"standard",
[
[
"i-a071c394",
"attached"
]
]
],
[
"vol-2e410a47",
"standard",
[
[
"i-4b41a37c",
"attached"
]
]
],
[
"vol-a1b3c7nd",
"standard",
[
[
"i-1jd73kv8",
"attached"
]
]
]
]
```
Um besser lesbar zu sein, flachen Sie den Ausdruck wie im folgenden Beispiel gezeigt ab.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType, Attachments[].[InstanceId, State][]][]'
[
"vol-e11a5288",
"standard",
[
"i-a071c394",
"attached"
],
"vol-2e410a47",
"standard",
[
"i-4b41a37c",
"attached"
],
"vol-a1b3c7nd",
"standard",
[
"i-1jd73kv8",
"attached"
]
]
```
Weitere Informationen finden Sie auf der *JMESPath Website* unter [Multiselect-Liste](https://jmespath.org/specification.html#multiselectlist).
### Hinzufügen von Beschriftungen zu ID-Werten
Um diese Ausgabe leichter lesbar zu machen, verwenden Sie einen Multi-Auswahl-Hash mit der folgenden Syntax.
**Syntax**
```
[].{