Filtrando a saída no AWS CLI - AWS Command Line Interface
Filtragem no lado do servidorFiltragem no lado do clienteCombinação das filtragens no lado do servidor e no lado do clienteRecursos adicionais

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Filtrando a saída no AWS CLI

O AWS Command Line Interface (AWS CLI) tem filtragem do lado do servidor e do lado do cliente que você pode usar individualmente ou em conjunto para filtrar sua saída. AWS CLI A filtragem no lado do servidor é processada primeiro e retorna a saída para a filtragem no lado do cliente.

  • A filtragem do lado do servidor é suportada peloAPI, e você geralmente a implementa com um parâmetro. --filter O serviço retorna apenas resultados correspondentes, o que pode acelerar os tempos de HTTP resposta para grandes conjuntos de dados.

  • A filtragem do lado do cliente é suportada pelo AWS CLI cliente usando o parâmetro. --query Esse parâmetro oferece recursos que a filtragem do lado do servidor pode não ter.

Filtragem no lado do servidor

A filtragem do lado do servidor no AWS CLI é fornecida pelo serviço. AWS API O AWS serviço retorna apenas os registros na HTTP resposta que correspondem ao seu filtro, o que pode acelerar os tempos de HTTP resposta para grandes conjuntos de dados. Como a filtragem do lado do servidor é definida pelo serviçoAPI, os nomes e funções dos parâmetros variam entre os serviços. Alguns nomes de parâmetros comuns usados na filtragem são:

Para obter informações sobre se um comando específico tem filtragem do lado do servidor e as regras de filtragem, consulte o guia de referência da versão 2 do .

Filtragem no lado do cliente

AWS CLI Ele fornece recursos integrados JSON de filtragem do lado do cliente com o parâmetro. --query O parâmetro --query é uma ferramenta poderosa que você pode usar para personalizar o conteúdo e estilo da sua saída. O --query parâmetro pega a HTTP resposta que retorna do servidor e filtra os resultados antes de exibi-los. Como toda a HTTP resposta é enviada ao cliente antes da filtragem, a filtragem do lado do cliente pode ser mais lenta do que a filtragem do lado do servidor para grandes conjuntos de dados.

A consulta usa a JMESPathsintaxe para criar expressões para filtrar sua saída. Para aprender a JMESPath sintaxe, consulte o Tutorial no JMESPathsite.

Importante

O tipo de saída especificado por você modifica a forma de operação da opção --query.

  • Se você especificar--output text, a saída será paginada antes da aplicação do --query filtro e AWS CLI executará a consulta uma vez em cada página da saída. Consequentemente, a consulta inclui o primeiro elemento correspondente em cada página, o que pode resultar em uma saída adicional inesperada. Para filtrar ainda mais a saída, é possível usar outras ferramentas da linha de comando, como head ou tail.

  • Se você especificar --output json, --output yaml ou --output yaml-stream, a saída será completamente processada como uma única estrutura JSON nativa antes que o filtro --query seja aplicado. Ele AWS CLI executa a consulta apenas uma vez em toda a estrutura, produzindo um resultado filtrado que é então gerado.

Antes de começar

Ao usar expressões de filtro usadas nesses exemplos, certifique-se de usar as regras de aspas corretas para o shell do terminal. Para obter mais informações, consulte Usando aspas e literais com cadeias de caracteres no AWS CLI.

A JSON saída a seguir mostra um exemplo do que o --query parâmetro pode produzir. O resultado descreve três EBS volumes da Amazon anexados a EC2 instâncias separadas da Amazon.

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

Identificadores

Identificadores são rótulos para valores de saída. Ao criar filtros, você usa identificadores para refinar os resultados da consulta. No exemplo de saída a seguir, todos os identificadores como Volumes, AvailabilityZone e AttachTime estão destacados. 

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

Para obter mais informações, consulte Identificadores no JMESPathsite.

Como selecionar em uma lista

Uma lista ou matriz é um identificador que é seguido por um colchete “[“, como Volumes e Attachments na Antes de começar.

Sintaxe

<listName>[ ]

Para filtrar toda a saída de uma matriz, você pode usar a notação curinga. Expressões curinga são expressões usadas para retornar elementos usando a notação *.

O exemplo a seguir consulta todo o conteúdo 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
  }
]

Para exibir um volume específico na matriz por índice, chame o índice da matriz. Por exemplo, o primeiro item na matriz Volumes tem um índice igual a 0, o que resulta na consulta Volumes[0]. Para obter mais informações sobre índices de matriz, consulte expressões de índice no JMESPathsite.

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

Para exibir um intervalo específico de volumes por índice, use slice com a seguinte sintaxe, onde start é o índice da matriz inicial, stop é o índice onde o filtro interrompe o processamento e step é o intervalo de salto.

Sintaxe

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

Se algum deles for omitido da expressão slice, os seguintes valores padrão serão usados:

  • Start: o primeiro índice na lista, 0.

  • Stop: o último índice na lista.

  • Step: sem pular etapas, onde o valor é 1.

Para retornar somente os dois primeiros volumes, use um valor de start igual a 0, um valor de stop igual 2 e um valor de step igual a 1, conforme mostrado no exemplo a seguir.

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

Como este exemplo contém valores padrão, você pode encurtar o slice de Volumes[0:2:1] para Volumes[:2].

O exemplo a seguir omite valores padrão e retorna cada dois volumes em toda a matriz.

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

Os valores de step também podem ser números negativos, o que resulta na filtragem em ordem inversa de uma matriz, conforme mostrado no exemplo a seguir. 

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

Para obter mais informações, consulte Slices no JMESPathsite.

Como filtrar dados aninhados

Para refinar a filtragem de Volumes[*] para valores aninhados, use subexpressões anexando um ponto e seus critérios de filtragem.

Sintaxe

<expression>.<expression>

O exemplo a seguir mostra todas as informações de Attachments para todos os 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"
    }
  ]
]

Para filtrar ainda mais os valores aninhados, acrescente a expressão para cada identificador aninhado. O exemplo a seguir lista o State para todos os Volumes.

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

Resultados da simplificação

Para obter mais informações, consulte SubExpressionsno JMESPathsite.

Você pode simplificar os resultados para Volumes[*].Attachments[*].State removendo a notação curinga, o que resultará na consulta Volumes[*].Attachments[].State. A simplificação muitas vezes é útil para melhorar a legibiliade dos resultados.

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

Para obter mais informações, consulte Flatten no JMESPathsite.

Filtragem de valores específicos

Para filtrar valores específicos em uma lista, use uma expressão de filtro como mostrado na sintaxe a seguir.

Sintaxe

? <expression> <comparator> <expression>]

Os comparadores de expressão incluem ==, !=, <, <=, > e >=. O exemplo a seguir filtra VolumeIds para todos os Volumes em um State igual a Attached.

$ aws ec2 describe-volumes \
    --query 'Volumes[*].Attachments[?State==`attached`].VolumeId'
[
  [
    "vol-e11a5288"
  ],
  [
    "vol-2e410a47"
  ],
  [
    "vol-a1b3c7nd"
  ]
]

Os resultados podem ser simplificados, o que resulta no exemplo a seguir.

$ aws ec2 describe-volumes \
    --query 'Volumes[*].Attachments[?State==`attached`].VolumeId[]'
[
  "vol-e11a5288",
  "vol-2e410a47",
  "vol-a1b3c7nd"
]

O exemplo a seguir filtra VolumeIds para todos os Volumes com tamanho inferior a 20.

$ aws ec2 describe-volumes \
    --query 'Volumes[?Size < `20`].VolumeId'
[
  "vol-2e410a47",
  "vol-a1b3c7nd"
]

Para obter mais informações, consulte Filtrar expressões no JMESPathsite.

Encadeamento de expressões

Você pode encadear resultados de um filtro para uma nova lista e, em seguida, filtrar o resultado com outra expressão usando a seguinte sintaxe:

Sintaxe

<expression> | <expression>]

O exemplo a seguir leva os resultados do filtro da expressão Volumes[*].Attachments[].InstanceId e produz o primeiro resultado na matriz. 

$ aws ec2 describe-volumes \
    --query 'Volumes[*].Attachments[].InstanceId | [0]'
"i-a071c394"

Esse exemplo faz isso criando primeiro a matriz a partir da expressão a seguir.

$ aws ec2 describe-volumes \
    --query 'Volumes[*].Attachments[].InstanceId'
"i-a071c394",
  "i-4b41a37c",
  "i-1jd73kv8"

Depois, devolva o primeiro elemento para essa matriz.

"i-a071c394"

Para obter mais informações, consulte Pipe Expressions no JMESPathsite.

Filtragem por vários valores de identificador

Para filtrar por vários identificadores, use uma lista de seleção múltipla usando a seguinte sintaxe:

Sintaxe

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

No exemplo a seguir, VolumeId e VolumeType são filtrados na lista Volumes, o que resulta na expressão abaixo.

$ aws ec2 describe-volumes \
    --query 'Volumes[].[VolumeId, VolumeType]'
[
  [
    "vol-e11a5288",
    "standard"
  ],
  [
    "vol-2e410a47",
    "standard"
  ],
  [
    "vol-a1b3c7nd",
    "standard"
  ]
]

Para adicionar dados aninhados à lista, adicione outra lista de seleção múltipla. O exemplo a seguir expande o exemplo anterior filtrando também por InstanceId e State na lista aninhada Attachments. Isso resulta na seguinte expressão.

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

Para torná-la mais legível, simplifique a expressão conforme mostrado no exemplo a seguir.

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

Para obter mais informações, consulte Lista de seleção múltipla no JMESPathsite.

Adição de rótulos a valores de identificador

Para tornar essa saída mais fácil de ler, use um hash de seleção múltipla com a sintaxe a seguir.

Sintaxe

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

O rótulo do identificador não precisa ser o mesmo que o nome do identificador. O exemplo a seguir usa o rótulo VolumeType para os valores VolumeType.

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

Para simplificar, o exemplo a seguir mantém os nomes dos identificadores para cada rótulo e exibe VolumeId, VolumeType, InstanceId e State para todos os 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"
  }
]

Para obter mais informações, consulte Hash de seleção múltipla JMESPath no site.

Funções

A JMESPath sintaxe contém muitas funções que você pode usar para suas consultas. Para obter informações sobre JMESPath funções, consulte Funções integradas no JMESPathsite.

Para demonstrar como você pode incorporar uma função em suas consultas, o exemplo a seguir usa a função sort_by. A função sort_by classifica uma matriz usando uma expressão como a chave de classificação com a seguinte sintaxe:

Sintaxe

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

O exemplo a seguir usa o exemplo de hash de multisseleção anterior e classifica a saída por 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"
  }
]

Para obter mais informações, consulte sort_by no site. JMESPath

Exemplos avançados --query

Para extrair informações de um item específico

O exemplo a seguir usa o parâmetro --query para localizar um item específico em uma lista e extrai as informações desse item. O exemplo lista todas as AvailabilityZones associadas ao endpoint de serviço especificado. Ele extrai o item da lista ServiceDetails que tem o ServiceName especificado e gera o campo AvailabilityZones do item selecionado. 

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

Para mostrar snapshots após a data de criação especificada

O exemplo a seguir mostra como listar todos os seus snapshots que foram criados após uma data especificada, incluindo apenas alguns dos campos disponíveis na saída.

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

Para mostrar o mais recente AMIs

O exemplo a seguir lista as cinco Amazon Machine Images (AMIs) mais recentes que você criou, classificadas da mais recente para a mais antiga.

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

Para mostrar instâncias não íntegras do Auto Scaling

O exemplo a seguir mostra apenas o InstanceId para todas as instâncias com problemas de integridade no grupo de AutoScaling especificado.

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

Para incluir volumes com a tag especificada

O exemplo a seguir descreve todas as instâncias com uma tag test. Contanto que haja outra etiqueta além de test anexada ao volume, o volume ainda é retornado nos resultados.

A expressão abaixo para retornar todas as tags com a tag test em uma matriz. Qualquer etiqueta que não é a etiqueta test contém um valor null.

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

Para excluir volumes com a etiqueta especificada

O exemplo a seguir descreve todas as instâncias sem uma etiqueta test. A utilização de uma expressão ?Value != `test` simples não funciona para excluir um volume, pois os volumes podem ter várias etiquetas. Contanto que haja outra etiqueta além de test anexada ao volume, o volume ainda é retornado nos resultados.

Para excluir todos os volumes com a etiqueta test, comece com a expressão abaixo para retornar todas as etiquetas com a etiqueta test em um array. Qualquer etiqueta que não é a etiqueta test contém um valor null.

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

Em seguida, filtrar todos os resultados test positivos usando a função not_null. 

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

Encadeie os resultados para simplificá-los, o que resultará na consulta a seguir.

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

Combinação das filtragens no lado do servidor e no lado do cliente

É possível usar as filtragens no lado do servidor e no lado do cliente ao mesmo tempo. A filtragem no lado do servidor é concluída primeiro, o que envia os dados para o cliente que, em seguida, são filtrados pelo parâmetro --query. Se você estiver usando grandes conjuntos de dados, usar primeiro a filtragem do lado do servidor pode reduzir a quantidade de dados enviados ao cliente para cada AWS CLI chamada, mantendo a personalização poderosa que a filtragem do lado do cliente oferece.

O exemplo a seguir lista os EC2 volumes da Amazon usando filtragem do lado do servidor e do lado do cliente. O serviço filtra uma lista de todos os volumes anexados na zona de disponibilidade us-west-2a. O parâmetro --query limita ainda mais a saída apenas para aqueles volumes com um valor Size maior que 50 e mostra apenas os campos especificados com nomes definidos pelo usuário.

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

O exemplo a seguir recupera uma lista de imagens que atendem a vários critérios. Depois, usa o parâmetro --query para classificar a saída por CreationDate, selecionando apenas as mais recentes. Por fim, ele exibe o ImageId dessa imagem.

$ 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

O exemplo a seguir exibe o número de volumes disponíveis que são mais de 1000 IOPS usando length para contar quantos estão em uma lista.

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

Recursos adicionais

Prompt automático da AWS CLI

Ao começar a usar expressões de filtro, você pode usar o recurso de solicitação automática na AWS CLI versão 2. O recurso de prompt automático mostra uma pré-visualização quando você pressiona a tecla F5. Para obter mais informações, consulte Ativando e usando os prompts de comando no AWS CLI.

JMESPathTerminal

JMESPathTerminal é um comando de terminal interativo para experimentar JMESPath expressões usadas para filtragem do lado do cliente. Usando o comando jpterm, o terminal mostra os resultados imediatos da consulta enquanto você está digitando. Você pode canalizar a AWS CLI saída diretamente para o terminal, permitindo a experimentação avançada de consultas.

O exemplo a seguir canaliza a aws ec2 describe-volumes saída diretamente para o JMESPath Terminal.

$ aws ec2 describe-volumes | jpterm

Para obter mais informações sobre o JMESPath Terminal e as instruções de instalação, consulte JMESPathTerminal ativado GitHub.

Utilitário jq

O jq fornece uma maneira de transformar sua saída no lado do cliente em um formato de saída desejado. Para obter mais informações jq e instruções de instalação, consulte jq on GitHub.