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.
# Utilisation de l’AWS CLI
Cette section fournit un aperçu complet de l’utilisation générale, des fonctionnalités communes et des options disponibles dans l’AWS Command Line Interface (AWS CLI), en allant au-delà des détails abordés dans la section de configuration [Utilisation de points de terminaison dans AWS CLI](cli-configure-endpoints.md).
Ce guide aborde les aspects fondamentaux de l’écriture de commandes AWS CLI, notamment leur structure de base, leur formatage et leurs capacités de filtrage. En comprenant ces éléments essentiels, vous serez en mesure de construire des commandes qui ciblent précisément les ressources et les actions dont vous avez besoin, sans avoir à naviguer dans des consoles Web complexes.
En outre, cela met en évidence le contenu d’aide et la documentation disponibles pour l’AWS CLI. De l’aide en ligne de commande intégrée au [guide de référence de l’AWS CLI version 2](https://docs.aws.amazon.com/cli/latest/reference/), vous aurez accès à des informations qui vous aideront à explorer les fonctionnalités et les capacités de l’AWS CLI.
Pour obtenir des exemples et des cas d’utilisation spécifiques à un Service AWS, consultez [Exemples pour l’AWS CLI](cli-chap-code-examples.md) ou le [guide de référence de l’AWS CLI version 2](https://docs.aws.amazon.com/cli/latest/reference/). Ils fournissent des informations spécifiques aux commandes et montrent des exemples sur la manière d’optimiser l’AWS CLI pour différents Services AWS.
**Note**
Par défaut, l’AWS CLI envoie des demandes aux Services AWS en utilisant HTTPS sur le port TCP 443. Pour bien utiliser l’AWS CLI, vous devez être en mesure d’effectuer des connexions sortantes sur ce port.
**Topics**
+ [Accès à l'aide et aux ressources pour AWS CLI](cli-usage-help.md)
+ [Structure de commande dans l’AWS CLI](cli-usage-commandstructure.md)
+ [Spécification des valeurs des paramètres dans l’AWS CLI](cli-usage-parameters.md)
+ [Activation et utilisation des invites de commande dans AWS CLI](cli-usage-parameters-prompting.md)
+ [Contrôle de la sortie des commandes dans le AWS CLI](cli-usage-output.md)
+ [Codes de retour de ligne de commande dans l’AWS CLI](cli-usage-returncodes.md)
+ [Utilisation d'assistants personnalisés pour exécuter des commandes interactives dans AWS CLI](cli-usage-wizard.md)
+ [Création et utilisation d'alias dans AWS CLI](cli-usage-alias.md)
+ [Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md)
# Accès à l'aide et aux ressources pour AWS CLI
Cette rubrique décrit comment accéder au contenu d'aide pour le AWS Command Line Interface (AWS CLI).
**Topics**
+ [La commande d' AWS CLI aide intégrée](#cli-usage-help-command)
+ [AWS CLI guide de référence](#cli-reference)
+ [Documentation sur les API](#api-reference)
+ [Résolution des erreurs](#help-tshoot)
+ [Aide supplémentaire](#help-additional)
## La commande d' AWS CLI aide intégrée
Vous pouvez obtenir de l'aide avec n'importe quelle commande lorsque vous utilisez le AWS Command Line Interface (AWS CLI). Pour cela, il vous suffit de saisir `help` à la fin d’un nom de commande.
Par exemple, la commande suivante affiche de l'aide concernant les AWS CLI options générales et les commandes de haut niveau disponibles.
```
$ aws help
```
La commande suivante affiche les commandes spécifiques à Amazon Elastic Compute Cloud (Amazon EC2) disponibles.
```
$ aws ec2 help
```
L’exemple suivant affiche l’aide détaillée pour l’opération `DescribeInstances` d’Amazon EC2. L’aide inclut des descriptions de ses paramètres d’entrée, les filtres disponibles, et ce qui est inclus dans la sortie. Elle inclut également des exemples illustrant la façon de saisir des variations courantes de la commande.
```
$ aws ec2 describe-instances help
```
À compter de la version `2.31.0`, l’affichage de la commande `help` est configuré par le paramètre `cli_help_output` et elle possède les valeurs suivantes :
+ **(par défaut)** `terminal` : ouverture de la page man dans le terminal.
+ `browser` : ouverture de la page man sous forme de fichier HTML local dans votre navigateur par défaut. Un message est imprimé sur votre terminal lorsque votre navigateur par défaut est ouvert, et un message d'erreur s'il AWS CLI ne peut pas ouvrir votre navigateur.
+ `url`‐ Imprimez l'URL du guide de AWS CLI référence en ligne correspondant à la version AWS CLI que vous avez installée. Les paramètres de pagination côté client, tels que la variable d'`AWS_PAGER`environnement, sont respectés.
Le contenu d’aide de chaque commande est divisé en six sections :
Nom
Le nom de la commande.
```
NAME
describe-instances -
```
Description
Une description de l’opération d’API que la commande appelle.
```
DESCRIPTION
Describes one or more of your instances.
If you specify one or more instance IDs, Amazon EC2 returns information
for those instances. If you do not specify instance IDs, Amazon EC2
returns information for all relevant instances. If you specify an
instance ID that is not valid, an error is returned. If you specify an
instance that you do not own, it is not included in the returned
results.
...
```
Résumé
La syntaxe de base pour utiliser la commande et ses options. Si une option est affichée entre crochets, elle est facultative ou elle a une valeur par défaut, ou bien une autre option peut être utilisée à la place.
```
SYNOPSIS
describe-instances
[--dry-run | --no-dry-run]
[--instance-ids ]
[--filters ]
[--cli-input-json ]
[--starting-token ]
[--page-size ]
[--max-items ]
[--generate-cli-skeleton]
```
Par exemple, `describe-instances` possède un comportement par défaut qui décrit ***toutes les*** instances du compte courant et de AWS la région. Si vous le souhaitez, vous pouvez spécifier une liste d’`instance-ids` pour décrire une ou plusieurs instances. `dry-run` est un indicateur booléen facultatif qui ne prend aucune valeur. Pour utiliser un indicateur booléen, indiquez la valeur affichée, dans le cas présent `--dry-run` ou `--no-dry-run`. De même, `--generate-cli-skeleton` ne prend pas de valeur. S’il existe des conditions sur l’utilisation d’une option, elles sont décrites dans la section `OPTIONS`, ou mentionnées dans les exemples.
Options
Une description de chacune des options affichées dans le résumé.
```
OPTIONS
--dry-run | --no-dry-run (boolean)
Checks whether you have the required permissions for the action,
without actually making the request, and provides an error response.
If you have the required permissions, the error response is DryRun-
Operation . Otherwise, it is UnauthorizedOperation .
--instance-ids (list)
One or more instance IDs.
Default: Describes all your instances.
...
```
Exemples
Des exemples illustrant l’utilisation de la commande et de ses options. Si aucun exemple n'est disponible pour une commande ou un cas d'utilisation dont vous avez besoin, demandez-en un en utilisant le lien de commentaires sur cette page ou dans la référence de AWS CLI commande sur la page d'aide de la commande.
```
EXAMPLES
To describe an Amazon EC2 instance
Command:
aws ec2 describe-instances --instance-ids i-5203422c
To describe all instances with the instance type m1.small
Command:
aws ec2 describe-instances --filters "Name=instance-type,Values=m1.small"
To describe all instances with an Owner tag
Command:
aws ec2 describe-instances --filters "Name=tag-key,Values=Owner"
...
```
Output
Des descriptions de chaque champ et type de données inclus dans la réponse d’ AWS.
Pour `describe-instances`, la sortie est une liste d’objets de réservation, chacun comportant plusieurs champs et des objets contenant des informations sur les instances qui lui sont associées. Ces informations sont issues de la [documentation d’API pour le type de données de réservation](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_Reservation.html) utilisée par Amazon EC2.
```
OUTPUT
Reservations -> (list)
One or more reservations.
(structure)
Describes a reservation.
ReservationId -> (string)
The ID of the reservation.
OwnerId -> (string)
The ID of the AWS account that owns the reservation.
RequesterId -> (string)
The ID of the requester that launched the instances on your
behalf (for example, AWS Management Console or Auto Scaling).
Groups -> (list)
One or more security groups.
(structure)
Describes a security group.
GroupName -> (string)
The name of the security group.
GroupId -> (string)
The ID of the security group.
Instances -> (list)
One or more instances.
(structure)
Describes an instance.
InstanceId -> (string)
The ID of the instance.
ImageId -> (string)
The ID of the AMI used to launch the instance.
State -> (structure)
The current state of the instance.
Code -> (integer)
The low byte represents the state. The high byte
is an opaque internal value and should be ignored.
...
```
Lorsque le résultat est AWS CLI rendu au format JSON, il devient un tableau d'objets de réservation, comme dans l'exemple suivant.
```
{
"Reservations": [
{
"OwnerId": "012345678901",
"ReservationId": "r-4c58f8a0",
"Groups": [],
"RequesterId": "012345678901",
"Instances": [
{
"Monitoring": {
"State": "disabled"
},
"PublicDnsName": "ec2-52-74-16-12.us-west-2.compute.amazonaws.com",
"State": {
"Code": 16,
"Name": "running"
},
...
```
Chaque objet de réservation contient les champs décrivant la réservation et un tableau des objets de l’instance, chacun avec ses propres champs (`PublicDnsName`, par exemple) et des objets (`State`, par exemple) qui le décrivent.
**Utilisateurs Windows**
Vous pouvez *acheminer* (\$1) la sortie de la commande d’aide vers la commande `more` pour afficher le fichier d’aide une page à la fois. Appuyez sur la barre d'espace ou **PgDn**pour afficher une plus grande partie du document, puis **q** pour quitter.
```
C:\> aws ec2 describe-instances help | more
```
## AWS CLI guide de référence
Les fichiers d’aide contiennent des liens qui ne peuvent pas être affichés ou accédés depuis la ligne de commande. Vous pouvez consulter ces liens et interagir avec eux en utilisant le [, version 2](https://docs.aws.amazon.com/cli/latest/reference/index.html). La référence contient également le contenu d'aide pour toutes les AWS CLI commandes. Les descriptions sont présentées pour faciliter la navigation et l’affichage sur les téléphones portables, les tablettes ou les écrans de bureau.
## Documentation sur les API
Toutes les commandes du AWS CLI correspondent aux demandes adressées à l'API AWS publique d'un service. Chaque service avec une API publique comprend une référence d’API disponible à partir de la page d’accueil du service sur le [site web de la documentation AWS](https://docs.aws.amazon.com/). Le contenu d’une référence d’API varie en fonction de la manière dont l’API est construite et du protocole qui est utilisé. En général, une référence d’API contient des informations détaillées sur les actions prises en charge par l’API, les données envoyées vers et depuis le service et les conditions d’erreur que le service peut signaler.
**Sections de la documentation d’API**
+ **Actions** : informations détaillées sur chaque opération et ses paramètres (y compris les contraintes de longueur et de contenu, et les valeurs par défaut). Cette section répertorie les erreurs qui peuvent se produire pour cette action. Chaque opération correspond à une sous-commande du AWS CLI.
+ **Types de données** : informations détaillées sur les structures qu’une commande peut nécessiter en tant que paramètre ou renvoyer en réponse à une demande.
+ **Paramètres communs** : informations détaillées sur les paramètres qui sont partagés par l’ensemble des actions d’un service.
+ **Erreurs courantes** : informations détaillées sur les erreurs qui peuvent être renvoyées par l’une des actions d’un service.
Le nom et la disponibilité de chaque section peuvent varier en fonction du service.
**Spécifique au service CLIs**
Certains services ont une CLI distincte qui date d'avant qu'une seule ne soit AWS CLI créée pour fonctionner avec tous les services. Ces documents spécifiques au service CLIs ont une documentation distincte qui est liée à la page de documentation du service. La documentation spécifique au service CLIs ne s'applique pas au. AWS CLI
## Résolution des erreurs
Pour obtenir de l'aide sur le diagnostic et la correction des AWS CLI erreurs, consultez[Résolution des erreurs liées au AWS CLI](cli-chap-troubleshooting.md).
## Aide supplémentaire
Pour obtenir de l'aide supplémentaire AWS CLI concernant vos problèmes, consultez la [AWS CLI communauté](https://github.com/aws/aws-cli/issues) sur *GitHub*.
# Structure de commande dans l’AWS CLI
Cette rubrique explique comment la commande de l’AWS Command Line Interface (AWS CLI) est structurée et comment utiliser les commandes wait.
**Topics**
+ [Structure de commande](#cli-usage-commandstructure-structure.title)
+ [Commandes wait](#cli-usage-commandstructure-wait)
## Structure de commande
L’AWS CLI utilise une structure en plusieurs parties sur la ligne de commande qui doit être spécifiée dans l’ordre suivant :
1. L’appel de base au programme `aws`.
1. La *commande* de niveau supérieur, qui correspond généralement à un service AWS pris en charge par l’AWS CLI.
1. La *sous-commande* qui spécifie l’opération à effectuer.
1. Les options d’AWS CLI générales ou les paramètres requis par l’opération. Vous pouvez les spécifier dans n’importe quel ordre tant qu’ils suivent les trois premières parties. Si un paramètre exclusif est spécifié plusieurs fois, seule la *dernière valeur* s’applique.
```
$ aws [options and parameters]
```
Les paramètres peuvent prendre différents types de valeurs d’entrée, comme des chiffres, des chaînes, des listes, des mappages et des structures JSON. Ce qui est pris en charge dépend de la commande et de la sous-commande que vous spécifiez.
### Exemples
**Amazon S3**
L’exemple suivant répertorie tous les compartiments Amazon S3.
```
$ aws s3 ls
2018-12-11 17:08:50 amzn-s3-demo-bucket1
2018-12-14 14:55:44 amzn-s3-demo-bucket2
```
Pour plus d’informations sur les commandes Amazon S3, consultez [https://docs.aws.amazon.com/cli/latest/reference/s3/index.html](https://docs.aws.amazon.com/cli/latest/reference/s3/index.html) dans la *Référence des commandes de l’AWS CLI*.
**AWS CloudFormation**
L’exemple de commande [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-change-set.html) suivant remplace le nom de la pile cloudformation par *my-change-set*.
```
$ aws cloudformation create-change-set --stack-name my-stack --change-set-name my-change-set
```
Pour plus d’informations sur les commandes AWS CloudFormation, consultez [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/index.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/index.html) dans la *Référence des commandes de l’AWS CLI*.
## Commandes wait
Des commandes `wait` sont disponibles pour certains services AWS. Toute commande utilisant `aws wait` attend généralement qu’une commande soit terminée avant de passer à l’étape suivante. C’est particulièrement utile pour les commandes en plusieurs parties ou les scripts, car vous pouvez utiliser une commande wait pour empêcher de passer aux étapes suivantes en cas d’échec de la commande wait.
L’AWS CLI utilise une structure en plusieurs parties sur la ligne de commande pour la commande `wait` qui doit être spécifiée dans l’ordre suivant :
1. L’appel de base au programme `aws`.
1. La *commande* de niveau supérieur, qui correspond généralement à un service AWS pris en charge par l’AWS CLI.
1. La commande `wait`.
1. La *sous-commande* qui spécifie l’opération à effectuer.
1. Les options CLI générales ou les paramètres requis par l’opération. Vous pouvez les spécifier dans n’importe quel ordre tant qu’ils suivent les trois premières parties. Si un paramètre exclusif est spécifié plusieurs fois, seule la *dernière valeur* s’applique.
```
$ aws wait [options and parameters]
```
Les paramètres peuvent prendre différents types de valeurs d’entrée, comme des chiffres, des chaînes, des listes, des mappages et des structures JSON. Ce qui est pris en charge dépend de la commande et de la sous-commande que vous spécifiez.
**Note**
Tous les services AWS ne prennent pas en charge les commandes `wait`. Consultez le [guide de référence de l’AWS CLI version 2](https://docs.aws.amazon.com/cli/latest/reference/index.html) pour voir si votre service prend en charge les commandes `wait`.
### Exemples
**AWS CloudFormation**
Les exemples de commande [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html) suivants s’interrompent et reprennent uniquement après avoir confirmé que le jeu de modifications *my-change-set* défini dans la pile *my-stack* est prêt pour exécution.
```
$ aws cloudformation wait change-set-create-complete --stack-name my-stack --change-set-name my-change-set
```
Pour plus d’informations sur les commandes `wait` d’AWS CloudFormation, consultez [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html) dans la *Référence des commandes de l’AWS CLI*.
**AWS CodeDeploy**
Les exemples de commande [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/change-set-create-complete.html) suivants sont mis en pause jusqu’à ce que le déploiement *d-A1B2C3111* soit terminé.
```
$ aws deploy wait deployment-successful --deployment-id d-A1B2C3111
```
Pour plus d’informations sur les commandes `wait` d’AWS CodeDeploy, consultez [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/wait/index.html) dans la *Référence des commandes de l’AWS CLI*.
# 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"}
]'
```
# Activation et utilisation des invites de commande dans AWS CLI
La AWS CLI version 2 peut vous demander des commandes, des paramètres et des ressources lorsque vous exécutez une `aws` commande.
**Topics**
+ [Comment ça marche](#cli-usage-auto-prompt-about)
+ [Fonctionnalités d’invite automatique](#cli-usage-auto-prompt-features)
+ [Modes d’invite automatique](#cli-usage-auto-prompt-modes)
+ [Configuration de l’invite automatique](#cli-usage-auto-prompt-configure)
## Comment ça marche
Si cette option est activée, l’invite automatique vous permet d’utiliser la touche **ENTRÉE** pour terminer une commande partiellement saisie. Une fois que vous avez appuyé sur la touche **ENTRÉE**, des commandes, des paramètres et des ressources sont suggérés en fonction de ce que vous continuez à saisir. Les suggestions indiquent le nom de la commande, du paramètre ou de la ressource sur la gauche et leur description sur la droite. Pour sélectionner et utiliser une suggestion, utilisez les flèches pour mettre en évidence une ligne, puis appuyez sur la touche **ESPACE**. Lorsque vous avez fini de saisir votre commande, appuyez sur **ENTRÉE** pour l’utiliser. L’exemple suivant montre à quoi ressemble une liste suggérée à partir d’une invite automatique.
```
$ aws
> aws a
accessanalyzer Access Analyzer
acm AWS Certificate Manager
acm-pca AWS Certificate Manager Private Certificate Authority
alexaforbusiness Alexa For Business
amplify AWS Amplify
```
## Fonctionnalités d’invite automatique
L’invite automatique contient les fonctionnalités utiles suivantes :
**Panneau de documentation**
Fournit la documentation d’aide pour la commande en cours. Pour ouvrir la documentation, appuyez sur la touche **F3**.
**Saisie automatique des commandes**
Suggère des commandes `aws` à utiliser. Pour voir une liste, entrez partiellement la commande. L’exemple suivant recherche un service commençant par la lettre `a`.
```
$ aws
> aws a
accessanalyzer Access Analyzer
acm AWS Certificate Manager
acm-pca AWS Certificate Manager Private Certificate Authority
alexaforbusiness Alexa For Business
amplify AWS Amplify
```
**Saisie automatique d’un paramètre**
Une fois qu’une commande est saisie, l’invite automatique commence à suggérer des paramètres. Les descriptions des paramètres incluent le type de valeur et une description de ce qu’est le paramètre. Les paramètres obligatoires sont répertoriés en premier et sont étiquetés comme obligatoires. L’exemple suivant montre la liste de paramètres générée par l’invite automatique pour `aws dynamodb describe-table`.
```
$ aws dynamodb describe-table
> aws dynamodb describe-table
--table-name (required) [string] The name of the table to describe.
--cli-input-json [string] Reads arguments from the JSON string provided. The JSON string follows the format provide...
--cli-input-yaml [string] Reads arguments from the YAML string provided. The YAML string follows the format provide...
--generate-cli-skeleton [string] Prints a JSON skeleton to standard output without sending an API request. If provided wit...
```
**Saisie automatique des ressources**
L’invite automatique effectue des appels d’API AWS en utilisant les propriétés des ressources AWS disponibles pour suggérer des valeurs de ressources. Cela permet à l’invite automatique de suggérer d’éventuelles ressources que vous possédez lors de la saisie des paramètres. Dans l’exemple suivant, l’invite automatique affiche la liste des noms de tables lorsque vous saisissez le paramètre `--table-name` de la commande `aws dynamodb describe-table`.
```
$ aws dynamodb describe-table
> aws dynamodb describe-table --table-name
Table1
Table2
Table3
```
**Saisie automatique d’une syntaxe raccourcie**
Pour les paramètres utilisant une syntaxe raccourcie, l’invite automatique suggère les valeurs à utiliser. Dans l’exemple suivant, l’invite automatique affiche la liste de valeurs de syntaxe raccourcie pour le paramètre `--placement` de la commande `aws ec2 run-instances`.
```
$ aws ec2 run-instances
> aws ec2 run-instances --placement
AvailabilityZone= [string] The Availability Zone of the instance. If not specified, an Availability Zone wil...
Affinity= [string] The affinity setting for the instance on the Dedicated Host. This parameter is no...
GroupName= [string] The name of the placement group the instance is in.
PartitionNumber= [integer] The number of the partition the instance is in. Valid only if the placement grou...
```
**Saisie automatique du fichier**
Lorsque vous remplissez des paramètres dans des commandes `aws`, la saisie automatique suggère des noms de fichiers locaux après utilisation du préfixe `file://` ou `fileb://`. Dans l’exemple suivant, l’invite automatique suggère des fichiers locaux après la saisie de `--item file://` pour la commande `aws ec2 run-instances`.
```
$ aws ec2 run-instances
> aws ec2 run-instances --item file://
item1.txt
file1.json
file2.json
```
**Saisie automatique de région**
Lorsque vous utilisez le paramètre global `--region`, l’invite automatique affiche la liste des régions qu’il est possible de sélectionner. Dans l’exemple suivant, l’invite automatique suggère des régions dans l’ordre alphabétique après la saisie de `--region` pour la commande `aws dynamodb list-tables`.
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --region
af-south-1
ap-east-1
ap-northeast-1
ap-northeast-2
```
**Saisie automatique de profil**
Lors de l’utilisation du paramètre global `--profile`, l’invite automatique affiche la liste de vos profils. Dans l’exemple suivant, l’invite automatique suggère vos profils après la saisie de `--profile` pour la commande `aws dynamodb list-tables`.
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --profile
profile1
profile2
profile3
```
**Recherches approximatives**
Commandes et valeurs complètes contenant un jeu de caractères spécifique. Dans l’exemple suivant, l’invite automatique suggère des régions qui contiennent `eu` après la saisie de `--region eu` pour la commande `aws dynamodb list-tables`.
```
$ aws dynamodb list-tables
> aws dynamodb list-tables --region west
eu-west-1
eu-west-2
eu-west-3
us-west-1
```
**History (Historique)**
Pour afficher et exécuter les commandes précédemment utilisées en mode invite automatique, appuyez sur **CTRL \$1 R**. L’historique répertorie les commandes précédentes que vous pouvez sélectionner à l’aide des touches fléchées. Dans l’exemple suivant, l’historique du mode d’invite automatique est affiché.
```
$ aws
> aws
dynamodb list-tables
s3 ls
```
## Modes d’invite automatique
L'invite automatique pour la AWS CLI version 2 dispose de 2 modes qui peuvent être configurés :
+ **Mode complet :** utilise l’invite automatique chaque fois que vous essayez d’exécuter une commande `aws`, que vous l’appeliez manuellement à l’aide du paramètre `--cli-auto-prompt` ou que vous l’activiez définitivement. Cela inclut le fait d’appuyer sur **ENTRÉE** après la saisie d’une commande complète ou incomplète.
+ **Mode partiel :** utilise l’invite automatique si une commande est incomplète ou ne peut pas être exécutée en raison d’erreurs de validation côté client. Ce mode est particulièrement utile si vous avez des scripts ou des dossiers d’exploitation préexistants, ou si vous souhaitez uniquement être automatiquement invité à entrer des commandes que vous ne connaissez pas au lieu d’être invité à chaque commande.
## Configuration de l’invite automatique
Pour configurer l’invite automatique, vous pouvez utiliser les méthodes suivantes par ordre de priorité :
+ Les **options de ligne de commande** activent ou désactivent l’invite automatique d’une commande unique. Utilisez `--cli-auto-prompt` pour appeler l’invite automatique et `--no-cli-auto-prompt` pour désactiver l’invite automatique.
+ Les **variables d’environnement** utilisent la variable `aws\$1cli\$1auto\$1prompt`.
+ Les **fichiers de configuration partagés** utilisent le paramètre `cli\$1auto\$1prompt`.
# Contrôle de la sortie des commandes dans le AWS CLI
Cette section décrit les différentes façons de contrôler la sortie de l’ AWS Command Line Interface (AWS CLI). La personnalisation de la AWS CLI sortie dans votre terminal peut améliorer la lisibilité, rationaliser l'automatisation des scripts et faciliter la navigation dans des ensembles de données plus volumineux.
Il AWS CLI prend en charge plusieurs [formats de sortie [`json`[`text`](cli-usage-output-format.md#text-output)](cli-usage-output-format.md#json-output)](cli-usage-output-format.md), notamment [`yaml`](cli-usage-output-format.md#yaml-output), [`off`](cli-usage-output-format.md#off-output), et [`table`](cli-usage-output-format.md#table-output). Certains services proposent une [pagination](cli-usage-pagination.md) côté serveur pour leurs données et AWS CLI fournissent leurs propres fonctionnalités côté client pour des options de pagination supplémentaires.
Enfin, il AWS CLI dispose d'un [filtrage côté serveur et côté client](cli-usage-filter.md) que vous pouvez utiliser individuellement ou ensemble pour filtrer votre sortie. AWS CLI
**Topics**
+ [Sortie sensible](#cli-usage-output-sensitive)
+ [Options de sortie côté serveur ou côté client](#cli-usage-output-server-client)
+ [Réglage du format de sortie dans AWS CLI](cli-usage-output-format.md)
+ [Sortie d'erreur structurée dans AWS CLI](cli-usage-error-format.md)
+ [À l'aide des options de pagination du AWS CLI](cli-usage-pagination.md)
+ [Filtrage de la sortie dans AWS CLI](cli-usage-filter.md)
## Sortie sensible
Certaines opérations AWS CLI peuvent renvoyer des informations pouvant être considérées comme sensibles, notamment des informations provenant de variables d'environnement. L’exposition de ces informations peut représenter un risque de sécurité dans certains scénarios ; par exemple, les informations peuvent être incluses dans les journaux d’intégration continue et de déploiement continu (CI/CD). Il est donc important de vérifier à quel moment vous incluez une telle sortie dans vos journaux et de supprimer la sortie lorsqu’elle n’est pas nécessaire.
Pour plus d’informations sur la protection des données sensibles, consultez [Protection des données dans le AWS CLI](data-protection.md).
Tenez compte des bonnes pratiques suivantes :
+ Envisagez d’extraire vos secrets par programmation dans un magasin de secrets, tel que AWS Secrets Manager.
+ Vérifiez le contenu de vos journaux de génération pour vous assurer qu’ils ne contiennent pas d’informations sensibles. Envisagez des approches telles que le transfert `/dev/null` ou la capture de la sortie sous forme de bash ou de PowerShell variable pour supprimer les sorties de commande.
Voici un exemple bash pour rediriger la sortie, mais pas les erreurs, vers `/dev/null` :
```
$ aws s3 ls > /dev/null
```
Pour plus d’informations sur la suppression de la sortie de votre terminal, consultez la documentation utilisateur du terminal que vous utilisez.
+ Tenez compte de l’accès à vos journaux et délimitez cet accès en fonction de votre cas d’utilisation.
## Options de sortie côté serveur ou côté client
AWS CLI Il dispose d'un [filtrage côté serveur et côté client](cli-usage-filter.md) que vous pouvez utiliser individuellement ou ensemble pour filtrer votre sortie. AWS CLI Le filtrage côté serveur est traité en premier et renvoie votre sortie pour le filtrage côté client. Le filtrage côté serveur est pris en charge par l’API du service. Le filtrage côté client est pris en charge par le AWS CLI client à l'aide du `--query` paramètre.
Les options de sortie **côté serveur** sont des fonctionnalités directement prises en charge par l' Service AWS API. Les données filtrées ou renvoyées ne sont pas envoyées au client, ce qui peut accélérer les temps de réponse HTTP et améliorer la bande passante pour les jeux de données plus volumineux.
Les options de sortie **côté client** sont des fonctionnalités créées par l’ AWS CLI. Toutes les données sont envoyées au client, puis les AWS CLI filtres ou les pages affichent le contenu. Les opérations côté client ne permettent pas d’économiser en termes de vitesse ou de bande passante pour les jeux de données plus volumineux.
Lorsque les options côté serveur et côté client sont utilisées conjointement, les opérations côté serveur sont d’abord effectuées, puis envoyées au client pour les opérations côté client. Cela permet de réaliser des économies de vitesse et de bande passante potentielles des options côté serveur, tout en utilisant des fonctionnalités d’ AWS CLI supplémentaires pour obtenir le résultat souhaité.
# Réglage du format de sortie dans AWS CLI
Cette rubrique décrit les différents formats de sortie pour le AWS Command Line Interface (AWS CLI). L’ AWS CLI prend en charge les formats de sortie suivants :
+ **[`json`](#json-output)** : la sortie est au format d’une chaîne [JSON](https://json.org/).
+ **[`yaml`](#yaml-output)** : la sortie est au format d’une chaîne [YAML](https://yaml.org/).
+ **[`yaml-stream`](#yaml-stream-output)** : la sortie est diffusée et au format d’une chaîne [YAML](https://yaml.org/). La diffusion permet de traiter plus rapidement de gros types de données.
+ **[`text`](#text-output)** : la sortie a le format de plusieurs lignes de valeurs de chaîne séparées par des tabulations. Cela peut être utile pour transmettre la sortie à un processeur de texte, comme `grep`, `sed` ou `awk`.
+ **[`table`](#table-output)** : la sortie est au format d’un tableau utilisant les caractères \$1\$1- pour délimiter les bordures des cellules. La présentation des informations est dans un format beaucoup plus lisible par l’utilisateur que les autres, mais peu pratique du point de vue programmation.
+ **[`off`](#off-output)**— La sortie supprime toutes les sorties de commande vers stdout. Cela est utile dans les scripts d'automatisation et les CI/CD pipelines où il suffit de vérifier le code de sortie de la commande sans traiter la sortie.
## Comment sélectionner le format de sortie
Comme expliqué dans la rubrique de [configuration](cli-chap-configure.md), le format de sortie peut être spécifié de trois façons :
+ **Utilisation de l’option `output` dans un profil nommé du fichier `config`** : l’exemple suivant définit le format de sortie par défaut sur `text`.
```
[default]
output=text
```
+ **Utilisation de la variable d’environnement `AWS_DEFAULT_OUTPUT`** : la sortie suivante définit le format sur `table` pour les commandes de cette session de ligne de commande jusqu’à ce que la variable soit modifiée ou que la session se termine. L’utilisation de cette variable d’environnement remplace toute valeur définie dans le fichier `config`.
```
$ export AWS_DEFAULT_OUTPUT="table"
```
+ **Utilisation de l’option `--output` sur la ligne de commande** : l’exemple suivant définit la sortie de cette seule commande sur `json`. Utiliser cette option sur la commande remplace n’importe quelle variable d’environnement actuellement définie ou la valeur dans le fichier `config`.
```
$ aws swf list-domains --registration-status REGISTERED --output json
```
**Important**
Le type de sortie que vous spécifiez influe sur la façon dont l’option `--query` fonctionne :
Si vous le spécifiez`--output text`, la sortie est paginée *avant que* le `--query` filtre ne soit appliqué, et la AWS CLI requête est exécutée une fois sur *chaque page* de la sortie. De ce fait, la requête inclut le premier élément correspondant sur chaque page, ce qui peut entraîner une sortie supplémentaire inattendue. Pour filtrer davantage la sortie, vous pouvez utiliser d’autres outils de ligne de commande, comme `head` ou `tail`.
Si vous spécifiez `--output json`, `--output yaml` ou `--output yaml-stream`, la sortie est totalement traitée et convertie en une structure JSON avant que le filtre `--query` ne soit appliqué. La requête n'est AWS CLI exécutée qu'une seule fois sur l'ensemble de la structure, produisant un résultat filtré qui est ensuite affiché.
## Format de sortie JSON
[JSON](https://json.org) est le format de sortie par défaut de l’ AWS CLI. La plupart des langages de programmation peuvent facilement décoder les chaînes JSON à l’aide de fonctions intégrées ou de bibliothèques disponibles au public. Vous pouvez combiner la sortie JSON avec l'[option --query](cli-usage-filter.md) de manière puissante pour filtrer et formater la sortie au format AWS CLI JSON.
Pour un filtrage plus avancé que vous ne pourriez peut-être pas faire avec `--query`, vous pouvez envisager `jq`, processeur JSON de ligne de commande. Vous pouvez le télécharger et trouver le didacticiel officiel à l’adresse [http://stedolan.github.io/jq/](http://stedolan.github.io/jq/).
Voici un exemple de données JSON :
```
$ aws iam list-users --output json
```
```
{
"Users": [
{
"Path": "/",
"UserName": "Admin",
"UserId": "AIDA1111111111EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/Admin",
"CreateDate": "2014-10-16T16:03:09+00:00",
"PasswordLastUsed": "2016-06-03T18:37:29+00:00"
},
{
"Path": "/backup/",
"UserName": "backup-user",
"UserId": "AIDA2222222222EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/backup/backup-user",
"CreateDate": "2019-09-17T19:30:40+00:00"
},
{
"Path": "/",
"UserName": "cli-user",
"UserId": "AIDA3333333333EXAMPLE",
"Arn": "arn:aws:iam::123456789012:user/cli-user",
"CreateDate": "2019-09-17T19:11:39+00:00"
}
]
}
```
## Format de sortie YAML
[YAML](https://yaml.org) [est un bon choix pour gérer la sortie par programmation avec des services et des outils qui émettent ou consomment des chaînes au format [YAML](https://yaml.org), comme CloudFormation sa prise en charge des modèles au format YAML.](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-formats.html)
Pour un filtrage plus avancé que vous ne pourriez peut-être pas faire avec `--query`, vous pouvez envisager `yq`, processeur YAML de ligne de commande. Vous pouvez le télécharger `yq` dans le [référentiel yq](https://github.com/mikefarah/yq) sur *GitHub*.
Voici un exemple de résultat YAML :
```
$ aws iam list-users --output yaml
```
```
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
## Format de sortie du flux YAML
Le format `yaml-stream` tire parti du format [YAML](https://yaml.org) tout en offrant une visualisation plus réactive/rapide des grands jeux de données en vous transmettant les données en streaming. Vous pouvez commencer à visualiser et à utiliser les données YAML avant le téléchargement complet des requêtes.
Pour un filtrage plus avancé que vous ne pourriez peut-être pas faire avec `--query`, vous pouvez envisager `yq`, processeur YAML de ligne de commande. Vous pouvez le télécharger `yq` dans le [référentiel yq](https://github.com/mikefarah/yq) sur *GitHub*.
Voici un exemple de sortie `yaml-stream`.
```
$ aws iam list-users --output yaml-stream
```
```
- IsTruncated: false
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
Voici un exemple de sortie `yaml-stream` associé à l’utilisation du paramètre `--page-size` pour paginer le contenu YAML diffusé.
```
$ aws iam list-users --output yaml-stream --page-size 2
```
```
- IsTruncated: true
Marker: ab1234cdef5ghi67jk8lmo9p/q012rs3t445uv6789w0x1y2z/345a6b78c9d00/1efgh234ij56klmno78pqrstu90vwxyx
Users:
- Arn: arn:aws:iam::123456789012:user/Admin
CreateDate: '2014-10-16T16:03:09+00:00'
PasswordLastUsed: '2016-06-03T18:37:29+00:00'
Path: /
UserId: AIDA1111111111EXAMPLE
UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /backup/
UserId: AIDA2222222222EXAMPLE
UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- IsTruncated: false
Users:
- Arn: arn:aws:iam::123456789012:user/cli-user
CreateDate: '2019-09-17T19:30:40+00:00'
Path: /
UserId: AIDA3333333333EXAMPLE
UserName: cli-user
```
## Format de sortie texte
Le `text` format organise la AWS CLI sortie en lignes délimitées par des tabulations. Il fonctionne bien avec les outils de texte Unix traditionnels tels que `grep``sed`,`awk`, et le traitement de texte effectué par PowerShell.
Le format de sortie `text` suit la structure de base ci-dessous. Les colonnes sont triées dans l’ordre alphabétique sur les noms de clés correspondants de l’objet JSON sous-jacent.
```
IDENTIFIER sorted-column1 sorted-column2
IDENTIFIER2 sorted-column1 sorted-column2
```
Voici un exemple de sortie `text`. Chaque champ est un onglet séparé des autres, avec un onglet supplémentaire où il y a un champ vide.
```
$ aws iam list-users --output text
```
```
USERS arn:aws:iam::123456789012:user/Admin 2014-10-16T16:03:09+00:00 2016-06-03T18:37:29+00:00 / AIDA1111111111EXAMPLE Admin
USERS arn:aws:iam::123456789012:user/backup/backup-user 2019-09-17T19:30:40+00:00 /backup/ AIDA2222222222EXAMPLE backup-user
USERS arn:aws:iam::123456789012:user/cli-user 2019-09-17T19:11:39+00:00 / AIDA3333333333EXAMPLE cli-user
```
La quatrième colonne est le champ `PasswordLastUsed`. Elle est vide pour les deux dernières entrées, car ces utilisateurs ne se connectent jamais à la console AWS Management Console.
**Important**
*Si vous spécifiez la sortie `text`, il est également fortement recommandé de toujours utiliser l’option [`--query`](cli-usage-filter.md) pour assurer un comportement cohérent*.
Cela est dû au fait que le format de texte classe les colonnes de sortie par ordre alphabétique selon le nom de clé de l'objet JSON sous-jacent renvoyé par le AWS service, et des ressources similaires peuvent ne pas porter les mêmes noms de clé. Par exemple, la représentation JSON d’une instance Amazon EC2 basée sur Linux peut comporter des éléments qui ne sont pas présents dans la représentation JSON d’une instance basée sur Windows, ou inversement. En outre, des ressources peuvent comporter des éléments clé-valeur ajoutés ou supprimés lors de futures mises à jour, ce qui modifie l’ordre des colonnes. C’est à ce stade que le code `--query` augmente la fonctionnalité de la sortie `text` afin de vous offrir un contrôle total sur le format de sortie.
Dans l’exemple suivant, la commande spécifie les éléments à afficher et *définit l’ordre* des colonnes avec la notation de liste `[key1, key2, ...]`. Cela vous permet d’être absolument sûr que les valeurs de clés correctes sont toujours affichées dans la colonne prévue. Enfin, remarquez comment les AWS CLI sorties sont `None` des valeurs pour des clés qui n'existent pas.
```
$ aws iam list-users --output text --query 'Users[*].[UserName,Arn,CreateDate,PasswordLastUsed,UserId]'
```
```
Admin arn:aws:iam::123456789012:user/Admin 2014-10-16T16:03:09+00:00 2016-06-03T18:37:29+00:00 AIDA1111111111EXAMPLE
backup-user arn:aws:iam::123456789012:user/backup-user 2019-09-17T19:30:40+00:00 None AIDA2222222222EXAMPLE
cli-user arn:aws:iam::123456789012:user/cli-backup 2019-09-17T19:11:39+00:00 None AIDA3333333333EXAMPLE
```
L’exemple suivant montre comment vous pouvez utiliser `grep` et `awk` avec la sortie `text` à partir de la commande `aws ec2 describe-instances`. La première commande affiche la zone de disponibilité, l’état actuel et l’ID d’instance de chaque instance dans la sortie `text`. La deuxième commande traite cette sortie pour afficher uniquement l'instance IDs de toutes les instances en cours d'exécution dans la zone de `us-west-2a` disponibilité.
```
$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text
```
```
us-west-2a running i-4b41a37c
us-west-2a stopped i-a071c394
us-west-2b stopped i-97a217a0
us-west-2a running i-3045b007
us-west-2a running i-6fc67758
```
```
$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text | grep us-west-2a | grep running | awk '{print $3}'
```
```
i-4b41a37c
i-3045b007
i-6fc67758
```
L’exemple suivant va encore plus loin et indique comment filtrer la sortie, mais également comment utiliser cette sortie pour automatiser la modification des types d’instance pour chaque instance arrêtée.
```
$ aws ec2 describe-instances --query 'Reservations[*].Instances[*].[State.Name, InstanceId]' --output text |
> grep stopped |
> awk '{print $2}' |
> while read line;
> do aws ec2 modify-instance-attribute --instance-id $line --instance-type '{"Value": "m1.medium"}';
> done
```
La `text` sortie peut également être utile dans PowerShell. Comme les colonnes de la `text` sortie sont séparées par des tabulations, vous pouvez facilement diviser la sortie en tableau en utilisant le PowerShell ``t` délimiteur. La commande suivante affiche la valeur de la troisième colonne (`InstanceId`) si la première colonne (`AvailabilityZone`) correspond à la chaîne `us-west-2a`.
```
PS C:\>aws ec2 describe-instances --query 'Reservations[*].Instances[*].[Placement.AvailabilityZone, State.Name, InstanceId]' --output text |
%{if ($_.split("`t")[0] -match "us-west-2a") { $_.split("`t")[2]; } }
```
```
-4b41a37c
i-a071c394
i-3045b007
i-6fc67758
```
Notez que même si l'exemple précédent montre comment utiliser le `--query` paramètre pour analyser les objets JSON sous-jacents et extraire la colonne souhaitée, il PowerShell possède sa propre capacité à gérer le JSON, si la compatibilité entre plateformes n'est pas un problème. Au lieu de gérer la sortie sous forme de texte, comme l'exigent la plupart des interfaces de commande, PowerShell vous pouvez utiliser l'`ConvertFrom-JSON`applet de commande pour produire un objet structuré hiérarchiquement. Vous pouvez ensuite accéder directement au membre souhaité à partir de cet objet.
```
(aws ec2 describe-instances --output json | ConvertFrom-Json).Reservations.Instances.InstanceId
```
**Astuce**
Si vous avez une sortie de texte et que vous filtrez la sortie vers un champ unique à l’aide du paramètre `--query`, la sortie consiste en une seule ligne de valeurs séparées par une tabulation. Pour voir chaque valeur sur une ligne distincte, vous pouvez placer le champ de sortie entre crochets comme illustré dans les exemples suivants :
Séparées par tabulation, sortie à ligne unique :
```
$ aws iam list-groups-for-user --user-name susan --output text --query "Groups[].GroupName"
```
```
HRDepartment Developers SpreadsheetUsers LocalAdmins
```
Chaque valeur sur sa propre ligne en plaçant `[GroupName]` entre crochets :
```
$ aws iam list-groups-for-user --user-name susan --output text --query "Groups[].[GroupName]"
```
```
HRDepartment
Developers
SpreadsheetUsers
LocalAdmins
```
## Format de sortie de tableau
Le format `table` produit des représentations explicites de la sortie complexe de l’ AWS CLI sous la forme d’un tableau.
```
$ aws iam list-users --output table
```
```
-----------------------------------------------------------------------------------------------------------------------------------------------------------------
| ListUsers |
+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
|| Users ||
|+----------------------------------------------------+---------------------------+---------------------------+----------+-----------------------+-------------+|
|| Arn | CreateDate | PasswordLastUsed | Path | UserId | UserName ||
|+----------------------------------------------------+---------------------------+---------------------------+----------+-----------------------+-------------+|
|| arn:aws:iam::123456789012:user/Admin | 2014-10-16T16:03:09+00:00 | 2016-06-03T18:37:29+00:00 | / | AIDA1111111111EXAMPLE | Admin ||
|| arn:aws:iam::123456789012:user/backup/backup-user | 2019-09-17T19:30:40+00:00 | | /backup/ | AIDA2222222222EXAMPLE | backup-user ||
|| arn:aws:iam::123456789012:user/cli-user | 2019-09-17T19:11:39+00:00 | | / | AIDA3333333333EXAMPLE | cli-user ||
+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
Vous pouvez combiner l’option `--query` avec le format `table` pour afficher un ensemble d’éléments pré-sélectionnés dans la sortie brute. Notez les différences de sortie entre le dictionnaire et les notations de liste : les noms de colonnes sont triés par ordre alphabétique dans le premier exemple et les colonnes sans nom sont triées en fonction du choix de l’utilisateur dans le second exemple. Pour plus d’informations sur l’option `--query`, consultez [Filtrage de la sortie dans AWS CLI](cli-usage-filter.md).
```
$ aws ec2 describe-volumes --query 'Volumes[*].{ID:VolumeId,InstanceId:Attachments[0].InstanceId,AZ:AvailabilityZone,Size:Size}' --output table
```
```
------------------------------------------------------
| DescribeVolumes |
+------------+----------------+--------------+-------+
| AZ | ID | InstanceId | Size |
+------------+----------------+--------------+-------+
| us-west-2a| vol-e11a5288 | i-a071c394 | 30 |
| us-west-2a| vol-2e410a47 | i-4b41a37c | 8 |
+------------+----------------+--------------+-------+
```
```
$ aws ec2 describe-volumes --query 'Volumes[*].[VolumeId,Attachments[0].InstanceId,AvailabilityZone,Size]' --output table
```
```
----------------------------------------------------
| DescribeVolumes |
+--------------+--------------+--------------+-----+
| vol-e11a5288| i-a071c394 | us-west-2a | 30 |
| vol-2e410a47| i-4b41a37c | us-west-2a | 8 |
+--------------+--------------+--------------+-----+
```
## Format hors sortie
Le `off` format supprime toutes les sorties de commande vers stdout. Cela est utile dans les scripts d'automatisation et les CI/CD pipelines où il suffit de vérifier le code de sortie de la commande sans traiter la sortie. Les messages d'erreur sont toujours affichés sur stderr.
L'exemple suivant montre comment le `off` format supprime une sortie réussie. Vous pouvez vérifier le code de sortie pour déterminer le succès :
```
$ aws s3api list-buckets --output off
$ echo $?
0
```
Cela est particulièrement utile dans les scripts shell où vous souhaitez vérifier l'existence d'une ressource sans capturer la sortie :
```
#!/bin/bash
if aws s3api head-bucket --bucket my-bucket --output off 2>/dev/null; then
echo "Bucket exists"
else
echo "Bucket does not exist"
fi
```
**Note**
Le `off` format supprime uniquement la sortie standard. Les erreurs sont toujours écrites dans stderr.
# Sortie d'erreur structurée dans AWS CLI
Cette rubrique décrit les formats de sortie d'erreur structurés pour le AWS Command Line Interface (AWS CLI). La CLI écrit les erreurs dans stderr et prend en charge les formats suivants :
+ **[`enhanced`](#cli-error-format-enhanced)**(par défaut) — Message d'erreur avec des détails supplémentaires affichés en ligne. À utiliser pour un débogage lisible par l'homme.
+ **[`json`](#cli-error-format-json)**— La sortie est formatée sous forme de chaîne [JSON](https://json.org/) avec tous les champs d'erreur. À utiliser pour l'automatisation et la création de scripts.
+ **[`yaml`](#cli-error-format-yaml)**— La sortie est formatée sous forme de chaîne [YAML](https://yaml.org/) avec tous les champs d'erreur. À utiliser pour l'automatisation et la création de scripts.
+ **[`text`](#cli-error-format-text)**— Erreurs de formatage à l'aide du formateur de texte. À utiliser pour un scan visuel rapide.
+ **[`table`](#cli-error-format-table)**— Formate les erreurs à l'aide du formateur de tableau. À utiliser pour un scan visuel rapide.
+ **[`legacy`](#cli-error-format-legacy)**— Format d'erreur original sans détails structurés. À utiliser pour des raisons de rétrocompatibilité.
## Configuration du format d'erreur
Vous pouvez configurer le format d'erreur à l'aide de l'une des méthodes suivantes :
Drapeau de ligne de commande
```
$ aws --cli-error-format json
```
Fichier de configuration (`~/.aws/config`)
```
[default]
cli_error_format = json
```
Variable d'environnement
```
$ export AWS_CLI_ERROR_FORMAT=yaml
```
## Formats de sortie d'erreur
Les sections suivantes décrivent chaque format :
### Format amélioré (par défaut)
Le format amélioré affiche les messages d'erreur avec des détails supplémentaires intégrés pour les valeurs simples. Pour les structures complexes, le format indique l'utilisation de JSON ou de YAML.
**Exemple : configuration de région manquante**
```
aws: [ERROR]: An error occurred (NoRegion): You must specify a region. You can also configure your region by running "aws configure".
```
**Exemple : fonction Lambda inexistante avec des champs supplémentaires**
```
aws: [ERROR]: An error occurred (ResourceNotFoundException) when calling the GetFunction operation: Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345
Additional error details:
Type: User
```
La section « Informations supplémentaires sur les erreurs » affiche uniquement les champs définis dans le modèle de forme d'erreur du service. Les champs non modélisés issus de la réponse d'erreur ne sont pas affichés.
**Exemple : champs d'erreur complexes**
```
An error occurred (TransactionCanceledException) when calling the TransactWriteItems operation: Transaction cancelled, please refer cancellation reasons for specific reasons [ConditionalCheckFailed, None]
Additional error details:
CancellationReasons:
Use "--cli-error-format json" or another error format to see the full details.
```
### Format JSON
Le format JSON fournit une représentation structurée avec tous les champs d'erreur.
**Exemple : configuration de région manquante**
```
{
"Code": "NoRegion",
"Message": "You must specify a region. You can also configure your region by running \"aws configure\"."
}
```
**Exemple : fonction Lambda inexistante**
```
{
"Code": "ResourceNotFoundException",
"Message": "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345",
"Type": "User"
}
```
### Format YAML
Le format YAML fournit une représentation structurée avec tous les champs d'erreur.
**Exemple : configuration de région manquante**
```
Code: NoRegion
Message: You must specify a region. You can also configure your region by running "aws configure".
```
**Exemple : fonction Lambda inexistante**
```
Code: ResourceNotFoundException
Message: "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345"
Type: User
```
### Format texte
Le format de texte utilise le même formateur que la sortie de commande réussie.
**Exemple : fonction Lambda inexistante**
```
ResourceNotFoundException Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345 User
```
### Format de tableau
Le format de table utilise le même formateur que la sortie de commande réussie.
**Exemple : fonction Lambda inexistante**
```
------------------------------------------------------------------------------------------------------------------------------------|
| error |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
| Code | Message | Type |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
| ResourceNotFoundException | Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345 | User |
+----------------------------+--------------------------------------------------------------------------------------------------+------+
```
### Ancien format
L'ancien format fournit le format d'erreur d'origine sans détails structurés. Ce format n'inclut pas le préfixe « Une erreur s'est produite (ErrorCode) : » pour les exceptions de la CLI.
**Exemple : configuration de région manquante**
```
aws: [ERROR]: You must specify a region. You can also configure your region by running "aws configure".
```
**Exemple : fonction Lambda inexistante**
```
An error occurred (ResourceNotFoundException) when calling the GetFunction operation: Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345
```
**Note**
Les erreurs incluent désormais systématiquement le `aws: [ERROR]:` préfixe des exceptions de la CLI. Les versions antérieures n'incluaient pas toujours ce préfixe.
Les exceptions suivantes utilisent toujours l'ancien format, quel que soit le format d'erreur configuré :
`UnknownArgumentError`— Affiche les informations d'utilisation
Interruptions du clavier () `KeyboardInterrupt`
## Exemple complet
L'exemple suivant montre une commande avec un formatage d'erreur JSON :
```
$ aws lambda get-function \
--function-name nonexistent-function-12345 \
--cli-error-format json
```
Sortie (stderr) :
```
{
"Code": "ResourceNotFoundException",
"Message": "Function not found: arn:aws:lambda:us-west-2:123456789012:function:nonexistent-function-12345",
"Type": "User"
}
```
Le `Type` champ est un membre d'erreur modélisé défini dans la forme d'erreur du service Lambda. Seuls les champs définis dans le modèle d'erreur du service sont inclus dans la sortie d'erreur structurée.
# À l'aide des options de pagination du AWS CLI
Cette rubrique décrit les différentes méthodes de pagination de la sortie à partir de AWS Command Line Interface (AWS CLI).
Il existe principalement deux manières de contrôler la pagination à partir de l’ AWS CLI.
+ [Utilisation des paramètres de pagination côté serveur.](#cli-usage-pagination-serverside)
+ [Utilisation de votre programme de pagination côté client en sortie par défaut](#cli-usage-pagination-clientside).
Les paramètres de pagination côté serveur traitent en premier et toute sortie est envoyée à la pagination côté client.
## Pagination côté serveur
Pour la plupart des commandes qui renvoient une longue liste d'éléments, plusieurs options côté serveur permettent de contrôler le nombre d'éléments inclus dans la sortie lorsque l'API d' AWS CLI un service est appelée pour remplir la liste. AWS CLI La pagination côté serveur dans le AWS CLI est activée par l'API du AWS service. Par conséquent, ces options ne fonctionnent que si l'API du service les active.
**Topics**
+ [--no-paginate](#cli-usage-pagination-nopaginate)
+ [--page-size](#cli-usage-pagination-pagesize)
+ [--max-items](#cli-usage-pagination-maxitems)
+ [--starting-token](#cli-usage-pagination-startingtoken)
Par défaut, il AWS CLI utilise un format de page déterminé par le service individuel et récupère tous les éléments disponibles. Par exemple, Amazon S3 a une taille de page par défaut de 1 000. Si vous exécutez le code `aws s3api list-objects` sur un compartiment S3 qui contient 3 500 objets, l’ AWS CLI effectue quatre appels à Amazon S3, en gérant la logique de pagination spécifique à un service en arrière-plan et en envoyant tous les 3 500 objets dans la sortie finale.
Pour savoir si une commande spécifique possède une pagination côté serveur, consultez le guide de référence [AWS CLI version 2](https://docs.aws.amazon.com/cli/latest/reference/index.html) du .
### Utilisation du paramètre --no-paginate
L’option `--no-paginate` désactive les jetons de pagination suivants côté client. Lorsque vous utilisez une commande, par défaut, elle effectue AWS CLI automatiquement plusieurs appels pour renvoyer tous les résultats possibles afin de créer une pagination. Un appel par page. La désactivation de la pagination AWS CLI ne nécessite qu'une seule fois la première page des résultats de commande.
Par exemple, si vous exécutez `aws s3api list-objects` un bucket Amazon S3 qui contient 3 500 objets, AWS CLI seul le premier appel est envoyé à Amazon S3, renvoyant uniquement les 1 000 premiers objets dans le résultat final.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--no-paginate
{
"Contents": [
...
```
### Utilisation du paramètre --page-size
Si vous constatez des problèmes lors de l’exécution de commandes de liste sur un grand nombre de ressources, la taille de page par défaut peut être trop élevée. Cela peut entraîner un dépassement de la durée maximale autorisée pour les appels aux AWS services et générer une erreur de « expiration du délai imparti ». Vous pouvez utiliser cette `--page-size` option pour spécifier que le AWS CLI nombre d'éléments demandés à chaque appel au AWS service est réduit. Il récupère AWS CLI toujours la liste complète, mais exécute un plus grand nombre d'appels d'API de service en arrière-plan et récupère un plus petit nombre d'éléments à chaque appel. Cela donne aux appels individuels une plus grande chance de réussite sans délai d’expiration. Modifier la taille de la page n’affecte pas la sortie ; cela affecte uniquement le nombre d’appels d’API qui doivent être effectués pour générer la sortie.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--page-size 100
{
"Contents": [
...
```
### Utilisation du paramètre --max-items
Pour inclure moins d'éléments à la fois dans la AWS CLI sortie, utilisez l'`--max-items`option. Le gère AWS CLI toujours la pagination avec le service comme décrit précédemment, mais n'imprime que le nombre d'éléments que vous spécifiez à la fois.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--max-items 100
{
"NextToken": "eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxfQ==",
"Contents": [
...
```
### Utilisation du paramètre --starting-token
Si le nombre d’éléments en sortie (`--max-items`) est inférieur au nombre total d’éléments renvoyés par les appels d’API sous-jacents, la sortie inclut un code `NextToken` que vous pouvez transmettre dans une commande suivante pour récupérer le prochain ensemble d’éléments. L’exemple suivant montre comment utiliser la valeur `NextToken` renvoyée par l’exemple précédent et vous permet de récupérer la deuxième centaine d’éléments.
**Note**
Le paramètre `--starting-token` ne peut pas être nul ni vide. Si la commande précédente ne renvoie pas de valeur `NextToken`, il n’y a plus aucun élément à renvoyer et vous ne devez plus rappeler la commande.
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--max-items 100 \
--starting-token eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxfQ==
{
"Contents": [
...
```
Le AWS service spécifié peut ne pas retourner les articles de la même commande à chaque fois que vous appelez. Si vous spécifiez des valeurs différentes pour les codes `--page-size` et `--max-items`, vous pouvez obtenir des résultats inattendus avec des éléments manquants ou des doublons. Pour empêcher que cela ne se produise, utilisez le même nombre pour les codes `--page-size` et `--max-items`, afin de synchroniser la pagination de l’ AWS CLI et celle du service sous-jacent. Vous pouvez également extraire la liste complète et exécuter les opérations de pagination nécessaires localement.
## Pager côté client
AWS CLI la version 2 fournit l'utilisation d'un programme de téléavertisseur côté client pour la sortie. Par défaut, cette fonctionnalité renvoie toutes les sorties via le programme de pager par défaut de votre système d’exploitation.
Par ordre de priorité, vous pouvez spécifier le pager de sortie de deux manières :
+ En utilisant le paramètre `cli_pager` du fichier `config` dans le profil `default` ou nommé.
+ À l’aide de la variable d’environnement `AWS_PAGER`.
+ À l’aide de la variable d’environnement `PAGER`.
Par ordre de priorité, vous pouvez désactiver toute utilisation d’un programme de pagination externe de la manière suivante :
+ Utilisez l’option de ligne de commande `--no-cli-pager` pour désactiver le pager pour l’utilisation d’une commande unique.
+ Définissez le paramètre `cli_pager` ou la variable `AWS_PAGER` sur une chaîne vide.
**Topics**
+ [cli\$1pager](#cli-usage-pagination-clipager)
+ [AWS\$1PAGER](#cli-usage-pagination-awspager)
+ [--no-cli-pager](#cli-usage-pagination-noclipager)
+ [Indicateurs de pager](#cli-usage-pagination-flags)
### Utilisation du paramètre cli\$1pager
Vous pouvez enregistrer vos paramètres de configuration utilisés fréquemment et vos informations d’identification dans des fichiers qui sont gérés par l’ AWS CLI. Les paramètres d’un profil de nom ont priorité sur les paramètres du profil `default`. Pour plus d’informations sur les paramètres de configuration, consultez [Paramètres des fichiers de configuration et d'identification dans AWS CLI](cli-configure-files.md).
L’exemple suivant définit le pager de sortie par défaut sur le programme `less`.
```
[default]
cli_pager=less
```
L’exemple suivant définit la valeur par défaut pour désactiver l’utilisation d’un pager.
```
[default]
cli_pager=
```
### Comment définir la variable d' AWS\$1PAGERenvironnement
L’exemple suivant définit le pager de sortie par défaut sur le programme `less`. Pour plus d’informations sur les variables d’environnement, consultez [Configuration des variables d'environnement pour AWS CLI](cli-configure-envvars.md).
------
#### [ Linux and macOS ]
```
$ export AWS_PAGER="less"
```
------
#### [ Windows ]
```
C:\> setx AWS_PAGER "less"
```
------
### Comment utiliser l'no-cli-pager option --
Pour désactiver l’utilisation d’un pager sur une commande unique, utilisez l’option `--no-cli-pager`. Pour plus d’informations sur les options de ligne de commande, consultez [Options de ligne de commande dans le AWS CLI](cli-configure-options.md).
```
$ aws s3api list-objects \
--bucket amzn-s3-demo-bucket \
--no-cli-pager
{
"Contents": [
...
```
### Utilisation des indicateurs de pager
Vous pouvez définir des indicateurs à utiliser automatiquement avec votre programme de pagination. Les indicateurs dépendent du programme de pagination que vous utilisez. Les exemples ci-dessous concernent les valeurs par défaut typiques de `less` et `more`.
------
#### [ Linux and macOS ]
Si vous ne spécifiez pas le contraire, le téléavertisseur utilisé par défaut par la AWS CLI version 2 est`less`. Si la variable d'`LESS`environnement n'est pas définie, la AWS CLI version 2 utilise les `FRX` drapeaux. Vous pouvez combiner des drapeaux en les spécifiant lors de la configuration du AWS CLI pager.
L’exemple suivant utilise l’indicateur `S`. Cet indicateur se combine ensuite avec les indicateurs `FRX` par défaut pour créer un indicateur `FRXS` final.
```
$ export AWS_PAGER="less -S"
```
Si vous ne voulez aucun des indicateurs `FRX`, vous pouvez les supprimer. L’exemple suivant refuse l’indicateur `F` afin de créer un indicateur `RX` final.
```
$ export AWS_PAGER="less -+F"
```
Pour plus d’informations sur les indicateurs `less`, consultez [less](http://manpages.org/less/1#options) sur *manpages.org*.
------
#### [ Windows ]
Si vous ne spécifiez pas le contraire, le téléavertisseur utilisé par défaut par la AWS CLI version 2 ne `more` comporte aucun indicateur supplémentaire.
L’exemple suivant utilise le paramètre `/c`.
```
C:\> setx AWS_PAGER "more /c"
```
Pour plus d’informations sur les indicateurs `more`, consultez `[more](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/more)` sur *Microsoft Docs*.
------
# Filtrage de la sortie dans AWS CLI
Le AWS Command Line Interface (AWS CLI) dispose d'un filtrage côté serveur et côté client que vous pouvez utiliser individuellement ou ensemble pour filtrer votre sortie. AWS CLI Le filtrage côté serveur est traité en premier et renvoie votre sortie pour le filtrage côté client.
+ Le filtrage côté serveur est pris en charge par l’API, et vous l’implémentez généralement avec un paramètre `--filter`. Le service renvoie uniquement les résultats correspondants, ce qui peut accélérer les temps de réponse HTTP pour les jeux de données volumineux.
+ Le filtrage côté client est pris en charge par le AWS CLI client à l'aide du `--query` paramètre. Ce paramètre possède des fonctionnalités que le filtrage côté serveur ne possède peut-être pas.
**Topics**
+ [Filtrage côté serveur](#cli-usage-filter-server-side)
+ [Filtrage côté client](#cli-usage-filter-client-side)
+ [Combinaison d’un filtrage côté serveur et côté client](#cli-usage-filter-combining)
+ [Ressources supplémentaires](#cli-usage-filter-resources)
## Filtrage côté serveur
Le filtrage côté serveur dans le AWS CLI est fourni par l'API du AWS service. Le service AWS renvoie uniquement dans la réponse HTTP les enregistrements qui correspondent à votre filtre, ce qui peut accélérer les temps de réponse HTTP pour les jeux de données volumineux. Le filtrage côté serveur étant défini par l’API du service, les noms des paramètres et les fonctions varient d’un service à l’autre. Les noms de paramètres couramment utilisés pour le filtrage sont les suivants :
+ `--filter` tels que [ses](https://docs.aws.amazon.com/cli/latest/reference/ses/create-receipt-filter.html) et [ce](https://docs.aws.amazon.com/cli/latest/reference/ce/get-cost-and-usage.html).
+ `--filters` tels que [ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-volumes.html), [autoscaling](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/describe-tags.html) et [rds](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html).
+ Noms commençant par le mot `filter`, par exemple `--filter-expression` pour la commande [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/scan.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/scan.html).
Pour savoir si une commande spécifique dispose d'un filtrage côté serveur et sur les règles de filtrage, consultez le guide de [de référence](https://docs.aws.amazon.com/cli/latest/reference/index.html).
## Filtrage côté client
AWS CLI fournit des fonctionnalités intégrées de filtrage côté client basées sur JSON avec le paramètre. `--query` Le paramètre `--query` est un outil puissant que vous pouvez utiliser pour personnaliser le contenu et le style de votre sortie. Le paramètre `--query` prend la réponse HTTP qui revient du serveur et filtre les résultats avant de les afficher. Comme l’intégralité de la réponse HTTP est envoyée au client avant le filtrage, le filtrage côté client peut être plus lent que le filtrage côté serveur pour les jeux de données volumineux.
Les requêtes utilisent [JMESPath la syntaxe](https://jmespath.org/) pour créer des expressions permettant de filtrer votre sortie. Pour apprendre JMESPath la syntaxe, consultez le [didacticiel](https://jmespath.org/tutorial.html) sur le *JMESPath site Web*.
**Important**
Le type de sortie que vous spécifiez influe sur la façon dont l’option `--query` fonctionne :
Si vous le spécifiez`--output text`, la sortie est paginée *avant que* le `--query` filtre ne soit appliqué, et la AWS CLI requête est exécutée une fois sur *chaque page* de la sortie. De ce fait, la requête inclut le premier élément correspondant sur chaque page, ce qui peut entraîner une sortie supplémentaire inattendue. Pour filtrer davantage la sortie, vous pouvez utiliser d’autres outils de ligne de commande, comme `head` ou `tail`.
Si vous spécifiez `--output json`, `--output yaml` ou `--output yaml-stream`, la sortie est totalement traitée et convertie en une structure JSON avant que le filtre `--query` ne soit appliqué. La requête n'est AWS CLI exécutée qu'une seule fois sur l'ensemble de la structure, produisant un résultat filtré qui est ensuite affiché.
**Topics**
+ [Avant de commencer](#cli-usage-filter-client-side-output)
+ [Identifiants](#cli-usage-filter-client-side-identifiers)
+ [Sélection dans une liste](#cli-usage-filter-client-side-select-list)
+ [Filtrage des données imbriquées](#cli-usage-filter-client-side-nested)
+ [Aplatissement des résultats](#cli-usage-filter-client-side-specific-flattening)
+ [Filtrage de valeurs spécifiques](#cli-usage-filter-client-side-specific-values)
+ [Expressions de redirection](#cli-usage-filter-client-side-pipe)
+ [Filtrage de plusieurs valeurs d’identifiant](#cli-usage-filter-client-side-miltiselect-list)
+ [Ajout d’étiquettes aux valeurs d’identifiant](#cli-usage-filter-client-side-multiselect-hash)
+ [Fonctions](#cli-usage-filter-client-side-functions)
+ [Exemples `--query` avancés](#cli-usage-filter-client-side-advanced)
### Avant de commencer
**Note**
Ces exemples d’expressions de filtre sont écrits pour des shells de base de type Linux. Lorsque vous utilisez ces exemples, veillez à utiliser les bonnes règles de guillemets pour votre shell de terminal. La façon dont votre terminal interprète vos entrées peut modifier considérablement ce qui est envoyé à l’ AWS CLI. La façon dont votre terminal lit les guillemets simples `'`, les guillemets doubles `"` ou les accents graves ``` peut modifier la façon dont le contenu est lu.
Pour de plus amples informations, veuillez consulter [Utiliser des guillemets et des littéraux avec des chaînes dans AWS CLI](cli-usage-parameters-quoting-strings.md).
La sortie JSON suivante montre un exemple de ce que le paramètre `--query` peut produire. La sortie décrit trois volumes Amazon EBS attachés à des instances Amazon EC2 distinctes.
#### Exemple de sortie
```
$ aws ec2 describe-volumes
{
"Volumes": [
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
}
```
### Identifiants
Les identifiants sont les étiquettes des valeurs de sortie. Lorsque vous créez des filtres, vous utilisez des identifiants pour affiner les résultats de vos requêtes. Dans l’exemple de sortie suivant, tous les identifiants, tels que `Volumes`, `AvailabilityZone` et `AttachTime` sont mis en évidence.
```
$ aws ec2 describe-volumes
{
"Volumes": [
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
}
```
Pour plus d'informations, consultez la section [Identifiants](https://jmespath.org/specification.html#identifiers ) sur le *JMESPath site Web*.
### Sélection dans une liste
Une liste ou un tableau est un identifiant suivi d’un crochet « `[` » tel que `Volumes` et `Attachments` dans [Avant de commencer](#cli-usage-filter-client-side-output).
**Syntaxe**
```
[ ]
```
Pour filtrer toutes les sorties d’un tableau, vous pouvez utiliser la notation générique. Les expressions [génériques](http://jmespath.org/specification.html#wildcard-expressions) sont des expressions utilisées pour renvoyer des éléments à l’aide de la notation `*`.
L’exemple suivant interroge tout le contenu `Volumes`.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
```
Pour afficher un volume spécifique du tableau par index, vous appelez l’index de tableau. Par exemple, le premier élément du tableau `Volumes` a un indice 0, ce qui donne lieu à la requête `Volumes[0]`. Pour plus d'informations sur les index de tableaux, consultez la section [expressions d'index](http://jmespath.org/specification.html#index-expressions) sur le *JMESPathsite Web*.
```
$ aws ec2 describe-volumes \
--query 'Volumes[0]'
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
}
```
Pour afficher une plage spécifique de volumes par index, utilisez `slice` avec la syntaxe suivante, où **start** est l’index du tableau de départ, **stop** est l’index où le filtre arrête le traitement et **step** est l’intervalle de saut.
**Syntaxe**
```
[::]
```
Si l’une de ces valeurs est omise dans l’expression slice, elle utilise les valeurs par défaut suivantes :
+ Départ : premier index de la liste, 0.
+ Arrêt : dernier index de la liste.
+ Étape : aucune étape n’est omise, la valeur étant 1.
Pour renvoyer uniquement les deux premiers volumes, vous devez utiliser une valeur de départ de 0, une valeur d’arrêt de 2 et une valeur d’étape de 1, comme indiqué dans l’exemple suivant.
```
$ aws ec2 describe-volumes \
--query 'Volumes[0:2:1]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-2e410a47",
"State": "in-use",
"SnapshotId": "snap-708e8348",
"CreateTime": "2013-09-18T20:26:15.000Z",
"Size": 8
}
]
```
Comme cet exemple contient des valeurs par défaut, vous pouvez raccourcir la tranche de `Volumes[0:2:1]` à `Volumes[:2]`.
L’exemple suivant omet les valeurs par défaut et renvoie tous les deux volumes de l’intégralité du tableau.
```
$ aws ec2 describe-volumes \
--query 'Volumes[::2]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
}
]
```
Les étapes peuvent également utiliser des nombres négatifs pour filtrer les valeurs dans l’ordre inverse d’un tableau, comme illustré dans l’exemple suivant.
```
$ aws ec2 describe-volumes \
--query 'Volumes[::-2]'
[
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-a1b3c7nd",
"State": "in-use",
"SnapshotId": "snap-234087fb",
"CreateTime": "2020-11-20T19:54:05.000Z",
"Size": 15
},
{
"AvailabilityZone": "us-west-2a",
"Attachments": [
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
"VolumeType": "standard",
"VolumeId": "vol-e11a5288",
"State": "in-use",
"SnapshotId": "snap-f23ec1c8",
"CreateTime": "2013-09-17T00:55:03.000Z",
"Size": 30
}
]
```
Pour plus d'informations, consultez la section [Slices](https://jmespath.org/specification.html#slices) sur le *JMESPath site Web*.
### Filtrage des données imbriquées
Pour affiner le filtrage de `Volumes[*]` pour les valeurs imbriquées, vous pouvez utiliser des sous-expressions en ajoutant un point et vos critères de filtre.
**Syntaxe**
```
.
```
L’exemple suivant montre toutes les informations `Attachments` pour tous les volumes.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments'
[
[
{
"AttachTime": "2013-09-17T00:55:03.000Z",
"InstanceId": "i-a071c394",
"VolumeId": "vol-e11a5288",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
[
{
"AttachTime": "2013-09-18T20:26:16.000Z",
"InstanceId": "i-4b41a37c",
"VolumeId": "vol-2e410a47",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
],
[
{
"AttachTime": "2020-11-20T19:54:06.000Z",
"InstanceId": "i-1jd73kv8",
"VolumeId": "vol-a1b3c7nd",
"State": "attached",
"DeleteOnTermination": true,
"Device": "/dev/sda1"
}
]
]
```
Pour filtrer davantage les valeurs imbriquées, ajoutez l’expression pour chaque identifiant imbriqué. L’exemple suivant répertorie le `State` pour tous les `Volumes`.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[*].State'
[
[
"attached"
],
[
"attached"
],
[
"attached"
]
]
```
### Aplatissement des résultats
Pour plus d'informations, consultez [SubExpressions](https://jmespath.org/specification.html#subexpressions)le *JMESPathsite Web*.
Vous pouvez aplatir les résultats de `Volumes[*].Attachments[*].State` en supprimant la notation générique à l’origine de la requête `Volumes[*].Attachments[].State`. L’aplatissement fréquent est utile pour améliorer la lisibilité des résultats.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].State'
[
"attached",
"attached",
"attached"
]
```
Pour plus d'informations, voir [Flatten](https://jmespath.org/specification.html#flatten) sur le *JMESPath site Web*.
### Filtrage de valeurs spécifiques
Pour filtrer des valeurs spécifiques dans une liste, vous devez utiliser une expression de filtre, comme indiqué dans la syntaxe suivante.
**Syntaxe**
```
? ]
```
Les comparateurs d’expressions incluent `==`, `!=`, `<`, `<=`, `>` et `>=`. L’exemple suivant filtre les `VolumeIds` de tous les `Volumes` ayant l’état `Attached``State`.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[?State==`attached`].VolumeId'
[
[
"vol-e11a5288"
],
[
"vol-2e410a47"
],
[
"vol-a1b3c7nd"
]
]
```
Cela peut ensuite être aplati, comme dans l’exemple suivant.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[?State==`attached`].VolumeId[]'
[
"vol-e11a5288",
"vol-2e410a47",
"vol-a1b3c7nd"
]
```
L’exemple suivant filtre les `VolumeIds` de tous les `Volumes` dont la taille est inférieure à 20.
```
$ aws ec2 describe-volumes \
--query 'Volumes[?Size < `20`].VolumeId'
[
"vol-2e410a47",
"vol-a1b3c7nd"
]
```
Pour plus d'informations, consultez [Filtrer les expressions](https://jmespath.org/specification.html#filterexpressions) sur le *JMESPathsite Web*.
### Expressions de redirection
Vous pouvez rediriger les résultats d’un filtre vers une nouvelle liste, puis filtrer le résultat avec une autre expression en utilisant la syntaxe suivante :
**Syntaxe**
```
| ]
```
L’exemple suivant prend les résultats du filtre de l’expression `Volumes[*].Attachments[].InstanceId` et affiche le premier résultat dans le tableau.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].InstanceId | [0]'
"i-a071c394"
```
Pour ce faire, cet exemple crée d’abord le tableau à partir de l’expression suivante.
```
$ aws ec2 describe-volumes \
--query 'Volumes[*].Attachments[].InstanceId'
"i-a071c394",
"i-4b41a37c",
"i-1jd73kv8"
```
Il renvoie ensuite le premier élément de ce tableau.
```
"i-a071c394"
```
Pour plus d'informations, consultez la section [Pipe Expressions](https://jmespath.org/specification.html#pipe-expressions) sur le *JMESPathsite Web*.
### Filtrage de plusieurs valeurs d’identifiant
Pour filtrer plusieurs identifiants, vous devez utiliser une liste à sélection multiple en utilisant la syntaxe suivante :
**Syntaxe**
```
[].[, ]
```
Dans l’exemple suivant, `VolumeId` et `VolumeType` sont filtrés dans la liste `Volumes`, ce qui donne l’expression suivante.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType]'
[
[
"vol-e11a5288",
"standard"
],
[
"vol-2e410a47",
"standard"
],
[
"vol-a1b3c7nd",
"standard"
]
]
```
Pour ajouter des données imbriquées à la liste, vous devez ajouter une autre liste de sélection multiple. L’exemple suivant développe l’exemple précédent en filtrant également `InstanceId` et `State` dans la liste imbriquée `Attachments`. Cela produit l’expression suivante.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType, Attachments[].[InstanceId, State]]'
[
[
"vol-e11a5288",
"standard",
[
[
"i-a071c394",
"attached"
]
]
],
[
"vol-2e410a47",
"standard",
[
[
"i-4b41a37c",
"attached"
]
]
],
[
"vol-a1b3c7nd",
"standard",
[
[
"i-1jd73kv8",
"attached"
]
]
]
]
```
Pour qu’elle soit plus lisible, aplatissez l’expression, comme illustré dans l’exemple suivant.
```
$ aws ec2 describe-volumes \
--query 'Volumes[].[VolumeId, VolumeType, Attachments[].[InstanceId, State][]][]'
[
"vol-e11a5288",
"standard",
[
"i-a071c394",
"attached"
],
"vol-2e410a47",
"standard",
[
"i-4b41a37c",
"attached"
],
"vol-a1b3c7nd",
"standard",
[
"i-1jd73kv8",
"attached"
]
]
```
Pour plus d'informations, consultez la section [Liste de sélections multiples](https://jmespath.org/specification.html#multiselectlist) sur le *JMESPath site Web*.
### Ajout d’étiquettes aux valeurs d’identifiant
Pour faciliter la lecture de cette sortie, utilisez un hachage à sélection multiple avec la syntaxe suivante.
**Syntaxe**
```
[].{