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.
# 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"}
]'
```