Ausgabe filtern in der AWS CLI - AWS Command Line Interface
Serverseitige FilterungClientseitige FilterungServerseitige und clientseitige Filterung kombinierenWeitere Ressourcen

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

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 und ce.

  • --filters wie beispielsweise ec2, autoscaling und rds.

  • Namen, die mit dem Wort filter beginnen, zum Beispiel --filter-expression für den Befehl aws dynamodb scan.

Informationen darüber, ob für einen bestimmten Befehl serverseitige Filterung und die Filterregeln gelten, finden Sie im Version 2.

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 verwendet, um Ausdrücke zum Filtern Ihrer Ausgabe zu erstellen. Informationen zum Erlernen der JMESPath Syntax finden Sie im Tutorial 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, --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.

Bevor Sie beginnen

Anmerkung

Diese Beispiele für Filterausdrücke wurden für einfache Linux-ähnliche Shells geschrieben. Achten Sie bei der Verwendung dieser Beispiele darauf, dass 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 gesendet wird. AWS CLI 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.

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 EC2 Amazon-Instances angehängt sind.

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

IDs

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 undAttachTime 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 auf der Website unter Identifikatoren. JMESPath

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.

Syntax

<listName>[ ]

Um durch die gesamte Ausgabe eines Arrays zu filtern, können Sie die Platzhalternotation verwenden. Platzhalterausdrücke 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. 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 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

<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

Weitere Informationen finden Sie SubExpressionsauf 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 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

? <expression> <comparator> <expression>]

Ausdruckskomparatoren umfassen ==, !=, <, <=, > und >=. Das folgende Beispiel filtert für die VolumeIds für alle Volumes in einem AttachedState.

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

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

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

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

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

<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 auf der JMESPath Website.

Funktionen

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 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 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_by auf der JMESPath Website.

Fortschrittliche --query-Beispiele

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 anzuzeigen 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 demtest 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

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 reduzieren, 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 EC2 Amazon-Volumes auf, die sowohl serverseitige als auch clientseitige Filterung verwenden. 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 von 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

Weitere Ressourcen

AWS CLI automatische Eingabeaufforderung

Wenn Sie anfangen, Filterausdrücke zu verwenden, können Sie die automatische Eingabeaufforderungsfunktion in AWS CLI Version 2 verwenden. Die automatische Eingabeaufforderungsfunktion bietet eine Vorschau, wenn Sie die Taste F5 drücken. Weitere Informationen finden Sie unter Aktivieren und Verwenden von Eingabeaufforderungen in AWS CLI.

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 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 on GitHub.