**Cette documentation concerne AWS CLI uniquement la version 1 du.**
Nous avons annoncé la sortie end-of-support de la AWS CLI version 1. Nous vous recommandons de migrer vers la AWS CLI version 2. Pour les dates, les détails supplémentaires et les informations sur la façon de migrer, consultez l'[annonce](https://aws.amazon.com/blogs/developer/cli-v1-maintenance-mode-announcement/). Pour la documentation relative à la version 2 du AWS CLI, consultez le [guide de l'utilisateur de la version 2](https://docs.aws.amazon.com/cli/latest/userguide/).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# 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 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 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)
+ [À 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/).
+ **[`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.
## 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`,, 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 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 |
+--------------+--------------+--------------+-----+
```
# À 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).
## 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 du [guide de AWS CLI référence](https://docs.aws.amazon.com/cli/v1/reference/).
### 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.
# 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/v1/reference/ses/create-receipt-filter.html) et [ce](https://docs.aws.amazon.com/cli/v1/reference/ce/get-cost-and-usage.html).
+ `--filters` tels que [ec2](https://docs.aws.amazon.com/cli/v1/reference/ec2/describe-volumes.html), [autoscaling](https://docs.aws.amazon.com/cli/v1/reference/autoscaling/describe-tags.html) et [rds](https://docs.aws.amazon.com/cli/v1/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/v1/reference/dynamodb/scan.html](https://docs.aws.amazon.com/cli/v1/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 [AWS CLI référence AWS CLI version 2 du guide](https://docs.aws.amazon.com/cli/v1/reference/) .
## 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`,, 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**
```
[].{