Como selecionar o formato de saída Formato da saída da JSON Formato de saída de texto Formato de saída de tabela

Definindo o formato de saída no AWS CLI

Este tópico descreve os diferentes formatos de saída do AWS Command Line Interface (AWS CLI). A AWS CLI oferece suporte aos seguintes formatos de saída:

json— A saída é formatada como uma JSONstring.
text: a saída é formatada como várias linhas de valores de string separados por tabulação. Isso pode ser útil para passar a saída para um processador de texto, como grep, sed ou awk.
table: a saída é formatada como uma tabela usando os caracteres +|- para formar as bordas da célula. Geralmente, a informação é apresentada em um formato "amigável", que é muito mais fácil de ler do que outros, mas não tão útil programaticamente.

Como selecionar o formato de saída

Como explicado no tópico sobre configuração, você pode especificar o formato de saída de três maneiras:

Usando a opção output em um perfil nomeado no arquivo config: o exemplo a seguir ajusta o formato de saída padrão como text.
```
[default]
output=text
```
Usando a variável de ambiente AWS_DEFAULT_OUTPUT: a saída a seguir ajusta o formato como table para os comandos nessa sessão de linhas de comandos até que a variável seja alterada ou a sessão encerrada. Usar essa variável de ambiente substitui qualquer valor definido no arquivo config.
```
$ export AWS_DEFAULT_OUTPUT="table"
```
Usando a opção --output na linha de comando: o exemplo a seguir define a saída apenas deste comando como json. Usar essa opção no comando substitui qualquer variável de ambiente definida atualmente ou o valor no arquivo config.
```
$ aws swf list-domains --registration-status REGISTERED --output json
```

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

Formato da saída da JSON

JSONé o formato de saída padrão do AWS CLI. A maioria das linguagens de programação pode decodificar facilmente JSON cadeias de caracteres usando funções integradas ou com bibliotecas disponíveis publicamente. Você pode combinar a JSON saída com a opção --query de maneiras poderosas para filtrar e formatar a saída AWS CLI JSON formatada.

Para uma filtragem mais avançada que talvez você não consiga fazer com --queryjq, considere um JSON processador de linha de comando. Baixe e localize o tutorial oficial em http://stedolan.github.io/jq/.

Veja a seguir um exemplo de JSON saída.


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

Formato de saída de texto

O text formato organiza a AWS CLI saída em linhas delimitadas por tabulação. Ele funciona bem com ferramentas de texto Unix tradicionaisgrep, como,sed, eawk, e o processamento de texto realizado por PowerShell.

O formato de saída text segue a estrutura básica mostrada abaixo. As colunas são classificadas alfabeticamente pelos nomes de chave correspondentes do objeto subjacente. JSON


IDENTIFIER  sorted-column1 sorted-column2
IDENTIFIER2 sorted-column1 sorted-column2

A seguir, veja um exemplo de saída text. Cada campo é separado dos outros por tabulação, com uma guia adicional na qual há um campo vazio.


$ 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

A quarta coluna é o campo PasswordLastUsed e está vazia nas duas últimas entradas porque esses usuários nunca fazem login no AWS Management Console.

Importante

É altamente recomendável que, se você especificar uma saída text, também use sempre a opção --query para garantir um comportamento consistente.

Isso ocorre porque o formato de texto ordena alfabeticamente as colunas de saída pelo nome da chave do JSON objeto subjacente retornado pelo AWS serviço, e recursos similares podem não ter os mesmos nomes de chave. Por exemplo, a JSON representação de uma instância EC2 Amazon baseada em Linux pode ter elementos que não estão presentes na JSON representação de uma instância baseada em Windows ou vice-versa. Além disso, os recursos podem ter elementos de valores de chave adicionados ou removidos em futuras atualizações, alterando a ordem das colunas. Este é o local em que --query expande a funcionalidade da saída text para fornecer total controle sobre o formato de saída.

No exemplo a seguir, o comando especifica quais elementos devem ser exibidos e define a ordem das colunas com a notação da lista [key1, key2, ...]. Isso oferece a você a segurança de que os valores de chave corretos sempre serão exibido na coluna esperada. Por fim, observe como as AWS CLI saídas None são o valor de chaves que não existem.


$ 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

O exemplo a seguir mostra como você pode usar grep e awk com a saída text do comando aws ec2 describe-instances. O primeiro comando exibe a zona de disponibilidade, o estado atual e o ID de cada instância na saída text. O segundo comando processa essa saída para exibir somente a instância IDs de todas as instâncias em execução na Zona de us-west-2a Disponibilidade.


$ 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

O exemplo a seguir vai mais longe e mostra não apenas como filtrar a saída, mas como usar essa saída para automatizar a alteração dos tipos de instância para cada instância interrompida.


$ 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

A text saída também pode ser útil em PowerShell. Como as colunas na text saída são delimitadas por tabulação, você pode facilmente dividir a saída em uma matriz usando o PowerShell delimitador`t. O comando a seguir exibe o valor da terceira coluna (InstanceId) se a primeira coluna (AvailabilityZone) corresponder à string 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

Observe que, embora o exemplo anterior mostre como usar o --query parâmetro para analisar os JSON objetos subjacentes e extrair a coluna desejada, PowerShell ele tem sua própria capacidade de lidarJSON, se a compatibilidade entre plataformas não for uma preocupação. Em vez de tratar a saída como texto, como a maioria dos shells de comando exige, PowerShell permite usar o ConvertFrom-JSON cmdlet para produzir um objeto estruturado hierarquicamente. Depois, é possível acessar diretamente o membro desejado usando esse objeto.


(aws ec2 describe-instances --output json | ConvertFrom-Json).Reservations.Instances.InstanceId

dica

Se você enviar o texto e filtrar a saída para um único campo usando o parâmetro --query, a saída será uma única linha de valores separados por tabulação. Para obter cada valor em uma linha separada, você pode colocar o campo de saída entre colchetes, conforme mostrado nos exemplos a seguir.

Saída de linha única separada por tabulação:


$ aws iam list-groups-for-user --user-name susan  --output text --query "Groups[].GroupName"


HRDepartment    Developers      SpreadsheetUsers  LocalAdmins

Cada valor em sua própria linha, colocando [GroupName] entre colchetes:


$ aws iam list-groups-for-user --user-name susan  --output text --query "Groups[].[GroupName]"


HRDepartment
Developers
SpreadsheetUsers
LocalAdmins

Formato de saída de tabela

O formato table produz representações legíveis da saída complexa da AWS CLI em um formato tabular.


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

É possível combinar a opção --query com o formato table para exibir um conjunto de elementos pré-selecionado na saída bruta. As diferenças das saída entre as notações de lista e dicionário: no primeiro exemplo, os nomes de coluna são ordenados alfabeticamente, e, no segundo, as colunas sem nome são ordenadas conforme definido pelo usuário. Para obter mais informações sobre a opção --query, consulte Filtrando a saída no AWS CLI.


$ aws ec2 describe-volumes --query 'Volumes[*].{ID:VolumeId,InstanceId:Attachments[0].InstanceId,AZ:AvailabilityZone,Size:Size}' --output table


------------------------------------------------------
|                   DescribeVolumes                  | 
+------------+----------------+--------------+-------+
|     AZ     |      ID        | InstanceId   | Size  |
+------------+----------------+--------------+-------+
|  us-west-2a|  vol-e11a5288  |  i-a071c394  |  30   |
|  us-west-2a|  vol-2e410a47  |  i-4b41a37c  |  8    |
+------------+----------------+--------------+-------+


$ aws ec2 describe-volumes --query 'Volumes[*].[VolumeId,Attachments[0].InstanceId,AvailabilityZone,Size]' --output table


----------------------------------------------------
|                  DescribeVolumes                 |
+--------------+--------------+--------------+-----+
|  vol-e11a5288|  i-a071c394  |  us-west-2a  |  30 |
|  vol-2e410a47|  i-4b41a37c  |  us-west-2a  |  8  |
+--------------+--------------+--------------+-----+

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Controlar a saída do comando

Paginação