# Control de la salida de comandos en la AWS CLI En esra sección se describen las diferentes formas de controlar la salida de AWS Command Line Interface (AWS CLI). La personalización de la salida de la AWS CLI de su terminal puede mejorar la legibilidad, agilizar la automatización del scripting y facilitar la navegación a través de conjuntos de datos más grandes. La AWS CLI admite varios [formatos de salida](cli-usage-output-format.md), incluidos [`json`](cli-usage-output-format.md#json-output), [`text`](cli-usage-output-format.md#text-output), [`yaml`](cli-usage-output-format.md#yaml-output), [`off`](cli-usage-output-format.md#off-output) y [`table`](cli-usage-output-format.md#table-output). Algunos servicios tienen [paginación](cli-usage-pagination.md) del servidor para sus datos y la AWS CLI proporciona sus propias características del cliente para opciones de paginación adicionales. Por último, la AWS CLI tiene [filtrado tanto del servidor como del cliente](cli-usage-filter.md) que se puede usar de forma individual o conjuntamente para filtrar la salida de la AWS CLI. **Topics** + [ ## Salida de información confidencial ](#cli-usage-output-sensitive) + [ ## Opciones de salida del servidor frente a las del cliente ](#cli-usage-output-server-client) + [ # Configuración del formato de salida en la AWS CLI ](cli-usage-output-format.md) + [ # Salida de error estructurado en la AWS CLI ](cli-usage-error-format.md) + [ # Uso de las opciones de paginación en la AWS CLI ](cli-usage-pagination.md) + [ # Filtrado de la salida en la AWS CLI ](cli-usage-filter.md) ## Salida de información confidencial Algunas operaciones de la AWS CLI pueden dar como resultado información que podría considerarse confidencial, por ejemplo, la información de las variables de entorno. La exposición de esta información puede representar un riesgo para la seguridad en ciertas situaciones; por ejemplo, la información podría incluirse en los registros de integración e implementación continuos (CI/CD). Por lo tanto, es importante que revise cuándo se incluyen dichos resultados como parte de los registros y que los suprima cuando no los necesite. Para obtener más información sobre la protección de datos confidenciales, consulte [Protección de datos en la AWS CLI](data-protection.md). Tenga en cuenta las siguientes prácticas recomendadas: + Considere la posibilidad de recuperar los secretos mediante programación de un almacén de secretos, como AWS Secrets Manager. + Revise el contenido de los registros de compilación para asegurarse de que no contienen información confidencial. Elija enfoques como canalizar a `/dev/null` o capturar la salida como una variable bash o PowerShell para suprimir las salidas de los comandos. El siguiente es un ejemplo de bash para redirigir la salida, pero no los errores, a `/dev/null`: ``` $ aws s3 ls > /dev/null ``` Para obtener información específica sobre cómo suprimir la salida del terminal, consulte la documentación del usuario del terminal que utilice. + Tenga en cuenta el acceso a los registros y determine un acceso adecuado para el caso de uso. ## Opciones de salida del servidor frente a las del cliente La AWS CLI tiene [filtrado tanto del servidor como del cliente](cli-usage-filter.md) que usted puede usar de forma individual o conjunta para filtrar la salida de la AWS CLI. El filtrado del servidor se procesa primero y devuelve su salida para el filtrado del cliente. La API del servicio admite el filtrado del servidor. El filtrado del cliente está respaldado por el cliente AWS CLI mediante el uso del parámetro `--query`. Las opciones de salida del **servidor** son características compatibles directamente con la API del servicio de Servicio de AWS. Los datos filtrados o paginados no se envían al cliente, lo que puede acelerar los tiempos de respuesta HTTP y mejorar el ancho de banda para conjuntos de datos más grandes. Las opciones de salida **del cliente** son características creadas por la AWS CLI. Todos los datos se envían al cliente y, a continuación, la AWS CLI filtra o pagina el contenido que se muestra. Las operaciones del cliente no ahorran velocidad ni ancho de banda en el caso de conjuntos de datos más grandes. Cuando las opciones del servidor y del cliente se utilizan juntas, las operaciones del servidor se completan primero y, después, se envían al cliente para las operaciones del cliente. De este modo se aprovechan los posibles ahorros de velocidad y ancho de banda de las opciones del servidor y, al mismo tiempo, se utilizan características adicionales de la AWS CLI para obtener el resultado deseado. # Configuración del formato de salida en 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`](#json-output)**: la salida se formatea como una cadena [JSON](https://json.org/). + **[`yaml`](#yaml-output)**: la salida se formatea como una cadena [YAML](https://yaml.org/). + **[`yaml-stream`](#yaml-stream-output)**: la salida se transmite y se formatea como una cadena [YAML](https://yaml.org/). La transmisión permite gestionar tipos de datos de gran tamaño de forma más rápida. + **[`text`](#text-output)** – 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`](#table-output)** – el resultado tiene el formato de una tabla en la que se usan los caracteres \$1\$1- 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. + **[`off`](#off-output)**: la salida suprime todas las salidas de comando a stdout. Esto resulta útil en scripts de automatización y en procesos de CI/CD, en los que solo es necesario comprobar el código de salida del comando sin procesar la salida. ## Cómo seleccionar el formato de salida Tal como se explica en el tema de [configuración](cli-chap-configure.md), 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 la 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`, `--output yaml` o‎ `--output yaml-stream` 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](https://json.org) 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](cli-usage-filter.md) 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/](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 YAML [YAML](https://yaml.org) es una buena opción para administrar la salida mediante programación con herramientas y servicios que emiten o consumen cadenas con formato [YAML](https://yaml.org), como CloudFormation, que admite [plantillas con formato YAML](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-formats.html). Para aplicar un filtrado más avanzado que el que permite `--query`, considere la posibilidad de utilizar `yq`, un procesador YAML de línea de comandos. Puede descargar `yq` en el [repositorio de yq](https://github.com/mikefarah/yq) de *GitHub*. A continuación, se muestra un ejemplo de una salida YAML. ``` $ 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 ``` ## Formato de salida de transmisión YAML‎ El formato `yaml-stream` aprovecha el formato [YAML](https://yaml.org) al tiempo que proporciona una visualización más receptiva/más rápida de los conjuntos de datos grandes mediante el streaming de datos a usted. Puede comenzar a ver y usar datos YAML antes de que se descargue toda la consulta. Para aplicar un filtrado más avanzado que el que permite `--query`, considere la posibilidad de utilizar `yq`, un procesador YAML de línea de comandos. Puede descargar `yq` en el [repositorio de yq](https://github.com/mikefarah/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 salida `yaml-stream` en combinación con el uso del parámetro `--page-size` para paginar el contenido de YAML transmitido. ``` $ 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 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 Consola de administración de AWS. **importante** *Le recomendamos encarecidamente que si especifica una salida `text`, utilice siempre la opción [`--query`](cli-usage-filter.md) 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 [Filtrado de la salida en la AWS CLI](cli-usage-filter.md). ``` $ 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 | +--------------+--------------+--------------+-----+ ``` ## Formato de salida “off” El formato `off` suprime todas las salidas de comando a stdout. Esto resulta útil en scripts de automatización y en procesos de CI/CD, en los que solo es necesario comprobar el código de salida del comando sin procesar la salida. Los mensajes de error siguen apareciendo en stderr. En el siguiente ejemplo se muestra cómo el formato `off` suprime la salida correcta. Puede comprobar el código de salida para determinar si es correcta: ``` $ aws s3api list-buckets --output off $ echo $? 0 ``` Esto resulta especialmente útil en scripts de intérprete de comandos en los que se desea comprobar si un recurso existe sin capturar la salida: ``` #!/bin/bash if aws s3api head-bucket --bucket my-bucket --output off 2>/dev/null; then echo "Bucket exists" else echo "Bucket does not exist" fi ``` **nota** El formato `off` solo suprime stdout. Los errores se siguen escribiendo en stderr. # Salida de error estructurado en la AWS CLI Este tema describe los formatos de salida de error estructurado para la AWS Command Line Interface (AWS CLI). La CLI escribe los errores en stderr y admite los siguientes formatos: + **[`enhanced`](#cli-error-format-enhanced)** (predeterminado): mensaje de error con detalles adicionales que se muestran en línea. Se utiliza para la depuración legible por el usuario. + **[`json`](#cli-error-format-json)**: la salida se formatea como una cadena [JSON](https://json.org/) con todos los campos de error. Se usa para la automatización y el scripting. + **[`yaml`](#cli-error-format-yaml)**: la salida se formatea como una cadena [YAML](https://yaml.org/) con todos los campos de error. Se usa para la automatización y el scripting. + **[`text`](#cli-error-format-text)**: formatea los errores usando el formateador de texto. Se utiliza para el escaneo visual rápido. + **[`table`](#cli-error-format-table)**: formatea los errores usando el formateador de tabla. Se utiliza para el escaneo visual rápido. + **[`legacy`](#cli-error-format-legacy)**: formato de error original sin detalles estructurados. Se usa para la retrocompatibilidad. ## Configuración del formato de error Puede configurar el formato de error utilizando cualquiera de los siguientes métodos: Indicador de línea de comandos ``` $ aws --cli-error-format json ``` Archivo de configuración: (`~/.aws/config`) ``` [default] cli_error_format = json ``` Variable de entorno ``` $ export AWS_CLI_ERROR_FORMAT=yaml ``` ## Formatos de salida de error En las secciones siguientes se describe cada formato: ### Formato mejorado (predeterminado) El formato mejorado muestra los mensajes de error con detalles adicionales en línea para valores simples. Para estructuras complejas, el formato proporciona una sugerencia para usar JSON o YAML. **Ejemplo: Ausencia de configuración de la región** ``` aws: [ERROR]: An error occurred (NoRegion): You must specify a region. You can also configure your region by running "aws configure". ``` **Ejemplo: Bucket de S3 inexistente con campos adicionales** ``` aws: [ERROR]: An error occurred (NoSuchBucket) when calling the GetObject operation: The specified bucket does not exist Additional error details: BucketName: amzn-s3-demo-bucket ``` **Ejemplo: Campos de error complejos** ``` An error occurred (TransactionCanceledException) when calling the TransactWriteItems operation: Transaction cancelled, please refer cancellation reasons for specific reasons [ConditionalCheckFailed, None] Additional error details: CancellationReasons: Use "--cli-error-format json" or another error format to see the full details. ``` ### Formato JSON El formato JSON proporciona una representación estructurada con todos los campos de error. **Ejemplo: Ausencia de configuración de la región** ``` { "Code": "NoRegion", "Message": "You must specify a region. You can also configure your region by running \"aws configure\"." } ``` **Ejemplo: Bucket de S3 inexistente** ``` { "Code": "NoSuchBucket", "Message": "The specified bucket does not exist", "BucketName": "amzn-s3-demo-bucket" } ``` ### Formato YAML El formato YAML proporciona una representación estructurada con todos los campos de error. **Ejemplo: Ausencia de configuración de la región** ``` Code: NoRegion Message: You must specify a region. You can also configure your region by running "aws configure". ``` **Ejemplo: Bucket de S3 inexistente** ``` Code: NoSuchBucket Message: The specified bucket does not exist BucketName: amzn-s3-demo-bucket ``` ### Formato de texto El formato de texto utiliza el mismo formateador que la salida del comando que se ha ejecutado correctamente. **Ejemplo: Bucket de S3 inexistente** ``` amzn-s3-demo-bucket NoSuchBucket The specified bucket does not exist ``` ### Formato de tabla El formato de tabla utiliza el mismo formateador que la salida del comando que se ha ejecutado correctamente. **Ejemplo: Bucket de S3 inexistente** ``` -------------------------------------------------------------------------------------| | error | +---------------------------+---------------+----------------------------------------+ | BucketName | Code | Message | +---------------------------+---------------+----------------------------------------+ | amzn-s3-demo-bucket | NoSuchBucket | The specified bucket does not exist | +---------------------------+---------------+----------------------------------------+ ``` ### Formato heredado El formato heredado proporciona el formato de error original sin detalles estructurados. Este formato no incluye el prefijo “Se produjo un error (ErrorCode):” para las excepciones de la CLI. **Ejemplo: Ausencia de configuración de la región** ``` aws: [ERROR]: You must specify a region. You can also configure your region by running "aws configure". ``` **Ejemplo: Bucket de S3 inexistente** ``` An error occurred (NoSuchBucket) when calling the GetObject operation: The specified bucket does not exist ``` **nota** Los errores incluyen ahora sistemáticamente el prefijo `aws: [ERROR]:` para las excepciones de la CLI. Las versiones anteriores no siempre incluían este prefijo. Las siguientes excepciones siempre utilizan el formato heredado, independientemente del formato de error configurado: `UnknownArgumentError`: muestra la información de uso. Interrupciones del teclado (`KeyboardInterrupt`) ## Ejemplo completo En el siguiente ejemplo se muestra un comando con formato de error JSON: ``` $ aws s3api get-object \ --bucket amzn-s3-demo-bucket \ --key file.txt out.txt \ --cli-error-format json ``` Salida (stderr): ``` { "Code": "NoSuchBucket", "Message": "The specified bucket does not exist", "BucketName": "amzn-s3-demo-bucket" } ``` El campo `BucketName` es un elemento de error modelado devuelto por el servicio Amazon S3. # Uso de las opciones de paginación en la AWS CLI En este tema se describen las diferentes formas de paginar la salida de AWS Command Line Interface (AWS CLI). Hay principalmente dos formas de controlar la paginación desde AWS CLI. + [Uso de parámetros de paginación del lado del servidor.](#cli-usage-pagination-serverside) + [Uso del programa de paginación del lado del cliente de salida predeterminado](#cli-usage-pagination-clientside). Los parámetros de paginación del lado del servidor procesan primero y cualquier salida se envía a la paginación del lado del cliente. ## Paginación del lado del servidor Para la mayoría de los comandos que pueden devolver una amplia lista de elementos, la AWS CLI tiene múltiples opciones del servidor para controlar el número de elementos que se incluyen en la salida cuando la AWS CLI llame a la API de un servicio para rellenar la lista. La API de servicio de AWS habilita la paginación del servidor en la AWS CLI, por lo que estas opciones solo funcionan si la API de servicio las habilita. **Topics** + [--no-paginate](#cli-usage-pagination-nopaginate) + [--page-size](#cli-usage-pagination-pagesize) + [--max-items](#cli-usage-pagination-maxitems) + [--starting-token](#cli-usage-pagination-startingtoken) De forma predeterminada, AWS CLI utiliza un tamaño de página determinado por el servicio individual y recupera todos los elementos disponibles. Por ejemplo, Simple Storage Service (Amazon S3) tiene un tamaño de página predeterminado de 1000. Si ejecuta `aws s3api list-objects` en un bucket de Simple Storage Service (Amazon S3) que contiene 3500 objetos, AWS CLI realiza cuatro llamadas a Simple Storage Service (Amazon S3) y se encarga de administrar por usted la lógica de paginación específica del servicio en segundo plano y de devolver los 3500 objetos en la salida final. ‎Para obtener información acerca de si un comando específico tiene paginación del servidor, consulte la [Guía de referencia de la AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/reference/index.html). ### Cómo usar el parámetro —no-paginate La opción `--no-paginate` desactiva los siguientes tokens de paginación en el lado del cliente. Cuando se utiliza un comando, de forma predeterminada, la AWS CLI realiza automáticamente varias llamadas para devolver todos los resultados posibles para crear paginación. Una llamada por cada página. La desactivación de la paginación hace la única llamada de la AWS CLI una vez para la primera página de resultados de comandos. Por ejemplo, si ejecuta `aws s3api list-objects` en un bucket de Amazon S3 que contiene 3500 objetos, la AWS CLI solo realiza la primera llamada a Amazon S3, devolviendo solo los primeros 1000 objetos de la salida final. ``` $ aws s3api list-objects \ --bucket amzn-s3-demo-bucket \ --no-paginate { "Contents": [ ... ``` ### Cómo usar el parámetro —page-size Si observa algún problema al ejecutar los comandos de la lista en un gran número de recursos, el tamaño de página predeterminado puede ser demasiado grande. Esto puede provocar las llamadas a los servicios de AWS para superar el tiempo máximo permitido y generar un error de "tiempo de espera agotado". Puede utilizar la opción `--page-size` para especificar que la AWS CLI solicite un número menor de elementos de cada llamada al servicio de AWS. La AWS CLI recupera aun así la lista completa, pero realiza un mayor número de llamadas a la API en segundo plano y recupera un menor número de elementos con cada llamada. Esto ofrece a las llamadas individuales una mayor posibilidad de que tengan éxito sin que se agote el tiempo de espera. El cambio del tamaño de página no afecta a la salida; solo afecta a la cantidad de llamadas a la API que hay que realizar para generar la salida. ``` $ aws s3api list-objects \ --bucket amzn-s3-demo-bucket \ --page-size 100 { "Contents": [ ... ``` ### Cómo usar el parámetro —max-items Para incluir menos elementos a la vez en la salida de la AWS CLI, utilice la opción `--max-items`. La AWS CLI sigue administrando la paginación con el servicio tal y como se indicó anteriormente, pero solamente muestra a la vez el número de elementos especificado. ``` $ aws s3api list-objects \ --bucket amzn-s3-demo-bucket \ --max-items 100 { "NextToken": "eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxfQ==", "Contents": [ ... ``` ### Cómo usar el parámetro —starting-token Si el número de elementos de salida (`--max-items`) es inferior al número total de elementos devueltos por las llamadas básicas a la API, la salida incluirá un `NextToken` que podrá pasar a un comando posterior para recuperar el siguiente conjunto de elementos. En el siguiente ejemplo se muestra cómo usar el valor `NextToken` devuelto por el ejemplo anterior y le permite recuperar los segundos 100 elementos. **nota** El parámetro `--starting-token` no puede ser nulo ni está vacío. Si el comando anterior no devuelve un valor `NextToken`, no hay más elementos para devolver y no es necesario llamar al comando de nuevo. ``` $ aws s3api list-objects \ --bucket amzn-s3-demo-bucket \ --max-items 100 \ --starting-token eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxfQ== { "Contents": [ ... ``` Puede que el servicio de AWS especificado no devuelva los elementos en el mismo orden cada vez que lo llame. Si especifica diferentes valores para `--page-size` y `--max-items`, puede obtener resultados inesperados en el que faltan elementos o están duplicados. Para evitar esto, utilice el mismo número con `--page-size` y `--max-items` para sincronizar la paginación de la AWS CLI con la del servicio subyacente. También puede recuperar la lista completa y realizar las operaciones de paginación necesarias de forma local. ## Paginación del lado del cliente AWS CLILa versión 2 de la proporciona el uso de un programa de paginación del lado del cliente para la salida. De forma predeterminada, esta función devuelve todas las salidas a través del programa de paginación predeterminado del sistema operativo. En orden de prioridad, puede especificar la paginación de salida de estas dos maneras: + Uso de la configuración de‎ `cli_pager` en el archivo `config` en el perfil `default` o ‎con nombre. + Uso de la variable de entorno `AWS_PAGER`. + Uso de la variable de entorno `PAGER`. En orden de prioridad, puede deshabilitar todo el uso de un programa de paginación externo de las siguientes maneras: + Use la opción de línea de comandos `--no-cli-pager` para desactivar la paginación para un solo uso de comando. + Establezca la configuración `cli_pager` o la variable `AWS_PAGER` en una cadena vacía. **Topics** + [cli\$1pager](#cli-usage-pagination-clipager) + [AWS\$1PAGER](#cli-usage-pagination-awspager) + [—no-cli-pager](#cli-usage-pagination-noclipager) + [Marcadores de paginación](#cli-usage-pagination-flags) ### Cómo utilizar la configuración cli\$1pager Puede guardar las opciones de configuración y las credenciales que utiliza con frecuencia en archivos que son mantenidos por la AWS CLI. La configuración de un perfil de nombre tiene prioridad sobre la configuración en el perfil `default`. Para obtener más información sobre los valores de configuración, consulte [Opciones de los archivos de configuración y credenciales en la AWS CLI](cli-configure-files.md). El siguiente ejemplo establece la paginación de salida predeterminada en el programa `less`. ``` [default] cli_pager=less ``` En el ejemplo siguiente se establece el valor predeterminado para deshabilitar el uso de un paginador. ``` [default] cli_pager= ``` ### Cómo definir la variable de entorno AWS\$1PAGER El siguiente ejemplo establece la paginación de salida predeterminada en el programa `less`. Para obtener más información sobre las variables de entorno, consulte [Configuración de variables de entorno para la AWS CLI](cli-configure-envvars.md). ------ #### [ Linux and macOS ] ``` $ export AWS_PAGER="less" ``` ------ #### [ Windows ] ``` C:\> setx AWS_PAGER "less" ``` ------ ### Cómo usar la opción —no-cli-pager Para deshabilitar el uso de un paginador en un único comando, utilice la opción `--no-cli-pager`. Para obtener más información acerca de las opciones de línea de comandos, consulte [Opciones de línea de comandos en la AWS CLI](cli-configure-options.md). ``` $ aws s3api list-objects \ --bucket amzn-s3-demo-bucket \ --no-cli-pager { "Contents": [ ... ``` ### Cómo usar marcadores de paginación Puede especificar marcadores que se usarán automáticamente con el programa de paginación. Los marcadores dependen del programa de paginación que utilice. Los siguientes ejemplos son para los valores predeterminados típicos de `less` y `more`. ------ #### [ Linux and macOS ] Si no especifica lo contrario, la versión 2 de AWS CLI que usa el paginador por defecto es `less`. Si no tiene el conjunto de variables de entorno `LESS`, la versión 2 de la AWS CLI utiliza los marcadores `FRX`. Puede combinar marcadores especificándolos al establecer el paginador AWS CLI. En este ejemplo se usa el marcador `S`. Este marcador se combina con los marcadores predeterminados `FRX` para crear un marcador `FRXS`. ``` $ export AWS_PAGER="less -S" ``` Si no quiere utilizar ninguno de los marcadores `FRX`, puede negarlos. En el siguiente ejemplo se niega el marcador `F` para crear un marcador `RX` final. ``` $ export AWS_PAGER="less -+F" ``` Para obtener más información sobre los marcadores `less`, consulte [menos](http://manpages.org/less/1#options) en *manpages.org*. ------ #### [ Windows ] Si no especifica lo contrario, la versión 2 de la AWS CLI del paginador utiliza por defecto `more` sin marcadores adicionales. En el siguiente ejemplo se usa el parámetro `/c`. ``` C:\> setx AWS_PAGER "more /c" ``` Para obtener más información sobre `more` marcadores, consulte `[more](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/more)` en *Documentos de Microsoft*. ------ # Filtrado de la salida en la AWS CLI La AWS Command Line Interface (AWS CLI) tiene filtrado tanto del servidor como del cliente que usted puede usar de forma individual o juntos para filtrar su salida AWS CLI. El filtrado del lado del servidor se procesa primero y devuelve su salida para el filtrado del lado del cliente. + El filtrado del lado del servidor es compatible con la API, y generalmente lo implementa con un parámetro `--filter`. El servicio solo devuelve resultados coincidentes que pueden acelerar los tiempos de respuesta HTTP para conjuntos de datos grandes. + El filtrado del cliente está respaldado por el cliente AWS CLI mediante el uso del parámetro `--query`. Este parámetro tiene capacidades que el filtrado del servidor puede no tener. **Topics** + [ ## Filtrado en el servidor ](#cli-usage-filter-server-side) + [ ## Filtrado del lado del cliente ](#cli-usage-filter-client-side) + [ ## Combinación del filtrado del lado del cliente y del servidor ](#cli-usage-filter-combining) + [ ## Recursos adicionales ](#cli-usage-filter-resources) ## Filtrado en el servidor El filtrado en el servidor en el AWS CLI se proporciona a través del API de servicio AWS. El servicio AWS solo devuelve los registros de la respuesta HTTP que coinciden con el filtro, lo que puede acelerar los tiempos de respuesta HTTP para conjuntos de datos grandes. Dado que el filtrado del lado del servidor está definido por la API del servicio, los nombres de los parámetros y las funciones varían entre los servicios. Algunos nombres de parámetros comunes utilizados para filtrar son: + `--filter` tales como [ses](https://docs.aws.amazon.com/cli/latest/reference/ses/create-receipt-filter.html) y [ce](https://docs.aws.amazon.com/cli/latest/reference/ce/get-cost-and-usage.html). + `--filters` tales como [ec2](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-volumes.html), [autoscaling](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/describe-tags.html) y [rds](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html). + ‎Nombres que empiezan por la palab‎ra `filter`‎,‎ por ejemplo `--filter-expression` para el comando [https://docs.aws.amazon.com/cli/latest/reference/dynamodb/scan.html](https://docs.aws.amazon.com/cli/latest/reference/dynamodb/scan.html). ‎Para obtener información acerca de si un comando específico tiene filtrado del lado del servidor y las reglas de filtrado, consulte la [Guía de referencia de la versión 2 de la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/index.html). ## Filtrado del lado del cliente La AWS CLI ofrece capacidades de filtrado de salida basadas en JSON integradas con el parámetro `--query`. El parámetro `--query` es una potente herramienta que se puede utilizar para personalizar el contenido y el estilo de la salida. El parámetro `--query` toma la respuesta HTTP que regresa del servidor y filtra los resultados antes de mostrarlos. Dado que toda la respuesta HTTP se envía al cliente antes del filtrado, el filtrado del lado del cliente puede ser más lento que el filtrado del lado del servidor para grandes conjuntos de datos. Las consultas usan [sintaxis JMESPath](https://jmespath.org/) para crear expresiones para filtrar la salida. Para obtener más información acerca de la sintaxis de JMesPath, consulte el [Tutorial](https://jmespath.org/tutorial.html) del *sitio web JMESPath*. **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 la 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`, `--output yaml` o‎ `--output yaml-stream` 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. **Topics** + [ ### Antes de comenzar ](#cli-usage-filter-client-side-output) + [ ### Identificadores ](#cli-usage-filter-client-side-identifiers) + [ ### Cómo seleccionar de una lista ](#cli-usage-filter-client-side-select-list) + [ ### Filtrado de datos anidados ](#cli-usage-filter-client-side-nested) + [ ### Aplanamiento de los resultados ](#cli-usage-filter-client-side-specific-flattening) + [ ### Filtrado para valores específicos ](#cli-usage-filter-client-side-specific-values) + [ ### Expresiones de canalización ](#cli-usage-filter-client-side-pipe) + [ ### Filtrado para varios valores de identificador ](#cli-usage-filter-client-side-miltiselect-list) + [ ### Agregado de etiquetas a valores de identificador ](#cli-usage-filter-client-side-multiselect-hash) + [ ### Funciones ](#cli-usage-filter-client-side-functions) + [ ### Ejemplos `--query` avanzados ](#cli-usage-filter-client-side-advanced) ### Antes de comenzar **nota** Estos ejemplos de expresiones de filtro están escritos para intérpretes de comandos de tipo Linux básicos. Cuando utilice estos ejemplos, asegúrese de utilizar las reglas de entrecomillado correctas para el intérprete de comandos del terminal. La forma en que el terminal interpreta las entradas puede cambiar enormemente lo que se envía a la AWS CLI. La forma en que el terminal lee las comillas simples`'`, las comillas dobles `"` o las comillas inversas ``` puede cambiar la forma de leer el contenido. Para obtener más información, consulte [Entrecomillado de cadenas y uso de literales en la AWS CLI](cli-usage-parameters-quoting-strings.md). En la siguiente salida JSON se muestra un ejemplo de lo que el parámetro `--query` puede producir. La salida describe tres volúmenes de Amazon EBS conectados a instancias independientes de Amazon EC2. #### Ejemplo de resultado ``` $ 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 Los identificadores son las etiquetas de los valores de salida. Al crear filtros, se utilizan identificadores para reducir los resultados de la consulta. En el siguiente ejemplo de salida, se resaltan todos los identificadores como `Volumes`, `AvailabilityZone` y `AttachTime`. ``` $ 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 obtener más información, consulte [Identificadores](https://jmespath.org/specification.html#identifiers ) en el *sitio web JMESPath*. ### Cómo seleccionar de una lista Una lista o matriz es un identificador que va seguido de un corchete “`[`” como `Volumes` y `Attachments` en la [Antes de comenzar](#cli-usage-filter-client-side-output). **Sintaxis** ``` [ ] ``` Para filtrar todos los resultados de una matriz, puede usar la notación comodín. Las expresiones [comodín](http://jmespath.org/specification.html#wildcard-expressions) son expresiones utilizadas para devolver elementos utilizando la notación `*`. En el siguiente ejemplo se consulta todo el contenido de `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 ver un volumen específico en la matriz por índice, se llama al índice de matriz. Por ejemplo, el primer elemento de la matriz `Volumes` tiene un índice de 0, lo que resulta en la consulta `Volumes[0]`. Para obtener más información acerca de los índices de matriz, consulte [Expresiones de índice](http://jmespath.org/specification.html#index-expressions) en el *Sitio web 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 } ``` Para ver un rango específico de volúmenes por índice, utilice `slice` con la siguiente sintaxis, donde ‎**iniciar** es el índice de matriz inicial, **detener** es el índice en el que el filtro deja de procesarse y **paso** es el intervalo de omisión. **Sintaxis** ``` [::] ``` Si se omite cualquiera de estos elementos de la expresión de sector, utilizan los siguientes valores predeterminados: + Iniciar: el primer índice de la lista, 0. + Detener: el último índice de la lista. + Paso: sin saltar paso, donde el valor es 1. Para devolver solo los dos primeros volúmenes, utilice un valor inicial de 0, un valor de detención de 2 y un valor de paso de 1, como se muestra en el siguiente ejemplo. ``` $ 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 } ] ``` Dado que este ejemplo contiene valores predeterminados, puede acortar el segmento de `Volumes[0:2:1]` a `Volumes[:2]`. En el ejemplo siguiente se omiten los valores predeterminados y se devuelve cada dos volúmenes de toda la 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 } ] ``` Los pasos también pueden utilizar números negativos para filtrar en el orden inverso de una matriz como se muestra en el siguiente ejemplo. ``` $ 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 obtener más información, consulte [Sectores](https://jmespath.org/specification.html#slices) en el *Sitio web JMESPath*. ### Filtrado de datos anidados Para restringir el filtrado de `Volumes[*]` para los valores anidados, se utilizan subexpresiones agregando un punto y sus criterios de filtro. **Sintaxis** ``` . ``` En el siguiente ejemplo se muestra toda la información de `Attachments`para todos los volúmenes. ``` $ 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 más los valores anidados, agregue la expresión para cada indentificador anidado. En el ejemplo siguiente, se muestran los `State` para todos los `Volumes`. ``` $ aws ec2 describe-volumes \ --query 'Volumes[*].Attachments[*].State' [ [ "attached" ], [ "attached" ], [ "attached" ] ] ``` ### Aplanamiento de los resultados Para obtener más información, consulte [SubExpresiones](https://jmespath.org/specification.html#subexpressions) en el*Sitio web JMESPath*. Puede aplanar los resultados de `Volumes[*].Attachments[*].State` eliminando la notación comodín que resulta en la consulta `Volumes[*].Attachments[].State`. El aplanamiento a menudo es útil para mejorar la legibilidad de los resultados. ``` $ aws ec2 describe-volumes \ --query 'Volumes[*].Attachments[].State' [ "attached", "attached", "attached" ] ``` Para obtener más información, consulte [Aplanar](https://jmespath.org/specification.html#flatten) en el *Sitio web JMESPath*. ### Filtrado para valores específicos Para filtrar valores específicos de una lista, utilice una expresión de filtro como se muestra en la siguiente sintaxis. **Sintaxis** ``` ? ] ``` Los comparadores de expresiones incluyen `==`, `!=`, `<`, `<=`, `>` y `>=`. En el ejemplo siguiente se filtra para el `VolumeIds`, para todos los `Volumes` en un `Attached``State`. ``` $ aws ec2 describe-volumes \ --query 'Volumes[*].Attachments[?State==`attached`].VolumeId' [ [ "vol-e11a5288" ], [ "vol-2e410a47" ], [ "vol-a1b3c7nd" ] ] ``` Esto se puede aplanar, lo que resulta en el siguiente ejemplo. ``` $ aws ec2 describe-volumes \ --query 'Volumes[*].Attachments[?State==`attached`].VolumeId[]' [ "vol-e11a5288", "vol-2e410a47", "vol-a1b3c7nd" ] ``` En el ejemplo siguiente se filtra para el `VolumeIds`, de todos los `Volumes` que tienen un tamaño inferior a 20. ``` $ aws ec2 describe-volumes \ --query 'Volumes[?Size < `20`].VolumeId' [ "vol-2e410a47", "vol-a1b3c7nd" ] ``` Para obtener más información, consulte [Expresiones de filtro](https://jmespath.org/specification.html#filterexpressions) en el *Sitio web JMESPath*. ### Expresiones de canalización Puede canalizar los resultados de un filtro a una nueva lista y, a continuación, filtrar el resultado con otra expresión utilizando la siguiente sintaxis: **Sintaxis** ``` | ] ``` En el siguiente ejemplo se toman los resultados del filtro de la expresión `Volumes[*].Attachments[].InstanceId` y genera el primer resultado en la matriz. ``` $ aws ec2 describe-volumes \ --query 'Volumes[*].Attachments[].InstanceId | [0]' "i-a071c394" ``` En este ejemplo, se crea primero la matriz a partir de la siguiente expresión. ``` $ aws ec2 describe-volumes \ --query 'Volumes[*].Attachments[].InstanceId' "i-a071c394", "i-4b41a37c", "i-1jd73kv8" ``` Y luego devuelve el primer elemento de esa matriz. ``` "i-a071c394" ``` Para obtener más información, consulte [Expresiones de canalización](https://jmespath.org/specification.html#pipe-expressions) en el *Sitio web JMESPath*. ### Filtrado para varios valores de identificador Para filtrar por varios identificadores, utilice una lista de selección múltiple mediante la siguiente sintaxis: **Sintaxis** ``` [].[, ] ``` En el siguiente ejemplo, `VolumeId` y `VolumeType` se filtran en la lista `Volumes` lo que resulta en la siguiente expresión. ``` $ aws ec2 describe-volumes \ --query 'Volumes[].[VolumeId, VolumeType]' [ [ "vol-e11a5288", "standard" ], [ "vol-2e410a47", "standard" ], [ "vol-a1b3c7nd", "standard" ] ] ``` Para agregar datos anidados a la lista, agregue otra lista de selección múltiple. El siguiente ejemplo amplía el ejemplo anterior al filtrar también `InstanceId` y `State` en la lista de `Attachments` anidada. Esto da como resultado la siguiente expresión. ``` $ 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 que sea más legible, aplane la expresión como se muestra en el siguiente ejemplo. ``` $ 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 obtener más información, consulte la [Lista de selección múltiple](https://jmespath.org/specification.html#multiselectlist) en el *Sitio web JMESPath*. ### Agregado de etiquetas a valores de identificador Para facilitar la lectura de este resultado, utilice un hash de selección múltiple con la siguiente sintaxis. **Sintaxis** ``` [].{