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.
# Verwendung der AWS CLI
Dieser Abschnitt bietet einen umfassenden Überblick über die allgemeine Verwendung sowie die allgemeinen Funktionen und Optionen, die in AWS Command Line Interface (AWS CLI) verfügbar sind und über die im Abschnitt [Verwenden von Endpunkten in der AWS CLI](cli-configure-endpoints.md) behandelten Details zur Konfiguration hinausgehen.
Dieses Handbuch befasst sich mit den wesentlichen Aspekten des Schreibens von AWS CLI-Befehlen, einschließlich ihrer grundlegenden Struktur, Formatierung und Filterfunktionen. Wenn Sie diese Kernelemente verstehen, können Sie Befehle erstellen, die genau auf die Ressourcen und Aktionen abzielen, die Sie benötigen, ohne sich in komplexen webbasierten Konsolen zurechtfinden zu müssen.
Darüber hinaus werden die für die AWS CLI verfügbaren Hilfeinhalte und die Dokumentation hervorgehoben. Von der integrierten Befehlszeilenhilfe bis hin zum umfassenden [Referenzhandbuch zu AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/reference/) haben Sie Zugriff auf Informationen, die Sie bei der Erkundung der Funktionen und Möglichkeiten der AWS CLI unterstützen.
Informationen zu AWS-Service-spezifischen Beispielen und Anwendungsfällen finden Sie unter [Beispiele für die AWS CLI](cli-chap-code-examples.md) oder im [Referenzhandbuch zu AWS CLI Version 2](https://docs.aws.amazon.com/cli/latest/reference/). Diese enthalten befehlsspezifische Informationen und zeigen Beispiele, wie Sie die AWS CLI für verschiedene AWS-Services nutzen können.
**Anmerkung**
Standardmäßig sendet die AWS CLI Anforderungen an AWS-Services mittels HTTPS auf TCP-Port 443. Für eine erfolgreiche Verwendung der AWS CLI müssen Sie für ausgehende Verbindungen auf diesem Port berechtigt sein.
**Topics**
+ [Zugriff auf Hilfe und Ressourcen für AWS CLI](cli-usage-help.md)
+ [Befehlsstruktur in der AWS CLI](cli-usage-commandstructure.md)
+ [Angeben von Parameterwerten in der AWS CLI](cli-usage-parameters.md)
+ [Aktivieren und Verwenden von Eingabeaufforderungen in AWS CLI](cli-usage-parameters-prompting.md)
+ [Steuerung der Befehlsausgabe in der AWS CLI](cli-usage-output.md)
+ [Befehlszeilen-Rückgabecodes in der AWS CLI](cli-usage-returncodes.md)
+ [Verwenden von benutzerdefinierten Assistenten zum Ausführen interaktiver Befehle in AWS CLI](cli-usage-wizard.md)
+ [Aliase erstellen und verwenden in AWS CLI](cli-usage-alias.md)
+ [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md)
# Zugriff auf Hilfe und Ressourcen für AWS CLI
In diesem Thema wird beschrieben, wie Sie auf Hilfeinhalte für AWS Command Line Interface (AWS CLI) zugreifen können.
**Topics**
+ [Der integrierte AWS CLI Hilfebefehl](#cli-usage-help-command)
+ [AWS CLI Referenzhandbuch](#cli-reference)
+ [API-Dokumentation](#api-reference)
+ [Behebung von Fehlern](#help-tshoot)
+ [Weitere Hilfe](#help-additional)
## Der integrierte AWS CLI Hilfebefehl
Sie können mit jedem Befehl Hilfe erhalten, wenn Sie die AWS Command Line Interface (AWS CLI) verwenden. Geben Sie dazu hinter einem Befehlsnamen einfach `help` ein.
Mit dem folgenden Befehl wird beispielsweise Hilfe zu den allgemeinen AWS CLI Optionen und den verfügbaren Befehlen der obersten Ebene angezeigt.
```
$ aws help
```
Der folgende Befehl zeigt die verfügbaren Amazon-Elastic-Compute-Cloud (Amazon EC2)-spezifischen Befehle an.
```
$ aws ec2 help
```
Im folgenden Beispiel wird die detaillierte Hilfe für die Amazon EC2 `DescribeInstances`-Operation angezeigt. Die Hilfe enthält Informationen zu den Eingabeparametern, verfügbaren Filter und dem Inhalt der Ausgabe. Sie enthält auch Beispiele dazu, wie Sie Variationen des Befehls eingeben können.
```
$ aws ec2 describe-instances help
```
Ab Version `2.31.0` wird die Anzeige für den Befehl `help` durch die Einstellung `cli_help_output` konfiguriert und hat die folgenden Werte:
+ **(Standard)** `terminal` – Öffnen Sie die Manpage im Terminal.
+ `browser` – Öffnen Sie die Manpage als lokale HTML-Datei in Ihrem Standardbrowser. Ein Hinweis wird auf Ihrem Terminal gedruckt, wenn Ihr Standardbrowser geöffnet wird, und eine Fehlermeldung, wenn der Browser AWS CLI nicht geöffnet werden kann.
+ `url`‐ Drucken Sie die URL zum AWS CLI Online-Referenzhandbuch für die Version aus, die AWS CLI Sie installiert haben. Die Einstellungen für das clientseitige Paging, wie z. B. die `AWS_PAGER` Umgebungsvariable, werden berücksichtigt.
Die Hilfeinhalte für jeden Befehl sind in sechs Abschnitte unterteilt:
Name
Der Name des Befehls.
```
NAME
describe-instances -
```
Description
Eine Beschreibung der API-Operation, die der Befehl aufruft.
```
DESCRIPTION
Describes one or more of your instances.
If you specify one or more instance IDs, Amazon EC2 returns information
for those instances. If you do not specify instance IDs, Amazon EC2
returns information for all relevant instances. If you specify an
instance ID that is not valid, an error is returned. If you specify an
instance that you do not own, it is not included in the returned
results.
...
```
Syntax
Die grundlegende Syntax für die Nutzung des Befehls und dessen Optionen. Wenn eine Option in eckigen Klammern dargestellt wird, ist sie optional oder hat einen Standardwert oder es gibt eine alternative Option, die verwendet werden kann.
```
SYNOPSIS
describe-instances
[--dry-run | --no-dry-run]
[--instance-ids ]
[--filters ]
[--cli-input-json ]
[--starting-token ]
[--page-size ]
[--max-items ]
[--generate-cli-skeleton]
```
`describe-instances`Hat beispielsweise ein Standardverhalten, das ***alle*** Instanzen im aktuellen Konto und in der Region beschreibt. AWS Sie können optional eine Liste mit `instance-ids` angeben, um eine oder mehrere Instances zu beschreiben. `dry-run` ist ein optionales boolesches Flag, das keinen Wert akzeptiert. Zur Verwendung eines booleschen Flags geben Sie einen der dargestellten Werte an, in diesem Fall `--dry-run` oder `--no-dry-run`. Ebenso akzeptiert `--generate-cli-skeleton` keinen Wert. Enthält eine Option Bedingungen für ihre Verwendung, sind diese im Abschnitt `OPTIONS` oder in den aufgeführten Beispielen angegeben.
Optionen
Eine Beschreibung der einzelnen Optionen aus der Zusammenfassung.
```
OPTIONS
--dry-run | --no-dry-run (boolean)
Checks whether you have the required permissions for the action,
without actually making the request, and provides an error response.
If you have the required permissions, the error response is DryRun-
Operation . Otherwise, it is UnauthorizedOperation .
--instance-ids (list)
One or more instance IDs.
Default: Describes all your instances.
...
```
Beispiele
Beispiele für die Nutzung des Befehls und seiner Optionen. Wenn kein Beispiel für einen Befehl oder Anwendungsfall verfügbar ist, den Sie benötigen, fordern Sie eines über den Feedback-Link auf dieser Seite oder in der AWS CLI Befehlsreferenz auf der Hilfeseite für den Befehl an.
```
EXAMPLES
To describe an Amazon EC2 instance
Command:
aws ec2 describe-instances --instance-ids i-5203422c
To describe all instances with the instance type m1.small
Command:
aws ec2 describe-instances --filters "Name=instance-type,Values=m1.small"
To describe all instances with an Owner tag
Command:
aws ec2 describe-instances --filters "Name=tag-key,Values=Owner"
...
```
Ausgabe
Beschreibungen der einzelnen Felder und Datentypen, die in der Antwort von AWS zurückgegeben werden.
Für `describe-instances` ist die Ausgabe ist eine Liste mit Reservierungsobjekten, die jeweils mehrere Felder und Objekte enthalten, die Informationen über die damit verknüpften Instances bereitstellen. Diese Informationen stammen aus der [-API-Dokumentation für den Reservierungsdatentyp](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_Reservation.html), der von Amazon EC2 verwendet wird.
```
OUTPUT
Reservations -> (list)
One or more reservations.
(structure)
Describes a reservation.
ReservationId -> (string)
The ID of the reservation.
OwnerId -> (string)
The ID of the AWS account that owns the reservation.
RequesterId -> (string)
The ID of the requester that launched the instances on your
behalf (for example, AWS Management Console or Auto Scaling).
Groups -> (list)
One or more security groups.
(structure)
Describes a security group.
GroupName -> (string)
The name of the security group.
GroupId -> (string)
The ID of the security group.
Instances -> (list)
One or more instances.
(structure)
Describes an instance.
InstanceId -> (string)
The ID of the instance.
ImageId -> (string)
The ID of the AMI used to launch the instance.
State -> (structure)
The current state of the instance.
Code -> (integer)
The low byte represents the state. The high byte
is an opaque internal value and should be ignored.
...
```
Wenn die Ausgabe in JSON AWS CLI gerendert wird, wird sie zu einem Array von Reservierungsobjekten, ähnlich dem folgenden Beispiel.
```
{
"Reservations": [
{
"OwnerId": "012345678901",
"ReservationId": "r-4c58f8a0",
"Groups": [],
"RequesterId": "012345678901",
"Instances": [
{
"Monitoring": {
"State": "disabled"
},
"PublicDnsName": "ec2-52-74-16-12.us-west-2.compute.amazonaws.com",
"State": {
"Code": 16,
"Name": "running"
},
...
```
Jedes Reservierungsobjekt enthält Felder mit einer Beschreibung der Reservierung und einem Array von Instance-Objekten, jedes mit eigenen Feldern (z. B. `PublicDnsName`) und Objekten (z. B. `State`), die es beschreiben.
**Windows-Nutzer**
Sie können die Ausgabe des Hilfebefehls *weiterleiten* (\$1) an den `more`-Befehl, um die Hilfedatei seitenweise anzusehen. Drücken Sie die Leertaste oder **PgDn**, um einen größeren Teil des Dokuments anzuzeigen und den Vorgang **q** zu beenden.
```
C:\> aws ec2 describe-instances help | more
```
## AWS CLI Referenzhandbuch
Die Hilfedateien enthalten Links, die nicht von der Befehlszeile aus angezeigt oder aufgerufen werden können. Sie können sich diese Links ansehen und mit ihnen interagieren, indem Sie das verwenden. Die Referenz enthält auch den Hilfeinhalt für alle AWS CLI Befehle. Die Beschreibungen sind so strukturiert, dass eine einfache Navigation und Anzeige auf Mobilgeräten, Tablets und Desktop-Bildschirmen möglich ist.
## API-Dokumentation
Alle Befehle in der AWS CLI entsprechen Anfragen, die an die öffentliche API eines AWS Dienstes gestellt wurden. Jeder Service mit einer öffentlichen API verfügt über eine API-Referenz, die über die Service-Startseite auf der Website [AWS -Dokumentation](https://docs.aws.amazon.com/) aufgerufen werden kann. Die Inhalte für eine API-Referenz sind unterschiedlich, je nachdem, wie die API erstellt wurde und welches Protokoll verwendet wird. Im Allgemeinen enthält eine API-Referenz detaillierte Informationen zu den von der API unterstützten Operationen, den Daten, die an den und von dem Service gesendet werden, und mögliche Fehlerbedingungen, die der Service ausgibt.
**API-Dokumentationsabschnitte**
+ **Aktionen** – Detaillierte Informationen zu den einzelnen Operationen und ihren Parametern (einschließlich Einschränkungen bei der Länge oder den Inhalten und Standardwerte). Listet die Fehler auf, die bei dieser Operation auftreten können. Jede Operation entspricht einem Unterbefehl in der AWS CLI.
+ **Datentypen** – Detaillierte Informationen zu Strukturen, die ein Befehl möglicherweise als Parameter erfordert oder als Reaktion auf eine Anfrage zurückgibt.
+ **Häufige Parameter** – Detaillierte Informationen zu Parametern, die von allen Aktionen für den Service geteilt werden.
+ **Häufige Fehler** – Ausführliche Informationen zu Fehlern, die von den Aktionen eines Services ausgegeben werden können.
Der Name und die Verfügbarkeit jedes Abschnitts kann abhängig vom Service variieren.
**Servicespezifisch CLIs**
Einige Dienste verfügen über eine separate CLI, die aus der Zeit stammt, bevor eine einzige erstellt AWS CLI wurde, um mit allen Diensten zu funktionieren. Für diese dienstspezifischen Dienste CLIs gibt es eine separate Dokumentation, die auf der Dokumentationsseite des Dienstes verlinkt ist. Die Dokumentation für dienstspezifische Zwecke gilt CLIs nicht für die. AWS CLI
## Behebung von Fehlern
Hilfe zur Diagnose und Behebung von AWS CLI Fehlern finden Sie unter. [Behebung von Fehlern für den AWS CLI](cli-chap-troubleshooting.md)
## Weitere Hilfe
Weitere Hilfe bei Ihren AWS CLI Problemen finden Sie in der [AWS CLI Community](https://github.com/aws/aws-cli/issues) unter *GitHub*.
# Befehlsstruktur in der AWS CLI
In diesem Thema wird beschrieben, wie ein AWS Command Line Interface (AWS CLI)-Befehl strukturiert ist und wie Wait–Befehle verwendet werden.
**Topics**
+ [Befehlsstruktur](#cli-usage-commandstructure-structure.title)
+ [Wait-Befehle](#cli-usage-commandstructure-wait)
## Befehlsstruktur
Die AWS CLI verwendet eine mehrteilige Struktur in der Befehlszeile, die in dieser Reihenfolge angegeben werden muss:
1. Basisaufruf des `aws`-Programms.
1. Der Top-Level-*Befehl*, der in der Regel einem AWS-Service entspricht, der von der AWS CLI unterstützt wird.
1. Der *Unterbefehl*, der den auszuführenden Vorgang angibt.
1. Allgemeine AWS CLI-Optionen oder -Parameter, die von dem Vorgang benötigt werden. Sie können diese in beliebiger Reihenfolge angeben, da diese Informationen nach den ersten drei Teilen aufgeführt werden. Bei mehrfacher Angabe eines exklusiven Parameters wird nur der *letzte Wert* angewendet.
```
$ aws [options and parameters]
```
Parameter können verschiedene Typen von Eingabewerten akzeptieren, darunter Zahlen, Zeichenfolgen, Listen, Zuordnungen und JSON-Strukturen. Was unterstützt wird, hängt von dem angegebenen Befehl und Unterbefehl ab.
### Beispiele
**Amazon S3**
Das folgende Beispiel listet alle Ihre Amazon-S3-Buckets auf.
```
$ aws s3 ls
2018-12-11 17:08:50 amzn-s3-demo-bucket1
2018-12-14 14:55:44 amzn-s3-demo-bucket2
```
Weitere Informationen zu den Amazon-S3-Befehlen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html) in der *AWS CLI-Befehlsreferenz.*
**AWS CloudFormation**
Das folgende [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-change-set.html)-Befehlsbeispiel ändert den Namen des Cloudformation-Stacks zu *my-change-set*.
```
$ aws cloudformation create-change-set --stack-name my-stack --change-set-name my-change-set
```
Weitere Informationen zu den AWS CloudFormation-Befehlen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/index.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/index.html) in der *AWS CLI-Befehlsreferenz*.
## Wait-Befehle
Für einige AWS-Services sind `wait`-Befehle verfügbar. Jeder Befehl, der `aws wait` verwendet, wartet normalerweise, bis ein Befehl abgeschlossen ist, bevor er zum nächsten Schritt übergeht. Dies ist besonders nützlich für mehrteilige Befehle oder Skripterstellung, da Sie einen Wait-Befehl verwenden können, um zu verhindern, dass zu nachfolgenden Schritten übergegangen wird, wenn der Wait-Befehl fehlschlägt.
Die AWS CLI verwendet eine mehrteilige Struktur in der Befehlszeile für den Befehl `wait`, die in dieser Reihenfolge angegeben werden muss:
1. Basisaufruf des `aws`-Programms.
1. Der Top-Level-*Befehl*, der in der Regel einem AWS-Service entspricht, der von der AWS CLI unterstützt wird.
1. Der `wait`-Befehl.
1. Der *Unterbefehl*, der den auszuführenden Vorgang angibt.
1. Allgemeine CLI-Optionen oder -Parameter, die von dem Vorgang benötigt werden. Sie können diese in beliebiger Reihenfolge angeben, da diese Informationen nach den ersten drei Teilen aufgeführt werden. Bei mehrfacher Angabe eines exklusiven Parameters wird nur der *letzte Wert* angewendet.
```
$ aws wait [options and parameters]
```
Parameter können verschiedene Typen von Eingabewerten akzeptieren, darunter Zahlen, Zeichenfolgen, Listen, Zuordnungen und JSON-Strukturen. Was unterstützt wird, hängt von dem angegebenen Befehl und Unterbefehl ab.
**Anmerkung**
Nicht jeder AWS-Service unterstützt `wait`-Befehle. Informieren Sie sich im [AWS CLIReferenzleitfaden für Version 2](https://docs.aws.amazon.com/cli/latest/reference/index.html) darüber, ob Ihr Service `wait`-Befehle unterstützt.
### Beispiele
**AWS CloudFormation**
Die folgenden [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html)-Befehlsbeispiele werden nur angehalten und fortgesetzt, nachdem bestätigt wurde, dass der Änderungssatz *my-change-set* im *my-stack*-Stack zur Ausführung bereit ist.
```
$ aws cloudformation wait change-set-create-complete --stack-name my-stack --change-set-name my-change-set
```
Weitere Informationen zu den AWS CloudFormation `wait`-Befehlen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html) in der *AWS CLI-Befehlsreferenz*.
**AWS CodeDeploy**
Folgende [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html)-Befehlsbeispiele werden angehalten, bis die *d-A1B2C3111*-Bereitstellung erfolgreich abgeschlossen wird.
```
$ aws deploy wait deployment-successful --deployment-id d-A1B2C3111
```
Weitere Informationen zu den AWS CodeDeploy `wait`-Befehlen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html) in der *AWS CLI-Befehlsreferenz*.
# Angeben von Parameterwerten in der AWS CLI
Viele in der AWS Command Line Interface (AWS CLI) verwendeten Parameter sind einfache Zeichenfolgen oder numerische Werte, wie der Schlüsselpaarname `my-key-pair` in folgendem Beispiel für den Befehl `aws ec2 create-key-pair`.
```
$ aws ec2 create-key-pair --key-name my-key-pair
```
Die Formatierung für den Befehl kann je nach Terminal unterschiedlich sein. Beispielsweise unterscheiden die meisten Terminals zwischen Groß- und Kleinschreibung, aber Powershell unterscheidet nicht zwischen Groß- und Kleinschreibung. Dies bedeutet, dass die beiden folgenden Befehlsbeispiele für Terminals, bei denen zwischen Groß- und Kleinschreibung unterschieden wird, unterschiedliche Ergebnisse liefern würden, da sie `MyFile*.txt` und `myfile*.txt` als **unterschiedliche** Parameter betrachten.
PowerShell würde diese Anfragen jedoch genauso verarbeiten, da es `MyFile*.txt` und `myfile*.txt` als**identische** Parameter betrachtet. Im folgenden Befehlsbeispiel werden diese Parameter mithilfe des Befehls `aws s3 cp` demonstriert:
```
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "MyFile*.txt"
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "myfile*.txt"
```
Weitere Informationen zur Nichtbeachtung von Groß- und Kleinschreibung in PowerShell finden Sie unter [about\$1Case-Sensitivity](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_case-sensitivity) in der *PowerShell-Dokumentation*.
Manchmal müssen Sie Anführungszeichen oder Literale für Zeichenketten verwenden, die Sonder- oder Leerzeichen enthalten. Die Regeln für diese Formatierung können zwischen den Terminals auch variieren. Weitere Hinweise zur Verwendung von Anführungszeichen um komplexe Parameter finden Sie unter [Verwenden von Anführungszeichen und Literalen mit Zeichenketten in AWS CLI](cli-usage-parameters-quoting-strings.md).
In diesen Themen werden die gängigsten Formatierungsregeln im Terminal behandelt. Wenn in Ihrem Terminal Probleme mit der Erkennung Ihrer Parameterwerte auftreten, lesen Sie unbedingt die Themen in diesem Abschnitt und informieren Sie sich außerdem in der Dokumentation Ihres Terminals über die spezifischen Syntaxregeln.
**Topics**
+ [Allgemeine Parametertypen in der AWS CLI](cli-usage-parameters-types.md)
+ [Verwenden von Anführungszeichen und Literalen mit Zeichenketten in AWS CLI](cli-usage-parameters-quoting-strings.md)
+ [Laden eines Parameters aus einer Datei in AWS CLI](cli-usage-parameters-file.md)
+ [AWS CLI Skelette und Eingabedateien in der AWS CLI](cli-usage-skeleton.md)
+ [Verwendung der Kurzsyntax in der AWS CLI](cli-usage-shorthand.md)
# Allgemeine Parametertypen in der AWS CLI
In diesem Abschnitt werden einige häufige Parametertypen sowie das in der Regel erforderliche Format beschrieben.
Wenn Sie Probleme mit der Formatierung eines Parameters für einen bestimmten Befehl haben, sehen Sie in der Hilfe nach, indem Sie nach dem Befehlsnamen **help** eingeben. Die Hilfe für jeden Unterbefehl enthält den Namen und die Beschreibung einer Option. Der Parametertyp der Option ist in Klammern angegeben. Weitere Informationen zur Anzeige der Hilfe finden Sie unter [Zugriff auf Hilfe und Ressourcen für AWS CLI](cli-usage-help.md).
**Topics**
+ [Zeichenfolge](#parameter-type-string)
+ [Zeitstempel](#parameter-type-timestamp)
+ [Auflisten](#parameter-type-list)
+ [Boolesch](#parameter-type-boolean)
+ [Ganzzahl](#parameter-type-integer)
+ [Binary/Blob (Binary Large Object) und Streaming-Blob](#parameter-type-blobs)
+ [Zuordnung](#parameter-type-map)
+ [Dokument](#parameter-type-document)
## Zeichenfolge
Zeichenfolgenparameter können alphanumerische Zeichen, Symbole und Leerzeichen aus dem [ASCII](https://wikipedia.org/wiki/ASCII)-Zeichensatz enthalten. Zeichenfolgen, die Leerzeichen enthalten, müssen in Anführungszeichen gesetzt werden. Wir empfehlen, keine anderen Symbole oder Leerzeichen als das Standardleerzeichen zu verwenden und die [Anführungszeichenregeln](cli-usage-parameters-quoting-strings.md) Ihres Terminals zu beachten, um unerwartete Ergebnisse zu vermeiden.
Einige Zeichenfolgenparameter können Binärdaten aus einer Datei akzeptieren. Ein Beispiel finden Sie unter [Binärdateien](cli-usage-parameters-file.md#cli-usage-parameters-file-binary).
## Zeitstempel
Zeitstempel sind nach dem [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html)-Standard formatiert. Diese werden oft als „`DateTime`“- oder „`Date`“-Parameter bezeichnet.
```
$ aws ec2 describe-spot-price-history --start-time 2014-10-13T19:00:00Z
```
Zu den akzeptierte Formaten zählen folgende:
+ *YYYY*- *MM* - *DD* T*hh*:*mm*: *ss.sss**TZD (UTC)*, zum Beispiel 2014-10-01T 20:30:00.000 Z
+ *YYYY*- *MM* - *DD* T::, zum Beispiel 2014-10-01T 12:30:00.000-08:00 *hh* *mm* *ss.sss* *TZD (with offset)*
+ *YYYY**MM*- -*DD*, zum Beispiel 2014-10-01
+ Unix-Zeit in Sekunden, beispielsweise 1 412 195 400. Dies wird manchmal als [Zeit seit Unix-Epoche](https://wikipedia.org/wiki/Unix_time) bezeichnet und gibt die Anzahl der Sekunden seit dem 1. Januar 1970, 0:00 Uhr UTC an.
Standardmäßig übersetzt AWS CLI Version 2 alle *** DateTime Antwortwerte*** in das ISO 8601-Format.
Sie können das Zeitstempelformat über die `cli\$1timestamp\$1format`-Dateieinstellung festlegen.
## Auflisten
Eine oder mehrere durch Leerzeichen voneinander getrennte Zeichenfolgen. Wenn eines der Zeichenfolgenelemente ein Leerzeichen enthält, müssen Sie es in Anführungszeichen setzen. Beachten Sie die [Anführungszeichenregeln](cli-usage-parameters-quoting-strings.md) Ihres Terminals, um unerwartete Ergebnisse zu vermeiden
```
$ aws ec2 describe-spot-price-history --instance-types m1.xlarge m1.medium
```
## Boolesch
Binäres Flag, das eine Option aktiviert oder deaktiviert. Zum Beispiel verfügt `ec2 describe-spot-price-history` über einen booleschen Parameter `--dry-run`. Wenn dieser angegeben wird, verifiziert er die Abfrage mit dem Service, ohne tatsächlich die Abfrage auszuführen.
```
$ aws ec2 describe-spot-price-history --dry-run
```
Die Ausgabe gibt an, ob der Befehl ordnungsgemäß formatiert wurde oder nicht. Dieser Befehl enthält auch eine Version des Parameters `--no-dry-run`, mit dem Sie explizit angeben können, dass der Befehl normal ausgeführt werden soll. Dies ist allerdings nicht erforderlich, da dies das Standardverhalten ist.
## Ganzzahl
Eine nicht signierte ganze Zahl.
```
$ aws ec2 describe-spot-price-history --max-items 5
```
## Binary/Blob (Binary Large Object) und Streaming-Blob
In der AWS CLI können Sie einen Binärwert als Zeichenfolge direkt in der Befehlszeile übergeben. Es gibt zwei Arten von Blobs:
+ [Blob](#parameter-type-blob)
+ [Streaming-Blob](#parameter-type-streaming-blob)
### Blob
Um einen Wert an einen Parameter vom Typ `blob` zu übergeben, müssen Sie unter Verwendung des Präfix `fileb://` einen Pfad zu einer lokalen Datei angeben, die die Binärdaten enthält. Dateien, auf die mit dem Präfix `fileb://` verwiesen wird, werden immer als unkodierte Binärdateien behandelt. Der angegebene Pfad wird als relativ zum aktuellen Arbeitsverzeichnis interpretiert. Beispiel: Der Parameter `--plaintext` für `aws kms encrypt` ist ein Blob.
```
$ aws kms encrypt \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--plaintext fileb://ExamplePlaintextFile \
--output text \
--query CiphertextBlob | base64 \
--decode > ExampleEncryptedFile
```
**Anmerkung**
Aus Gründen der Abwärtskompatibilität können Sie das Präfix `file://` verwenden. Basierend auf der Dateieinstellung `cli\$1binary\$1format` oder der Befehlszeilenoption `--cli-binary-format` werden zwei Formate verwendet:
Standard für die AWS CLI Version 2. Wenn der Wert der Einstellung `base64` lautet, werden Dateien, auf die mit dem Präfix `file://` verwiesen wird, als base64-kodierter Text behandelt.
Standard für die AWS CLI Version 1. Wenn der Wert der Einstellung `raw-in-base64-out` lautet, werden Dateien, auf die mit dem Präfix `file://` verwiesen wird, als Text gelesen und dann versucht die AWS CLI , sie in Binärform zu codieren.
Weitere Informationen finden Sie in der Erläuterung zur Dateieinstellung `cli\$1binary\$1format` oder zur Befehlszeilenoption `--cli-binary-format`.
### Streaming-Blob
Streaming-Blobs wie z. B. `aws cloudsearchdomain upload-documents` verwenden keine Präfixe. Stattdessen werden Streaming-Blob-Parameter unter Verwendung des direkten Dateipfads formatiert. Im folgenden Beispiel wird der direkte Dateipfad `document-batch.json` für den Befehl `aws cloudsearchdomain upload-documents` verwendet:
```
$ aws cloudsearchdomain upload-documents \
--endpoint-url https://doc-my-domain.us-west-1.cloudsearch.amazonaws.com \
--content-type application/json \
--documents document-batch.json
```
## Zuordnung
Ein Satz von Schlüssel-Wert-Paaren, der in JSON oder mit der [Kurznotation](cli-usage-shorthand.md) der CLI angegeben wird. Das folgende JSON-Beispiel liest ein Element aus einer Amazon-DynamoDB-Tabelle namens *my-table* mit einem Zuordnungs-Parameter, `--key`. Der Parameter gibt den Primärschlüssel namens *id* mit einem Zahlenwert von *1* in einer geschachtelten JSON-Struktur an.
Für eine erweiterte JSON-Nutzung in einer Befehlszeile sollten Sie einen Befehlszeilen-JSON-Prozessor wie `jq` verwenden, um JSON-Strings zu erstellen. Weitere Informationen zu `jq` finden Sie im [jq-Repository](http://stedolan.github.io/jq/) unter *GitHub*.
```
$ aws dynamodb get-item --table-name my-table --key '{"id": {"N":"1"}}'
{
"Item": {
"name": {
"S": "John"
},
"id": {
"N": "1"
}
}
}
```
## Dokument
**Anmerkung**
[Kurzsyntax](cli-usage-shorthand.md) ist mit Dokumenttypen nicht kompatibel.
Dokumenttypen werden verwendet, um Daten zu senden, ohne JSON in Zeichenfolgen einbetten zu müssen. Der Dokumenttyp ermöglicht Services, willkürliche Schemata bereitzustellen, damit Sie flexiblere Datentypen verwenden können.
Dies ermöglicht das Senden von JSON-Daten, ohne Werte in Escape-Zeichen einschließen zu müssen. Anstatt beispielsweise die folgende JSON-Eingabe mit Escape-Zeichen zu verwenden:
```
{"document": "{\"key\":true}"}
```
Können Sie den folgenden Dokumenttyp verwenden:
```
{"document": {"key": true}}
```
### Gültige Werte für Dokumenttypen
Aufgrund der flexiblen Natur von Dokumenttypen gibt es mehrere gültige Werttypen. Gültige Werte sind z. B. die Folgenden:
**Zeichenfolge**
```
--option '"value"'
```
**Zahl**
```
--option 123
--option 123.456
```
**Boolesch**
```
--option true
```
**Null**
```
--option null
```
**Array**
```
--option '["value1", "value2", "value3"]'
--option '["value", 1, true, null, ["key1", 2.34], {"key2": "value2"}]'
```
**Objekt**
```
--option '{"key": "value"}'
--option '{"key1": "value1", "key2": 123, "key3": true, "key4": null, "key5": ["value3", "value4"], "key6": {"value5": "value6"}'
```
# Verwenden von Anführungszeichen und Literalen mit Zeichenketten in AWS CLI
Es gibt generell zwei Möglichkeiten, wie einfache und doppelte Anführungszeichen in der AWS CLI verwendet werden.
+ [Verwenden von Anführungszeichen um Zeichenfolgen, die Leerzeichen enthalten](#cli-usage-parameters-quoting-strings-around)
+ [Verwenden von Anführungszeichen in Zeichenfolgen](#cli-usage-parameters-quoting-strings-containing)
## Verwenden von Anführungszeichen um Zeichenfolgen, die Leerzeichen enthalten
Parameternamen und ihre Werte werden in der Befehlszeile durch Leerzeichen getrennt. Wenn ein Zeichenkettenwert ein eingebettetes Leerzeichen enthält, müssen Sie die gesamte Zeichenfolge in Anführungszeichen setzen, um zu verhindern, dass das AWS CLI Leerzeichen als Trennzeichen zwischen dem Wert und dem nächsten Parameternamen falsch interpretiert wird. Welche Art von Anführungszeichen Sie verwenden, hängt vom Betriebssystem ab, auf dem Sie das Programm ausführen. AWS CLI
------
#### [ Linux and macOS ]
Verwenden Sie einfache Anführungszeichen `' '`
```
$ aws ec2 create-key-pair --key-name 'my key pair'
```
Weitere Informationen zur Verwendung von Anführungszeichen finden Sie in der Benutzerdokumentation für Ihre bevorzugte Shell.
------
#### [ PowerShell ]
**Einfache Anführungszeichen (empfohlen)**
Einfache Anführungszeichen `' '` werden als `verbatim`-Zeichenfolge bezeichnet. Die Zeichenfolge wird genau so an den Befehl übergeben, wie Sie sie eingeben, was bedeutet, dass PowerShell Variablen nicht weitergegeben werden.
```
PS C:\> aws ec2 create-key-pair --key-name 'my key pair'
```
**Doppelte Anführungszeichen**
Doppelte Anführungszeichen `" "` werden als `expandable`-Zeichenfolge bezeichnet. Variablen können in erweiterbaren Zeichenfolgen übergeben werden.
```
PS C:\> aws ec2 create-key-pair --key-name "my key pair"
```
Weitere Informationen zur Verwendung von Anführungszeichen finden Sie unter [About Rules](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) in den *Microsoft PowerShell Docs*.
------
#### [ Windows command prompt ]
Verwenden Sie doppelte Anführungszeichen `" "`.
```
C:\> aws ec2 create-key-pair --key-name "my key pair"
```
------
Sie können optional den Parameternamen vom Wert durch ein Gleichheitszeichen `=` statt eines Leerzeichens trennen. Dies ist in der Regel nur erforderlich, wenn der Wert des Parameters mit einem Bindestrich beginnt.
```
$ aws ec2 delete-key-pair --key-name=-mykey
```
## Verwenden von Anführungszeichen in Zeichenfolgen
Zeichenfolgen können Anführungszeichen enthalten und Ihre Shell erfordert möglicherweise Escape-Anführungszeichen, damit sie ordnungsgemäß funktionieren. Einer der allgemeinen Parameterwerttypen ist eine JSON-Zeichenfolge. Dies ist komplex, da es Leerzeichen und doppelte Anführungszeichen `" "` um jeden Elementnamen und Wert in der JSON-Struktur enthält. Wie Sie JSON-formatierte Parameter an der Befehlszeile eingeben, unterscheidet sich je nach Betriebssystem.
Für eine erweiterte JSON-Nutzung in einer Befehlszeile sollten Sie einen Befehlszeilen-JSON-Prozessor wie `jq` verwenden, um JSON-Strings zu erstellen. Weitere Informationen zu finden Sie im `jq` [jq-Repository](http://stedolan.github.io/jq/) unter. *GitHub*
------
#### [ Linux and macOS ]
Damit Linux und macOS Strings buchstäblich interpretieren, verwenden Sie einfache Anführungszeichen `' '`, um die JSON-Datenstruktur einzuschließen, wie im folgenden Beispiel. In die JSON-Zeichenfolge eingebettete doppelte Anführungszeichen müssen nicht mit Escape-Zeichen versehen werden, da sie wörtlich behandelt werden. Da die JSON in einfache Anführungszeichen eingeschlossen ist, müssen alle einfachen Anführungszeichen in der Zeichenfolge mit Escapezeichen versehen werden. Dies wird normalerweise mit einem umgekehrten Schrägstrich vor dem einfachen Anführungszeichen `\'` erreicht.
```
$ aws ec2 run-instances \
--image-id ami-12345678 \
--block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]'
```
Weitere Informationen zur Verwendung von Anführungszeichen finden Sie in der Benutzerdokumentation für Ihre bevorzugte Shell.
------
#### [ PowerShell ]
Verwenden Sie einfache Anführungszeichen `' '` oder doppelte Anführungszeichen `" "`.
**Einfache Anführungszeichen (empfohlen)**
Einfache Anführungszeichen `' '` werden als `verbatim`-Zeichenfolge bezeichnet. Die Zeichenfolge wird genau so an den Befehl übergeben, wie Sie sie eingeben, was bedeutet, dass PowerShell Variablen nicht weitergeleitet werden.
Da JSON-Datenstrukturen doppelte Anführungszeichen enthalten, empfehlen wir **einfache** Anführungszeichen `' '`, um sie einzuschließen. Wenn Sie **einfache** Anführungszeichen verwenden, müssen Sie in die JSON-Zeichenfolge eingebettete **doppelte** Anführungszeichen nicht mit Escape-Zeichen versehen. Sie müssen jedoch jedes **einzelne** Anführungszeichen mit einem Backtick ``` innerhalb der JSON-Struktur markieren.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]'
```
**Doppelte Anführungszeichen**
Doppelte Anführungszeichen `" "` werden als `expandable`-Zeichenfolgen bezeichnet. Variablen können in erweiterbaren Zeichenfolgen übergeben werden.
Wenn Sie **doppelte** Anführungszeichen verwenden, müssen Sie in die JSON-Zeichenfolge eingebettete **einfache** Anführungszeichen nicht mit Escape-Zeichen versehen. Sie müssen jedoch jedes **doppelte** Anführungszeichen mit einem Backtick ``` innerhalb der JSON-Struktur markieren, wie im folgenden Beispiel.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings "[{`"DeviceName`":`"/dev/sdb`",`"Ebs`":{`"VolumeSize`":20,`"DeleteOnTermination`":false,`"VolumeType`":`"standard`"}}]"
```
Weitere Informationen zur Verwendung von Anführungszeichen finden Sie unter [About Rules](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) in den *Microsoft PowerShell Docs*.
**Warnung**
Before PowerShell sendet einen Befehl an die AWS CLI und bestimmt, ob Ihr Befehl anhand typischer Regeln PowerShell oder mit `CommandLineToArgvW` Anführungszeichen interpretiert wird. Wenn PowerShell Prozesse verwenden`CommandLineToArgvW`, müssen Sie Zeichen mit einem `\` umgekehrten Schrägstrich maskieren.
Weitere Informationen dazu finden Sie unter [Was ist mit der seltsamen Behandlung von Anführungszeichen und Backslashes durch CommandLineToArgv W](https://devblogs.microsoft.com/oldnewthing/20100917-00/?p=12833) in *Microsoft DevBlogs*, [Jeder zitiert Befehlszeilenargumente falsch im](https://docs.microsoft.com/en-us/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way) *Microsoft Docs-Blog* und [CommandLineToArgvW-Funktion](https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-commandlinetoargvw#remarks) in den *Microsoft* Docs. `CommandLineToArgvW` PowerShell
**Einfache Anführungszeichen**
Einfache Anführungszeichen `' '` werden als `verbatim`-Zeichenfolge bezeichnet. Die Zeichenfolge wird genau so an den Befehl übergeben, wie Sie sie eingeben, was bedeutet, dass PowerShell Variablen nicht weitergeleitet werden. Verwenden Sie einen Backslash `\` als Escape-Zeichen.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings '[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]'
```
**Doppelte Anführungszeichen**
Doppelte Anführungszeichen `" "` werden als `expandable`-Zeichenfolgen bezeichnet. Variablen können in `expandable`-Zeichenfolgen übergeben werden. Bei Zeichenketten in doppelten Anführungszeichen müssen Sie zweimal Escape-Zeichen verwenden, indem Sie *`\$1* für jedes Anführungszeichen verwenden, anstatt nur einen Backtick zu verwenden. Der Backtick maskiert den Backslash, und der Backslash wird als Escape-Zeichen für den `CommandLineToArgvW`-Prozess verwendet.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings "[{`\"DeviceName`\":`\"/dev/sdb`\",`\"Ebs`\":{`\"VolumeSize`\":20,`\"DeleteOnTermination`\":false,`\"VolumeType`\":`\"standard`\"}}]"
```
**Blobs (empfohlen)**
Um die PowerShell Anführungsregeln für die JSON-Dateneingabe zu umgehen, verwenden Sie Blobs, um Ihre JSON-Daten direkt an die zu übergeben. AWS CLI Weitere Informationen zu Blobs finden Sie unter [Blob](cli-usage-parameters-types.md#parameter-type-blob).
------
#### [ Windows command prompt ]
Die Windows-Eingabeaufforderung verwendet doppelte Anführungszeichen `" "` vor und nach der JSON-Datenstruktur. Um zu verhindern, dass der Befehlsprozessor die in JSON eingebetteten doppelten Anführungszeichen falsch interpretiert, müssen Sie auch jedes doppelte Anführungszeichen `\` innerhalb der JSON-Datenstruktur selbst maskieren (als Escapezeichen einen umgekehrten Schrägstrich `"` voranstellen), wie im folgenden Beispiel.
```
C:\> aws ec2 run-instances ^
--image-id ami-12345678 ^
--block-device-mappings "[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]"
```
Nur die äußersten doppelten Anführungszeichen benötigen kein Escape-Zeichen.
------
# Laden eines Parameters aus einer Datei in AWS CLI
Einige Parameter erwarten Dateinamen als Argumente, aus denen die Daten AWS CLI geladen werden. Mit anderen Parametern können Sie den Parameterwert als Text angeben, der in die Befehlszeile eingegeben wird oder aus einer Datei gelesen wird. Unabhängig davon, ob eine Datei erforderlich oder optional ist, müssen Sie die Datei korrekt codieren, damit sie verstanden AWS CLI werden kann. Die Kodierung der Datei muss mit dem Standardgebietsschema des Lesesystems übereinstimmen. Sie können dies mithilfe der Python-Methode `locale.getpreferredencoding()` bestimmen.
Diese Methode dient zum Laden einer Datei für einen einzelnen Parameter. Weitere Informationen zum Laden mehrerer Parameter mit einer einzigen Datei finden Sie unter [AWS CLI Skelette und Eingabedateien in der AWS CLI](cli-usage-skeleton.md).
**Anmerkung**
Standardmäßig PowerShell gibt Windows Text als UTF-16 aus, was mit der UTF-8-Kodierung kollidiert, die von JSON-Dateien und vielen Linux-Systemen verwendet wird. Wir empfehlen Ihnen, dies `-Encoding ascii` zusammen mit Ihren PowerShell `Out-File` Befehlen zu verwenden, um sicherzustellen, dass die resultierende Datei gelesen AWS CLI werden kann.
**Topics**
+ [So laden Sie Parameter aus einer Datei](#cli-usage-parameters-file-how)
+ [Binärdateien](#cli-usage-parameters-file-binary)
+ [Laden einer Datei als Kurznotationssyntax-Wert](#cli-usage-parameters-file-shorthand)
## So laden Sie Parameter aus einer Datei
Manchmal ist es praktisch, einen Parameterwert aus einer Datei zu laden, anstatt den gesamten Wert in die Befehlszeile einzugeben, beispielsweise, wenn es sich bei dem Parameterwert um eine komplexe JSON-Zeichenfolge handelt. Um eine Datei anzugeben, die den Wert enthält, geben Sie eine Datei-URL im folgenden Format an.
```
file://complete/path/to/file
```
+ Die ersten beiden Schrägstriche "/" sind Teil der Spezifikation. Wenn der erforderliche Pfad mit einem "/" beginnt, besteht das Ergebnis aus drei Schrägstrichen: `file:///folder/file`.
+ Die URL gibt den Pfad zu der Datei mit dem tatsächlichen Parameterinhalt an.
+ Wenn Sie Dateien mit Leerzeichen oder Sonderzeichen verwenden, befolgen Sie die [Anführungszeichen- und Escape-Regeln](cli-usage-parameters-quoting-strings.md) Ihres Terminals.
Die Dateipfade in den folgenden Beispielen werden als relativ zum aktuellen Arbeitsverzeichnis interpretiert.
------
#### [ Linux or macOS ]
```
// Read from a file in the current directory
$ aws ec2 describe-instances --filters file://filter.json
// Read from a file in /tmp
$ aws ec2 describe-instances --filters file:///tmp/filter.json
// Read from a file with a filename with whitespaces
$ aws ec2 describe-instances --filters 'file://filter content.json'
```
------
#### [ Windows command prompt ]
```
// Read from a file in C:\temp
C:\> aws ec2 describe-instances --filters file://C:\temp\filter.json
// Read from a file with a filename with whitespaces
C:\> aws ec2 describe-instances --filters "file://C:\temp\filter content.json"
```
------
Die Präfixoption `file://` unterstützt Erweiterungen im Unix-Stil, einschließlich "`~/`", "`./`" und "`../`". Unter Windows erfolgt mit dem Ausdruck "`~/`" die Erweiterung zu Ihrem Benutzerverzeichnis, das in der Umgebungsvariablen `%USERPROFILE%` gespeichert ist. Beispielsweise befindet sich das Benutzerverzeichnis in Windows 10 in der Regel unter `%USERPROFILE%`.
JSON-Dokumente, die als Wert eines anderen JSON-Dokuments eingebettet sind, müssen weiterhin durch ein Escape-Zeichen geschützt werden.
```
$ aws sqs create-queue --queue-name my-queue --attributes file://attributes.json
```
**attributes.json**
```
{
"RedrivePolicy": "{\"deadLetterTargetArn\":\"arn:aws:sqs:us-west-2:0123456789012:deadletter\", \"maxReceiveCount\":\"5\"}"
}
```
## Binärdateien
Für Befehle, die Binärdaten als Parameter annehmen, geben Sie mit dem Präfix `fileb://` an, dass es sich bei den Daten um binäre Inhalte handelt. Zu den Befehlen, die Binärdaten akzeptieren, zählen:
+ **`aws ec2 run-instances:`** `--user-data`-Parameter.
+ **`aws s3api put-object:`** `--sse-customer-key`-Parameter.
+ **`aws kms decrypt:`** `--ciphertext-blob`-Parameter.
Das folgende Beispiel generiert mit einem Linux-Befehlszeilen-Tool einen binären 256-Bit-AES-Schlüssel und stellt diesen dann in Amazon S3 bereit, um eine hochgeladene Datei serverseitig zu verschlüsseln.
```
$ dd if=/dev/urandom bs=1 count=32 > sse.key
32+0 records in
32+0 records out
32 bytes (32 B) copied, 0.000164441 s, 195 kB/s
$ aws s3api put-object \
--bucket amzn-s3-demo-bucket \
--key test.txt \
--body test.txt \
--sse-customer-key fileb://sse.key \
--sse-customer-algorithm AES256
{
"SSECustomerKeyMD5": "iVg8oWa8sy714+FjtesrJg==",
"SSECustomerAlgorithm": "AES256",
"ETag": "\"a6118e84b76cf98bf04bbe14b6045c6c\""
}
```
Ein weiteres Beispiel mit einem Verweis auf eine Datei mit JSON-formatierten Parametern finden Sie unter [Anfügen einer IAM-verwalteten Richtlinie an einen Benutzer](cli-services-iam.md#cli-services-iam-policy).
## Laden einer Datei als Kurznotationssyntax-Wert
Wenn die Kurznotationssyntax für einen großen oder komplexen Wert verwendet wird, ist es oft einfacher, eine Datei als Wert zu laden. Um eine Datei als Kurznotationssyntax-Wert zu laden, ändert sich die Formatierung geringfügig. Statt `key=value` verwenden Sie den Operator `@=` anstelle des Operators `=`. `@=` weist die AWS CLI darauf hin, dass der Wert als Dateipfad und nicht als Zeichenfolge gelesen werden soll. Das folgende Beispiel zeigt ein Schlüssel-Wert-Paar, das eine Datei für seinen Wert lädt.
------
#### [ Linux or macOS ]
```
--option key@=file://template.txt
```
------
#### [ Windows ]
```
--option "key1@=file://template.txt"
```
------
Das folgende Beispiel zeigt, wie eine Zertifikatsdatei für den Befehl `aws rolesanywhere create-trust-anchor` geladen wird.
```
$ aws rolesanywhere create-trust-anchor --name TrustAnchor \
--source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \
--enabled
```
Weitere Informationen zur Kurznotationssyntax finden Sie unter [Verwendung der Kurzsyntax in der AWS CLI](cli-usage-shorthand.md).
# AWS CLI Skelette und Eingabedateien in der AWS CLI
Die meisten AWS CLI Befehle akzeptieren den Import von Parametereingaben aus einer Datei. Diese Vorlagen können mit der Option `generate-cli-skeleton` generiert und dann mit den Parametern `--cli-input-json` und`--cli-input-yaml` importiert werden.
**Topics**
+ [Über AWS CLI Skelette und Eingabedateien](#cli-usage-skeleton-about)
+ [Generieren und Importieren eines Befehls-Skeletons](#cli-usage-skeleton-generate)
+ [Kombinieren von Eingabedateien und Befehlszeilenparametern](#cli-usage-skeleton-combine)
## Über AWS CLI Skelette und Eingabedateien
Die meisten Befehle AWS Command Line Interface (AWS CLI) unterstützen die Fähigkeit, Parametereingaben aus einer Datei mit den `--cli-input-yaml` Parametern `--cli-input-json` und s zu akzeptieren.
Dieselben Befehle nutzen den Parameter `--generate-cli-skeleton` zum Generieren einer Datei im JSON- oder YAML-Format mit allen Parametern, die Sie bearbeiten und füllen können. Anschließend können Sie den Befehl mit dem Parameter `--cli-input-json` oder `--cli-input-yaml` ausführen und auf die gefüllte Datei zeigen.
**Wichtig**
Benutzerdefinierte AWS CLI Befehle, wie z. B. die [command](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html), unterstützen weder die in diesem Thema beschriebenen `--cli-input-yaml` Parameter `--generate-cli-skeleton` oder `--cli-input-json` noch die Parameter. Um zu überprüfen, ob ein bestimmter Befehl diese Parameter unterstützt, führen Sie den [`help`Befehl für den Befehl](cli-usage-help.md#cli-usage-help-command) aus, den Sie verwenden möchten, oder schlagen Sie im Referenzhandbuch für [Version 2](https://docs.aws.amazon.com/cli/latest/reference/index.html) nach.
Mit dem Befehl `--generate-cli-skeleton` wird eine Parametervorlage generiert und angezeigt, die Sie anpassen und als Eingabe für einen Befehl verwenden können. Die generierte Vorlage enthält alle Parameter, die der Befehl unterstützt.
Der `--generate-cli-skeleton`-Parameter akzeptiert einen der folgenden Werte:
+ `input` – Die generierte Vorlage enthält alle Eingabeparameter, die als JSON formatiert sind. Dies ist der Standardwert.
+ `yaml-input` – Die generierte Vorlage enthält alle Eingabeparameter, die als YAML formatiert sind.
+ `output` – Die generierte Vorlage enthält alle Ausgabeparameter, die als JSON formatiert sind. Sie können die Ausgabeparameter derzeit nicht als YAML anfordern.
Da AWS CLI es sich im Grunde um einen „Wrapper“ rund um die API des Dienstes handelt, erwartet die Skelettdatei, dass Sie auf alle Parameter anhand ihrer zugrunde liegenden API-Parameternamen verweisen. Dies unterscheidet sich wahrscheinlich vom AWS CLI Parameternamen. Beispielsweise `user-name` könnte ein benannter AWS CLI Parameter dem API-Parameter namens des AWS Dienstes zugeordnet sein `UserName` (beachten Sie die geänderte Großschreibung und den fehlenden Bindestrich). Wir empfehlen, die Option `--generate-cli-skeleton` zu verwenden, um die Vorlage mit den „richtigen“ Parameternamen zu generieren und so Fehler zu vermeiden. Sie können das API-Referenzhandbuch zum Service nutzen, um die erwarteten Parameternamen anzuzeigen. Sie können alle Parameter aus der Vorlage löschen, die nicht erforderlich sind und für die Sie keinen Wert angeben möchten.
Wenn Sie beispielsweise den folgenden Befehl ausführen, wird die Parametervorlage für den Amazon-Elastic-Compute-Cloud (Amazon EC2)-Befehl **run-instances** generiert.
------
#### [ JSON ]
Das folgende Beispiel zeigt, wie eine in JSON formatierte Vorlage generiert wird, indem der Standardwert (`input`) für den `--generate-cli-skeleton`-Parameter verwendet wird.
```
$ aws ec2 run-instances --generate-cli-skeleton
```
```
{
"DryRun": true,
"ImageId": "",
"MinCount": 0,
"MaxCount": 0,
"KeyName": "",
"SecurityGroups": [
""
],
"SecurityGroupIds": [
""
],
"UserData": "",
"InstanceType": "",
"Placement": {
"AvailabilityZone": "",
"GroupName": "",
"Tenancy": ""
},
"KernelId": "",
"RamdiskId": "",
"BlockDeviceMappings": [
{
"VirtualName": "",
"DeviceName": "",
"Ebs": {
"SnapshotId": "",
"VolumeSize": 0,
"DeleteOnTermination": true,
"VolumeType": "",
"Iops": 0,
"Encrypted": true
},
"NoDevice": ""
}
],
"Monitoring": {
"Enabled": true
},
"SubnetId": "",
"DisableApiTermination": true,
"InstanceInitiatedShutdownBehavior": "",
"PrivateIpAddress": "",
"ClientToken": "",
"AdditionalInfo": "",
"NetworkInterfaces": [
{
"NetworkInterfaceId": "",
"DeviceIndex": 0,
"SubnetId": "",
"Description": "",
"PrivateIpAddress": "",
"Groups": [
""
],
"DeleteOnTermination": true,
"PrivateIpAddresses": [
{
"PrivateIpAddress": "",
"Primary": true
}
],
"SecondaryPrivateIpAddressCount": 0,
"AssociatePublicIpAddress": true
}
],
"IamInstanceProfile": {
"Arn": "",
"Name": ""
},
"EbsOptimized": true
}
```
------
#### [ YAML ]
Das folgende Beispiel zeigt, wie eine in YAML formatierte Vorlage generiert wird, indem der Wert `yaml-input` für den `--generate-cli-skeleton`-Parameter verwendet wird.
```
$ aws ec2 run-instances --generate-cli-skeleton yaml-input
```
```
BlockDeviceMappings: # The block device mapping entries.
- DeviceName: '' # The device name (for example, /dev/sdh or xvdh).
VirtualName: '' # The virtual device name (ephemeralN).
Ebs: # Parameters used to automatically set up Amazon EBS volumes when the instance is launched.
DeleteOnTermination: true # Indicates whether the EBS volume is deleted on instance termination.
Iops: 0 # The number of I/O operations per second (IOPS) that the volume supports.
SnapshotId: '' # The ID of the snapshot.
VolumeSize: 0 # The size of the volume, in GiB.
VolumeType: st1 # The volume type. Valid values are: standard, io1, gp2, sc1, st1.
Encrypted: true # Indicates whether the encryption state of an EBS volume is changed while being restored from a backing snapshot.
KmsKeyId: '' # Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed KMS key under which the EBS volume is encrypted.
NoDevice: '' # Suppresses the specified device included in the block device mapping of the AMI.
ImageId: '' # The ID of the AMI.
InstanceType: c4.4xlarge # The instance type. Valid values are: t1.micro, t2.nano, t2.micro, t2.small, t2.medium, t2.large, t2.xlarge, t2.2xlarge, t3.nano, t3.micro, t3.small, t3.medium, t3.large, t3.xlarge, t3.2xlarge, t3a.nano, t3a.micro, t3a.small, t3a.medium, t3a.large, t3a.xlarge, t3a.2xlarge, m1.small, m1.medium, m1.large, m1.xlarge, m3.medium, m3.large, m3.xlarge, m3.2xlarge, m4.large, m4.xlarge, m4.2xlarge, m4.4xlarge, m4.10xlarge, m4.16xlarge, m2.xlarge, m2.2xlarge, m2.4xlarge, cr1.8xlarge, r3.large, r3.xlarge, r3.2xlarge, r3.4xlarge, r3.8xlarge, r4.large, r4.xlarge, r4.2xlarge, r4.4xlarge, r4.8xlarge, r4.16xlarge, r5.large, r5.xlarge, r5.2xlarge, r5.4xlarge, r5.8xlarge, r5.12xlarge, r5.16xlarge, r5.24xlarge, r5.metal, r5a.large, r5a.xlarge, r5a.2xlarge, r5a.4xlarge, r5a.8xlarge, r5a.12xlarge, r5a.16xlarge, r5a.24xlarge, r5d.large, r5d.xlarge, r5d.2xlarge, r5d.4xlarge, r5d.8xlarge, r5d.12xlarge, r5d.16xlarge, r5d.24xlarge, r5d.metal, r5ad.large, r5ad.xlarge, r5ad.2xlarge, r5ad.4xlarge, r5ad.8xlarge, r5ad.12xlarge, r5ad.16xlarge, r5ad.24xlarge, x1.16xlarge, x1.32xlarge, x1e.xlarge, x1e.2xlarge, x1e.4xlarge, x1e.8xlarge, x1e.16xlarge, x1e.32xlarge, i2.xlarge, i2.2xlarge, i2.4xlarge, i2.8xlarge, i3.large, i3.xlarge, i3.2xlarge, i3.4xlarge, i3.8xlarge, i3.16xlarge, i3.metal, i3en.large, i3en.xlarge, i3en.2xlarge, i3en.3xlarge, i3en.6xlarge, i3en.12xlarge, i3en.24xlarge, i3en.metal, hi1.4xlarge, hs1.8xlarge, c1.medium, c1.xlarge, c3.large, c3.xlarge, c3.2xlarge, c3.4xlarge, c3.8xlarge, c4.large, c4.xlarge, c4.2xlarge, c4.4xlarge, c4.8xlarge, c5.large, c5.xlarge, c5.2xlarge, c5.4xlarge, c5.9xlarge, c5.12xlarge, c5.18xlarge, c5.24xlarge, c5.metal, c5d.large, c5d.xlarge, c5d.2xlarge, c5d.4xlarge, c5d.9xlarge, c5d.18xlarge, c5n.large, c5n.xlarge, c5n.2xlarge, c5n.4xlarge, c5n.9xlarge, c5n.18xlarge, cc1.4xlarge, cc2.8xlarge, g2.2xlarge, g2.8xlarge, g3.4xlarge, g3.8xlarge, g3.16xlarge, g3s.xlarge, g4dn.xlarge, g4dn.2xlarge, g4dn.4xlarge, g4dn.8xlarge, g4dn.12xlarge, g4dn.16xlarge, cg1.4xlarge, p2.xlarge, p2.8xlarge, p2.16xlarge, p3.2xlarge, p3.8xlarge, p3.16xlarge, p3dn.24xlarge, d2.xlarge, d2.2xlarge, d2.4xlarge, d2.8xlarge, f1.2xlarge, f1.4xlarge, f1.16xlarge, m5.large, m5.xlarge, m5.2xlarge, m5.4xlarge, m5.8xlarge, m5.12xlarge, m5.16xlarge, m5.24xlarge, m5.metal, m5a.large, m5a.xlarge, m5a.2xlarge, m5a.4xlarge, m5a.8xlarge, m5a.12xlarge, m5a.16xlarge, m5a.24xlarge, m5d.large, m5d.xlarge, m5d.2xlarge, m5d.4xlarge, m5d.8xlarge, m5d.12xlarge, m5d.16xlarge, m5d.24xlarge, m5d.metal, m5ad.large, m5ad.xlarge, m5ad.2xlarge, m5ad.4xlarge, m5ad.8xlarge, m5ad.12xlarge, m5ad.16xlarge, m5ad.24xlarge, h1.2xlarge, h1.4xlarge, h1.8xlarge, h1.16xlarge, z1d.large, z1d.xlarge, z1d.2xlarge, z1d.3xlarge, z1d.6xlarge, z1d.12xlarge, z1d.metal, u-6tb1.metal, u-9tb1.metal, u-12tb1.metal, u-18tb1.metal, u-24tb1.metal, a1.medium, a1.large, a1.xlarge, a1.2xlarge, a1.4xlarge, a1.metal, m5dn.large, m5dn.xlarge, m5dn.2xlarge, m5dn.4xlarge, m5dn.8xlarge, m5dn.12xlarge, m5dn.16xlarge, m5dn.24xlarge, m5n.large, m5n.xlarge, m5n.2xlarge, m5n.4xlarge, m5n.8xlarge, m5n.12xlarge, m5n.16xlarge, m5n.24xlarge, r5dn.large, r5dn.xlarge, r5dn.2xlarge, r5dn.4xlarge, r5dn.8xlarge, r5dn.12xlarge, r5dn.16xlarge, r5dn.24xlarge, r5n.large, r5n.xlarge, r5n.2xlarge, r5n.4xlarge, r5n.8xlarge, r5n.12xlarge, r5n.16xlarge, r5n.24xlarge.
Ipv6AddressCount: 0 # [EC2-VPC] The number of IPv6 addresses to associate with the primary network interface.
Ipv6Addresses: # [EC2-VPC] The IPv6 addresses from the range of the subnet to associate with the primary network interface.
- Ipv6Address: '' # The IPv6 address.
KernelId: '' # The ID of the kernel.
KeyName: '' # The name of the key pair.
MaxCount: 0 # [REQUIRED] The maximum number of instances to launch.
MinCount: 0 # [REQUIRED] The minimum number of instances to launch.
Monitoring: # Specifies whether detailed monitoring is enabled for the instance.
Enabled: true # [REQUIRED] Indicates whether detailed monitoring is enabled.
Placement: # The placement for the instance.
AvailabilityZone: '' # The Availability Zone of the instance.
Affinity: '' # The affinity setting for the instance on the Dedicated Host.
GroupName: '' # The name of the placement group the instance is in.
PartitionNumber: 0 # The number of the partition the instance is in.
HostId: '' # The ID of the Dedicated Host on which the instance resides.
Tenancy: dedicated # The tenancy of the instance (if the instance is running in a VPC). Valid values are: default, dedicated, host.
SpreadDomain: '' # Reserved for future use.
RamdiskId: '' # The ID of the RAM disk to select.
SecurityGroupIds: # The IDs of the security groups.
- ''
SecurityGroups: # [default VPC] The names of the security groups.
- ''
SubnetId: '' # [EC2-VPC] The ID of the subnet to launch the instance into.
UserData: '' # The user data to make available to the instance.
AdditionalInfo: '' # Reserved.
ClientToken: '' # Unique, case-sensitive identifier you provide to ensure the idempotency of the request.
DisableApiTermination: true # If you set this parameter to true, you can't terminate the instance using the Amazon EC2 console, CLI, or API; otherwise, you can.
DryRun: true # Checks whether you have the required permissions for the action, without actually making the request, and provides an error response.
EbsOptimized: true # Indicates whether the instance is optimized for Amazon EBS I/O.
IamInstanceProfile: # The IAM instance profile.
Arn: '' # The Amazon Resource Name (ARN) of the instance profile.
Name: '' # The name of the instance profile.
InstanceInitiatedShutdownBehavior: stop # Indicates whether an instance stops or terminates when you initiate shutdown from the instance (using the operating system command for system shutdown). Valid values are: stop, terminate.
NetworkInterfaces: # The network interfaces to associate with the instance.
- AssociatePublicIpAddress: true # Indicates whether to assign a public IPv4 address to an instance you launch in a VPC.
DeleteOnTermination: true # If set to true, the interface is deleted when the instance is terminated.
Description: '' # The description of the network interface.
DeviceIndex: 0 # The position of the network interface in the attachment order.
Groups: # The IDs of the security groups for the network interface.
- ''
Ipv6AddressCount: 0 # A number of IPv6 addresses to assign to the network interface.
Ipv6Addresses: # One or more IPv6 addresses to assign to the network interface.
- Ipv6Address: '' # The IPv6 address.
NetworkInterfaceId: '' # The ID of the network interface.
PrivateIpAddress: '' # The private IPv4 address of the network interface.
PrivateIpAddresses: # One or more private IPv4 addresses to assign to the network interface.
- Primary: true # Indicates whether the private IPv4 address is the primary private IPv4 address.
PrivateIpAddress: '' # The private IPv4 addresses.
SecondaryPrivateIpAddressCount: 0 # The number of secondary private IPv4 addresses.
SubnetId: '' # The ID of the subnet associated with the network interface.
InterfaceType: '' # The type of network interface.
PrivateIpAddress: '' # [EC2-VPC] The primary IPv4 address.
ElasticGpuSpecification: # An elastic GPU to associate with the instance.
- Type: '' # [REQUIRED] The type of Elastic Graphics accelerator.
ElasticInferenceAccelerators: # An elastic inference accelerator to associate with the instance.
- Type: '' # [REQUIRED] The type of elastic inference accelerator.
TagSpecifications: # The tags to apply to the resources during launch.
- ResourceType: network-interface # The type of resource to tag. Valid values are: client-vpn-endpoint, customer-gateway, dedicated-host, dhcp-options, elastic-ip, fleet, fpga-image, host-reservation, image, instance, internet-gateway, launch-template, natgateway, network-acl, network-interface, reserved-instances, route-table, security-group, snapshot, spot-instances-request, subnet, traffic-mirror-filter, traffic-mirror-session, traffic-mirror-target, transit-gateway, transit-gateway-attachment, transit-gateway-route-table, volume, vpc, vpc-peering-connection, vpn-connection, vpn-gateway.
Tags: # The tags to apply to the resource.
- Key: '' # The key of the tag.
Value: '' # The value of the tag.
LaunchTemplate: # The launch template to use to launch the instances.
LaunchTemplateId: '' # The ID of the launch template.
LaunchTemplateName: '' # The name of the launch template.
Version: '' # The version number of the launch template.
InstanceMarketOptions: # The market (purchasing) option for the instances.
MarketType: spot # The market type. Valid values are: spot.
SpotOptions: # The options for Spot Instances.
MaxPrice: '' # The maximum hourly price you're willing to pay for the Spot Instances.
SpotInstanceType: one-time # The Spot Instance request type. Valid values are: one-time, persistent.
BlockDurationMinutes: 0 # The required duration for the Spot Instances (also known as Spot blocks), in minutes.
ValidUntil: 1970-01-01 00:00:00 # The end date of the request.
InstanceInterruptionBehavior: terminate # The behavior when a Spot Instance is interrupted. Valid values are: hibernate, stop, terminate.
CreditSpecification: # The credit option for CPU usage of the T2 or T3 instance.
CpuCredits: '' # [REQUIRED] The credit option for CPU usage of a T2 or T3 instance.
CpuOptions: # The CPU options for the instance.
CoreCount: 0 # The number of CPU cores for the instance.
ThreadsPerCore: 0 # The number of threads per CPU core.
CapacityReservationSpecification: # Information about the Capacity Reservation targeting option.
CapacityReservationPreference: none # Indicates the instance's Capacity Reservation preferences. Valid values are: open, none.
CapacityReservationTarget: # Information about the target Capacity Reservation.
CapacityReservationId: '' # The ID of the Capacity Reservation.
HibernationOptions: # Indicates whether an instance is enabled for hibernation.
Configured: true # If you set this parameter to true, your instance is enabled for hibernation.
LicenseSpecifications: # The license configurations.
- LicenseConfigurationArn: '' # The Amazon Resource Name (ARN) of the license configuration.
```
------
## Generieren und Importieren eines Befehls-Skeletons
**So generieren und verwenden Sie eine Parameter-Skeleton-Datei**
1. Führen Sie den Befehl mit dem `--generate-cli-skeleton`-Parameter aus, um entweder JSON oder YAML zu erzeugen, und leiten Sie die Ausgabe an eine Datei, um sie zu speichern.
------
#### [ JSON ]
```
$ aws ec2 run-instances --generate-cli-skeleton input > ec2runinst.json
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --generate-cli-skeleton yaml-input > ec2runinst.yaml
```
------
1. Öffnen Sie die Parameter-Skeleton-Datei in Ihrem Texteditor und entfernen Sie alle Parameter, die Sie nicht benötigen. Beispielsweise können Sie die Vorlage auf Folgendes beschränken. Stellen Sie sicher, dass die Datei noch immer das gültige JSON- oder YAML-Format aufweist, nachdem Sie die Elemente entfernt haben, die Sie nicht benötigen.
------
#### [ JSON ]
```
{
"DryRun": true,
"ImageId": "",
"KeyName": "",
"SecurityGroups": [
""
],
"InstanceType": "",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: true
ImageId: ''
KeyName: ''
SecurityGroups:
- ''
InstanceType:
Monitoring:
Enabled: true
```
------
In diesem Beispiel lassen wir den `DryRun`-Parameter auf `true` eingestellt, um das Amazon-EC2-DryRun-Feature zu verwenden. Mit diesem Feature können Sie den Befehl sicher testen, ohne tatsächlich Ressourcen zu erstellen oder zu ändern.
1. Füllen Sie den Rest mit Werten auf, die sich für Ihr Szenario eignen. In diesem Beispiel stellen wir den Instance-Typ, den Schlüsselnamen, die Sicherheitsgruppe und die ID des zu verwendenden Amazon Machine Image (AMI) bereit. In diesem Beispiel wird von der Standardeinstellung AWS-Region ausgegangen. Das AMI `ami-dfc39aef` ist ein 64-Bit-Amazon-Linux-Image, das in der Region `us-west-2` gehostet ist. Wenn Sie eine andere Region verwenden, müssen Sie [die richtige AMI-ID finden](https://aws.amazon.com/amazon-linux-ami/).
------
#### [ JSON ]
```
{
"DryRun": true,
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: true
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
1. Führen Sie den Befehl mit den abgeschlossenen Parametern aus, indem Sie die fertige Vorlagendatei mit dem `--cli-input-json`-Präfix an den Parameter `cli-input-yaml` oder den Parameter `file://` übergeben. Der AWS CLI interpretiert den Pfad als relativ zu Ihrem aktuellen Arbeitsverzeichnis. Im folgenden Beispiel wird AWS CLI nach der Datei im aktuellen Arbeitsverzeichnis gesucht.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
Die Probelauf-Fehlermeldung gibt an, dass der JSON- oder YAML-Code korrekt formatiert wird und die Parameterwerte gültig sind. Wenn andere Probleme in der Ausgabe gemeldet werden, beheben Sie sie und wiederholen Sie den vorherigen Schritt, bis die Meldung „`Request would have succeeded`“ angezeigt wird.
1. Jetzt können Sie den Parameter `DryRun` auf `false` setzen, um den Probelauf zu deaktivieren.
------
#### [ JSON ]
```
{
"DryRun": false,
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: false
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
1. Führen Sie den Befehl aus. `run-instances` startet eine Amazon-EC2-Instance und zeigt die Details an, die durch den erfolgreichen Start generiert wurden. Das Format der Ausgabe wird vom `--output`-Parameter unabhängig vom Format Ihrer Eingabeparametervorlage gesteuert.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json --output json
```
```
{
"OwnerId": "123456789012",
"ReservationId": "r-d94a2b1",
"Groups": [],
"Instances": [
...
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --output yaml
```
```
OwnerId: '123456789012'
ReservationId: 'r-d94a2b1',
Groups":
- ''
Instances:
...
```
------
## Kombinieren von Eingabedateien und Befehlszeilenparametern
Eine Eingabedatei kann für alle Parameter verwendet oder mit den in der AWS CLI angegebenen Parametern kombiniert werden. Sie können dieses Feature für Einstellungen verwenden, die Sie häufig in einer Eingabedatei wiederverwenden, während Sie Ihre individuellen Einstellungen im Befehl selbst beibehalten.
In den folgenden Beispielen für `aws ec2 run-instances` wird die Verwendung einer Eingabedatei mit Parametern kombiniert. Wir geben den Instance-Typ, den Schlüsselnamen, die Sicherheitsgruppe und die ID des zu verwendenden Amazon Machine Image (AMI) an und gehen von der Standardeinstellung aus AWS-Region. Das AMI `ami-dfc39aef` ist ein 64-Bit-Amazon-Linux-Image, das in der Region `us-west-2` gehostet ist. Wenn Sie eine andere Region verwenden, müssen Sie [die richtige AMI-ID finden](https://aws.amazon.com/amazon-linux-ami/).
------
#### [ JSON ]
Inhalt der JSON-Datei:
```
{
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
Inhalt der YAML-Datei:
```
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
Im folgenden Beispiel wird anhand der Eingabedatei in Kombination mit dem Parameter `--dry-run` ein Probelauf des Befehls durchgeführt, um zu überprüfen, ob Sie über die erforderlichen Berechtigungen verfügen und die Datei mit gültigen Werten ausgefüllt haben.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json --dry-run
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --dry-run
```
```
A client error (DryRunOperation) occurred when calling the RunInstances operation: Request would have succeeded, but DryRun flag is set.
```
------
Im folgenden Beispiel wird dann dieselbe Eingabedatei, jedoch mit dem Parameter `--no-dry-run` verwendet, um den Befehl vollständig auszuführen.
------
#### [ JSON ]
```
$ aws ec2 run-instances --cli-input-json file://ec2runinst.json --no-dry-run --output json
```
```
{
"OwnerId": "123456789012",
"ReservationId": "r-d94a2b1",
"Groups": [],
"Instances": [
...
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --cli-input-yaml file://ec2runinst.yaml --no-dry-run --output yaml
```
```
OwnerId: '123456789012'
ReservationId: 'r-d94a2b1',
Groups":
- ''
Instances:
...
```
------
# Verwendung der Kurzsyntax in der AWS CLI
The AWS Command Line Interface (AWS CLI) kann viele seiner Optionsparameter im JSON-Format akzeptieren. Allerdings ist es mühsam, große JSON-Listen oder -Strukturen in die Befehlszeile einzugeben. Um dies zu vereinfachen, unterstützt der AWS CLI auch eine Kurzsyntax, die eine einfachere Darstellung Ihrer Optionsparameter ermöglicht als die Verwendung des vollständigen JSON-Formats.
**Topics**
+ [Strukturparameter mit Schlüssel-Wert-Paaren](#shorthand-structure-parameters)
+ [Laden einer Datei als Kurznotationssyntax-Wert](#shorthand-files)
+ [Verwenden Sie die Kurzsyntax mit dem AWS CLI](#shorthand-list-parameters)
## Strukturparameter mit Schlüssel-Wert-Paaren
Die Kurzsyntax in der AWS CLI erleichtert Benutzern die Eingabe flacher Parameter (nicht verschachtelte Strukturen). Das Format ist eine durch Kommata getrennte Liste mit Schlüssel-Wert-Paaren. Verwenden Sie die geeigneten [Anführungszeichen-](cli-usage-parameters-quoting-strings.md) und Escape-Zeichen-Regeln für Ihr Terminal, da es sich bei der Kurznotation um Zeichenfolgen handelt.
------
#### [ Linux or macOS ]
```
--option key1=value1,key2=value2,key3=value3
```
Entspricht dem unten stehenden JSON-formatierten Beispiel.
```
--option '{"key1":"value1","key2":"value2","key3":"value3"}'
```
------
#### [ Windows ]
```
--option "key1=value1,key2=value2,key3=value3"
```
Entspricht dem unten stehenden JSON-formatierten Beispiel.
```
--option '{"key1":"value1","key2":"value2","key3":"value3"}'
```
------
Zwischen den einzelnen kommagetrennten Schlüssel-Wert-Paaren sind keine Leerzeichen erlaubt. Hier sehen Sie ein Beispiel für den `update-table`-Amazon-DynamoDB-Befehl mit der Option `--provisioned-throughput` in der Kurznotation.
```
$ aws dynamodb update-table \
--provisioned-throughput ReadCapacityUnits=15,WriteCapacityUnits=10 \
--table-name MyDDBTable
```
Dies entspricht dem unten stehenden JSON-formatierten Beispiel.
```
$ aws dynamodb update-table \
--provisioned-throughput '{"ReadCapacityUnits":15,"WriteCapacityUnits":10}' \
--table-name MyDDBTable
```
## Laden einer Datei als Kurznotationssyntax-Wert
Bei großen oder komplexen Werten ist es oft einfacher, eine Datei als Wert zu laden. Um eine Datei als Kurznotationssyntax-Wert zu laden, ändert sich die Formatierung geringfügig. Statt `key=value` verwenden Sie den Operator `@=` anstelle des Operators `=`. Das `@=` bedeutet für sie, AWS CLI dass der Wert als Dateipfad und nicht als Zeichenfolge gelesen werden sollte. Beim Laden von Dateien in Kurznotationssyntax gelten die üblichen [AWS CLI -Dateiformatierungsregeln](cli-usage-parameters-file.md). Das folgende Beispiel zeigt ein Schlüssel-Wert-Paar, das eine Datei für seinen Wert lädt.
------
#### [ Linux or macOS ]
```
--option key@=file://template.txt
```
------
#### [ Windows ]
```
--option "key1@=file://template.txt"
```
------
Das folgende Beispiel zeigt, wie eine Zertifikatsdatei für den Befehl `aws rolesanywhere create-trust-anchor` geladen wird.
```
$ aws rolesanywhere create-trust-anchor --name TrustAnchor \
--source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \
--enabled
```
## Verwenden Sie die Kurzsyntax mit dem AWS CLI
Sie können Eingabeparameter in einem Listenformular auf zwei verschiedene Arten angeben: JSON und Kurznotation. Die Syntax-Kurznotation in der AWS CLI erleichtert die Eingabe von Listen mit Zahlen, Zeichenfolgen oder nicht geschachtelten Strukturen.
Das grundlegende Format wird hier dargestellt, wobei die Werte in der Liste durch ein einzelnes Leerzeichen voneinander getrennt sind.
```
--option value1 value2 value3
```
Dies entspricht dem unten stehenden JSON-formatierten Beispiel.
```
--option '[value1,value2,value3]'
```
Wie bereits erwähnt, können Sie eine Liste mit Zahlen, eine Liste mit Zeichenfolgen oder eine Liste nicht geschachtelter Strukturen in Kurznotation angeben. Das folgende Beispiel zeigt den Befehl `stop-instances` für Amazon Elastic Compute Cloud (Amazon EC2), wobei die Eingabeparameter (Liste aus Zeichenfolgen) für die Option `--instance-ids` in Kurznotation angegeben sind.
```
$ aws ec2 stop-instances \
--instance-ids i-1486157a i-1286157c i-ec3a7e87
```
Dies entspricht dem unten stehenden JSON-formatierten Beispiel.
```
$ aws ec2 stop-instances \
--instance-ids '["i-1486157a","i-1286157c","i-ec3a7e87"]'
```
Das folgende Beispiel zeigt den `create-tags`-Befehl von Amazon EC2, der eine Liste nicht geschachtelter Strukturen für die Option `--tags` erwartet. Die Option `--resources` gibt die ID der Instance an, die markiert werden soll.
```
$ aws ec2 create-tags \
--resources i-1286157c \
--tags Key=My1stTag,Value=Value1 Key=My2ndTag,Value=Value2 Key=My3rdTag,Value=Value3
```
Dies entspricht dem unten stehenden JSON-formatierten Beispiel. Der JSON-Parameter ist für eine bessere Lesbarkeit auf mehrere Zeilen verteilt.
```
$ aws ec2 create-tags \
--resources i-1286157c \
--tags '[
{"Key": "My1stTag", "Value": "Value1"},
{"Key": "My2ndTag", "Value": "Value2"},
{"Key": "My3rdTag", "Value": "Value3"}
]'
```
# Aktivieren und Verwenden von Eingabeaufforderungen in AWS CLI
Sie können sich von AWS CLI Version 2 bei der Ausführung eines `aws` Befehls nach Befehlen, Parametern und Ressourcen erkundigen lassen.
**Topics**
+ [Funktionsweise](#cli-usage-auto-prompt-about)
+ [Features für automatische Eingabeaufforderung](#cli-usage-auto-prompt-features)
+ [Automatischer Eingabeaufforderungsmodi](#cli-usage-auto-prompt-modes)
+ [Konfigurieren der automatischen Eingabeaufforderung](#cli-usage-auto-prompt-configure)
## Funktionsweise
Wenn die Funktion aktiviert ist, können Sie mit der automatischen Eingabeaufforderung die **EINGABETASTE** verwenden, um einen teilweise eingegebenen Befehl zu vervollständigen. Nachdem Sie die **EINGABETASTE** gedrückt haben, werden Befehle, Parameter und Ressourcen basierend auf Ihrer weiteren Eingabe vorgeschlagen. Die Vorschläge enthalten links den Namen des Befehls, Parameters oder der Ressource und rechts eine Beschreibung. Um einen Vorschlag auszuwählen und zu verwenden, verwenden Sie die Pfeiltasten, um eine Zeile hervorzuheben, und drücken Sie dann die **LEERTASTE**. Wenn Sie mit der Eingabe Ihres Befehls fertig sind, drücken Sie die **EINGABETASTE**, um den Befehl zu verwenden. Das folgende Beispiel zeigt, wie eine vorgeschlagene Liste aus der automatischen Eingabeaufforderung aussieht.
```
$ aws
> aws a
accessanalyzer Access Analyzer
acm AWS Certificate Manager
acm-pca AWS Certificate Manager Private Certificate Authority
alexaforbusiness Alexa For Business
amplify AWS Amplify
```
## Features für automatische Eingabeaufforderung
Die automatische Eingabeaufforderung enthält die folgenden nützlichen Features:
**Dokumentationsbereich**
Stellt die Hilfedokumentation für den aktuellen Befehl bereit. Um die Dokumentation zu öffnen, drücken Sie die **F3**-Taste.
**Vervollständigung von Befehlen**
Schlägt zu verwendende `aws`-Befehle vor. Um eine Liste anzuzeigen, geben Sie den Befehl teilweise ein. Im folgenden Beispiel wird nach einem Service gesucht, der mit dem Buchstaben `a` beginnt.
```
$ aws
> aws a
accessanalyzer Access Analyzer
acm AWS Certificate Manager
acm-pca AWS Certificate Manager Private Certificate Authority
alexaforbusiness Alexa For Business
amplify AWS Amplify
```
**Parametervervollständigung**
Nachdem ein Befehl eingegeben wurde, beginnt die automatische Eingabeaufforderung, Parameter vorzuschlagen. Die Beschreibungen für die Parameter umfassen den Werttyp und eine Beschreibung dessen, was der Parameter ist. Erforderliche Parameter werden zuerst aufgeführt und als erforderlich (required) gekennzeichnet. Das folgende Beispiel zeigt die Parameterliste, die von der automatischen Eingabeaufforderung für `aws dynamodb describe-table` erstellt wird.
```
$ aws dynamodb describe-table
> aws dynamodb describe-table
--table-name (required) [string] The name of the table to describe.
--cli-input-json [string] Reads arguments from the JSON string provided. The JSON string follows the format provide...
--cli-input-yaml [string] Reads arguments from the YAML string provided. The YAML string follows the format provide...
--generate-cli-skeleton [string] Prints a JSON skeleton to standard output without sending an API request. If provided wit...
```
**Ressourcenvervollständigung**
Die automatische Eingabeaufforderung führt AWS-API-Aufrufe mithilfe der verfügbaren AWS-Ressourceneigenschaften durch, um Ressourcenwerte vorzuschlagen. Auf diese Weise kann die automatische Eingabeaufforderung bei der Eingabe von Parametern mögliche Ressourcen vorschlagen, die Sie besitzen. Im folgenden Beispiel listet die automatische Eingabeaufforderung Ihre Tabellennamen auf, wenn Sie den Parameter `--table-name` für den Befehl `aws dynamodb describe-table` eingeben.
```
$ aws dynamodb describe-table
> aws dynamodb describe-table --table-name
Table1
Table2
Table3
```
**Kurzschriftvervollständigung**
Für Parameter, die Kurzschriftensyntax verwenden, schlägt die automatische Eingabeaufforderung Werte vor, die verwendet werden sollen. Im folgenden Beispiel listet die automatische Eingabeaufforderung die Kurzschriften-Syntaxwerte für den `--placement`-Parameter im `aws ec2 run-instances`-Befehl auf.
```
$ aws ec2 run-instances
> aws ec2 run-instances --placement
AvailabilityZone= [string] The Availability Zone of the instance. If not specified, an Availability Zone wil...
Affinity= [string] The affinity setting for the instance on the Dedicated Host. This parameter is no...
GroupName= [string] The name of the placement group the instance is in.
PartitionNumber= [integer] The number of the partition the instance is in. Valid only if the placement grou...
```
**Dateivervollständigung**
Beim Ausfüllen von Parametern in `aws`-Befehlen schlägt die automatische Vervollständigung lokale Dateinamen vor, nachdem das Präfix `file://` oder `fileb://` verwendet wurde. Im folgenden Beispiel schlägt die automatische Eingabeaufforderung lokale Dateien vor, nachdem `--item file://` für den Befehl `aws ec2 run-instances` eingegeben wurde.
```
$ aws ec2 run-instances
> aws ec2 run-instances --item file://
item1.txt
file1.json
file2.json
```
**Regionvervollständigung**
Bei Verwendung des globalen Parameters `--region` listet die automatische Eingabeaufforderung mögliche Regionen zur Auswahl auf. Im folgenden Beispiel schlägt die automatische Eingabeaufforderung Regionen in alphabetischer Reihenfolge vor, nachdem `--region` für den Befehl `aws dynamodb list-tables` eingegeben wurde.
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --region
af-south-1
ap-east-1
ap-northeast-1
ap-northeast-2
```
**Profilvervollständigung**
Wenn Sie den globalen Parameter `--profile` verwenden, listet die automatische Eingabeaufforderung Ihre Profile auf. Im folgenden Beispiel schlägt die automatische Eingabeaufforderung Ihre Profile vor, nachdem `--profile` für den Befehl `aws dynamodb list-tables` eingegeben wurde.
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --profile
profile1
profile2
profile3
```
**Fuzzy-Suche**
Vervollständigen Sie Befehle und Werte, die einen bestimmten Satz von Zeichen enthalten. Im folgenden Beispiel schlägt die automatische Eingabeaufforderung Regionen vor, die `eu` enthalten, nachdem `--region eu` für den Befehl `aws dynamodb list-tables` eingegeben wurde.
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --region west
eu-west-1
eu-west-2
eu-west-3
us-west-1
```
**Verlauf**
Um zuvor verwendete Befehle im automatischen Eingabeaufforderungsmodus anzuzeigen und auszuführen, drücken Sie **STRG \$1 R**. Der Verlauf listet vorherige Befehle auf, die Sie mit den Pfeiltasten auswählen können. Im folgenden Beispiel wird der Verlauf des automatischen Eingabeaufforderungsmodus angezeigt.
```
$ aws
> aws
dynamodb list-tables
s3 ls
```
## Automatischer Eingabeaufforderungsmodi
Die automatische Eingabeaufforderung für AWS CLI Version 2 hat zwei Modi, die konfiguriert werden können:
+ **Vollmodus:** Verwendet die automatische Eingabeaufforderung jedes Mal, wenn Sie versuchen, einen `aws`-Befehl auszuführen, unabhängig davon, ob Sie ihn manuell mit dem Parameter `--cli-auto-prompt` aufrufen oder ihn dauerhaft aktiviert haben. Dazu gehört das Drücken der **EINGABETASTE** sowohl nach einem vollständigen Befehl als auch nach einem unvollständigen Befehl.
+ **Teilmodus:** Verwendet die automatische Eingabeaufforderung, wenn ein Befehl unvollständig ist oder aufgrund von clientseitigen Validierungsfehlern nicht ausgeführt werden kann. Dieser Modus ist besonders nützlich, wenn Sie über bereits vorhandene Skripts oder Runbooks verfügen oder nur für Befehle, mit denen Sie nicht vertraut sind, automatisch aufgefordert werden möchten, anstatt bei jedem Befehl gefragt zu werden.
## Konfigurieren der automatischen Eingabeaufforderung
Um die automatische Eingabeaufforderung zu konfigurieren, können Sie die folgenden Methoden in der Reihenfolge ihrer Rangfolge verwenden:
+ **Befehlszeilenoptionen** aktivieren oder deaktivieren die automatische Eingabeaufforderung für einen einzelnen Befehl. Verwenden Sie `--cli-auto-prompt`, um die automatische Eingabeaufforderung aufzurufen, und `--no-cli-auto-prompt`, um die automatische Eingabeaufforderung zu deaktivieren.
+ **Umgebungsvariablen** verwenden die Variable `aws\$1cli\$1auto\$1prompt`.
+ **Freigegebene Konfigurationsdateien** verwenden die Einstellung `cli\$1auto\$1prompt`.
# 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.
Das AWS CLI unterstützt mehrere [Ausgabeformate](cli-usage-output-format.md), darunter, [`json`[`text`](cli-usage-output-format.md#text-output)](cli-usage-output-format.md#json-output), [`yaml`](cli-usage-output-format.md#yaml-output)und. [`off`[`table`](cli-usage-output-format.md#table-output)](cli-usage-output-format.md#off-output) Einige Dienste verfügen über eine serverseitige [Paginierung](cli-usage-pagination.md) für ihre Daten und AWS CLI bieten eigene clientseitige Funktionen für 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)
+ [Strukturierte Fehlerausgabe in der AWS CLI](cli-usage-error-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.
+ **[`yaml`](#yaml-output)** –Die Ausgabe erfolgt im [YAML](https://yaml.org/)-Format.
+ **[`yaml-stream`](#yaml-stream-output)** – Die Ausgabe erfolgt im [YAML](https://yaml.org/)-Format und wird so auch gestreamt. Streaming ermöglicht eine schnellere Handhabung großer Datentypen.
+ **[`text`](#text-output)** – Die Ausgabe wird als mehrere Zeilen mit tabulatorgetrennten Zeichenfolgenwerten formatiert. Dies kann nützlich sein, um die Ausgabe an einen Textprozessor wie `grep`, `sed` oder `awk` zu übergeben.
+ **[`table`](#table-output)** – Die Ausgabe erfolgt in Form einer Tabelle mit den Zeichen \$1\$1-, um die Zellenrahmen zu bilden. Normalerweise wird die Information in einem benutzerfreundlichen Format wiedergegeben, das viel einfacher zu lesen ist als die anderen, jedoch programmatisch nicht so nützlich ist.
+ **[`off`](#off-output)**— Die Ausgabe unterdrückt alle Befehlsausgaben an die Standardausgabe. Dies ist nützlich in Automatisierungsskripten und CI/CD Pipelines, bei denen Sie nur den Exit-Code des Befehls überprüfen müssen, ohne die Ausgabe zu verarbeiten.
## Auswählen des Ausgabeformats
Wie im Thema [Konfiguration](cli-chap-configure.md) erläutert, gibt es drei verschiedene Methoden, das Ausgabeformat anzugeben:
+ **Verwenden der Option `output` in einem benannten Profil in der `config`-Datei** – Im folgenden Beispiel wird das Standardausgabeformat auf `text` festgelegt.
```
[default]
output=text
```
+ **Verwenden der Umgebungsvariablen `AWS_DEFAULT_OUTPUT`** – Die folgende Ausgabe legt das Format für die Befehle in dieser Befehlszeilensitzung auf `table` fest, bis die Variable geändert wird oder die Sitzung endet. Diese Umgebungsvariable überschreibt alle Werte, die in der Datei `config` festgelegt sind.
```
$ export AWS_DEFAULT_OUTPUT="table"
```
+ **Verwenden der Option `--output` in der Befehlszeile** – Im folgenden Beispiel wird nur die Ausgabe dieses einen Befehls auf `json` gesetzt. Mit dieser Option für den Befehl werden alle aktuell festgelegten Umgebungsvariablen überschrieben oder der Wert in der Datei `config`.
```
$ aws swf list-domains --registration-status REGISTERED --output json
```
**Wichtig**
Der von Ihnen angegebene Ausgabetyp ändert die Funktionsweise der Option `--query`:
Wenn Sie angeben`--output text`, wird die Ausgabe paginiert, *bevor* der `--query` Filter angewendet wird, und die Abfrage wird auf *jeder Seite* der Ausgabe einmal AWS CLI ausgeführt. Aus diesem Grund enthält die Abfrage das erste passende Element auf jeder Seite, was zu unerwarteten zusätzlichen Ausgaben führen kann. Um die Ausgabe zusätzlich zu filtern, können Sie andere Befehlszeilentools wie `head` oder `tail` verwenden.
Wenn Sie `--output json`, `--output yaml` oder `--output yaml-stream` angeben, wird die Ausgabe vollständig als einzelne, native Struktur verarbeitet, bevor der `--query`-Filter angewendet wird. Der AWS CLI führt die Abfrage nur einmal für die gesamte Struktur aus, wodurch ein gefiltertes Ergebnis erzeugt wird, das dann ausgegeben wird.
## JSON-Ausgabeformat
[JSON](https://json.org) ist das Standardausgabeformat der AWS CLI. Die meisten Programmiersprachen können JSON-Zeichenfolgen mit integrierten Funktionen oder öffentlich verfügbaren Bibliotheken problemlos dekodieren. Sie können die JSON-Ausgabe mit der [Option --query](cli-usage-filter.md) auf leistungsstarke Weise kombinieren, um die Ausgabe im AWS CLI JSON-Format zu filtern und zu formatieren.
Für eine erweiterte Filterung, die Sie möglicherweise mit `--query` nicht durchführen können, können Sie `jq`, einen Befehlszeilen-JSON-Prozessor, in Betracht ziehen. Sie können dies unter [http://stedolan.github.io/jq/](http://stedolan.github.io/jq/) herunterladen und finden hier auch die offizielle praktische Anleitung.
Nachfolgend finden Sie ein Beispiel für eine JSON-Ausgabe.
```
$ aws iam list-users --output json
```
```
{
"Users": [
{
"Path": "/",
"UserName": "Admin",
"UserId": "AIDA1111111111EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/Admin",
"CreateDate": "2014-10-16T16:03:09+00:00",
"PasswordLastUsed": "2016-06-03T18:37:29+00:00"
},
{
"Path": "/backup/",
"UserName": "backup-user",
"UserId": "AIDA2222222222EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/backup/backup-user",
"CreateDate": "2019-09-17T19:30:40+00:00"
},
{
"Path": "/",
"UserName": "cli-user",
"UserId": "AIDA3333333333EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/cli-user",
"CreateDate": "2019-09-17T19:11:39+00:00"
}
]
}
```
## YAML-Ausgabeformat
[YAML](https://yaml.org) [ist eine gute Wahl für die programmgesteuerte Verarbeitung der Ausgabe mit Diensten und Tools, die Zeichenketten im YAML-Format ausgeben oder verarbeiten, z. B. aufgrund der Unterstützung für Vorlagen im [YAML-Format](https://yaml.org). CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-formats.html)
Für eine erweiterte Filterung, die Sie möglicherweise mit `--query` nicht durchführen können, können Sie `yq`, einen Befehlszeilen-YAML-Prozessor, in Betracht ziehen. [Sie können es im YQ-Repository unter herunterladen. `yq`*GitHub*](https://github.com/mikefarah/yq)
Es folgt ein Beispiel für die YAML-Ausgabe.
```
$ aws iam list-users --output yaml
```
```
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
## YAML-Stream-Ausgabeformat
Das Format `yaml-stream` nutzt das [YAML](https://yaml.org)-Format und bietet gleichzeitig eine reaktionsschnellere/schnellere Anzeige großer Datensätze durch das Streamen der Daten an Sie. Sie können YAML-Daten anzeigen und verwenden, bevor die gesamte Abfrage heruntergeladen wird.
Für eine erweiterte Filterung, die Sie möglicherweise mit `--query` nicht durchführen können, können Sie `yq`, einen Befehlszeilen-YAML-Prozessor, in Betracht ziehen. Sie können es `yq` im [YQ-Repository](https://github.com/mikefarah/yq) unter herunterladen. *GitHub*
Es folgt ein Beispiel für die `yaml-stream`-Ausgabe.
```
$ aws iam list-users --output yaml-stream
```
```
- IsTruncated: false
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
Im Folgenden sehen Sie ein Beispiel für die `yaml-stream`-Ausgabe in Verbindung mit der Verwendung des `--page-size`-Parameters zum Paginieren des gestreamten YAML-Inhalts.
```
$ aws iam list-users --output yaml-stream --page-size 2
```
```
- IsTruncated: true
Marker: ab1234cdef5ghi67jk8lmo9p/q012rs3t445uv6789w0x1y2z/345a6b78c9d00/1efgh234ij56klmno78pqrstu90vwxyx
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- IsTruncated: false
Users:
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
## Textausgabeformat
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 |
+--------------+--------------+--------------+-----+
```
## Ausgabeformat deaktiviert
Das `off` Format unterdrückt die gesamte Befehlsausgabe an die Standardausgabe. Dies ist in Automatisierungsskripten und CI/CD Pipelines nützlich, bei denen Sie nur den Exit-Code des Befehls überprüfen müssen, ohne die Ausgabe zu verarbeiten. Fehlermeldungen werden weiterhin auf stderr angezeigt.
Das folgende Beispiel zeigt, wie das `off` Format eine erfolgreiche Ausgabe unterdrückt. Sie können den Exit-Code überprüfen, um festzustellen, ob der Vorgang erfolgreich war:
```
$ aws s3api list-buckets --output off
$ echo $?
0
```
Dies ist besonders nützlich in Shell-Skripten, bei denen Sie überprüfen möchten, ob eine Ressource existiert, ohne die Ausgabe zu erfassen:
```
#!/bin/bash
if aws s3api head-bucket --bucket my-bucket --output off 2>/dev/null; then
echo "Bucket exists"
else
echo "Bucket does not exist"
fi
```
**Anmerkung**
Das `off` Format unterdrückt nur stdout. Fehler werden immer noch auf stderr geschrieben.
# Strukturierte Fehlerausgabe in der AWS CLI
In diesem Thema werden die strukturierten Fehlerausgabeformate für AWS Command Line Interface (AWS CLI) beschrieben. Die CLI schreibt Fehler in stderr und unterstützt die folgenden Formate:
+ **[`enhanced`](#cli-error-format-enhanced)**(Standard) — Fehlermeldung mit zusätzlichen Details, die direkt angezeigt werden. Wird für menschenlesbares Debugging verwendet.
+ **[`json`](#cli-error-format-json)**— Die Ausgabe ist als [JSON-Zeichenfolge](https://json.org/) mit allen Fehlerfeldern formatiert. Wird für Automatisierung und Skripting verwendet.
+ **[`yaml`](#cli-error-format-yaml)**— Die Ausgabe ist als [YAML-String](https://yaml.org/) mit allen Fehlerfeldern formatiert. Wird für Automatisierung und Skripting verwendet.
+ **[`text`](#cli-error-format-text)**— Formatiert Fehler mit dem Textformatierer. Für schnelles visuelles Scannen verwenden.
+ **[`table`](#cli-error-format-table)**— Formatiert Fehler mit dem Tabellenformatierer. Für schnelles visuelles Scannen verwenden.
+ **[`legacy`](#cli-error-format-legacy)**— Ursprüngliches Fehlerformat ohne strukturierte Details. Aus Gründen der Abwärtskompatibilität verwenden.
## Fehlerformat wird konfiguriert
Sie können das Fehlerformat mit einer der folgenden Methoden konfigurieren:
Befehlszeilen-Flag
```
$ aws --cli-error-format json
```
Konfigurationsdatei () `~/.aws/config`
```
[default]
cli_error_format = json
```
Umgebungsvariable
```
$ export AWS_CLI_ERROR_FORMAT=yaml
```
## Fehler bei den Ausgabeformaten
In den folgenden Abschnitten werden die einzelnen Formate beschrieben:
### Verbessertes Format (Standard)
Das erweiterte Format zeigt Fehlermeldungen mit zusätzlichen Inline-Details für einfache Werte an. Für komplexe Strukturen bietet das Format einen Hinweis zur Verwendung von JSON oder YAML.
**Beispiel: Fehlende Regionskonfiguration**
```
aws: [ERROR]: An error occurred (NoRegion): You must specify a region. You can also configure your region by running "aws configure".
```
**Beispiel: Nicht existierende Lambda-Funktion mit zusätzlichen Feldern**
```
aws: [ERROR]: An error occurred (ResourceNotFoundException) when calling the GetFunction operation: Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345
Additional error details:
Type: User
```
Im Abschnitt „Zusätzliche Fehlerdetails“ werden nur Felder angezeigt, die im Fehlerformmodell des Dienstes definiert sind. Nicht modellierte Felder aus der Fehlerantwort werden nicht angezeigt.
**Beispiel: Komplexe Fehlerfelder**
```
An error occurred (TransactionCanceledException) when calling the TransactWriteItems operation: Transaction cancelled, please refer cancellation reasons for specific reasons [ConditionalCheckFailed, None]
Additional error details:
CancellationReasons:
Use "--cli-error-format json" or another error format to see the full details.
```
### JSON-Format
Das JSON-Format bietet eine strukturierte Darstellung mit allen Fehlerfeldern.
**Beispiel: Fehlende Regionskonfiguration**
```
{
"Code": "NoRegion",
"Message": "You must specify a region. You can also configure your region by running \"aws configure\"."
}
```
**Beispiel: Lambda-Funktion nicht vorhanden**
```
{
"Code": "ResourceNotFoundException",
"Message": "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345",
"Type": "User"
}
```
### YAML-Format
Das YAML-Format bietet eine strukturierte Darstellung mit allen Fehlerfeldern.
**Beispiel: Fehlende Regionskonfiguration**
```
Code: NoRegion
Message: You must specify a region. You can also configure your region by running "aws configure".
```
**Beispiel: Lambda-Funktion nicht vorhanden**
```
Code: ResourceNotFoundException
Message: "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345"
Type: User
```
### Textformat
Das Textformat verwendet denselben Formatierer wie die erfolgreiche Befehlsausgabe.
**Beispiel: Lambda-Funktion nicht vorhanden**
```
ResourceNotFoundException Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345 User
```
### Tabellenformat
Das Tabellenformat verwendet denselben Formatierer wie die erfolgreiche Befehlsausgabe.
**Beispiel: Lambda-Funktion nicht vorhanden**
```
------------------------------------------------------------------------------------------------------------------------------------|
| error |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
| Code | Message | Type |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
| ResourceNotFoundException | Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345 | User |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
```
### Legacy-Format
Das Legacy-Format bietet das ursprüngliche Fehlerformat ohne strukturierte Details. Dieses Format enthält nicht das Präfix „Ein Fehler ist aufgetreten (ErrorCode):“ für CLI-Ausnahmen.
**Beispiel: Fehlende Regionskonfiguration**
```
aws: [ERROR]: You must specify a region. You can also configure your region by running "aws configure".
```
**Beispiel: Lambda-Funktion nicht vorhanden**
```
An error occurred (ResourceNotFoundException) when calling the GetFunction operation: Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345
```
**Anmerkung**
Fehler enthalten jetzt durchgängig das `aws: [ERROR]:` Präfix für CLI-Ausnahmen. Frühere Versionen enthielten dieses Präfix nicht immer.
Die folgenden Ausnahmen verwenden immer das Legacy-Format, unabhängig vom konfigurierten Fehlerformat:
`UnknownArgumentError`— Zeigt Nutzungsinformationen an
Tastaturunterbrechungen () `KeyboardInterrupt`
## Vollständiges Beispiel
Das folgende Beispiel zeigt einen Befehl mit JSON-Fehlerformatierung:
```
$ aws lambda get-function \
--function-name nonexistent-function-12345 \
--cli-error-format json
```
Ausgabe (stderr):
```
{
"Code": "ResourceNotFoundException",
"Message": "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345",
"Type": "User"
}
```
Das `Type` Feld ist ein modelliertes Fehlerelement, das in der Fehlerform des Lambda-Service definiert ist. Nur Felder, die im Fehlermodell des Dienstes definiert sind, sind in der strukturierten Fehlerausgabe enthalten.
# 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.
Es gibt hauptsächlich zwei Möglichkeiten, die Paginierung vom AWS CLI aus zu steuern.
+ [Verwenden von serverseitigen Paginierungsparametern.](#cli-usage-pagination-serverside)
+ [Verwenden des standardmäßigen clientseitigen Auslagerungsprogramms für die Ausgabe](#cli-usage-pagination-clientside).
Serverseitige Paginierungsparameter werden zuerst verarbeitet und jede Ausgabe wird an die clientseitige Paginierung gesendet.
## 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 [Version 2.](https://docs.aws.amazon.com/cli/latest/reference/index.html)
### 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.
## Clientseitiger Pager
AWS CLI Version 2 bietet die Verwendung eines clientseitigen Pager-Programms für die Ausgabe. Standardmäßig gibt dieses Feature alle Ausgaben über das Standard-Pager-Programm Ihres Betriebssystems zurück.
In der Reihenfolge der Rangfolge können Sie den Ausgabe-Pager wie folgt angeben:
+ Verwenden der Einstellung `cli_pager` in der Datei `config` im `default` oder einem benannten Profil.
+ Über die `AWS_PAGER` Umgebungsvariable.
+ Über die `PAGER` Umgebungsvariable.
In der Rangfolge können Sie die Verwendung eines externen Paging-Programms auf folgende Weise deaktivieren:
+ Verwenden Sie die `--no-cli-pager`-Befehlszeilenoption, um den Pager für eine einzelne Befehlsverwendung zu deaktivieren.
+ Setzen Sie die Einstellung `cli_pager` oder Variable `AWS_PAGER` auf eine leere Zeichenfolge.
**Topics**
+ [cli\$1pager](#cli-usage-pagination-clipager)
+ [AWS\$1PAGER](#cli-usage-pagination-awspager)
+ [--no-cli-pager](#cli-usage-pagination-noclipager)
+ [Pager-Flags](#cli-usage-pagination-flags)
### So verwenden Sie die cli\$1pager-Einstellung
Sie können Ihre häufig verwendeten Konfigurationseinstellungen und Anmeldeinformationen in Dateien speichern, die von der AWS CLI verwaltet werden. Einstellungen in einem Namensprofil haben Vorrang vor den Einstellungen im `default`-Profil. Weitere Informationen zu den verschiedenen Konfigurationseinstellungen finden Sie unter [Einstellungen für die Konfiguration und die Anmeldeinformationsdatei in der AWS CLI](cli-configure-files.md).
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=
```
### Wie legt man die Umgebungsvariable fest AWS\$1PAGER
Im folgenden Beispiel wird der Standard-Ausgabe-Pager auf das `less`-Programm eingestellt. Weitere Informationen zu Umgebungsvariablen finden Sie unter [Konfiguration von Umgebungsvariablen für AWS CLI](cli-configure-envvars.md).
------
#### [ Linux and macOS ]
```
$ export AWS_PAGER="less"
```
------
#### [ Windows ]
```
C:\> setx AWS_PAGER "less"
```
------
### Wie benutzt man die no-cli-pager Option --
Um die Verwendung eines Pagers für einen einzelnen Befehl zu deaktivieren, verwenden Sie die Option `--no-cli-pager`. Weitere Informationen zu diesen Befehlszeilenoptionen finden Sie unter [Befehlszeilenoptionen in der AWS CLI](cli-configure-options.md).
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--no-cli-pager
{
"Contents": [
...
```
### So verwenden Sie Pager-Flags
Sie können Flags angeben, die automatisch mit Ihrem Paging-Programm verwendet werden sollen. Flags sind abhängig von dem Paging-Programm, das Sie verwenden. Die folgenden Beispiele beziehen sich auf die typischen Standardwerte von `less` und `more`.
------
#### [ Linux and macOS ]
Wenn Sie nichts anderes angeben, verwendet die AWS CLI Pager-Version 2 standardmäßig ist`less`. Wenn Sie die `LESS` Umgebungsvariable nicht gesetzt haben, verwendet AWS CLI Version 2 die `FRX` Flags. Sie können Flags kombinieren, indem Sie sie bei der Einstellung des AWS CLI Pagers angeben.
Im folgenden Beispiel wird die `S`-Flag verwendet. Dieses Flag wird dann mit den Standard-Flags `FRX` kombiniert, um ein endgültiges Flag `FRXS` zu erstellen.
```
$ export AWS_PAGER="less -S"
```
Wenn Sie keines der Flags `FRX` möchten, können Sie sie negieren. Im folgenden Beispiel wird das `F`-Flag negiert, um ein endgültiges `RX`-Flag zu erstellen.
```
$ export AWS_PAGER="less -+F"
```
Weitere Informationen zu `less`-Flags finden Sie unter [weniger](http://manpages.org/less/1#options) unter *manpages.org*.
------
#### [ Windows ]
Wenn Sie nichts anderes angeben, enthält der Pager, den AWS CLI Version 2 standardmäßig verwendet, keine zusätzlichen `more` Flags.
Im folgenden Beispiel wird der Parameter `/c` genutzt.
```
C:\> setx AWS_PAGER "more /c"
```
Weitere Informationen zu `more`-Flags finden Sie unter `[more](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/more)` auf *Microsoft Docs*.
------
# 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/latest/reference/ses/create-receipt-filter.html) und [ce](https://docs.aws.amazon.com/cli/latest/reference/ce/get-cost-and-usage.html).
+ `--filters` wie beispielsweise [ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-volumes.html), [autoscaling](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/describe-tags.html) und [rds](https://docs.aws.amazon.com/cli/latest/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/latest/reference/dynamodb/scan.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/scan.html).
Informationen darüber, ob für einen bestimmten Befehl serverseitige Filterung und die Filterregeln gelten, finden Sie im [Version 2.](https://docs.aws.amazon.com/cli/latest/reference/index.html)
## 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`, `--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.
**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**
```
[].{