Steuern der Befehlsausgabe von der AWS CLI - AWS Command Line Interface

Steuern der Befehlsausgabe von der AWS CLI

In diesem Thema werden die verschiedenen Möglichkeiten beschrieben, die Ausgabe von AWS Command Line Interface (AWS CLI) zu steuern.

Auswählen des Ausgabeformats

Die AWS CLI unterstützt vier Ausgabeformate:

  • json: Die Ausgabe wird als JSON-Zeichenfolge formatiert.

  • yaml: Die Ausgabe wird als YAML-Zeichenfolge formatiert. (Nur in AWS CLI Version 2 verfügbar.)

  • text: Die Ausgabe wird als mehrzeilige Folge von Zeichenfolgewerten mit Tabulatoren als Trennzeichen formatiert. Dies kann nützlich sein, wenn die Ausgabe an ein Modul zur Verarbeitung von Text wie grep, sed oder awk übergeben werden soll.

  • table: Die Ausgabe erfolgt in Form einer Tabelle mit den Zeichen +|-, die den Zellenrahmen 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.

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

  • Verwenden der Option output in einem benannten Profil in der config-Datei – Im folgenden Beispiel wird das Standardausgabeformat auf text festgelegt.

    [default] output=text
  • Verwenden der Umgebungsvariablen AWS_DEFAULT_OUTPUT – Die folgende Ausgabe legt das Format für die Befehle in dieser Befehlszeilensitzung auf table fest, bis die Variable geändert wird oder die Sitzung endet. Diese Umgebungsvariable überschreibt alle Werte, die in der Datei config festgelegt sind.

    $ export AWS_DEFAULT_OUTPUT="table"
  • Verwenden der Option --output in der Befehlszeile – Im folgenden Beispiel wird nur die Ausgabe dieses einen Befehls auf json gesetzt. Mit dieser Option für den Befehl werden alle aktuell festgelegten Umgebungsvariablen überschrieben oder der Wert in der Datei config.

    $ aws swf list-domains --registration-status REGISTERED --output json

Sie können die Ergebnisse in einem beliebigen Format anpassen und filtern, indem Sie den Parameter --query verwenden. Weitere Informationen finden Sie unter Filtern der Ausgabe mit der Option --query.

JSON-Ausgabeformat

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

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

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

$ aws iam list-users --output json
{ "Users": [ { "Path": "/", "UserName": "Admin", "UserId": "AIDA1111111111EXAMPLE", "Arn": "arn:aws:iam::123456789012:user/Admin", "CreateDate": "2014-10-16T16:03:09+00:00", "PasswordLastUsed": "2016-06-03T18:37:29+00:00" }, { "Path": "/backup/", "UserName": "backup-user", "UserId": "AIDA2222222222EXAMPLE", "Arn": "arn:aws:iam::123456789012:user/backup/backup-user", "CreateDate": "2019-09-17T19:30:40+00:00" }, { "Path": "/", "UserName": "cli-user", "UserId": "AIDA3333333333EXAMPLE", "Arn": "arn:aws:iam::123456789012:user/cli-user", "CreateDate": "2019-09-17T19:11:39+00:00" } ] }

YAML-Ausgabeformat

Diese Funktion ist nur mit AWS CLI Version 2 verfügbar.

Die folgende Funktion ist nur verfügbar, wenn Sie AWS CLI Version 2 verwenden. Sie ist nicht verfügbar, wenn Sie AWS CLI Version 1 ausführen. Informationen zur Installation von Version 2 finden Sie unter Installieren der AWS CLI Version 2.

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

Für eine erweiterte Filterung, die Sie möglicherweise mit --query nicht durchführen können, können Sie yq, einen Befehlszeilen-YAML-Prozessor, in Betracht ziehen. Sie können ihn herunterladen. Die Dokumentation finden Sie unter http://mikefarah.github.io/yq/.

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

$ aws iam list-users --output yaml
Users: - Arn: arn:aws:iam::123456789012:user/Admin CreateDate: '2014-10-16T16:03:09+00:00' PasswordLastUsed: '2016-06-03T18:37:29+00:00' Path: / UserId: AIDA1111111111EXAMPLE UserName: Admin - Arn: arn:aws:iam::123456789012:user/backup/backup-user CreateDate: '2019-09-17T19:30:40+00:00' Path: /backup/ UserId: AIDA2222222222EXAMPLE UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19 - Arn: arn:aws:iam::123456789012:user/cli-user CreateDate: '2019-09-17T19:30:40+00:00' Path: / UserId: AIDA3333333333EXAMPLE UserName: cli-user

Textausgabeformat

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

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

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

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

$ aws iam list-users --output text
USERS arn:aws:iam::123456789012:user/Admin 2014-10-16T16:03:09+00:00 2016-06-03T18:37:29+00:00 / AIDA1111111111EXAMPLE Admin USERS arn:aws:iam::123456789012:user/backup/backup-user 2019-09-17T19:30:40+00:00 /backup/ AIDA2222222222EXAMPLE backup-user USERS arn:aws:iam::123456789012:user/cli-user 2019-09-17T19:11:39+00:00 / AIDA3333333333EXAMPLE cli-user

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

Wichtig

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

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

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

$ aws iam list-users --output text --query 'Users[*].[UserName,Arn,CreateDate,PasswordLastUsed,UserId]'
Admin arn:aws:iam::123456789012:user/Admin 2014-10-16T16:03:09+00:00 2016-06-03T18:37:29+00:00 AIDA1111111111EXAMPLE backup-user arn:aws:iam::123456789012:user/backup-user 2019-09-17T19:30:40+00:00 None AIDA2222222222EXAMPLE cli-user arn:aws:iam::123456789012:user/cli-backup 2019-09-17T19:11:39+00:00 None AIDA3333333333EXAMPLE

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

$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text
us-west-2a running i-4b41a37c us-west-2a stopped i-a071c394 us-west-2b stopped i-97a217a0 us-west-2a running i-3045b007 us-west-2a running i-6fc67758
$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text | grep us-west-2a | grep running | awk '{print $3}'
i-4b41a37c i-3045b007 i-6fc67758

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

$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[State.Name, InstanceId]' --output text | > grep stopped | > awk '{print $2}' | > while read line; > do aws ec2 modify-instance-attribute --instance-id $line --instance-type '{"Value": "m1.medium"}'; > done

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

PS C:\>aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text | %{if ($_.split("`t")[0] -match "us-west-2a") { $_.split("`t")[2]; } }
-4b41a37c i-a071c394 i-3045b007 i-6fc67758

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

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

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

Tabulatorgetrennte, einzeilige Ausgabe:

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

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

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

Tabellenausgabeformat

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

$ aws iam list-users --output table
----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ListUsers | +---------------------------------------------------------------------------------------------------------------------------------------------------------------+ || Users || |+----------------------------------------------------+---------------------------+---------------------------+----------+-----------------------+-------------+| || Arn | CreateDate | PasswordLastUsed | Path | UserId | UserName || |+----------------------------------------------------+---------------------------+---------------------------+----------+-----------------------+-------------+| || arn:aws:iam::123456789012:user/Admin | 2014-10-16T16:03:09+00:00 | 2016-06-03T18:37:29+00:00 | / | AIDA1111111111EXAMPLE | Admin || || arn:aws:iam::123456789012:user/backup/backup-user | 2019-09-17T19:30:40+00:00 | | /backup/ | AIDA2222222222EXAMPLE | backup-user || || arn:aws:iam::123456789012:user/cli-user | 2019-09-17T19:11:39+00:00 | | / | AIDA3333333333EXAMPLE | cli-user || +---------------------------------------------------------------------------------------------------------------------------------------------------------------+

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

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

Filtern der Ausgabe mit der Option --query

Die AWS CLI bietet integrierte JSON-basierte Funktionen zum Filtern der Ausgabe mit der Option --query. Der --query-Parameter akzeptiert Zeichenfolgen, die mit der JMESPath-Spezifikation kompatibel sind.

Wichtig

Der von Ihnen angegebene Ausgabetyp (json, yaml, text oder table) beeinflusst, wie die Option --query funktioniert:

  • Wenn Sie --output text angeben, wird die Ausgabe paginiert, bevor der --query-Filter angewendet wird, und die AWS CLI führt die Abfrage einmal auf jeder Seite der Ausgabe durch. Dies kann zu unerwarteten zusätzlichen Ausgaben führen, besonders, wenn Ihr Filter ein Array-Element angibt, das etwa [0] verwendet, da die Ausgabe dann das erste passende Element auf jeder Seite enthält. Um die zusätzliche Ausgabe zu umgehen, die --output text erzeugen kann, können Sie --no-paginate angeben. Dies bewirkt, dass der Filter nur auf den vollständigen Satz von Ergebnissen angewendet wird. Es entfernt allerdings jegliche Paginierung, sodass es zu einer langen Ausgabe führen kann. Sie können auch andere Befehlszeilen-Tools wie head oder tail verwenden, um die Ausgabe zusätzlich zu filtern, um nur die gewünschten Werte zu erhalten.

  • Wenn Sie --output json angeben, wird die Ausgabe vollständig verarbeitet und in eine JSON-Struktur konvertiert, bevor der --query-Filter angewendet wird. Die AWS CLI führt die Abfrage nur einmal für die gesamte JSON-Struktur aus, wodurch ein gefiltertes JSON-Ergebnis erzeugt wird, das dann ausgegeben wird.

  • Wenn Sie --output yaml angeben, wird die Ausgabe vollständig verarbeitet und in eine JSON-Struktur konvertiert, bevor der --query-Filter angewendet wird. Die AWS CLI führt die Abfrage nur einmal für die gesamte JSON-Struktur aus, wodurch ein gefiltertes JSON-Ergebnis erzeugt wird, das dann in YAML konvertiert und ausgegeben wird.

Um zu demonstrieren, wie --query funktioniert, beginnen wir zuerst mit der folgenden Standard-JSON-Ausgabe. Dies beschreibt zwei Amazon Elastic Block Store (Amazon EBS)-Volumes, die separaten Amazon EC2-Instances zugeordnet 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 } ] }

Sie können wählen, nur das erste Volume aus der Liste Volumes anzuzeigen, indem Sie den folgenden Befehl verwenden, der das erste Volume im Array indiziert.

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

Im nächsten Beispiel wird der Platzhalter [*] verwendet, um alle Volumes in der Liste zu durchlaufen und die folgenden drei Elemente aus jedem Volume herauszufiltern: VolumeId, AvailabilityZone und Size. Die Wörterbuchnotation erfordert, dass Sie einen Alias für jeden JSON-Schlüssel bereitstellen. Beispiel: {Alias1:JSONKey1,Alias2:JSONKey2}. Ein Wörterbuch ist prinzipiell unsortiert, sodass die Reihenfolge der Schlüssel-Aliase innerhalb einer Struktur möglicherweise nicht konsistent ist.

$ aws ec2 describe-volumes --query 'Volumes[*].{ID:VolumeId,AZ:AvailabilityZone,Size:Size}'
[ { "AZ": "us-west-2a", "ID": "vol-e11a5288", "Size": 30 }, { "AZ": "us-west-2a", "ID": "vol-2e410a47", "Size": 8 } ]

Mithilfe der Wörterbuchnotation können Sie auch verkettete Schlüssel wie key1.key2[0].key3 verwenden, um tief geschachtelte Elemente innerhalb der Struktur zu filtern. Das Beispiel unten zeigt dies anhand des Schlüssels Attachments[0].InstanceId, für den der einfache Alias InstanceId verwendet wird.

$ aws ec2 describe-volumes --query 'Volumes[*].{ID:VolumeId,InstanceId:Attachments[0].InstanceId,AZ:AvailabilityZone,Size:Size}'
[ { "InstanceId": "i-a071c394", "AZ": "us-west-2a", "ID": "vol-e11a5288", "Size": 30 }, { "InstanceId": "i-4b41a37c", "AZ": "us-west-2a", "ID": "vol-2e410a47", "Size": 8 } ]

Sie können mit der Listennotation [key1, key2] auch mehrere Elemente filtern. Dadurch werden alle gefilterten Attribute in einer einzelnen geordneten Liste pro Objekt formatiert, unabhängig vom Typ.

$ aws ec2 describe-volumes --query 'Volumes[*].[VolumeId, Attachments[0].InstanceId, AvailabilityZone, Size]'
[ [ "vol-e11a5288", "i-a071c394", "us-west-2a", 30 ], [ "vol-2e410a47", "i-4b41a37c", "us-west-2a", 8 ] ]

Wenn Sie die Ergebnisse nach dem Wert eines bestimmten Felds filtern möchten, verwenden Sie den JMESPath-Operator „?“. Die folgende Beispielabfrage gibt nur Volumes in der Availability Zone us-west-2a aus.

$ aws ec2 describe-volumes \ --query 'Volumes[?AvailabilityZone==`us-west-2a`]'
Anmerkung

Wenn Sie einen Literalwert wie oben "us-west-2" in einem JMESPath-Abfrageausdruck angeben, müssen Sie den Wert in einfache umgekehrte Anführungszeichen (` `) einschließen, damit er korrekt gelesen wird.

Hier sind einige zusätzliche Beispiele, die veranschaulichen, wie Sie nur die Details erhalten können, die Sie von der Ausgabe Ihrer Befehle erwarten.

Das folgende Beispiel listet Amazon EC2-Volumes auf. Der Service erstellt 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, "Type": "gp2" } ]

Das folgende Beispiel ruft eine Liste von Bildern 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 einen Bildes 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

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 Availability Zones 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" ] ]

Mit dem --query-Parameter können Sie die Elemente in der Ausgabe zählen. 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

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

Das folgende Beispiel listet die fünf neuesten Amazon Machine Images (AMIs) auf, die Sie erstellt haben, sortiert von den neuesten zu den ä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" } ]

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'

Zusammen mit den Ausgabeformaten, die zuvor in diesem Thema näher erläutert wurden, ist die Option --query ein leistungsstarkes Tool, mit dem Sie Inhalte und Formate von Ausgaben anpassen können.

Weitere Beispiele und die vollständige Spezifikation von JMESPath, der zugrunde liegenden JSON-Verarbeitungsbibliothek, finden Sie unter http://jmespath.org/specification.html.

So legen Sie das Standard-Pager-Programm der Ausgabe fest

Diese Funktion ist nur mit AWS CLI Version 2 verfügbar.

Die folgende Funktion ist nur verfügbar, wenn Sie AWS CLI Version 2 verwenden. Sie ist nicht verfügbar, wenn Sie AWS CLI Version 1 ausführen. Informationen zur Installation von Version 2 finden Sie unter Installieren der AWS CLI Version 2.

AWS CLI Version 2 ermöglicht die Verwendung eines clientseitigen Pager-Programms für die Ausgabe. Standardmäßig gibt diese Funktion alle Ausgaben über das Standard-Pager-Programm Ihres Betriebssystems zurück. Die clientseitige Paginierung erfolgt nach einer serverseitigen Paginierung, die Sie angeben, siehe Paginierung.

Um die gesamte Verwendung eines externen Auslagerungsprogramms zu deaktivieren, setzen Sie die Variable auf eine leere Zeichenfolge.

Sie können den Ausgabe-Pager auf zwei Arten angeben:

  • Verwenden der Option cli_pager in der config-Datei – Im folgenden Beispiel wird der Standard-Ausgabe-Pager auf das less-Programm eingestellt.

    [default] cli_pager=less

    Im folgenden Beispiel wird die Standardeinstellung zur Deaktivierung der Verwendung eines Pagers festgelegt.

    [default] cli_pager=
  • Verwenden der AWS_PAGER-Umgebungsvariable – Im folgenden Beispiel wird der Standard-Ausgabe-Pager auf das less-Programm eingestellt.

    Linux oder macOS

    $ export AWS_PAGER="less"

    Windows

    C:\> setx AWS_PAGER "less"

    Im folgenden Beispiel wird die Verwendung eines Pagers deaktiviert.

    Linux oder macOS

    $ export AWS_PAGER=""

    Windows

    C:\> setx AWS_PAGER ""