AWS CLI Sortie du filtre - AWS Command Line Interface
Filtrage côté serveurFiltrage côté clientCombinaison du filtrage côté serveur et côté clientRessources supplémentaires

Cette documentation concerne AWS CLI uniquement la version 1 du. Pour la documentation relative à la version 2 du AWS CLI, consultez le guide de l'utilisateur de la version 2.

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.

AWS CLI Sortie du filtre

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 --filter paramètre. Le service renvoie uniquement des résultats correspondants, ce qui peut accélérer les temps de réponse HTTP pour les grands ensembles de données.

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

Filtrage côté serveur

Le filtrage côté serveur dans le AWS CLI est fourni par l'API du AWS service. Le AWS service renvoie uniquement les enregistrements de la réponse HTTP qui correspondent à votre filtre, ce qui peut accélérer les temps de réponse HTTP pour les grands ensembles de données. 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 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 .

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 --query paramètre est un outil puissant que vous pouvez utiliser pour personnaliser le contenu et le style de votre sortie. Le --query paramètre 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 grands ensembles de données.

Les requêtes utilisent la syntaxe JMESPath pour créer des expressions permettant de filtrer votre sortie. Pour connaître la syntaxe de JMESpath, consultez le didacticiel sur le site Web de JMESpath.

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 si --output yaml-stream la sortie est entièrement traitée comme une structure native unique avant que le --query filtre ne soit appliqué. 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é.

Avant de commencer

Lorsque vous utilisez les expressions de filtre utilisées dans ces exemples, veillez à utiliser les règles de citation correctes pour votre terminal shell. Pour plus d’informations, consultez Guillemets avec des chaînes dans AWS CLI.

La sortie JSON suivante montre un exemple de ce que le --query paramètre peut produire. Le résultat 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 identificateurs 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 identificateurs tels que VolumesAvailabilityZone, et AttachTime sont surlignés. 

$ 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 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 leAvant 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 l'ensemble Volumes du contenu.

$ 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 le tableau index. Par exemple, le premier élément du Volumes tableau a un indice de 0, ce qui donne lieu à la Volumes[0] requête. Pour plus d'informations sur les index de tableaux, consultez la section 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 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 de la tranche, elle utilise les valeurs par défaut suivantes :

  • Début : premier index de la liste, 0.

  • Stop : dernier index de la liste.

  • Étape — Aucune étape n'est sautée, la valeur étant 1.

Pour renvoyer uniquement les deux premiers volumes, vous devez utiliser une valeur de départ de 0, une valeur de fin 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'ensemble 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 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.

Filtrer les données imbriquées

Pour affiner le filtrage des valeurs imbriquées, vous pouvez utiliser des sous-expressions en ajoutant un point et vos critères de filtre. Volumes[*]

Syntaxe

<expression>.<expression>

L'exemple suivant montre toutes les Attachments informations 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 identificateur imbriqué. L'exemple suivant répertorie les State pour tousVolumes.

$ aws ec2 describe-volumes \
    --query 'Volumes[*].Attachments[*].State'
[
  [
    "attached"
  ],
  [
    "attached"
  ],
  [
    "attached"
  ]
]

Aplatir les résultats

Pour plus d'informations, consultez SubExpressionsle site Web de JMESpath.

Vous pouvez aplatir les résultats Volumes[*].Attachments[*].State en supprimant la notation générique à l'origine de la Volumes[*].Attachments[].State requête. 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 sur le site Web de JMESpath.

Filtrage pour des 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 VolumeIds pour tous Volumes dans un 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 tous ceux VolumeIds 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 sur le site Web de JMESpath.

Expressions de tuyauterie

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'Volumes[*].Attachments[].InstanceIdexpression 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"

Puis renvoie le premier élément de ce tableau.

"i-a071c394"

Pour plus d'informations, consultez la section Pipe Expressions sur le site Web de JMESpath.

Filtrage pour plusieurs valeurs d'identifiant

Pour filtrer plusieurs identificateurs, 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 Volumes liste, 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 pour InstanceId et State dans la Attachments liste imbriquée. Cela donne 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 indiqué 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 sur le site Web de JMESpath.

Ajouter des étiquettes aux valeurs d'identification

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'identification soit identique au nom de l'identifiant. L'exemple suivant utilise l'étiquette VolumeType pour les VolumeType valeurs.

$ 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 VolumeIdVolumeType,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 la section 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 la section Fonctions intégrées sur le site Web de JMESpath.

Pour montrer comment intégrer une fonction dans vos requêtes, l'exemple suivant utilise cette sort_by fonction. La sort_by fonction 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.

--queryExemples avancés

Pour extraire des 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 tous les éléments AvailabilityZones associés 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 Auto Scaling défectueuses

L'exemple suivant montre uniquement InstanceId les instances défectueuses du 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 dotées d'une test balise. Tant qu'une autre balise est test attachée au volume à côté, le volume est toujours renvoyé dans les résultats.

Expression ci-dessous pour renvoyer toutes les balises dont la test balise est dans un tableau. Toute balise autre que la test balise contient une null valeur.

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

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

L'exemple suivant décrit toutes les instances sans test balise. L'utilisation d'une ?Value != `test` expression simple ne fonctionne pas pour exclure un volume, car les volumes peuvent avoir plusieurs balises. Tant qu'une autre balise est test attachée au volume à côté, le volume est toujours renvoyé dans les résultats.

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

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

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

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

Répartissez 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 du filtrage côté serveur et côté client

Vous pouvez utiliser conjointement le 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 --query paramètre filtre ensuite. Si vous utilisez de grands ensembles de données, 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 AWS CLI appel, 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 us-west-2a disponibilité. Le paramètre --query supplémentaire limite la sortie uniquement vers les volumes avec 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 le 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

Ressources supplémentaires

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 jpterm cette commande, le terminal affiche les résultats de la requête immédiatement au fur et à mesure que vous tapez. Vous pouvez directement diriger la AWS CLI sortie vers le terminal, ce qui permet d'expérimenter des requêtes avancées.

L'exemple suivant dirige la aws ec2 describe-volumes sortie directement vers le terminal JMESpath.

$ aws ec2 describe-volumes | jpterm

Pour plus d'informations sur le terminal JMESpath et les instructions d'installation, consultez la section Terminal JMESpath activé. GitHub

utilitaire jq

L'jqutilitaire vous permet de transformer votre sortie côté client dans le format de sortie que vous souhaitez. Pour plus d'informations jq et des instructions d'installation, consultez jq on GitHub.