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

# Ausgabe filtern in AWS CLI
<a name="cli-usage-filter"></a>

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
<a name="cli-usage-filter-server-side"></a>

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
<a name="cli-usage-filter-client-side"></a>

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
<a name="cli-usage-filter-client-side-output"></a>

**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
<a name="cli-usage-filter-client-side-output-example"></a>

```
$ 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
<a name="cli-usage-filter-client-side-identifiers"></a>

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
<a name="cli-usage-filter-client-side-select-list"></a>

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**

```
<listName>[ ]
```

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**

```
<arrayName>[<start>:<stop>:<step>]
```

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
<a name="cli-usage-filter-client-side-nested"></a>

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**

```
<expression>.<expression>
```

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
<a name="cli-usage-filter-client-side-specific-flattening"></a>

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
<a name="cli-usage-filter-client-side-specific-values"></a>

Um nach bestimmten Werten in einer Liste zu filtern, verwenden Sie einen Filterausdruck, wie in der folgenden Syntax dargestellt.

**Syntax**

```
? <expression> <comparator> <expression>]
```

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
<a name="cli-usage-filter-client-side-pipe"></a>

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**

```
<expression> | <expression>] 
```

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
<a name="cli-usage-filter-client-side-miltiselect-list"></a>

Um nach mehreren IDs zu filtern, verwenden Sie eine Multi-Auswahl-Liste mithilfe der folgenden Syntax: 

**Syntax**

```
<listName>[].[<expression>, <expression>]
```

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
<a name="cli-usage-filter-client-side-multiselect-hash"></a>

Um diese Ausgabe leichter lesbar zu machen, verwenden Sie einen Multi-Auswahl-Hash mit der folgenden Syntax.

**Syntax**

```
<listName>[].{<label>: <expression>, <label>: <expression>}
```

Ihre ID-Bezeichnung muss nicht mit dem Namen der ID übereinstimmen. Im folgenden Beispiel wird die Beschriftung `VolumeType` für `VolumeType`-Werte genutzt.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[].{VolumeType: VolumeType}'
[
  {
    "VolumeType": "standard",
  },
  {
    "VolumeType": "standard",
  },
  {
    "VolumeType": "standard",
  }
]
```

Der Einfachheit halber behält das folgende Beispiel die Bezeichnernamen für jede Markierung bei und zeigt die `VolumeId`, `VolumeType`, `InstanceId` und `State` für alle Volumes an:

```
$ aws ec2 describe-volumes \
    --query 'Volumes[].{VolumeId: VolumeId, VolumeType: VolumeType, InstanceId: Attachments[0].InstanceId, State: Attachments[0].State}'
[
  {
    "VolumeId": "vol-e11a5288",
    "VolumeType": "standard",
    "InstanceId": "i-a071c394",
    "State": "attached"
  },
  {
    "VolumeId": "vol-2e410a47",
    "VolumeType": "standard",
    "InstanceId": "i-4b41a37c",
    "State": "attached"
  },
  {
    "VolumeId": "vol-a1b3c7nd",
    "VolumeType": "standard",
    "InstanceId": "i-1jd73kv8",
    "State": "attached"
  }
]
```

*Weitere Informationen finden Sie unter [Multiselect-Hash](https://jmespath.org/specification.html#multiselecthash) auf der JMESPath Website.*

### Funktionen
<a name="cli-usage-filter-client-side-functions"></a>

Die JMESPath Syntax enthält viele Funktionen, die Sie für Ihre Abfragen verwenden können. Informationen zu JMESPath Funktionen finden Sie unter [Integrierte Funktionen](https://jmespath.org/specification.html#built-in-functions) auf der *JMESPathWebsite*.

Um zu demonstrieren, wie Sie eine Funktion in Ihre Abfragen integrieren können, verwendet das folgende Beispiel die `sort_by`-Funktion. Die `sort_by`-Funktion sortiert ein Array mit einem Ausdruck als Sortierschlüssel mit der folgenden Syntax:

**Syntax**

```
sort_by(<listName>, <sort expression>)[].<expression>
```

Im folgenden Beispiel wird das vorherige [Multi-Auswahl-Hash-Beispiel](#cli-usage-filter-client-side-multiselect-hash) verwendet und die Ausgabe nach `VolumeId` sortiert. 

```
$ aws ec2 describe-volumes \
    --query 'sort_by(Volumes, &VolumeId)[].{VolumeId: VolumeId, VolumeType: VolumeType, InstanceId: Attachments[0].InstanceId, State: Attachments[0].State}'
[
  {
    "VolumeId": "vol-2e410a47",
    "VolumeType": "standard",
    "InstanceId": "i-4b41a37c",
    "State": "attached"
  },
  {
    "VolumeId": "vol-a1b3c7nd",
    "VolumeType": "standard",
    "InstanceId": "i-1jd73kv8",
    "State": "attached"
  },
  {
    "VolumeId": "vol-e11a5288",
    "VolumeType": "standard",
    "InstanceId": "i-a071c394",
    "State": "attached"
  }
]
```

*Weitere Informationen finden Sie unter [sort\$1by](https://jmespath.org/specification.html#sort-by) auf der JMESPath Website.*

### Fortschrittliche `--query`-Beispiele
<a name="cli-usage-filter-client-side-advanced"></a>

**So extrahieren Sie Informationen aus einem bestimmten Element**

Das folgende Beispiel verwendet den `--query`-Parameter, um ein bestimmtes Element in einer Liste zu suchen, und extrahiert anschließend Informationen aus diesem Element. Das Beispiel listet alle `AvailabilityZones` im Zusammenhang mit dem angegebenen Service-Endpunkt auf. Es extrahiert das Element aus der `ServiceDetails`-Liste mit dem angegebenen `ServiceName` und gibt dann das Feld `AvailabilityZones` aus dem ausgewählten Element aus. 

```
$ aws --region us-east-1 ec2 describe-vpc-endpoint-services \
    --query 'ServiceDetails[?ServiceName==`com.amazonaws.us-east-1.ecs`].AvailabilityZones'
[
    [
        "us-east-1a",
        "us-east-1b",
        "us-east-1c",
        "us-east-1d",
        "us-east-1e",
        "us-east-1f"
    ]
]
```

**So zeigen Sie Snapshots nach dem angegebenen Erstellungsdatum an**

Das folgende Beispiel zeigt, wie Sie alle Ihre Snapshots auflisten können, die nach einem bestimmten Datum erstellt wurden, einschließlich nur einiger der verfügbaren Felder in der Ausgabe.

```
$ aws ec2 describe-snapshots --owner self \
    --output json \
    --query 'Snapshots[?StartTime>=`2018-02-07`].{Id:SnapshotId,VId:VolumeId,Size:VolumeSize}'
[
    {
        "id": "snap-0effb42b7a1b2c3d4",
        "vid": "vol-0be9bb0bf12345678",
        "Size": 8
    }
]
```

**Um die neuesten zu zeigen AMIs**

Das folgende Beispiel listet die fünf neuesten Amazon Machine Images (AMIs) auf, die Sie erstellt haben, sortiert vom neuesten zum ältesten.

```
$ aws ec2 describe-images \
    --owners self \
    --query 'reverse(sort_by(Images,&CreationDate))[:5].{id:ImageId,date:CreationDate}'
[
    {
        "id": "ami-0a1b2c3d4e5f60001",
        "date": "2018-11-28T17:16:38.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60002",
        "date": "2018-09-15T13:51:22.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60003",
        "date": "2018-08-19T10:22:45.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60004",
        "date": "2018-05-03T12:04:02.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60005",
        "date": "2017-12-13T17:16:38.000Z"
    }
]
```

**So zeigen Sie ungesunde Auto-Scaling-Instances an**

Das folgende Beispiel zeigt nur die `InstanceId` für alle fehlerhaften Instances in der angegebenen Auto-Scaling-Gruppe an.

```
$ aws autoscaling describe-auto-scaling-groups \
    --auto-scaling-group-name My-AutoScaling-Group-Name \
    --output text \
    --query 'AutoScalingGroups[*].Instances[?HealthStatus==`Unhealthy`].InstanceId'
```

**So schließen Sie Volumes mit dem angegebenen Tag aus**

Im folgenden Beispiel werden alle Instances ohne `test`-Tag beschrieben. Solange dem Volume neben `test` ein weiteres Tag angehängt ist, wird das Volume dennoch in den Ergebnissen zurückgegeben.

Der folgende Ausdruck, um alle Tags mit dem`test` Tag in einem Array zurückzugeben. Alle Tags, die nicht das Tag `test` sind, enthalten einen `null`-Wert.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[*].Tags[?Value == `test`]'
```

**So schließen Sie Volumes mit dem angegebenen Tag aus**

Im folgenden Beispiel werden alle Instances ohne `test`-Tag beschrieben. Die Verwendung eines einfachen `?Value != `test``-Ausdrucks funktioniert nicht, um ein Volume auszuschließen, da Volumes mehrere Tags haben können. Solange dem Volume neben `test` ein weiteres Tag angehängt ist, wird das Volume dennoch in den Ergebnissen zurückgegeben.

Um alle Volumes mit dem Tag `test` auszuschließen, beginnen Sie mit dem folgenden Ausdruck, um alle Tags mit dem Tag `test` in einem Array zurückzugeben. Alle Tags, die nicht das Tag `test` sind, enthalten einen `null`-Wert.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[*].Tags[?Value == `test`]'
```

Dann filtern Sie alle positiven `test`-Ergebnisse mit der `not_null`-Funktion. 

```
$ aws ec2 describe-volumes \
    --query 'Volumes[?!not_null(Tags[?Value == `test`].Value)]'
```

Leiten Sie die Ergebnisse weiter, um die Ergebnisse abzuflachen, was zu der folgenden Abfrage führt.

```
$ aws ec2 describe-volumes \
    --query 'Volumes[?!not_null(Tags[?Value == `test`].Value)] | []'
```

## Serverseitige und clientseitige Filterung kombinieren
<a name="cli-usage-filter-combining"></a>

Sie können serverseitige und clientseitige Filterung zusammen verwenden. Zuerst wird die serverseitige Filterung abgeschlossen, die die Daten an den Client sendet, die der Parameter `--query` dann filtert. Wenn Sie große Datenmengen verwenden, können Sie zunächst die serverseitige Filterung verwenden, um die Datenmenge zu verringern, die bei jedem AWS CLI Anruf an den Client gesendet wird, und gleichzeitig die leistungsstarken Anpassungsmöglichkeiten beibehalten, die die clientseitige Filterung bietet.

Das folgende Beispiel listet Amazon-EC2-Volumes mit serverseitiger und clientseitiger Filterung auf. Der Service filtert eine Liste aller angehängten Volumes in der `us-west-2a` Availability Zone. Der Parameter `--query` begrenzt die Ausgabe weiter auf die Volumes mit einem Wert `Size`, der größer als 50 ist, und zeigt nur die angegebenen Felder mit benutzerdefinierten Namen an.

```
$ aws ec2 describe-volumes \
    --filters "Name=availability-zone,Values=us-west-2a" "Name=status,Values=attached" \
    --query 'Volumes[?Size > `50`].{Id:VolumeId,Size:Size,Type:VolumeType}'
[
    {
        "Id": "vol-0be9bb0bf12345678",
        "Size": 80,
        "VolumeType": "gp2"
    }
]
```

Das folgende Beispiel ruft eine Liste mit Images ab, die mehrere Kriterien erfüllen. Anschließend wird mit dem Parameter `--query` die Ausgabe nach `CreationDate` sortiert und nur das neueste ausgewählt. Schließlich wird die `ImageId` dieses ein Image angezeigt.

```
$ aws ec2 describe-images \
    --owners amazon \
    --filters "Name=name,Values=amzn*gp2" "Name=virtualization-type,Values=hvm" "Name=root-device-type,Values=ebs" \
    --query "sort_by(Images, &CreationDate)[-1].ImageId" \
    --output text
ami-00ced3122871a4921
```

Im folgenden Beispiel wird die Anzahl der verfügbaren Volumes mit mehr als 1000 IOPS angezeigt, indem mit `length` die Anzahl der in einer Liste enthaltenen Volumes gezählt wird.

```
$ aws ec2 describe-volumes \
    --filters "Name=status,Values=available" \
    --query 'length(Volumes[?Iops > `1000`])'
3
```

Im folgenden Beispiel werden die Namen von Auto Scaling Scaling-Gruppen abgerufen, die Startkonfigurationen in den angegebenen Bereichen AWS-Region verwenden und CloudFormation Stacks verwenden.

```
$ aws autoscaling describe-auto-scaling-groups --region us-west-2 \
  --filters Name=tag-key,Values=aws:cloudformation:stack-name \
  --query 'AutoScalingGroups[?LaunchConfigurationName!=`null`].AutoScalingGroupName'
[
    "group-1",
    "group-2",
    "group-3"
]
```

## Weitere Ressourcen
<a name="cli-usage-filter-resources"></a>

**JMESPath Terminal**  
JMESPath Terminal ist ein interaktiver Terminalbefehl zum Experimentieren mit JMESPath Ausdrücken, die für die clientseitige Filterung verwendet werden. Mit dem Befehl `jpterm` zeigt das Terminal während der Eingabe sofort Abfrageergebnisse an. Sie können die AWS CLI Ausgabe direkt an das Terminal weiterleiten, was erweiterte Abfrageexperimente ermöglicht.   
Das folgende Beispiel leitet die `aws ec2 describe-volumes` Ausgabe direkt an das Terminal weiter JMESPath .  

```
$ aws ec2 describe-volumes | jpterm
```
Weitere Informationen zu JMESPath Terminal und Installationsanweisungen finden Sie unter [JMESPathTerminal](https://github.com/jmespath/jmespath.terminal) on *GitHub*.

**JQ-Serviceprogramm**  
Das `jq`-Serviceprogramm bietet Ihnen eine Möglichkeit, Ihre Ausgabe auf der Client-Seite in ein gewünschtes Ausgabeformat umzuwandeln. Weitere Informationen `jq` und Installationsanweisungen finden Sie unter [jq](https://stedolan.github.io/jq/) on *GitHub*.