Comment sélectionner le format de sortie Format de sortie JSON Format de sortie YAML Format de sortie du flux YAML Format de sortie texte Format de sortie de tableau

Définition du format de sortie dans l’AWS CLI

Cette rubrique décrit les différents formats de sortie pour l’AWS Command Line Interface (AWS CLI). L’AWS CLI prend en charge les formats de sortie suivants :

json : la sortie est au format d’une chaîne JSON.
yaml : la sortie est au format d’une chaîne YAML.
yaml-stream : la sortie est diffusée et au format d’une chaîne YAML. La diffusion permet de traiter plus rapidement de gros types de données.
text : 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 : la sortie est au format d’un tableau utilisant les caractères +|- 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, 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 spécifiez --output text, la sortie est paginée avant que le filtre --query ne soit appliqué et que l’AWS CLI n’exécute la requête 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é. L’AWS CLI exécute la requête une seule fois sur l’ensemble de la structure, produisant un résultat filtré qui est ensuite sorti.

Format de sortie JSON

JSON 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 de manière puissante pour filtrer et formater la sortie JSON de l’AWS CLI.

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/.

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 est un bon choix pour gérer la sortie par programmation avec des outils qui émettent ou utilisent des chaînes formatées YAML comme CloudFormation avec sa prise en charge des modèles formatés YAML.

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 télécharger yq dans le référentiel 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 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.

Voici un exemple de résultat 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 format text organise la sortie de l’AWS CLI sous la forme de lignes délimitées par des tabulations. Il fonctionne bien avec les outils de traitement de texte Unix traditionnels, tels que grep, sed et awk, ainsi que le traitement de texte exécuté 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 résultat 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 pour assurer un comportement cohérent.

Cela est dû au fait que le format de texte trie par ordre alphabétique les colonnes de sortie par le nom de clé de l’objet JSON sous-jacent renvoyé par le service AWS, et que des ressources similaires peuvent ne pas avoir 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, notez que l’AWS CLI génère la valeur None en sortie pour les 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 les ID d’instance de toutes les instances en cours d’exécution dans la zone de disponibilité us-west-2a.


$ 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 sortie text peut également être utile dans PowerShell. Comme les colonnes de la sortie text sont délimitées par des tabulations, vous pouvez facilement diviser la sortie et la convertir en tableau à l’aide du délimiteur `t de PowerShell. 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

Veuillez noter que même si l’exemple précédent montre comment utiliser le paramètre --query pour analyser les objets JSON sous-jacents et extraire la colonne souhaitée, PowerShell est en mesure de gérer JSON lui-même, si la compatibilité entre plateformes n’est pas un problème. Au lieu de traiter la sortie sous forme de texte, comme la plupart des shells de commande l’exigent, PowerShell vous permet d’utiliser l’applet de commande ConvertFrom-JSON pour produire un objet structuré de façon hiérarchique. 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 l’AWS CLI.


$ 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  |
+--------------+--------------+--------------+-----+

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Contrôle de la sortie de commande

Pagination