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

Configurar el formato de salida de la AWS CLI

Este tema describe los diferentes formatos de salida para la AWS Command Line Interface (AWS CLI). La AWS CLI admite los siguientes formatos de salida:

json: la salida se formatea como una cadena JSON.
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 especifica --output text‎, la salida se pagina antes‎ de que se aplique el filtro --query‎ y AWS CLI‎ ejecuta la consulta una vez en cada página de la salida. 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, la salida se procesará por completo como‎ una única estructura nativa antes de aplicar el filtro --query. La AWS CLI ejecuta la consulta solo una vez en toda la estructura y produce un resultado filtrado que luego se ofrece como salida.

Formato de salida JSON

JSON es el formato de salida predeterminado de la AWS CLI. La mayoría de lenguajes de programación pueden decodificar fácilmente cadenas JSON con funciones integradas o con bibliotecas disponibles públicamente. Puede combinar la salida JSON con la opción —query de una forma eficaz para aplicar filtros y formato a la salida JSON de la AWS CLI.

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

A continuación, se muestra un ejemplo de una salida JSON:


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

El formato text organiza la salida de la AWS CLI en líneas delimitadas por tabulaciones. Este formato funciona bien con herramientas de texto tradicionales de Unix, como grep, sed y awk, así como con el procesamiento de texto que realiza 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 de las claves correspondientes del objeto JSON subyacente.


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 la clave del objeto JSON subyacente que el servicio de AWS devuelve y podría haber recursos similares con distintos nombres de clave. Por ejemplo, la representación JSON de una instancia de Amazon EC2 basada en Linux podría tener elementos que no están presentes en la representación JSON 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, tenga en cuenta que la AWS CLI devuelve el valor None para 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 esa salida para mostrar únicamente los ID de instancia de todas las instancias en ejecución en la zona de disponibilidad us-west-2a.


$ 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

La salida text también puede resultar útil en PowerShell. Como las columnas de la salida text están delimitadas por tabulaciones, puede dividir fácilmente la salida en una matriz utilizando el delimitador `t de PowerShell. 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

Tenga en cuenta que, aunque en el ejemplo anterior se muestra cómo utilizar el parámetro --query para analizar los objetos JSON subyacentes y extraer la columna deseada, PowerShell dispone de una funcionalidad propia para gestionar JSON si la compatibilidad entre plataformas no es un problema. En lugar de tratar la salida como texto, como requieren la mayoría de los shells de comandos, PowerShell le permite utilizar el cmdlet ConvertFrom-JSON para producir 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 AWS CLI Salida de filtro.


$ 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