Cómo seleccionar el formato de salida Formato de salida de JSON Formato de salida de YAML YAMLformato de salida de flujo Formato de salida de texto Formato de salida de tabla

Configuración del formato de salida en el AWS CLI

En este tema se describen los diferentes formatos de salida de AWS Command Line Interface (AWS CLI). La AWS CLI admite los siguientes formatos de salida:

json— La salida tiene el formato de una JSONcadena.
yaml— La salida tiene el formato de una YAMLcadena.
yaml-stream— La salida se transmite y se formatea como una cadena. YAML El streaming permite un manejo más rápido de tipos de datos de gran tamaño.
text: la salida tiene el formato de varias líneas de valores de cadena separados por tabuladores. Esto puede ser útil para pasar la salida a un procesador de texto, como grep, sed o awk.
table: el resultado tiene el formato de una tabla en la que se usan los caracteres +|- para los bordes de celda. Normalmente, la información se presenta en un formato que es más fácil de leer que los demás formatos, pero que no es útil para programar.

Cómo seleccionar el formato de salida

Tal como se explica en el tema de configuración, el formato de salida se puede especificar de tres formas diferentes:

Uso de la opciópn output en un perfil con nombre en el archivo config: el siguiente ejemplo establece el formato de la salida predeterminado como text.
```
[default]
output=text
```
Uso de la variable de entorno de AWS_DEFAULT_OUTPUT: la siguiente salida establece el formato como table para los comandos de esta sesión de línea de comandos hasta que se cambie la variable o finalice la sesión. Con esta variable de entorno, se invalida cualquier valor establecido en el archivo config.
```
$ export AWS_DEFAULT_OUTPUT="table"
```
Uso de la opción --output en la línea de comandos: el siguiente ejemplo establece la salida únicamente de este comando como json. El uso de esta opción en el comando anula cualquier variable de entorno definida actualmente o el valor en el archivo config.
```
$ aws swf list-domains --registration-status REGISTERED --output json
```

importante

El tipo de salida que especifique cambia cómo opera la opción --query:

Si lo especifica--output text, el resultado se pagina antes de aplicar el --query filtro y AWS CLI ejecuta la consulta una vez en cada página del resultado. Debido a esto, la consulta incluye el primer elemento que coincide en cada página, lo que puede dar lugar a una salida adicional inesperada. Para filtrar más la salida, puede usar otras herramientas de la línea de comandos como head o tail.
Si especifica --output json, --output yaml o‎ --output yaml-stream la salida se procesará por completo como‎ una única estructura nativa antes de aplicar el filtro --query. AWS CLI Ejecuta la consulta solo una vez en toda la estructura, lo que produce un resultado filtrado que luego se muestra.

Formato de salida de JSON

JSONes el formato de salida predeterminado de AWS CLI. La mayoría de los lenguajes de programación pueden decodificar JSON cadenas fácilmente mediante funciones integradas o con bibliotecas disponibles públicamente. Puede combinar la JSON salida con la opción --query de formas eficaces para filtrar y formatear la AWS CLI JSON salida con formato.

Para un filtrado más avanzado que tal vez no pueda utilizar--query, puede considerar jq la posibilidad de utilizar un procesador de línea de comandos. JSON Puede descargarlo y consultar el tutorial oficial en http://stedolan.github.io/jq/.

A continuación se muestra un ejemplo de JSON salida.


$ 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 salida de YAML

YAML es una buena opción para gestionar la salida mediante programación con servicios y herramientas que emiten o consumen cadenas con YAMLformato, por ejemplo, su compatibilidad AWS CloudFormation con plantillas con formato. YAML

Para un filtrado más avanzado que quizás no pueda realizar--query, puede considerar yq la posibilidad de utilizar un procesador de línea de comandos. YAML Puede descargarlo yq en el repositorio yq de GitHub.

El siguiente es un ejemplo de YAML salida.


$ aws iam list-users --output yaml


Users:
- Arn: arn:aws:iam::123456789012:user/Admin
  CreateDate: '2014-10-16T16:03:09+00:00'
  PasswordLastUsed: '2016-06-03T18:37:29+00:00'
  Path: /
  UserId: AIDA1111111111EXAMPLE
  UserName: Admin
- Arn: arn:aws:iam::123456789012:user/backup/backup-user
  CreateDate: '2019-09-17T19:30:40+00:00'
  Path: /backup/
  UserId: AIDA2222222222EXAMPLE
  UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- Arn: arn:aws:iam::123456789012:user/cli-user
  CreateDate: '2019-09-17T19:30:40+00:00'
  Path: /
  UserId: AIDA3333333333EXAMPLE
  UserName: cli-user

YAMLformato de salida de flujo

El yaml-stream formato aprovecha las ventajas del YAMLformato y, al mismo tiempo, proporciona una visualización más rápida y con mayor capacidad de respuesta de conjuntos de datos de gran tamaño al transmitirle los datos en streaming. Puede empezar a ver y usar los YAML datos antes de que se descargue toda la consulta.

Para un filtrado más avanzado que tal vez no pueda utilizar--query, puede considerar yq la posibilidad de utilizar un YAML procesador de línea de comandos. Puede descargarlo yq en el repositorio yq de GitHub.

A continuación se muestra un ejemplo de la salida de yaml-stream.


$ aws iam list-users --output yaml-stream


- IsTruncated: false
  Users:
  - Arn: arn:aws:iam::123456789012:user/Admin
    CreateDate: '2014-10-16T16:03:09+00:00'
    PasswordLastUsed: '2016-06-03T18:37:29+00:00'
    Path: /
    UserId: AIDA1111111111EXAMPLE
    UserName: Admin
  - Arn: arn:aws:iam::123456789012:user/backup/backup-user
    CreateDate: '2019-09-17T19:30:40+00:00'
    Path: /backup/
    UserId: AIDA2222222222EXAMPLE
    UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
  - Arn: arn:aws:iam::123456789012:user/cli-user
    CreateDate: '2019-09-17T19:30:40+00:00'
    Path: /
    UserId: AIDA3333333333EXAMPLE
    UserName: cli-user

A continuación se muestra un ejemplo de yaml-stream salida junto con el uso del --page-size parámetro para paginar el contenido reproducido. YAML


$ aws iam list-users --output yaml-stream --page-size 2


- IsTruncated: true
  Marker: ab1234cdef5ghi67jk8lmo9p/q012rs3t445uv6789w0x1y2z/345a6b78c9d00/1efgh234ij56klmno78pqrstu90vwxyx  
  Users:
  - Arn: arn:aws:iam::123456789012:user/Admin
    CreateDate: '2014-10-16T16:03:09+00:00'
    PasswordLastUsed: '2016-06-03T18:37:29+00:00'
    Path: /
    UserId: AIDA1111111111EXAMPLE
    UserName: Admin
  - Arn: arn:aws:iam::123456789012:user/backup/backup-user
    CreateDate: '2019-09-17T19:30:40+00:00'
    Path: /backup/
    UserId: AIDA2222222222EXAMPLE
    UserName: arq-45EFD6D1-CE56-459B-B39F-F9C1F78FBE19
- IsTruncated: false
  Users:
  - Arn: arn:aws:iam::123456789012:user/cli-user
    CreateDate: '2019-09-17T19:30:40+00:00'
    Path: /
    UserId: AIDA3333333333EXAMPLE
    UserName: cli-user

Formato de salida de texto

El text formato organiza la AWS CLI salida en líneas delimitadas por tabulaciones. Funciona bien con las herramientas de texto tradicionales de Unixgrep, como, y sedawk, y con el procesamiento de texto realizado por. PowerShell

El formato de salida de text sigue la estructura básica que se muestran a continuación. Las columnas se ordenan alfabéticamente según los nombres clave correspondientes del objeto subyacente. JSON


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

A continuación se muestra un ejemplo de la salida de text. Cada campo está separado por tabulaciones de los demás, con una tabulación adicional si hay un campo vacío.


$ aws iam list-users --output text


USERS   arn:aws:iam::123456789012:user/Admin                2014-10-16T16:03:09+00:00   2016-06-03T18:37:29+00:00   /          AIDA1111111111EXAMPLE   Admin
USERS   arn:aws:iam::123456789012:user/backup/backup-user   2019-09-17T19:30:40+00:00                               /backup/   AIDA2222222222EXAMPLE   backup-user
USERS   arn:aws:iam::123456789012:user/cli-user             2019-09-17T19:11:39+00:00                               /          AIDA3333333333EXAMPLE   cli-user

La cuarta columna es el campo PasswordLastUsed y está vacía en las dos últimas entradas, ya que esos usuarios nunca inician sesión en la AWS Management Console.

importante

Le recomendamos encarecidamente que si especifica una salida text, utilice siempre la opción --query para garantizar un comportamiento coherente.

Esto se debe a que el formato de texto ordena alfabéticamente las columnas de salida por el nombre de clave del JSON objeto subyacente devuelto por el AWS servicio y es posible que recursos similares no tengan los mismos nombres de clave. Por ejemplo, la JSON representación de una instancia de EC2 Amazon basada en Linux puede tener elementos que no estén presentes en JSON la representación de una instancia basada en Windows, o viceversa. Además, los recursos podrían tener elementos de valor de clave añadidos o eliminados en futuras actualizaciones, alterando el orden de las columnas. Aquí es donde --query incrementa la funcionalidad de la salida text para proporcionarle un control total sobre el formato de salida.

En el ejemplo siguiente, el comando especifica qué elementos se van a mostrar y define el orden de las columnas con la notación en lista [key1, key2, ...]. Esto le ofrece la plena confianza de que los valores de clave correctos se mostrarán siempre en la columna prevista. Por último, observa cómo las AWS CLI salidas son None el valor de las claves que no existen.


$ 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

El siguiente ejemplo muestra cómo se puede usar grep y awk con la salida text del comando aws ec2 describe-instances. El primer comando muestra la zona de disponibilidad, el estado actual y el ID de cada instancia en la salida text. El segundo comando procesa ese resultado para mostrar solo la instancia IDs de todas las instancias en ejecución en la zona de us-west-2a disponibilidad.


$ 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

El siguiente ejemplo va un paso más allá y muestra no solo cómo filtrar el resultado, sino cómo utilizar esa salida para automatizar los tipos de instancias cambiantes para cada instancia detenida.


$ 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

El text resultado también puede ser útil en PowerShell. Como las columnas de la text salida están delimitadas por tabulaciones, puede dividir fácilmente la salida en una matriz utilizando el PowerShell `t delimitador. El siguiente comando muestra el valor de la tercera columna (InstanceId) si la primera columna (AvailabilityZone) coincide con la cadena 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

Ten en cuenta que, aunque en el ejemplo anterior se muestra cómo utilizar el --query parámetro para analizar los JSON objetos subyacentes y extraer la columna deseada, PowerShell tiene su propia capacidad de gestiónJSON, siempre y cuando la compatibilidad multiplataforma no sea un problema. En lugar de tratar el resultado como texto, como requieren la mayoría de las consolas de comandos, PowerShell permite usar el ConvertFrom-JSON cmdlet para generar un objeto estructurado jerárquicamente. A continuación, podrá acceder directamente al miembro que desee desde ese objeto.


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

sugerencia

Si obtiene un texto en la salida y lo filtra con un solo campo utilizando el parámetro --query, la salida será una sola línea de valores separados por tabuladores. Para obtener cada valor en una línea independiente, puede colocar el campo de salida entre corchetes, tal y como se muestra en los siguientes ejemplos.

Salida de una sola línea separada por tabuladores:


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


HRDepartment    Developers      SpreadsheetUsers  LocalAdmins

Cada valor en su propia línea incluyendo [GroupName] entre corchetes:


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


HRDepartment
Developers
SpreadsheetUsers
LocalAdmins

Formato de salida de tabla

El formato table produce representaciones legibles para los humanos de la salida de la AWS CLI compleja en forma de tabla.


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

Puede combinar la opción --query con el formato table para mostrar un conjunto de elementos preseleccionados a partir de la salida en bruto. Observe las diferencias de la salida entre las notaciones de diccionario y lista: en el primer ejemplo los nombres de columna están ordenados alfabéticamente, y en el segundo ejemplo las columnas sin nombre se ordenan según lo definido por el usuario. Para obtener más información acerca de la opción --query, consulte Filtrar la salida en el 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  |
+--------------+--------------+--------------+-----+

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Salida del comando de control

Paginación