Comment sélectionner le format de sortie JSONformat de sortie YAMLformat de sortie YAMLformat de sortie du flux Format de sortie texte Format de sortie de tableau

Configuration du format de sortie dans le AWS CLI

Cette rubrique décrit les différents formats de sortie pour le AWS Command Line Interface (AWS CLI). AWS CLI Supporte les formats de sortie suivants :

json— La sortie est formatée sous forme de JSONchaîne.
yaml— La sortie est formatée sous forme de YAMLchaîne.
yaml-stream— La sortie est diffusée et formatée sous forme de chaîne. YAML Le streaming permet de traiter plus rapidement de gros types de données.
text— La sortie est formatée sous la forme de plusieurs lignes de valeurs de chaîne séparées par des tabulations. Cela peut être utile pour transmettre le résultat à un processeur de texte, comme grepsed, ouawk.
table— La sortie est formatée sous forme de tableau en utilisant les caractères +|- pour former 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'outputoption dans un profil nommé dans le config fichier — L'exemple suivant définit le format de sortie par défaut surtext.
```
[default]
output=text
```
Utilisation de la variable d'AWS_DEFAULT_OUTPUTenvironnement — La sortie suivante définit le format des commandes de table 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'--outputoption sur la ligne de commande — L'exemple suivant définit la sortie de cette seule commande surjson. 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 modifie le mode de fonctionnement de l'--queryoption :

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 également la sortie, vous pouvez utiliser d'autres outils de ligne de commande tels que head outail.
Si vous spécifiez --output json --output yaml, ou si --output yaml-stream la sortie est entièrement traitée comme une structure native unique avant l'application du --query filtre. AWS CLI Exécute la requête une seule fois sur l'ensemble de la structure, produisant un résultat filtré qui est ensuite affiché.

JSONformat de sortie

JSONest le format de sortie par défaut du AWS CLI. La plupart des langages de programmation peuvent facilement décoder JSON des chaînes à l'aide de fonctions intégrées ou de bibliothèques accessibles au public. Vous pouvez combiner la JSON sortie avec l'option --query de manière puissante pour filtrer et formater la sortie AWS CLI JSON formatée.

Pour un filtrage plus avancé que vous ne pourriez peut-être pas utiliser--query, vous pouvez envisager jq un JSON processeur 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 JSON sortie.


$ 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"
        }
    ]
}

YAMLformat de sortie

YAML est un bon choix pour gérer la sortie par programmation avec des services et des outils qui émettent ou consomment des chaînes YAMLformatées, par exemple AWS CloudFormation avec sa prise en charge des modèles formatés. YAML

Pour un filtrage plus avancé que vous ne pourriez peut-être pas utiliser--query, vous pouvez envisager yq un YAML processeur de ligne de commande. Vous pouvez le télécharger yq dans le référentiel yq sur GitHub.

Voici un exemple de YAML sortie.


$ 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

YAMLformat de sortie du flux

Le yaml-stream format tire parti du YAMLformat tout en offrant une visualisation plus réactive/plus rapide de grands ensembles de données en vous transmettant les données en streaming. Vous pouvez commencer à consulter et à utiliser YAML les données avant le téléchargement complet de la requête.

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 yaml-stream sortie associé à l'utilisation du --page-size paramètre pour paginer le contenu diffusé YAML en continu.


$ 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 séparées par des tabulations. Il fonctionne bien avec les outils de texte Unix traditionnels tels que grepsed,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 par ordre alphabétique selon les noms de clé correspondants de l'JSONobjet 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 classe les colonnes de sortie par ordre alphabétique selon le nom de clé de l'JSONobjet sous-jacent renvoyé par le AWS service, et des ressources similaires peuvent ne pas porter les mêmes noms de clé. Par exemple, la JSON représentation d'une instance EC2 Amazon basée sur Linux peut comporter des éléments qui ne sont pas présents dans JSON la représentation d'une instance Windows, ou vice versa. 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 JSON objets sous-jacents et extraire la colonne souhaitée, il PowerShell possède sa propre capacité de gestionJSON, 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-JSONapplet 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.


$ 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

Sortie de commande de contrôle

Pagination