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.
# 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**
```
[].{