Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Spécification des valeurs des paramètres dans l’AWS CLI
Nombre de paramètres utilisés dans l’AWS Command Line Interface (AWS CLI) se présentent sous forme de chaîne simple ou de valeurs numériques, par exemple le nom de paire de clés `my-key-pair` dans l’exemple de commande `aws ec2 create-key-pair` suivant.
```
$ aws ec2 create-key-pair --key-name my-key-pair
```
Le formatage de la commande peut varier d’un terminal à l’autre. Par exemple, la plupart des terminaux font la distinction entre majuscules et minuscules, mais Powershell ne fait pas cette distinction. Cela signifie que les deux exemples de commandes suivants produiraient des résultats différents pour les terminaux distinguant les majuscules et les minuscules, car ils considèrent `MyFile*.txt` et `myfile*.txt` comme des paramètres **différents**.
Cependant, PowerShell traiterait ces demandes de la même manière, car il considère `MyFile*.txt` et `myfile*.txt` comme des paramètres **identiques**. L’exemple de commande suivant illustre ces paramètres à l’aide de la commande `aws s3 cp` :
```
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "MyFile*.txt"
$ aws s3 cp . s3://amzn-s3-demo-bucket/path --include "myfile*.txt"
```
Pour plus d’informations sur l’insensibilité à la casse de PowerShell, consultez [about\$1Case-Sensitivity](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_case-sensitivity) dans la *documentation PowerShell*.
Vous devez parfois utiliser des guillemets ou des littéraux autour des chaînes contenant des caractères spéciaux ou des espaces. Les règles relatives à ce formatage peuvent également varier d’un terminal à l’autre. Pour plus d’informations sur l’utilisation de guillemets autour de paramètres complexes, consultez [Utiliser des guillemets et des littéraux avec des chaînes dans AWS CLI](cli-usage-parameters-quoting-strings.md).
Ces rubriques couvrent les règles de formatage des terminaux les plus courantes. Si vous ne parvenez pas à faire reconnaître les valeurs de vos paramètres par votre terminal, n’oubliez pas de consulter les rubriques de cette section et de consulter la documentation de votre terminal pour connaître les règles de syntaxe spécifiques.
**Topics**
+ [
# Types de paramètres courants dans le AWS CLI
](cli-usage-parameters-types.md)
+ [
# Utiliser des guillemets et des littéraux avec des chaînes dans AWS CLI
](cli-usage-parameters-quoting-strings.md)
+ [
# Chargement d'un paramètre depuis un fichier dans AWS CLI
](cli-usage-parameters-file.md)
+ [
# AWS CLI squelettes et fichiers d'entrée dans le AWS CLI
](cli-usage-skeleton.md)
+ [
# En utilisant la syntaxe abrégée dans le AWS CLI
](cli-usage-shorthand.md)
# Types de paramètres courants dans le AWS CLI
Cette section décrit certains types de paramètres communs et le format typique requis.
Si vous rencontrez des difficultés pour la mise en forme d’un paramètre d’une commande spécifique, consultez l’aide ; pour ce faire, saisissez **help** après le nom de la commande. L’aide pour chaque sous-commande inclut le nom et la description d’une option. Le type de paramètre de l’option est répertorié entre parenthèses. Pour plus d’informations sur l’affichage de l’aide, consultez [Accès à l'aide et aux ressources pour AWS CLI](cli-usage-help.md).
**Topics**
+ [
## String
](#parameter-type-string)
+ [
## Horodatage
](#parameter-type-timestamp)
+ [
## List
](#parameter-type-list)
+ [
## Booléen
](#parameter-type-boolean)
+ [
## Entier
](#parameter-type-integer)
+ [
## Binaire/blob (gros objet binaire) et blob de streaming
](#parameter-type-blobs)
+ [
## Map
](#parameter-type-map)
+ [
## Document
](#parameter-type-document)
## String
Les paramètres de chaîne peuvent contenir des caractères alphanumériques, des symboles et des espaces blancs du jeu de caractères [ASCII](https://wikipedia.org/wiki/ASCII). Les chaînes qui contiennent des espaces blancs doivent être placées entre guillemets. Nous vous recommandons de ne pas utiliser de symboles ni d’espaces blancs autres que le caractère d’espace standard et de respecter les [règles de guillemets](cli-usage-parameters-quoting-strings.md) de votre terminal pour éviter des résultats inattendus.
Certains paramètres de chaîne peuvent accepter les données binaires d’un fichier. Consultez [Fichiers binaires](cli-usage-parameters-file.md#cli-usage-parameters-file-binary) pour voir un exemple.
## Horodatage
Les horodatages sont mis en forme selon la norme [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html). Ceux-ci sont souvent appelés paramètres « `DateTime` » ou `Date` « ».
```
$ aws ec2 describe-spot-price-history --start-time 2014-10-13T19:00:00Z
```
Les formats acceptables sont les suivants :
+ *YYYY*- *MM* - *DD* T *hh* : *mm* : *ss.sss**TZD (UTC)*, par exemple, 2014-10-01T 20:30:00.000 Z
+ *YYYY*- *MM* - *DD* T *hh* : *mm* : *ss.sss**TZD (with offset)*, par exemple, 2014-10-01T 12:30:00.000-08:00
+ *YYYY*- *MM* -*DD*, par exemple, 2014-10-01
+ Horaire Unix en secondes, par exemple 1412195400. Ceci est parfois appelé [Heure d’époque Unix](https://wikipedia.org/wiki/Unix_time) et représente le nombre de secondes écoulées depuis le 1er janvier 1970 à minuit, UTC.
Par défaut, la AWS CLI version 2 traduit toutes les DateTime valeurs de ***réponse*** au format ISO 8601.
Vous pouvez définir le format d’horodatage à l’aide du paramètre de fichier `cli\$1timestamp\$1format`.
## List
Une ou plusieurs chaînes séparées par des espaces. Si l’un des éléments de chaîne contient un espace, vous devez mettre cet élément entre guillemets. Respectez les [règles de guillemets](cli-usage-parameters-quoting-strings.md) de votre terminal pour éviter des résultats inattendus.
```
$ aws ec2 describe-spot-price-history --instance-types m1.xlarge m1.medium
```
## Booléen
Indicateur binaire qui active ou désactive une option. Par exemple, `ec2 describe-spot-price-history` comporte un paramètre d’essai booléen `--dry-run` qui, lorsqu’il est spécifié, valide la demande sur le service sans réellement exécuter la requête.
```
$ aws ec2 describe-spot-price-history --dry-run
```
La sortie indique si la commande était ou non correctement mise en forme. Cette commande inclut également une version `--no-dry-run` du paramètre qui peut être utilisée pour indiquer de manière explicite que la commande doit s’exécuter normalement. Il n’est pas nécessaire de l’inclure puisqu’il s’agit du comportement par défaut.
## Entier
Nombre entier non signé.
```
$ aws ec2 describe-spot-price-history --max-items 5
```
## Binaire/blob (gros objet binaire) et blob de streaming
Dans le AWS CLI, vous pouvez transmettre une valeur binaire sous forme de chaîne directement sur la ligne de commande. Il existe deux types de blobs :
+ [Blob](#parameter-type-blob)
+ [Blob de streaming](#parameter-type-streaming-blob)
### Blob
Pour transmettre une valeur à un paramètre de type `blob`, vous devez spécifier un chemin d’accès à un fichier local contenant les données binaires à l’aide du préfixe `fileb://`. Les fichiers référencés à l’aide du préfixe `fileb://` sont toujours traités comme des fichiers binaires bruts non codés. Le chemin spécifié est interprété comme étant relatif au répertoire de travail actuel. Par exemple, le paramètre `--plaintext` pour `aws kms encrypt` est un objet blob.
```
$ aws kms encrypt \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--plaintext fileb://ExamplePlaintextFile \
--output text \
--query CiphertextBlob | base64 \
--decode > ExampleEncryptedFile
```
**Note**
Pour des raisons de rétrocompatibilité, vous pouvez utiliser le préfixe `file://`. Deux formats sont utilisés en fonction de l’option de ligne de commande `cli\$1binary\$1format` ou `--cli-binary-format` du paramètre de fichier :
Par défaut pour la AWS CLI version 2. Si la valeur du paramètre est `base64`, les fichiers référencés à l’aide du préfixe `file://` sont traités comme du texte codé en base64.
Par défaut pour la AWS CLI version 1. Si la valeur du paramètre est `raw-in-base64-out`, les fichiers référencés à l’aide du préfixe `file://` sont lus sous forme de texte, puis l’ AWS CLI essaie de les coder en binaire.
Pour plus d’informations, consultez le paramètre de fichier `cli\$1binary\$1format` ou l’option de ligne de commande `--cli-binary-format`.
### Blob de streaming
Les blobs de streaming tels que `aws cloudsearchdomain upload-documents` n’utilisent pas de préfixes. Au lieu de cela, les paramètres du blob de streaming sont formatés à l’aide du chemin de fichier direct. L’exemple suivant utilise le chemin de fichier direct `document-batch.json` pour la commande `aws cloudsearchdomain upload-documents` :
```
$ aws cloudsearchdomain upload-documents \
--endpoint-url https://doc-my-domain.us-west-1.cloudsearch.amazonaws.com \
--content-type application/json \
--documents document-batch.json
```
## Map
Ensemble de paires clés-valeurs spécifiées en JSON ou à l’aide de la [syntaxe raccourcie](cli-usage-shorthand.md) de l’interface de ligne de commande. L’exemple JSON suivant lit un élément d’un tableau Amazon DynamoDB nommé *my-table* avec un paramètre map, `--key`. Le paramètre spécifie la clé primaire nommée *id* avec la valeur numérique *1* dans une structure JSON imbriquée.
Pour une utilisation plus avancée du JSON dans une ligne de commande, pensez à utiliser un processeur JSON en ligne de commande`jq`, par exemple pour créer des chaînes JSON. Pour plus d'informations sur`jq`, consultez le [référentiel jq](http://stedolan.github.io/jq/) sur *GitHub*.
```
$ aws dynamodb get-item --table-name my-table --key '{"id": {"N":"1"}}'
{
"Item": {
"name": {
"S": "John"
},
"id": {
"N": "1"
}
}
}
```
## Document
**Note**
La [syntaxe raccourcie](cli-usage-shorthand.md) n’est pas compatible avec les types de documents.
Les types de documents sont utilisés pour envoyer des données sans qu’il soit nécessaire d’intégrer du JSON dans des chaînes. Le type de document permet aux services de fournir des schémas arbitraires afin que vous puissiez utiliser des types de données plus flexibles.
Cela permet d’envoyer des données JSON sans avoir à échapper des valeurs. Par exemple, au lieu d’utiliser l’entrée JSON échappée suivante :
```
{"document": "{\"key\":true}"}
```
Vous pouvez utiliser le type de document suivant :
```
{"document": {"key": true}}
```
### Valeurs valides pour les types de documents
En raison de la flexibilité des types de documents, il existe plusieurs types de valeurs valides. Les valeurs valides sont les suivantes :
**String**
```
--option '"value"'
```
**Number**
```
--option 123
--option 123.456
```
**Booléen**
```
--option true
```
**Null**
```
--option null
```
**Tableau**
```
--option '["value1", "value2", "value3"]'
--option '["value", 1, true, null, ["key1", 2.34], {"key2": "value2"}]'
```
**Objet**
```
--option '{"key": "value"}'
--option '{"key1": "value1", "key2": 123, "key3": true, "key4": null, "key5": ["value3", "value4"], "key6": {"value5": "value6"}'
```
# Utiliser des guillemets et des littéraux avec des chaînes dans AWS CLI
Il existe principalement deux manières d’utiliser des guillemets simples et doubles dans l’ AWS CLI.
+ [Utilisation de guillemets autour des chaînes contenant des espaces blancs](#cli-usage-parameters-quoting-strings-around)
+ [Utilisation de guillemets à l’intérieur des chaînes](#cli-usage-parameters-quoting-strings-containing)
## Utilisation de guillemets autour des chaînes contenant des espaces blancs
Les noms des paramètres et leurs valeurs sont séparés par des espaces sur la ligne de commande. Si une valeur de chaîne contient un espace intégré, vous devez entourer la chaîne entière de guillemets pour éviter que l' AWS CLI espace ne soit mal interprété comme un séparateur entre la valeur et le nom du paramètre suivant. Le type de guillemet que vous utilisez dépend du système d'exploitation AWS CLI sur lequel vous l'exécutez.
------
#### [ Linux and macOS ]
Utilisation des guillemets simples `' '`
```
$ aws ec2 create-key-pair --key-name 'my key pair'
```
Pour plus d’informations sur l’utilisation des guillemets, consultez la documentation utilisateur de votre shell préféré.
------
#### [ PowerShell ]
**Guillemets simples (recommandé)**
Les guillemets simples `' '` sont appelées chaînes `verbatim`. La chaîne est transmise à la commande exactement telle que vous la tapez, ce qui signifie que PowerShell les variables ne seront pas transmises.
```
PS C:\> aws ec2 create-key-pair --key-name 'my key pair'
```
**Guillemets doubles**
Les guillemets doubles `" "` sont appelés chaînes `expandable`. Les variables peuvent être transmises sous forme de chaînes extensibles.
```
PS C:\> aws ec2 create-key-pair --key-name "my key pair"
```
Pour plus d'informations sur l'utilisation des guillemets, voir [À propos des règles de citation](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) dans *Microsoft PowerShell Docs*.
------
#### [ Windows command prompt ]
Utilisation des guillemets doubles `" "`.
```
C:\> aws ec2 create-key-pair --key-name "my key pair"
```
------
Si vous le souhaitez, vous pouvez séparer le nom de paramètre de la valeur par un signe égal `=` au lieu d’un espace. Cela n’est généralement nécessaire que si la valeur du paramètre commence par un trait d’union.
```
$ aws ec2 delete-key-pair --key-name=-mykey
```
## Utilisation de guillemets à l’intérieur des chaînes
Les chaînes peuvent contenir des guillemets, et votre shell peut avoir besoin de guillemets pour fonctionner correctement. L’un des types de valeurs de paramètre courants est une chaîne JSON. Ceci est complexe, car il inclut des espaces et des guillemets doubles `" "` autour du nom et de la valeur de chaque élément dans la structure JSON. La manière dont vous entrez des paramètres au format JSON sur la ligne de commande varie selon le système d’exploitation.
Pour une utilisation plus avancée du JSON dans la ligne de commande, pensez à utiliser un processeur JSON de ligne de commande, par exemple `jq`, pour créer des chaînes JSON. Pour plus d'informations sur`jq`, consultez le [référentiel jq](http://stedolan.github.io/jq/) sur *GitHub*.
------
#### [ Linux and macOS ]
Pour que Linux et macOS interprètent littéralement les chaînes, utilisez des guillemets simples `' '` pour entourer la structure de données JSON, comme dans l’exemple suivant. Il n’est pas nécessaire d’échapper les guillemets doubles intégrés dans la chaîne JSON, car ils sont traités littéralement. Comme le JSON est placé entre guillemets simples, tous les guillemets simples de la chaîne devront être échappés. Cela se fait généralement en utilisant une barre oblique inverse avant le guillemet simple `\'`.
```
$ aws ec2 run-instances \
--image-id ami-12345678 \
--block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]'
```
Pour plus d’informations sur l’utilisation des guillemets, consultez la documentation utilisateur de votre shell préféré.
------
#### [ PowerShell ]
Utilisez des guillemets simples `' '` ou des guillemets doubles `" "`.
**Guillemets simples (recommandé)**
Les guillemets simples `' '` sont appelées chaînes `verbatim`. La chaîne est transmise à la commande exactement telle que vous la tapez, ce qui signifie que PowerShell les variables ne seront pas transmises.
Étant donné que les structures de données JSON contiennent des guillemets doubles, nous vous recommandons d’utiliser des guillemets **simples** `' '` pour les entourer. Si vous utilisez des guillemets **simples**, il n’est pas nécessaire d’échapper les guillemets **doubles** intégrés dans la chaîne JSON. Cependant, vous devez éviter d’échapper chaque guillemet **simple** par un accent grave ``` au sein de la structure JSON.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings '[{"DeviceName":"/dev/sdb","Ebs":{"VolumeSize":20,"DeleteOnTermination":false,"VolumeType":"standard"}}]'
```
**Guillemets doubles**
Les guillemets doubles `" "` sont appelés chaînes `expandable`. Les variables peuvent être transmises sous forme de chaînes extensibles.
Si vous utilisez des guillemets **doubles**, il n’est pas nécessaire d’échapper les guillemets **simples** intégrés dans la chaîne JSON. Cependant, vous devez éviter d’échapper chaque guillemet **simple** par un accent grave ``` au sein de la structure JSON, comme dans l’exemple suivant.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings "[{`"DeviceName`":`"/dev/sdb`",`"Ebs`":{`"VolumeSize`":20,`"DeleteOnTermination`":false,`"VolumeType`":`"standard`"}}]"
```
Pour plus d'informations sur l'utilisation des guillemets, voir [À propos des règles de citation](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules?view=powershell-7) dans *Microsoft PowerShell Docs*.
**Avertissement**
Avant d' PowerShell envoyer une commande au AWS CLI, il détermine si votre commande est interprétée à l'aide de règles classiques PowerShell ou entre `CommandLineToArgvW` guillemets. Lorsque PowerShell des processus l'utilisent`CommandLineToArgvW`, vous devez éviter les caractères marqués d'une barre oblique inversée`\`.
*Pour plus d'informations sur `CommandLineToArgvW` in PowerShell, consultez [What's up with the strange treatment of guillemets and backslashes par CommandLineToArgv W](https://devblogs.microsoft.com/oldnewthing/20100917-00/?p=12833) dans *Microsoft DevBlogs*, [Everyone cite les arguments de ligne de commande de la mauvaise façon dans le](https://docs.microsoft.com/en-us/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way) *blog Microsoft Docs*, et sur la [fonction CommandLineToArgv W](https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-commandlinetoargvw#remarks) dans Microsoft Docs.*
**Guillemets simples**
Les guillemets simples `' '` sont appelées chaînes `verbatim`. La chaîne est transmise à la commande exactement telle que vous la tapez, ce qui signifie que PowerShell les variables ne seront pas transmises. Échappez les caractères avec une barre oblique inverse `\`.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings '[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]'
```
**Guillemets doubles**
Les guillemets doubles `" "` sont appelés chaînes `expandable`. Les variables peuvent être transmises sous forme de chaînes `expandable`. Pour les chaînes entre guillemets, vous devez éviter d'utiliser deux fois *`\$1* pour chaque guillemet au lieu de simplement utiliser un backtick. L’accent grave échappe la barre oblique inverse, puis la barre oblique inverse est utilisée comme caractère d’échappement pour le traitement de la commande `CommandLineToArgvW`.
```
PS C:\> aws ec2 run-instances `
--image-id ami-12345678 `
--block-device-mappings "[{`\"DeviceName`\":`\"/dev/sdb`\",`\"Ebs`\":{`\"VolumeSize`\":20,`\"DeleteOnTermination`\":false,`\"VolumeType`\":`\"standard`\"}}]"
```
**Blobs (recommandé)**
Pour contourner les règles PowerShell de citation pour la saisie de données JSON, utilisez Blobs pour transmettre vos données JSON directement au. AWS CLI Pour plus d’informations sur les blobs, consultez [Blob](cli-usage-parameters-types.md#parameter-type-blob).
------
#### [ Windows command prompt ]
L’invite de commande Windows exige que la structure de données JSON soit placée entre guillemets doubles `" "`. De plus, pour empêcher le processeur de commandes de mal interpréter les guillemets doubles incorporés dans la structure JSON, vous devez également échapper (ajouter une barre oblique inverse `\` avant) chaque guillemet double `"` dans la structure de données JSON elle-même, comme dans l’exemple suivant.
```
C:\> aws ec2 run-instances ^
--image-id ami-12345678 ^
--block-device-mappings "[{\"DeviceName\":\"/dev/sdb\",\"Ebs\":{\"VolumeSize\":20,\"DeleteOnTermination\":false,\"VolumeType\":\"standard\"}}]"
```
Seuls les guillemets doubles les plus à l’extérieur ne sont pas placés dans une séquence d’échappement.
------
# Chargement d'un paramètre depuis un fichier dans AWS CLI
Certains paramètres attendent des noms de fichiers comme arguments, à partir desquels ils AWS CLI chargent les données. D’autres paramètres vous permettent de spécifier la valeur du paramètre sous forme de texte saisi sur la ligne de commande ou de lecture à partir d’un fichier. Qu'un fichier soit obligatoire ou facultatif, vous devez le coder correctement pour qu'ils AWS CLI puissent le comprendre. L’encodage du fichier doit correspondre aux paramètres régionaux par défaut du système de lecture. Vous pouvez déterminer cela à l’aide de la méthode `locale.getpreferredencoding()` Python.
Cette méthode permet de charger un fichier pour un paramètre unique. Pour plus d’informations sur le chargement de plusieurs paramètres avec un fichier unique, consultez [AWS CLI squelettes et fichiers d'entrée dans le AWS CLI](cli-usage-skeleton.md).
**Note**
Par défaut, Windows PowerShell affiche le texte au format UTF-16, ce qui est en conflit avec le codage UTF-8 utilisé par les fichiers JSON et de nombreux systèmes Linux. Nous vous recommandons de l'utiliser `-Encoding ascii` avec vos PowerShell `Out-File` commandes pour vous assurer qu' AWS CLI ils peuvent lire le fichier obtenu.
**Topics**
+ [
## Chargement d’un paramètre depuis un fichier
](#cli-usage-parameters-file-how)
+ [
## Fichiers binaires
](#cli-usage-parameters-file-binary)
+ [
## Chargement d’un fichier en tant que valeur de syntaxe raccourcie
](#cli-usage-parameters-file-shorthand)
## Chargement d’un paramètre depuis un fichier
Il est parfois pratique de charger une valeur de paramètre à partir d’un fichier plutôt que d’essayer de la taper entièrement comme valeur de paramètre de ligne de commande, par exemple lorsque le paramètre est une chaîne JSON complexe. Pour spécifier un fichier qui contient la valeur, spécifiez une URL de fichier au format suivant :
```
file://complete/path/to/file
```
+ Les deux premières barres obliques « / » font partie de la spécification. Si le chemin d’accès requis commence par un caractère « / », le résultat contiendra trois barres obliques : `file:///folder/file`.
+ L’URL fournit le chemin d’accès au fichier qui contient le contenu effectif du paramètre.
+ Lors de l’utilisation de fichiers contenant des espaces ou des caractères spéciaux, suivez les [règles en matière de guillemets](cli-usage-parameters-quoting-strings.md) pour votre terminal.
Les chemins de fichiers des exemples suivants sont interprétés comme étant relatifs au répertoire de travail actuel.
------
#### [ 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"
```
------
L’option de préfixe `file://` prend en charge les extensions de style Unix, dont « `~/` », « `./` » et « `../` ». Sous Windows, l’expression « `~/` » s’étend à votre répertoire utilisateur, stocké dans la variable d’environnement `%USERPROFILE%`. Par exemple, sous Windows 10, un répertoire utilisateur figure généralement sous `%USERPROFILE%`.
Les documents JSON qui sont intégrés en tant que valeur d’un autre document JSON doivent toujours inclure une séquence d’échappement.
```
$ 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\"}"
}
```
## Fichiers binaires
Pour les commandes qui acceptent des données binaires comme paramètre, spécifiez que les données sont un contenu binaire à l’aide du préfixe `fileb://`. Les commandes qui acceptent des données binaires sont les suivantes :
+ Paramètre **`aws ec2 run-instances:`** `--user-data`.
+ Paramètre **`aws s3api put-object:`** `--sse-customer-key`.
+ Paramètre **`aws kms decrypt:`** `--ciphertext-blob`.
L’exemple suivant génère une clé AES binaire 256 bits à l’aide d’un outil de ligne de commande Linux, puis la fournit à Amazon S3 pour chiffrer un fichier chargé côté serveur.
```
$ 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\""
}
```
Pour obtenir un autre exemple faisant référence à un fichier contenant des paramètres au format JSON, consultez [Attachement d’une politique gérée par IAM à un utilisateur](cli-services-iam.md#cli-services-iam-policy).
## Chargement d’un fichier en tant que valeur de syntaxe raccourcie
Lors de l’utilisation d’une syntaxe raccourcie dans laquelle une valeur est grande ou complexe, il est souvent plus facile de la charger dans un fichier en tant que valeur. Pour charger un fichier en tant que valeur de syntaxe raccourcie, le formatage changera légèrement. Au lieu de `key=value`, vous utiliserez l’opérateur `@=` au lieu de l’opérateur `=`. Le code `@=` signifie à l’ AWS CLI que la valeur doit être lue comme un chemin de fichier et non comme une chaîne. L’exemple suivant montre une paire clé-valeur en train de charger un fichier pour sa valeur.
------
#### [ Linux or macOS ]
```
--option key@=file://template.txt
```
------
#### [ Windows ]
```
--option "key1@=file://template.txt"
```
------
L’exemple suivant montre comment charger un fichier de certificat pour la commande `aws rolesanywhere create-trust-anchor`.
```
$ aws rolesanywhere create-trust-anchor --name TrustAnchor \
--source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \
--enabled
```
Pour plus d’informations sur la syntaxe raccourcie, consultez [En utilisant la syntaxe abrégée dans le AWS CLI](cli-usage-shorthand.md).
# AWS CLI squelettes et fichiers d'entrée dans le AWS CLI
La plupart des AWS CLI commandes acceptent d'importer des entrées de paramètres à partir d'un fichier. Ces modèles peuvent être générés à l’aide de l’option `generate-cli-skeleton`, puis importés à l’aide des paramètres `--cli-input-json` et `--cli-input-yaml`.
**Topics**
+ [
## À propos des AWS CLI squelettes et des fichiers d'entrée
](#cli-usage-skeleton-about)
+ [
## Génération et importation d’un squelette de commande
](#cli-usage-skeleton-generate)
+ [
## Combinaison de fichiers d’entrée et de paramètres de ligne de commande
](#cli-usage-skeleton-combine)
## À propos des AWS CLI squelettes et des fichiers d'entrée
La plupart des commandes AWS Command Line Interface (AWS CLI) permettent d'accepter les entrées de paramètres d'un fichier à l'aide du `--cli-input-yaml` paramètre s `--cli-input-json` et.
Ces mêmes commandes utilisent le paramètre `--generate-cli-skeleton` pour générer un fichier soit au format JSON, soit au format YAML, avec tous les paramètres que vous pouvez modifier et renseigner. Vous pouvez ensuite exécuter la commande avec le paramètre `--cli-input-json` ou `--cli-input-yaml` et pointer vers le fichier renseigné.
**Important**
Les AWS CLI commandes personnalisées, telles que les , ne prennent en charge ni les paramètres `--generate-cli-skeleton` or ni `--cli-input-json` les `--cli-input-yaml` paramètres décrits dans cette rubrique. Pour vérifier si une commande spécifique prend en charge ces paramètres, exécutez la [`help`commande](cli-usage-help.md#cli-usage-help-command) que vous souhaitez utiliser ou reportez-vous au [version 2 du guide de référence](https://docs.aws.amazon.com/cli/latest/reference/index.html).
`--generate-cli-skeleton` génère et affiche un modèle de paramètres que vous pouvez personnaliser et utiliser comme entrée dans une commande. Le modèle généré inclut tous les paramètres pris en charge par la commande.
Le paramètre `--generate-cli-skeleton` accepte l’une des valeurs suivantes :
+ `input` : le modèle généré inclut tous les paramètres d’entrée formatés en JSON. C’est la valeur par défaut.
+ `yaml-input` : le modèle généré inclut tous les paramètres d’entrée formatés en YAML.
+ `output` : le modèle généré inclut tous les paramètres de sortie formatés en JSON. Vous ne pouvez actuellement pas demander les paramètres de sortie au format YAML.
Comme il AWS CLI s'agit essentiellement d'une « enveloppe » autour de l'API du service, le fichier squelette s'attend à ce que vous référenciez tous les paramètres par leurs noms de paramètres d'API sous-jacents. Il est probablement différent du nom du AWS CLI paramètre. Par exemple, un AWS CLI paramètre nommé `user-name` peut être mappé au paramètre d'API du AWS service nommé `UserName` (notez la modification des majuscules et l'absence du tiret). Nous vous recommandons d’utiliser l’option `--generate-cli-skeleton` pour générer le modèle avec les noms de paramètres « corrects » afin d’éviter des erreurs. Vous pouvez également consulter le Guide de référence des API pour le service afin de connaître le nom des paramètres attendus. Vous pouvez supprimer dans le modèle tous les paramètres qui ne sont pas obligatoires et pour lesquels vous ne souhaitez pas fournir de valeur.
Par exemple, si vous exécutez la commande suivante, elle génère le modèle de paramètre pour la commande **run-instances** Amazon Elastic Compute Cloud (Amazon EC2).
------
#### [ JSON ]
L’exemple suivant montre comment générer un modèle formaté en JSON à l’aide de la valeur par défaut (`input`) pour le paramètre `--generate-cli-skeleton`.
```
$ 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 ]
L’exemple suivant montre comment générer un modèle formaté en YAML à l’aide de la valeur `yaml-input` du paramètre `--generate-cli-skeleton`.
```
$ 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.
```
------
## Génération et importation d’un squelette de commande
**Pour générer et utiliser un fichier de squelette de paramètre**
1. Exécutez la commande avec le paramètre `--generate-cli-skeleton` pour produire soit un format JSON, soit un format YAML, et diriger la sortie vers un fichier pour l’enregistrer.
------
#### [ JSON ]
```
$ aws ec2 run-instances --generate-cli-skeleton input > ec2runinst.json
```
------
#### [ YAML ]
```
$ aws ec2 run-instances --generate-cli-skeleton yaml-input > ec2runinst.yaml
```
------
1. Ouvrez le fichier de squelette de paramètre dans votre éditeur de texte et supprimez les paramètres dont vous n’avez pas besoin. Par exemple, vous pouvez supprimer le modèle comme suit. Assurez-vous que le fichier est toujours dans un format JSON ou YAML valide après avoir supprimé les éléments dont vous n’avez pas besoin.
------
#### [ JSON ]
```
{
"DryRun": true,
"ImageId": "",
"KeyName": "",
"SecurityGroups": [
""
],
"InstanceType": "",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
```
DryRun: true
ImageId: ''
KeyName: ''
SecurityGroups:
- ''
InstanceType:
Monitoring:
Enabled: true
```
------
Dans cet exemple, nous laissons le paramètre `DryRun` défini sur `true` pour utiliser la fonctionnalité d’essai Amazon EC2. Cette fonctionnalité vous permet de tester la commande en toute sécurité sans créer ou modifier de ressources.
1. Remplissez les valeurs restantes avec les valeurs appropriées pour votre scénario. Dans cet exemple, nous fournissons le type d’instance, le nom de la clé, le groupe de sécurité et l’identifiant de l’AMI à utiliser. Cet exemple suppose la valeur par défaut Région AWS. L’AMI `ami-dfc39aef` est une image Amazon Linux 64 bits hébergée dans la région `us-west-2`. Si vous utilisez une autre région, vous devez [identifier le bon ID d’AMI à utiliser](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. Exécutez la commande avec les paramètres complétés en passant le fichier de modèle terminé soit au paramètre `--cli-input-json`, soit au paramètre --`cli-input-yaml` à l’aide du préfixe `file://`. AWS CLI Interprète le chemin comme étant relatif à votre répertoire de travail actuel. L'exemple suivant AWS CLI recherche le fichier dans le répertoire de travail actuel.
------
#### [ 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.
```
------
L’erreur d’essai indique que le fichier JSON ou YAML est correctement mis en forme et que les valeurs des paramètres sont valides. Si d’autres problèmes sont signalés dans la sortie, corrigez-les et répétez l’étape précédente jusqu’à ce que le message `Request would have succeeded` s’affiche.
1. Vous pouvez maintenant définir le paramètre `DryRun` comme `false` pour désactiver l’essai.
------
#### [ 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. Quand vous exécutez la commande, `run-instances` lance réellement une instance EC2 et affiche les détails générés par le lancement réussi. Le format de la sortie est contrôlé par le paramètre `--output`, séparément du format de votre modèle de paramètre d’entrée.
------
#### [ 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:
...
```
------
## Combinaison de fichiers d’entrée et de paramètres de ligne de commande
Un fichier d’entrée peut être utilisé pour tous les paramètres ou peut être combiné avec les paramètres spécifiés dans l’ AWS CLI. Vous pouvez utiliser cette fonctionnalité pour les paramètres que vous réutilisez fréquemment dans un fichier d’entrée, tout en conservant vos paramètres individuels dans la commande elle-même.
Les exemples `aws ec2 run-instances` suivants combinent l’utilisation d’un fichier d’entrée et de paramètres. Nous indiquons le type d'instance, le nom de clé, le groupe de sécurité, l'identifiant de l'Amazon Machine Image (AMI) à utiliser et nous supposons qu'il s'agit de l'image par défaut Région AWS. L’AMI `ami-dfc39aef` est une image Amazon Linux 64 bits hébergée dans la région `us-west-2`. Si vous utilisez une autre région, vous devez [identifier le bon ID d’AMI à utiliser](https://aws.amazon.com/amazon-linux-ami/).
------
#### [ JSON ]
Contenu du fichier JSON :
```
{
"ImageId": "ami-dfc39aef",
"KeyName": "mykey",
"SecurityGroups": [
"my-sg"
],
"InstanceType": "t2.micro",
"Monitoring": {
"Enabled": true
}
}
```
------
#### [ YAML ]
Contenu du fichier YAML :
```
ImageId: 'ami-dfc39aef'
KeyName: 'mykey'
SecurityGroups:
- 'my-sg'
InstanceType: 't2.micro'
Monitoring:
Enabled: true
```
------
L’exemple suivant utilise le fichier d’entrée en combinaison avec le paramètre `--dry-run` pour exécuter un essai de la commande afin de confirmer que vous disposez des autorisations requises et que vous avez renseigné le fichier avec des valeurs valides.
------
#### [ 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.
```
------
L’exemple suivant utilise ensuite le même fichier d’entrée, mais avec le paramètre `--no-dry-run` afin d’exécuter la commande dans son intégralité.
------
#### [ 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:
...
```
------
# En utilisant la syntaxe abrégée dans le AWS CLI
Le AWS Command Line Interface (AWS CLI) peut accepter plusieurs de ses paramètres d'option au format JSON. Toutefois, il peut être fastidieux de saisir de longues listes ou structures JSON sur la ligne de commande. Pour vous faciliter la tâche, il prend AWS CLI également en charge une syntaxe abrégée qui permet une représentation plus simple des paramètres de vos options qu'en utilisant le format JSON complet.
**Topics**
+ [
## Paramètres de structure avec paires clé-valeur
](#shorthand-structure-parameters)
+ [
## Chargement d’un fichier en tant que valeur de syntaxe raccourcie
](#shorthand-files)
+ [
## En utilisant une syntaxe abrégée avec le AWS CLI
](#shorthand-list-parameters)
## Paramètres de structure avec paires clé-valeur
La syntaxe abrégée utilisée dans le AWS CLI permet aux utilisateurs de saisir plus facilement des paramètres plats (structures non imbriquées). Le format est une liste séparée par des virgules des paires clé-valeur. Veillez à utiliser les règles de [guillemets](cli-usage-parameters-quoting-strings.md) et d’échappement adaptées à votre terminal, car les syntaxes raccourcies sont des chaînes.
------
#### [ Linux or macOS ]
```
--option key1=value1,key2=value2,key3=value3
```
Cela équivaut à l’exemple suivant, au format JSON.
```
--option '{"key1":"value1","key2":"value2","key3":"value3"}'
```
------
#### [ Windows ]
```
--option "key1=value1,key2=value2,key3=value3"
```
Cela équivaut à l’exemple suivant, au format JSON.
```
--option '{"key1":"value1","key2":"value2","key3":"value3"}'
```
------
Il ne doit y avoir aucun espace entre chaque paire clé-valeur séparée par des virgules. Voici un exemple de la commande `update-table` Amazon DynamoDB avec l’option `--provisioned-throughput` indiquée en syntaxe raccourcie.
```
$ aws dynamodb update-table \
--provisioned-throughput ReadCapacityUnits=15,WriteCapacityUnits=10 \
--table-name MyDDBTable
```
Cela équivaut à l’exemple suivant au format JSON.
```
$ aws dynamodb update-table \
--provisioned-throughput '{"ReadCapacityUnits":15,"WriteCapacityUnits":10}' \
--table-name MyDDBTable
```
## Chargement d’un fichier en tant que valeur de syntaxe raccourcie
Lorsqu’une valeur est grande ou complexe, il est souvent plus facile de la charger en tant que valeur. Pour charger un fichier en tant que valeur de syntaxe raccourcie, le formatage changera légèrement. Au lieu de `key=value`, vous utiliserez l’opérateur `@=` au lieu de l’opérateur `=`. Cela `@=` signifie AWS CLI que la valeur doit être lue comme un chemin de fichier et non comme une chaîne. Lorsque vous chargez des fichiers en syntaxe raccourcie, les [règles habituelles de formatage des fichiers de l’AWS CLI](cli-usage-parameters-file.md) s’appliquent. L’exemple suivant montre une paire clé-valeur en train de charger un fichier pour sa valeur.
------
#### [ Linux or macOS ]
```
--option key@=file://template.txt
```
------
#### [ Windows ]
```
--option "key1@=file://template.txt"
```
------
L’exemple suivant montre comment charger un fichier de certificat pour la commande `aws rolesanywhere create-trust-anchor`.
```
$ aws rolesanywhere create-trust-anchor --name TrustAnchor \
--source sourceData={x509CertificateData@=file://root-ca.crt},sourceType="CERTIFICATE_BUNDLE" \
--enabled
```
## En utilisant une syntaxe abrégée avec le AWS CLI
Vous pouvez spécifier les paramètres d’entrée sous forme de liste de deux manières : JSON ou syntaxe raccourcie. La syntaxe raccourcie de l’ AWS CLI est conçue pour faciliter la transmission de listes comportant des nombres, des chaînes ou des structures non imbriquées.
Le format de base est illustré ici, avec les valeurs de la liste séparées par une seule espace.
```
--option value1 value2 value3
```
Cela équivaut à l’exemple suivant au format JSON.
```
--option '[value1,value2,value3]'
```
Comme indiqué plus haut, vous pouvez utiliser une syntaxe raccourcie pour indiquer une liste de nombres, une liste de chaînes ou une liste de structures non imbriquées. Voici un exemple de commande `stop-instances` pour Amazon Elastic Compute Cloud (Amazon EC2), dans laquelle le paramètre d’entrée (liste de chaînes) de l’option `--instance-ids` est indiqué en syntaxe raccourcie.
```
$ aws ec2 stop-instances \
--instance-ids i-1486157a i-1286157c i-ec3a7e87
```
Cela équivaut à l’exemple suivant au format JSON.
```
$ aws ec2 stop-instances \
--instance-ids '["i-1486157a","i-1286157c","i-ec3a7e87"]'
```
L’exemple suivant montre la commande `create-tags` d’Amazon EC2, qui utilise une liste de structures non imbriquées pour l’option `--tags`. L’option `--resources` spécifie l’ID de l’instance à baliser.
```
$ aws ec2 create-tags \
--resources i-1286157c \
--tags Key=My1stTag,Value=Value1 Key=My2ndTag,Value=Value2 Key=My3rdTag,Value=Value3
```
Cela équivaut à l’exemple suivant au format JSON. Le paramètre JSON est écrit sur plusieurs lignes pour une meilleure lisibilité.
```
$ aws ec2 create-tags \
--resources i-1286157c \
--tags '[
{"Key": "My1stTag", "Value": "Value1"},
{"Key": "My2ndTag", "Value": "Value2"},
{"Key": "My3rdTag", "Value": "Value3"}
]'
```