

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

# Réglage du format de sortie dans AWS CLI
<a name="cli-usage-output-format"></a>

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
<a name="cli-usage-output-format-how"></a>

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
<a name="json-output"></a>

[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
<a name="text-output"></a>

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
<a name="table-output"></a>

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