**Cette documentation concerne AWS CLI uniquement la version 1 du.**
Nous avons annoncé la sortie end-of-support de la AWS CLI version 1. Nous vous recommandons de migrer vers la AWS CLI version 2. Pour les dates, les détails supplémentaires et les informations sur la façon de migrer, consultez l'[annonce](https://aws.amazon.com/blogs/developer/cli-v1-maintenance-mode-announcement/). Pour la documentation relative à la version 2 du AWS CLI, consultez le [guide de l'utilisateur de la version 2](https://docs.aws.amazon.com/cli/latest/userguide/).
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.
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
```
### 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)
+ [Fichiers éloignés](#cli-usage-parameters-file-remote)
+ [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.
**Note**
Ce comportement est automatiquement désactivé pour les paramètres qui attendent déjà une URL, tels que les paramètres identifiant une URL de CloudFormation modèle. Vous pouvez également désactiver ce comportement en désactivant le [`cli_follow_urlparam`](cli-configure-files.md#cli-config-cli_follow_urlparam)paramètre dans votre fichier AWS CLI de configuration.
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\""
}
```
## Fichiers éloignés
AWS CLI Il prend également en charge le chargement de paramètres à partir d'un fichier hébergé sur Internet avec une `https://` URL `http://` ou. L’exemple suivant fait référence à un fichier stocké dans un compartiment Amazon S3. Cela vous permet d’accéder à des fichiers de paramètres depuis n’importe quel ordinateur, mais le conteneur doit être publiquement accessible.
```
$ aws ec2 run-instances \
--image-id ami-12345678 \
--block-device-mappings http://amzn-s3-demo-bucket.s3.amazonaws.com/filename.json
```
Les exemples précédents supposent que le fichier `filename.json` contient les données JSON suivantes.
```
[
{
"DeviceName": "/dev/sdb",
"Ebs": {
"VolumeSize": 20,
"DeleteOnTermination": false,
"VolumeType": "standard"
}
}
]
```
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` .
**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` .
Ces mêmes commandes utilisent le paramètre `--generate-cli-skeleton` pour générer un fichier au format JSON, , 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` et pointer vers le fichier renseigné.
**Important**
Les AWS CLI commandes personnalisées, telles que les [https://docs.aws.amazon.com/cli/v1/reference/s3/index.html](https://docs.aws.amazon.com/cli/v1/reference/s3/index.html), ne prennent en charge ni les paramètres `--generate-cli-skeleton` or ni `--cli-input-json` 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 [guide de référence AWS CLI version 1 AWS CLI](https://docs.aws.amazon.com/cli/v1/reference/) .
`--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.
+ `output` : le modèle généré inclut tous les paramètres de sortie formatés en JSON.
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
}
```
------
## 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 JSON, , et diriger la sortie vers un fichier pour l’enregistrer.
------
#### [ JSON ]
```
$ aws ec2 run-instances --generate-cli-skeleton input > ec2runinst.json
```
------
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 valide après avoir supprimé les éléments dont vous n’avez pas besoin.
------
#### [ JSON ]
```
{
"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
}
}
```
------
1. Exécutez la commande avec les paramètres complétés en passant le fichier de modèle terminé paramètre `--cli-input-json`, à 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.
```
------
L’erreur d’essai indique que le fichier JSON 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
}
}
```
------
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": [
...
```
------
## 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
}
}
```
------
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.
```
------
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": [
...
```
------
# 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"}
]'
```