Filtrage de la sortie dans l’AWS CLI - AWS Command Line Interface
Filtrage côté serveurFiltrage côté clientCombinaison d’un filtrage côté serveur et côté clientRessources supplémentaires

Filtrage de la sortie dans l’AWS CLI

L’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 client AWS CLI à l’aide du paramètre --query. Ce paramètre possède des fonctionnalités que le filtrage côté serveur ne possède peut-être pas.

Filtrage côté serveur

Le filtrage côté serveur dans l’AWS CLI est fourni par l’API du service AWS. 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 :

Pour savoir si une commande spécifique dispose d’un filtrage et de règles de filtrage côté serveur, consultez le guide de référence de l’AWS CLI version 2.

Filtrage côté client

L’AWS CLI offre des fonctions de filtrage côté client basées sur JSON intégrées 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 la syntaxe JMESPath pour créer des expressions permettant de filtrer votre sortie. Pour connaître la syntaxe JMESPath, consultez Didacticiel sur le site web de JMESPath.

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.

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 plus d’informations, consultez Utilisation de guillemets et de littéraux avec des chaînes dans l’AWS CLI.

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.

$ 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 Identifiants sur le site Web de JMESPath.

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.

Syntaxe

<listName>[ ]

Pour filtrer toutes les sorties d’un tableau, vous pouvez utiliser la notation générique. Les expressions génériques 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 tableau, consultez expressions d’index sur le site Web de JMESPath.

$ 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

<arrayName>[<start>:<stop>:<step>]

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 Slices sur le site Web de JMESPath.

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

<expression>.<expression>

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 sur le site Web de JMESPath.

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, consultez Flatten sur le site Web de JMESPath.

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

? <expression> <comparator> <expression>]

Les comparateurs d’expressions incluent ==, !=, <, <=, > et >=. L’exemple suivant filtre les VolumeIds de tous les Volumes ayant l’état AttachedState.

$ 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 Filter Expressions sur le site Web de JMESPath.

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

<expression> | <expression>]

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 Pipe Expressions sur le site Web de JMESPath.

Filtrage de plusieurs valeurs d’identifiant

Pour filtrer plusieurs identifiants, vous devez utiliser une liste à sélection multiple en utilisant la syntaxe suivante :

Syntaxe

<listName>[].[<expression>, <expression>]

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 Multiselect list sur le site Web de JMESPath.

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

<listName>[].{<label>: <expression>, <label>: <expression>}

Il n’est pas nécessaire que votre étiquette d’identifiant soit identique au nom de l’identifiant. L’exemple suivant utilise l’étiquette VolumeType pour les valeurs VolumeType.

$ aws ec2 describe-volumes \
    --query 'Volumes[].{VolumeType: VolumeType}'
[
  {
    "VolumeType": "standard",
  },
  {
    "VolumeType": "standard",
  },
  {
    "VolumeType": "standard",
  }
]

Pour des raisons de simplicité, l’exemple suivant conserve les noms d’identifiant pour chaque étiquette et affiche les noms VolumeId, VolumeType, InstanceId et State pour tous les volumes :

$ aws ec2 describe-volumes \
    --query 'Volumes[].{VolumeId: VolumeId, VolumeType: VolumeType, InstanceId: Attachments[0].InstanceId, State: Attachments[0].State}'
[
  {
    "VolumeId": "vol-e11a5288",
    "VolumeType": "standard",
    "InstanceId": "i-a071c394",
    "State": "attached"
  },
  {
    "VolumeId": "vol-2e410a47",
    "VolumeType": "standard",
    "InstanceId": "i-4b41a37c",
    "State": "attached"
  },
  {
    "VolumeId": "vol-a1b3c7nd",
    "VolumeType": "standard",
    "InstanceId": "i-1jd73kv8",
    "State": "attached"
  }
]

Pour plus d’informations, consultez Multiselect hash sur le site Web de JMESPath.

Fonctions

La syntaxe JMESPath contient de nombreuses fonctions que vous pouvez utiliser pour vos requêtes. Pour plus d’informations sur les fonctions JMESPath, consultez Built-in Functions sur le site Web de JMESPath.

Pour montrer comment intégrer une fonction dans vos requêtes, l’exemple suivant utilise la fonction sort_by. La fonction sort_by trie un tableau en utilisant une expression comme clé de tri selon la syntaxe suivante :

Syntaxe

sort_by(<listName>, <sort expression>)[].<expression>

L’exemple suivant utilise l’exemple de hachage à sélection multiple précédent et trie la sortie par VolumeId. 

$ aws ec2 describe-volumes \
    --query 'sort_by(Volumes, &VolumeId)[].{VolumeId: VolumeId, VolumeType: VolumeType, InstanceId: Attachments[0].InstanceId, State: Attachments[0].State}'
[
  {
    "VolumeId": "vol-2e410a47",
    "VolumeType": "standard",
    "InstanceId": "i-4b41a37c",
    "State": "attached"
  },
  {
    "VolumeId": "vol-a1b3c7nd",
    "VolumeType": "standard",
    "InstanceId": "i-1jd73kv8",
    "State": "attached"
  },
  {
    "VolumeId": "vol-e11a5288",
    "VolumeType": "standard",
    "InstanceId": "i-a071c394",
    "State": "attached"
  }
]

Pour plus d’informations, consultez sort_by sur le site Web de JMESPath.

Exemples --query avancés

Pour récupérer les informations d’un élément spécifique

L’exemple suivant utilise le paramètre --query pour rechercher un élément spécifique dans une liste, puis extrait les informations de cet élément. L’exemple répertorie toutes les AvailabilityZones associées au point de terminaison de service spécifié. Il extrait l’élément de la liste ServiceDetails pour lequel ServiceName est spécifié, puis il génère en sortie le champ AvailabilityZones à partir de cet élément sélectionné. 

$ aws --region us-east-1 ec2 describe-vpc-endpoint-services \
    --query 'ServiceDetails[?ServiceName==`com.amazonaws.us-east-1.ecs`].AvailabilityZones'
[
    [
        "us-east-1a",
        "us-east-1b",
        "us-east-1c",
        "us-east-1d",
        "us-east-1e",
        "us-east-1f"
    ]
]

Pour afficher les instantanés après la date de création spécifiée

L’exemple suivant montre comment référencer tous vos instantanés qui ont été créés après une date spécifiée, y compris certains champs disponibles dans la sortie.

$ aws ec2 describe-snapshots --owner self \
    --output json \
    --query 'Snapshots[?StartTime>=`2018-02-07`].{Id:SnapshotId,VId:VolumeId,Size:VolumeSize}'
[
    {
        "id": "snap-0effb42b7a1b2c3d4",
        "vid": "vol-0be9bb0bf12345678",
        "Size": 8
    }
]

Pour afficher les AMI les plus récentes

L’exemple suivant répertorie les cinq AMI les plus récentes que vous avez créées, triées de la plus récente à la plus ancienne.

$ aws ec2 describe-images \
    --owners self \
    --query 'reverse(sort_by(Images,&CreationDate))[:5].{id:ImageId,date:CreationDate}'
[
    {
        "id": "ami-0a1b2c3d4e5f60001",
        "date": "2018-11-28T17:16:38.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60002",
        "date": "2018-09-15T13:51:22.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60003",
        "date": "2018-08-19T10:22:45.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60004",
        "date": "2018-05-03T12:04:02.000Z"
    },
    {
        "id": "ami-0a1b2c3d4e5f60005",
        "date": "2017-12-13T17:16:38.000Z"
    }
]

Pour afficher les instances autoscaling défectueuses

L’exemple suivant affiche uniquement l’InstanceId de toutes les instances défectueuses dans le groupe Auto Scaling spécifié.

$ aws autoscaling describe-auto-scaling-groups \
    --auto-scaling-group-name My-AutoScaling-Group-Name \
    --output text \
    --query 'AutoScalingGroups[*].Instances[?HealthStatus==`Unhealthy`].InstanceId'

Pour inclure des volumes dotés de la balise spécifiée

L’exemple suivant décrit toutes les instances comportant une balise test. Tant qu’il y a une autre balise en plus de la balise test attachée au volume, le volume est toujours renvoyé dans les résultats.

L’expression ci-dessous renvoie toutes les balises contenant la balise test dans un tableau. Toute balise autre que la balise test contient une valeur null.

$ aws ec2 describe-volumes \
    --query 'Volumes[*].Tags[?Value == `test`]'

Pour exclure des volumes dotés de la balise spécifiée

L’exemple suivant décrit toutes les instances ne comportant aucune balise test. L’utilisation d’une expression ?Value != `test` simple ne fonctionne pas pour exclure un volume, car les volumes peuvent avoir plusieurs balises. Tant qu’il y a une autre balise en plus de la balise test attachée au volume, le volume est toujours renvoyé dans les résultats.

Pour exclure tous les volumes dotés de la balise test, commencez par l’expression ci-dessous pour renvoyer toutes les balises contenant la balise test dans un tableau. Toute balise autre que la balise test contient une valeur null.

$ aws ec2 describe-volumes \
    --query 'Volumes[*].Tags[?Value == `test`]'

Filtrez ensuite tous les résultats test positifs à l’aide de la fonction not_null. 

$ aws ec2 describe-volumes \
    --query 'Volumes[?!not_null(Tags[?Value == `test`].Value)]'

Redirigez les résultats pour les aplatir, ce qui donne lieu à la requête suivante.

$ aws ec2 describe-volumes \
    --query 'Volumes[?!not_null(Tags[?Value == `test`].Value)] | []'

Combinaison d’un filtrage côté serveur et côté client

Vous pouvez utiliser conjointement un filtrage côté serveur et côté client. Le filtrage côté serveur est effectué en premier, ce qui envoie les données au client que le paramètre --query filtre ensuite. Si vous utilisez des jeux de données volumineux, le fait d’utiliser d’abord le filtrage côté serveur peut réduire la quantité de données envoyées au client pour chaque appel AWS CLI, tout en conservant la puissante personnalisation qu’offre le filtrage côté client.

L’exemple suivant répertorie les volumes Amazon EC2 utilisant le filtrage côté serveur et côté client. Le service filtre une liste de tous les volumes attachés dans la zone de disponibilité us-west-2a. Le paramètre --query supplémentaire limite la sortie uniquement aux volumes ayant une valeur Size supérieure à 50, et indique uniquement les champs spécifiés avec des noms définis par l’utilisateur.

$ aws ec2 describe-volumes \
    --filters "Name=availability-zone,Values=us-west-2a" "Name=status,Values=attached" \
    --query 'Volumes[?Size > `50`].{Id:VolumeId,Size:Size,Type:VolumeType}'
[
    {
        "Id": "vol-0be9bb0bf12345678",
        "Size": 80,
        "VolumeType": "gp2"
    }
]

L’exemple suivant récupère une liste d’images qui répondent à plusieurs critères. Il utilise ensuite le paramètre --query pour trier la sortie CreationDate, en sélectionnant uniquement les plus récentes. Il affiche ensuite l’ImageId de cette seule image.

$ aws ec2 describe-images \
    --owners amazon \
    --filters "Name=name,Values=amzn*gp2" "Name=virtualization-type,Values=hvm" "Name=root-device-type,Values=ebs" \
    --query "sort_by(Images, &CreationDate)[-1].ImageId" \
    --output text
ami-00ced3122871a4921

L’exemple suivant montre comment afficher le nombre de volumes disponibles qui sont supérieurs à 1 000 E/S par seconde en utilisant length pour compter leur nombre dans une liste.

$ aws ec2 describe-volumes \
    --filters "Name=status,Values=available" \
    --query 'length(Volumes[?Iops > `1000`])'
3

L’exemple suivant récupère les noms des groupes Auto Scaling qui utilisent des configurations de lancement dans la Région AWS spécifiée qui utilisent des piles CloudFormation.

$ aws autoscaling describe-auto-scaling-groups --region us-west-2 \
  --filters Name=tag-key,Values=aws:cloudformation:stack-name \
  --query 'AutoScalingGroups[?LaunchConfigurationName!=`null`].AutoScalingGroupName'
[
    "group-1",
    "group-2",
    "group-3"
]

Ressources supplémentaires

Invite automatique dans l’AWS CLI

Lorsque vous commencez à utiliser des expressions de filtre, vous pouvez utiliser la fonctionnalité d’invite automatique de l’AWS CLI version 2. La fonctionnalité d’invite automatique fournit un aperçu lorsque vous appuyez sur la touche F5. Pour plus d’informations, consultez Activation et utilisation des invites de commande dans l’AWS CLI.

Terminal JMESPath

Le terminal JMESPath est une commande de terminal interactive permettant d’expérimenter les expressions JMESPath utilisées pour le filtrage côté client. À l’aide de la commande jpterm, le terminal affiche les résultats de la requête immédiatement au fur et à mesure que vous tapez. Vous pouvez directement rediriger la sortie AWS CLI vers le terminal, ce qui permet d’expérimenter des requêtes avancées.

L’exemple suivant redirige la sortie aws ec2 describe-volumes directement vers le terminal JMESPath.

$ aws ec2 describe-volumes | jpterm

Pour plus d’informations sur le terminal JMESPath et les instructions d’installation, consultez JMESPath Terminal sur GitHub.

Utilitaire jq

L’utilitaire jq vous permet de transformer votre sortie côté client dans le format de sortie que vous souhaitez. Pour plus d’informations sur jq et pour obtenir des instructions d’installation, consultez jq sur GitHub.