.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Extrae los campos `loggingTime`, `loggingType` y `loggingMessage`, filtra hasta los eventos de registro que contienen cadenas `ERROR` o `INFO` y, a continuación, muestra solo los campos `loggingMessage` y `loggingType` para los eventos que contienen una cadena `ERROR`.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# sort
Use `sort` para mostrar eventos de registro en orden ascendente (`asc`) o descendente (`desc`) por un campo especificado. Puede usarlo con el comando `limit` para crear consultas de los “primeros N” o los “últimos N”.
El algoritmo de clasificación es una versión actualizada de la clasificación natural. Si ordena en orden ascendente, se utiliza la siguiente lógica.
+ Todos los valores no numéricos aparecen antes que todos los valores numéricos. Los *valores numéricos* son valores que incluyen únicamente números, no una mezcla de números y otros caracteres.
+ Para los valores que no son numéricos, el algoritmo agrupa los caracteres numéricos consecutivos y los caracteres alfabéticos consecutivos en fragmentos separados para compararlos. Ordena las partes no numéricas por sus valores Unicode y ordena las partes numéricas primero por su longitud y, después, por su valor numérico.
Para obtener más información sobre el orden Unicode, consulte [Lista de caracteres Unicode](https://en.wikipedia.org/wiki/List_of_Unicode_characters).
Por ejemplo, la información siguiente es el resultado de una clasificación en orden ascendente.
```
!: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sorted by unicode order
#
*%04
0# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Alphanumeric starting with numbers
5A
111A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Starts with more digits than 5A, so it sorted to be later than 5A
2345_
@ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2345 is compared with @ in the unicode order,
@_
A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Values starting with letters
A9876fghj
a12345hfh
0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Number values
01
1
2
3
```
Si ordena en orden descendente, los resultados de la clasificación se invertirán.
Por ejemplo, la siguiente consulta para los registros de flujo de Amazon VPC busca las 15 transferencias principales de paquetes entre hosts.
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
# stats
Utilice `stats` para crear visualizaciones de los datos de registro, como gráficos de barras, gráficos de líneas y gráficos de áreas apiladas. Esto le ayuda a identificar de forma más eficiente los patrones en los datos de registro. CloudWatch Logs Insights genera visualizaciones para las consultas que utilizan la `stats` función y una o más funciones de agregación.
Por ejemplo, la siguiente consulta en un grupo de registro de Route 53 devuelve visualizaciones que muestran la distribución de los registros de Route 53 por hora, por tipo de consulta.
```
stats count(*) by queryType, bin(1h)
```
Todas estas consultas pueden generar gráficos de barras. Si la consulta utiliza la función `bin()` para agrupar los datos en función de un mismo campo a lo largo del tiempo, también puede ver gráficos de líneas y gráficos de áreas apiladas.
La función `bin` admite las siguientes unidades de tiempo y abreviaturas. Para todas las unidades y abreviaturas que incluyan más de un carácter, se admite agregar s para pluralizar. Así que tanto `hr` como `hrs` funcionan para especificar las horas.
+ `millisecond` `ms` `msec`
+ `second` `s` `sec`
+ `minute` `m` `min`
+ `hour` `h` `hr`
+ `day` `d`
+ `week` `w`
+ `month` `mo` `mon`
+ `quarter` `q` `qtr`
+ `year` `y` `yr`
**Topics**
+ [Visualización de datos de series temporales](#CWL_Insights-Visualizing-TimeSeries)
+ [Visualización de datos de registro agrupados por campos](#CWL_Insights-Visualizing-ByFields)
+ [Utilice varios comandos de estadísticas en una sola consulta](#CWL_QuerySyntax-stats-multi)
+ [Funciones para usar con estadísticas](#CWL_QuerySyntax-stats-functions)
## Visualización de datos de series temporales
Las visualizaciones de series temporales funcionan con las consultas que tienen las siguientes características:
+ La consulta contiene una o varias funciones de agregación. Para obtener más información, consulte [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
+ La consulta utiliza la función `bin()` para agrupar los datos por un campo.
Estas consultas pueden generar gráficos de líneas, de áreas apiladas, de barras y circulares.
**Ejemplos**
Para ver un tutorial completo, consulte [Tutorial: Ejecutar una consulta que produce una visualización de serie temporal](CWL_AnalyzeLogData_VisualizationQuery.md).
Aquí hay más consultas de ejemplo que funcionan para la visualización de series temporales.
La siguiente consulta genera una visualización de los valores medios del campo `myfield1`, con un punto de datos creado cada cinco minutos. Cada punto de datos es la agregación de las medias de los valores `myfield1` de los registros de los últimos cinco minutos.
```
stats avg(myfield1) by bin(5m)
```
La siguiente consulta genera una visualización de los tres valores basados en diferentes campos, con un punto de datos creado cada cinco minutos. La visualización se genera porque la consulta contiene las funciones de agregación y utiliza `bin()` como campo de agrupación.
```
stats avg(myfield1), min(myfield2), max(myfield3) by bin(5m)
```
**Restricciones de los gráficos de líneas y de áreas apiladas**
Las consultas que agregan información de entradas de registro pero no utilizan la función `bin()` pueden generar gráficos de barras. Sin embargo, las consultas no pueden generar gráficos de líneas ni gráficos de áreas apiladas. Para obtener más información sobre estos tipos de consultas, visite [Visualización de datos de registro agrupados por campos](#CWL_Insights-Visualizing-ByFields).
## Visualización de datos de registro agrupados por campos
Puede generar gráficos de barras para consultas que utilizan la función `stats` y una o varias funciones de agregación. Para obtener más información, consulte [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
Para ver la visualización, ejecute la consulta. A continuación, elija la pestaña **Visualization (Visualización)**, seleccione la flecha situada junto a **Line (Línea)** y haga clic en **Bar (Barra)**. Las visualizaciones de los gráficos de barras tienen un límite máximo de 100 barras.
**Ejemplos**
Para ver un tutorial completo, consulte [Tutorial: Ejecutar una consulta que produce una visualización agrupada por campos de registro](CWL_AnalyzeLogData_VisualizationFieldQuery.md). Los párrafos siguientes incluyen más consultas de ejemplo de visualizaciones por campos.
La siguiente consulta de registro de flujo de VPC busca el número medio de bytes transferidos por sesión en cada dirección de destino.
```
stats avg(bytes) by dstAddr
```
También puede generar un gráfico que contenga varias barras para cada valor resultante. Por ejemplo, la siguiente consulta de registro de flujo de VPC busca el número medio y máximo de bytes transferidos por sesión en cada dirección de destino.
```
stats avg(bytes), max(bytes) by dstAddr
```
En la siguiente consulta, se busca el número de registros de Amazon Route 53 para cada tipo de consulta.
```
stats count(*) by queryType
```
## Utilice varios comandos de estadísticas en una sola consulta
Puede usar hasta dos comandos `stats` en una sola consulta. Esto le permite realizar una agregación adicional en el resultado de la primera agregación.
**Ejemplo: consulta con dos comandos `stats`**
Por ejemplo, la siguiente consulta busca primero el volumen de tráfico total en los intervalos de 5 minutos y, a continuación, calcula el volumen de tráfico más alto, más bajo y medio de esos intervalos de 5 minutos.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length)/1024/1024 as logs_mb BY bin(5m)
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb
```
**Ejemplo: combine varios comandos de estadísticas con otras funciones, como `filter`, `fields`, `bin`**
Puede combinar dos comandos `stats` con otros comandos, como `filter` y `fields`, en una sola consulta. Por ejemplo, la siguiente consulta busca el número de direcciones IP distintas en las sesiones y busca el número de sesiones por plataforma de cliente, filtra esas direcciones IP y, finalmente, busca el promedio de solicitudes de sesión por plataforma del cliente.
```
STATS count_distinct(client_ip) AS session_ips,
count(*) AS requests BY session_id, client_platform
| FILTER session_ips > 1
| STATS count(*) AS multiple_ip_sessions,
sum(requests) / count(*) AS avg_session_requests BY client_platform
```
Puede utilizar funciones `bin` y `dateceil` en consultas con varios comandos `stats`. Por ejemplo, la siguiente consulta combina primero los mensajes en bloques de 5 minutos, luego agrega esos bloques de 5 minutos en bloques de 10 minutos y calcula los volúmenes de tráfico más altos, más bajos y promedio dentro de cada bloque de 10 minutos.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) / 1024 / 1024 AS logs_mb BY BIN(5m) as @t
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb BY dateceil(@t, 10m)
```
**Notas y limitaciones**
Una consulta puede tener un máximo de dos comandos `stats`. Esta cuota no se puede cambiar.
Si utiliza un comando `sort` o `limit`, debe aparecer después del segundo comando `stats`. Si está antes del segundo comando `stats`, la consulta no es válida.
Cuando una consulta tiene dos comandos `stats`, los resultados parciales de la consulta no comienzan a mostrarse hasta que se completa la primera agregación `stats`.
En el segundo comando `stats` de una consulta única, solo puede hacer referencia a los campos definidos en el primer comando `stats`. Por ejemplo, la siguiente consulta no es válida porque el campo `@message` no estará disponible después de la primera agregación `stats`.
```
FIELDS @message
| STATS SUM(Fault) by Operation
# You can only reference `SUM(Fault)` or Operation at this point
| STATS MAX(strlen(@message)) AS MaxMessageSize # Invalid reference to @message
```
Todos los campos a los que haga referencia después del primer comando `stats` deben definirse en ese primer comando `stats`.
```
STATS sum(x) as sum_x by y, z
| STATS max(sum_x) as max_x by z
# You can only reference `max(sum_x)`, max_x or z at this point
```
**importante**
La función `bin` siempre utiliza el campo `@timestamp` de forma implícita. Esto significa que no se puede usar `bin` en el segundo comando `stats` sin usar el primer comando `stats` para propagar el campo `timestamp`. Por ejemplo, la siguiente consulta no es válida.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes BY @logStream
| STATS avg(ingested_bytes) BY bin(5m) # Invalid reference to @timestamp field
```
En su lugar, defina el campo `@timestamp` en el primer comando `stats` y, a continuación, podrá usarlo con `dateceil` en el segundo comando `stats`, como en el siguiente ejemplo.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes, max(@timestamp) as @t BY @logStream
| STATS avg(ingested_bytes) BY dateceil(@t, 5m)
```
## Funciones para usar con estadísticas
CloudWatch Logs Insights admite funciones de agregación de estadísticas y funciones de no agregación de estadísticas.
Utilice las funciones de agregación de estadísticas en el comando `stats` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `avg(fieldName: NumericLogField)` | número | La media de los valores en el campo especificado. |
| `count()` `count(fieldName: LogField)` | número | Cuenta los eventos de registro. `count()` (o `count(*)`) cuenta todos los eventos devueltos por la consulta, mientras que `count(fieldName)` cuenta todos los registros que incluyen el nombre de campo especificado. |
| `count_distinct(fieldName: LogField)` | número | Devuelve el número de valores únicos para el campo. Si el campo tiene una cardinalidad muy alta (contiene muchos valores únicos), el valor devuelto por `count_distinct` es solo una aproximación. |
| `max(fieldName: LogField)` | LogFieldValue | El máximo de los valores para este campo de registro en los registros consultados. |
| `min(fieldName: LogField)` | LogFieldValue | El mínimo de los valores para este campo de registro en los registros consultados. |
| `pct(fieldName: LogFieldValue, percent: number)` | LogFieldValue | Un percentil indica el peso relativo de un valor en un conjunto de datos. Por ejemplo, `pct(@duration, 95)` devuelve el valor `@duration` en que el 95 % de los valores de `@duration` son inferiores a este valor y un 5 por ciento son superiores a este valor. |
| `stddev(fieldName: NumericLogField)` | número | El desvío estándar de los valores en el campo especificado. |
| `sum(fieldName: NumericLogField)` | número | La suma de los valores en el campo especificado. |
**Funciones sin agregación de estadísticas**
Utilice las funciones de no agregación en el comando `stats` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `earliest(fieldName: LogField)` | LogField | Devuelve el valor de `fieldName` desde el evento de registro que tiene la primera marca temporal en los registros consultados. |
| `latest(fieldName: LogField)` | LogField | Devuelve el valor de `fieldName` desde el evento de registro que tiene la última marca temporal en los registros consultados. |
| `sortsFirst(fieldName: LogField)` | LogField | Devuelve el valor de `fieldName` que ordena en primer lugar los registros consultados. |
| `sortsLast(fieldName: LogField)` | LogField | Devuelve el valor de `fieldName` que ordena al final los registros consultados. |
# límite
Use `limit` para especificar el número de eventos de registro que desea que devuelva la consulta. Si omite `limit`, la consulta devolverá hasta 10 000 eventos de registro en los resultados.
Por ejemplo, el siguiente ejemplo devuelve solo los 25 eventos de registro más recientes
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
# dedup
Utilice `dedup` para eliminar los resultados duplicados en función de valores específicos en los campos que indique. Puede utilizar `dedup` con uno o más campos. Si especifica un campo con `dedup`, solo se devolverá un evento de registro por cada valor único de ese campo. Si especifica varios campos, se devolverá un evento de registro por cada combinación única de valores para esos campos.
Los resultados duplicados se descartan según el orden de clasificación y solo se conserva el primer resultado del orden de clasificación. Le recomendamos que ordene los resultados antes de someterlos al comando `dedup`. Si los resultados no se ordenan antes de analizarlos con `dedup`, se utiliza el orden de clasificación descendente predeterminado de `@timestamp`.
Los valores nulos no se consideran duplicados para la evaluación. Se conservan los eventos de registro con valores nulos para cualquiera de los campos especificados. Para eliminar campos con valores nulos, utilice **`filter`** mediante la función `isPresent(field)`.
El único comando de consulta que puede utilizar en una consulta después del comando `dedup` es `limit`.
Cuando se utiliza `dedup` en una consulta, la consola muestra un mensaje como **Mostrar X de Y registros, donde X** es el número de resultados deduplicados e Y es el número total de registros coincidentes antes de la deduplicación. Esto indica que se eliminaron los registros duplicados y no significa que falten datos.
**Ejemplo: Vea solo el evento de registro más reciente para cada valor único del campo denominado `server`**
En el siguiente ejemplo, se muestran los campos `timestamp`, `server`, `severity` y `message` solo para el evento más reciente de cada valor único de `server`.
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server
```
Para ver más ejemplos de consultas de CloudWatch Logs Insights, consulte[Consultas generales](CWL_QuerySyntax-examples.md#CWL_QuerySyntax-examples-general).
# unmask
`unmask` se utiliza para mostrar todo el contenido de un evento de registro que tiene parte del contenido enmascarado debido a una política de protección de datos. Para ejecutar este comando, debe tener el permiso `logs:Unmask`.
Para obtener más información sobre la protección de datos en grupos de registro, consulte [Ayude a proteger los datos de registro confidenciales con el enmascaramiento](mask-sensitive-log-data.md).
# unnest
Se debe utilizar `unnest` para aplanar una lista tomada como entrada y generar varios registros con un único registro para cada elemento de la lista. En función de la cantidad de elementos que contenga un campo, este comando descarta el registro actual y genera nuevos registros. Cada registro incluye el `unnested_field`, que representa un elemento. Todos los demás campos provienen del registro original.
La entrada para `unnest` es `LIST`, que proviene de la función `jsonParse`. Para obtener más información, consulte [Tipos de estructura](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html#CWL_QuerySyntax-structure-types). Cualquier otro tipo, como `MAP`, `String` y `numbers`, se trata como una lista con un elemento en `unnest`.
**Estructura de comandos**
En el ejemplo siguiente, se describe el formato de este comando.
```
unnest field into unnested_field
```
**Consulta de ejemplo**
En el siguiente ejemplo, se analiza una cadena de objeto JSON y se amplía una lista de eventos de campo.
```
fields jsonParse(@message) as json_message
| unnest json_message.events into event
| display event.name
```
El evento de registro de esta consulta de ejemplo podría ser una cadena JSON de la siguiente manera:
```
{
"events": [
{
"name": "exception"
},
{
"name": "user action"
}
]
}
```
En este caso, la consulta de ejemplo genera dos registros en el resultado de la consulta, uno con `event.name` como `exception` y otro con `event.name` como **acción del usuario**
**Consulta de ejemplo**
En el siguiente ejemplo, se aplana una lista y, a continuación, se filtran los elementos.
```
fields jsonParse(@message) as js
| unnest js.accounts into account
| filter account.type = "internal"
```
**Consulta de ejemplo**
En el siguiente ejemplo, se aplana una lista para su agregación.
```
fields jsonParse(trimmedData) as accounts
| unnest accounts into account
| stats sum(account.droppedSpans) as n by account.accountId
| sort n desc
| limit 10
```
# lookup
Se utiliza `lookup` para enriquecer los resultados de la consulta con datos de referencia de una tabla de consulta. Una tabla de consulta contiene datos CSV que subes a Amazon CloudWatch Logs. Cuando se ejecuta una consulta, el `lookup` comando compara un campo del registro de eventos con un campo de la tabla de consulta y agrega los campos de salida especificados a los resultados.
Utilice tablas de consulta para escenarios de enriquecimiento de datos, como mapear los detalles de un usuario IDs a otro, los códigos de producto a la información del producto o los códigos de error a las descripciones de los errores.
## Creación y administración de tablas de consulta
Antes de poder utilizar el `lookup` comando en una consulta, debe crear una tabla de consulta. Puede crear y gestionar tablas de búsqueda desde la CloudWatch consola o mediante la API de Amazon CloudWatch Logs.
**Para crear una tabla de consulta (consola)**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Configuración** y, a continuación, elija la pestaña **Registros**.
1. Desplázate hasta **Tablas de búsqueda** y selecciona **Administrar**.
1. Seleccione **Crear tabla de consulta**.
1. Introduzca un nombre para la tabla de consulta. El nombre solo puede contener caracteres alfanuméricos, guiones y guiones bajos.
1. (Opcional) Introduzca una descripción.
1. Cargue un archivo CSV. El archivo debe incluir una fila de encabezado con los nombres de las columnas, utilizar la codificación UTF-8 y no superar los 10 MB.
1. (Opcional) Especifique una AWS KMS clave para cifrar los datos de la tabla.
1. Seleccione **Crear**.
Después de crear una tabla de consulta, puede verla en el editor de consultas de CloudWatch Logs Insights. Seleccione la pestaña **Tablas de búsqueda** para buscar las tablas disponibles y sus campos.
Para actualizar una tabla de consulta, selecciónela y elija **Acciones**, **Actualizar**. Cargue un nuevo archivo CSV para reemplazar todo el contenido existente. Para eliminar una tabla de consulta, selecciona **Acciones**, **Eliminar**.
**nota**
Puede crear hasta 100 tablas de búsqueda por cuenta y por cuenta Región de AWS. Los archivos CSV pueden ocupar hasta 10 MB. También puedes gestionar las tablas de búsqueda mediante la API de Amazon CloudWatch Logs. Para obtener más información, consulta [CreateLookupTable](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLookupTable.html)la *referencia de la API CloudWatch de Amazon Logs*.
**nota**
Si la tabla de consulta está cifrada con una clave de KMS, la persona que llama debe tener el `kms:Decrypt` permiso sobre la clave (la clave de KMS utilizada para cifrar la tabla de consulta) para utilizar la `StartQuery` API con una consulta que haga referencia a esa tabla de consulta. Para obtener más información, consulte [Cifre las tablas de búsqueda en CloudWatch los registros mediante AWS Key Management Service](encrypt-lookup-tables-kms.md).
## Sintaxis de consulta para la búsqueda
**Estructura de comandos**
A continuación se muestra el formato de este comando.
```
lookup table lookup-field as log-field [,...] output-mode output-field[,...]
```
El comando utiliza los siguientes argumentos:
+ `table`— El nombre de la tabla de consulta que se va a utilizar.
+ `lookup-field`— El campo de la tabla de consulta con el que se va a comparar.
+ `log-field`— El campo del registro de eventos que debe coincidir. La coincidencia es exacta y distingue mayúsculas de minúsculas.
+ `output-mode`— Especifique si `OUTPUT` desea añadir los campos de salida a los resultados. Si ya existe un campo con el mismo nombre en el registro de eventos, se sobrescribe.
+ `output-field`— Uno o más campos de la tabla de consulta para añadirlos a los resultados.
**Ejemplo: enriquece los eventos del registro con los detalles del usuario**
Supongamos que tiene un grupo de registros con eventos que contienen un `id` campo y una tabla de consulta `user_data` con las columnas `id``name`,`email`, y`department`. La siguiente consulta enriquece cada evento de registro con el nombre, el correo electrónico y el departamento del usuario de la tabla de búsqueda.
```
fields action, status, name, email, department
| lookup user_data id OUTPUT name, email, department
```
**Ejemplo: utilice la búsqueda con agregación**
Puede utilizar los campos de salida de la búsqueda con funciones de agregación. La siguiente consulta enriquece los eventos del registro con los detalles del usuario y, a continuación, cuenta los eventos agrupados por dirección de correo electrónico.
```
fields user_id, action, username, email, department
| lookup user_data user_id OUTPUT username, email, department
| stats count(*) by email
```
**Ejemplo: utilice la búsqueda con un filtro**
Puede filtrar los resultados en función de los campos devueltos por la búsqueda. La siguiente consulta enriquece el registro de eventos y, a continuación, filtra para mostrar solo los eventos de un departamento específico.
```
fields user_id, action
| lookup user_data user_id OUTPUT username, email, department
| filter department = "Engineering"
```
# Funciones booleanas, de comparación, numéricas, de fecha y hora y otras
CloudWatch Logs Insights admite muchas otras operaciones y funciones en las consultas, como se explica en las siguientes secciones.
**Topics**
+ [Operadores aritméticos](#CWL_QuerySyntax-operations-arithmetic)
+ [Operadores booleanos](#CWL_QuerySyntax-operations-Boolean)
+ [Operadores de comparación](#CWL_QuerySyntax-operations-comparison)
+ [Operadores numéricos](#CWL_QuerySyntax-operations-numeric)
+ [Tipos de estructura](#CWL_QuerySyntax-structure-types)
+ [Funciones DateTime](#CWL_QuerySyntax-datetime)
+ [Funciones generales](#CWL_QuerySyntax-general-functions)
+ [Funciones JSON](#CWL_QuerySyntax-json-functions)
+ [Funciones de cadena de dirección IP](#CWL_QuerySyntax-IPaddress-functions)
+ [Funciones de cadena](#CWL_QuerySyntax-string-functions)
## Operadores aritméticos
Los operadores aritméticos aceptan tipos de datos numéricos como argumentos y devuelven resultados numéricos. Utilice operadores aritméticos en los comandos `filter` y `fields` y como argumentos para otras funciones.
| Operación | Description (Descripción) |
| --- | --- |
| `a + b` | Suma |
| `a - b` | Resta |
| `a * b` | Multiplicación |
| `a / b` | División |
| `a ^ b` | Potencia (`2 ^ 3` devuelve `8`) |
| `a % b` | Resto o módulo (`10 % 3` devuelve `1`) |
## Operadores booleanos
Utilice los operadores booleanos `and`, `or` y `not`.
**nota**
Utilice operadores booleanos solo en funciones que devuelvan el valor **TRUE** o **FALSE**.
## Operadores de comparación
Los operadores de comparación aceptan todos los tipos de datos como argumentos y devuelven un resultado booleano. Utilice operadores de comparación en el comando `filter` y como argumentos para otras funciones.
| Operador | Description (Descripción) |
| --- | --- |
| `=` | Igualdad |
| `!=` | Desigualdad |
| `<` | Menor que |
| `>` | Mayor que |
| `<=` | Menor o igual que |
| `>=` | Mayor o igual que |
## Operadores numéricos
Las operaciones numéricas aceptan tipos de datos numéricos como argumentos y devuelven resultados numéricos. Utilice operaciones numéricas en los comandos `filter` y `fields` y como argumentos para otras funciones.
| Operación | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `abs(a: number)` | número | Valor absoluto |
| `ceil(a: number)` | número | Redondeo a valor máximo (menor número entero que es mayor que el valor de `a`). |
| `floor(a: number)` | número | Redondeo a valor mínimo (mayor número entero que es menor que el valor de `a`). |
| `greatest(a: number, ...numbers: number[])` | número | Devuelve el valor más alto |
| `least(a: number, ...numbers: number[])` | número | Devuelve el valor más bajo |
| `log(a: number)` | número | Registro natural |
| `sqrt(a: number)` | número | Raíz cuadrada |
## Tipos de estructura
Un mapa o una lista es un tipo de estructura de CloudWatch Logs Insights que permite acceder a los atributos de las consultas y utilizarlos.
**Ejemplo: obtención de un mapa o una lista**
Se usa `jsonParse` para analizar un campo que es una cadena json y convertirlo en un mapa o una lista.
```
fields jsonParse(@message) as json_message
```
**Ejemplo: acceso a los atributos**
Utilice el operador de acceso por puntos (map.attribute) para acceder a los elementos de un mapa. Si un atributo de un mapa contiene caracteres especiales, utilice acentos graves para incluir el nombre del atributo (map.attributes.`special.char`).
```
fields jsonParse(@message) as json_message
| stats count() by json_message.status_code
```
Utilice el operador de acceso entre corchetes (list[index]) para recuperar un elemento en una posición específica de la lista.
```
fields jsonParse(@message) as json_message
| filter json_message.users[1].action = "PutData"
```
Coloque los caracteres especiales entre acentos graves (``) cuando haya caracteres especiales en el nombre de la clave.
```
fields jsonParse(@message) as json_message
| filter json_message.`user.id` = "123"
```
**Ejemplo: resultados vacíos**
Los mapas y las listas se consideran nulos para las funciones de cadena, número, y fecha y hora.
```
fields jsonParse(@message) as json_message
| display toupper(json_message)
```
La comparación del mapa y la lista con cualquier otro campo da como resultado `false`.
**nota**
No se admite el uso de mapas y listas en `dedup`, `pattern`,`sort` y `stats`.
## Funciones DateTime
**Funciones DateTime**
Utilice funciones datetime en los comandos `fields` y `filter` y como argumentos para otras funciones. Utilice estas funciones para crear buckets de hora para consultas con funciones de agregación. Utilice períodos de tiempo que tengan un número y uno de los siguientes valores:
+ `ms` para milisegundos
+ `s` para segundos
+ `m` para minutos
+ `h` para horas
Por ejemplo, `10m` es 10 minutos y `1h` es 1 hora.
**nota**
Utilice la unidad de tiempo más adecuada para su función de fecha y hora. CloudWatch Los registros limitan la solicitud en función de la unidad de tiempo que elija. Por ejemplo, pone un límite de 60 como valor máximo para cualquier solicitud que utilice `s`. Por lo tanto, si lo especificas`bin(300s)`, CloudWatch Logs en realidad lo implementa como 60 segundos, ya que 60 es el número de segundos en un minuto, por lo que CloudWatch Logs no utilizará un número superior a 60`s`. Para crear un bucket de 5 minutos, utilice `bin(5m)` en su lugar.
El límite de `ms` es 1000, el límite de `s` y `m` es 60 y el límite de `h` es 24.
En la siguiente tabla, se incluye una lista de las distintas funciones datetime que se pueden usar en comandos de consulta. La tabla enumera el tipo de resultado de cada función y contiene una descripción de cada función.
**sugerencia**
Al crear un comando de consulta, puede utilizar el selector de intervalos de tiempo para seleccionar un periodo de tiempo que desea consultar. Por ejemplo, puede establecer un periodo entre intervalos de 5 a 30 minutos; intervalos de 1, 3 y 12 horas; o un marco temporal personalizado. También puede establecer periodos de tiempo entre fechas específicas.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `bin(period: Period)` | Timestamp | Redondea el valor de `@timestamp` según el periodo de tiempo indicado y, a continuación, trunca. Por ejemplo, `bin(5m)` redondea el valor de `@timestamp` a los 5 minutos más cercanos. Puede usarlo para agrupar varias entradas de registro en una consulta. En el siguiente ejemplo, se devuelve el número de excepciones por hora: filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
La función `bin` admite las siguientes unidades de tiempo y abreviaturas. Para todas las unidades y abreviaturas que incluyan más de un carácter, se admite agregar s para pluralizar. Así que tanto `hr` como `hrs` funcionan para especificar las horas. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html) |
| `datefloor(timestamp: Timestamp, period: Period)` | Timestamp | Trunca la marca temporal según el periodo indicado. Por ejemplo, `datefloor(@timestamp, 1h)` trunca todos los valores de `@timestamp` en la parte inferior de la hora. |
| `dateceil(timestamp: Timestamp, period: Period)` | Timestamp | Redondea hacia arriba la marca temporal según el periodo indicado y, a continuación, trunca. Por ejemplo, `dateceil(@timestamp, 1h)` trunca todos los valores de `@timestamp` en la parte superior de la hora. |
| `fromMillis(fieldName: number)` | Timestamp | Interpreta el campo de entrada como el número de milisegundos desde la fecha de inicio de Unix y lo convierte en una marca de tiempo. |
| `toMillis(fieldName: Timestamp)` | número | Convierte la marca de tiempo que se encontró en el campo con nombre asignado en un número que representa los milisegundos desde la fecha de inicio de Unix. Por ejemplo, `toMillis(@timestamp)` convierte la marca temporal `2022-01-14T13:18:031.000-08:00` a `1642195111000`. |
| `now()` | número | Devuelve la hora en que se inició el procesamiento de la consulta, en segundos por época. Esta función no toma argumentos. Puede usarlo para filtrar los resultados de la consulta según la hora actual. Por ejemplo, la siguiente consulta devuelve todos los errores 4xx de las últimas dos horas: parse @message "Status Code: *;" as statusCode\n
| filter statusCode >= 400 and statusCode <= 499 \n
| filter toMillis(@timestamp) >= (now() * 1000 - 7200000)
El ejemplo siguiente devuelve todas las entradas de registro de las últimas cinco horas que contienen la palabra `error` o `failure` fields @timestamp, @message
| filter @message like /(?i)(error|failure)/
| filter toMillis(@timestamp) >= (now() * 1000 - 18000000)
|
**nota**
Actualmente, CloudWatch Logs Insights no admite el filtrado de registros con marcas de tiempo legibles por humanos.
## Funciones generales
**Funciones generales**
Utilice funciones generales en los comandos `fields` y `filter` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `ispresent(fieldName: LogField)` | Booleano | Devuelve `true` si el campo existe |
| `coalesce(fieldName: LogField, ...fieldNames: LogField[])` | LogField | Devuelve el primer valor no nulo de la lista |
## Funciones JSON
**Funciones JSON**
Utilice funciones JSON en los comandos `fields` y `filter` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `jsonParse(fieldName: string)` | Mapa \$1 Lista \$1 Vacío | Devuelve un mapa o una lista cuando la entrada es una representación en cadena de un objeto JSON o una matriz JSON. Devuelve un valor vacío si la entrada no es una de las representaciones. |
| `jsonStringify(fieldName: Map \| List)` | Cadena | Devuelve una cadena JSON de un mapa o de una lista de datos. |
## Funciones de cadena de dirección IP
**Funciones de cadena de dirección IP**
Utilice funciones de cadena de dirección IP en los comandos `filter` y `fields` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `isValidIp(fieldName: string)` | booleano | Devuelve `true` si el campo es una IPv6 dirección IPv4 OR válida. |
| `isValidIpV4(fieldName: string)` | booleano | Devuelve `true` si el campo es una IPv4 dirección válida. |
| `isValidIpV6(fieldName: string)` | booleano | Devuelve `true` si el campo es una IPv6 dirección válida. |
| `isIpInSubnet(fieldName: string, subnet: string)` | booleano | Devuelve `true` si el campo es una IPv6 dirección IPv4 o dirección válida dentro de la subred v4 o v6 especificada. Al especificar la subred, utilice la notación CIDR como `192.0.2.0/24` o `2001:db8::/32`, donde `192.0.2.0` o `2001:db8::` es el inicio del bloque de CIDR. |
| `isIpv4InSubnet(fieldName: string, subnet: string)` | booleano | Devuelve `true` si el campo es una IPv4 dirección válida dentro de la subred v4 especificada. Al especificar la subred, utilice la notación CIDR como `192.0.2.0/24`, donde `192.0.2.0` es el inicio del bloque de CIDR. |
| `isIpv6InSubnet(fieldName: string, subnet: string)` | booleano | Devuelve `true` si el campo es una IPv6 dirección válida dentro de la subred v6 especificada. Al especificar la subred, utilice la notación CIDR como `2001:db8::/32`, donde `2001:db8::` es el inicio del bloque de CIDR. |
## Funciones de cadena
**Funciones de cadena**
Utilice funciones de cadena en los comandos `fields` y `filter` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `isempty(fieldName: string)` | Número | Devuelve `1` si el campo no se encuentra o es una cadena vacía. |
| `isblank(fieldName: string)` | Número | Devuelve `1` si el campo no se encuentra, es una cadena vacía o solo contiene espacio en blanco. |
| `concat(str: string, ...strings: string[])` | cadena | Concatena las cadenas. |
| `ltrim(str: string)` `ltrim(str: string, trimChars: string)` | cadena | Si la función no tiene un segundo argumento de cadena, elimina los espacios en blanco de la izquierda de la cadena. Si la función tiene un segundo argumento de cadena, no elimina espacios en blanco. En su lugar, elimina los caracteres de `trimChars` desde la izquierda de `str`. Por ejemplo, `ltrim("xyZxyfooxyZ","xyZ")` devuelve `"fooxyZ"`. |
| `rtrim(str: string)` `rtrim(str: string, trimChars: string)` | cadena | Si la función tiene un segundo argumento de cadena, elimina los espacios en blanco de la derecha de la cadena. Si la función tiene un segundo argumento de cadena, no elimina espacios en blanco. En su lugar, elimina los caracteres de `trimChars` desde la derecha de `str`. Por ejemplo, `rtrim("xyZfooxyxyZ","xyZ")` devuelve `"xyZfoo"`. |
| `trim(str: string)` `trim(str: string, trimChars: string)` | cadena | Si la función no tiene un segundo argumento, elimina espacios en blanco de ambos extremos de la cadena. Si la función tiene un segundo argumento de cadena, no elimina espacios en blanco. En su lugar, elimina los caracteres de `trimChars` desde ambos lados de `str`. Por ejemplo, `trim("xyZxyfooxyxyZ","xyZ")` devuelve `"foo"`. |
| `strlen(str: string)` | número | Devuelve la longitud de la cadena puntos de código Unicode. |
| `toupper(str: string)` | cadena | Convierte la cadena en mayúsculas. |
| `tolower(str: string)` | cadena | Convierte la cadena de caracteres en minúsculas. |
| `substr(str: string, startIndex: number)` `substr(str: string, startIndex: number, length: number)` | cadena | Devuelve una subcadena del índice especificado por el argumento numérico al final de la cadena. Si la función tiene un segundo argumento numérico, contiene la longitud de la subcadena que debe recuperarse. Por ejemplo, `substr("xyZfooxyZ",3, 3)` devuelve `"foo"`. |
| `replace(fieldName: string, searchValue: string, replaceValue: string)` | cadena | Sustituye todas las instancias de `searchValue` en `fieldName: string` por `replaceValue`. Por ejemplo, la función `replace(logGroup,"smoke_test","Smoke")` busca eventos de registro en los que el campo `logGroup` contiene el valor de cadena `smoke_test` y reemplaza el valor por la cadena `Smoke`. |
| `strcontains(str: string, searchValue: string)` | número | Devuelve 1 si `str` contiene `searchValue` y 0 en los demás casos. |
# Campos que contienen caracteres especiales
Si un campo contiene caracteres no alfanuméricos distintos al símbolo `@` o al punto (`.`), debe rodearlo con caracteres de comillas invertidas (```). Por ejemplo, el campo de registro `foo-bar` debe aparecer entre acentos graves (``foo-bar``), porque contiene un carácter no alfanumérico, el guion (`-`).
# Uso de alias y comentarios en las consultas
Cree consultas que contengan alias. Utilice alias para cambiar el nombre de los campos de registro o al extraer valores en campos. Utilice la palabra clave `as` para asignar un alias a un resultado o campo de registro. Puede utilizar más de un alias en una consulta. Puede utilizar alias en los siguientes comandos:
+ `fields`
+ `parse`
+ `sort`
+ ` stats `
En los siguientes ejemplos, se muestra cómo crear consultas que contienen alias.
**Ejemplo**
La consulta contiene un alias en el comando `fields`.
```
fields @timestamp, @message, accountId as ID
| sort @timestamp desc
| limit 20
```
La consulta devuelve los valores de los campos `@timestamp`, `@message` y `accountId`. Los resultados se muestran en orden descendente y su número se limita a 20. Los valores de `accountId` aparecen bajo el alias `ID`.
**Ejemplo**
La consulta contiene alias en los comandos `sort` y `stats`.
```
stats count(*) by duration as time
| sort time desc
```
La consulta cuenta el número de veces que el campo `duration` aparece en el grupo de registro y muestra los resultados en orden descendente. Los valores de `duration` aparecen bajo el alias `time`.
## Uso de comentarios
CloudWatch Logs Insights admite comentarios en las consultas. Utilice el carácter de la almohadilla (**\$1**) para desactivar los comentarios. Puede utilizar comentarios para que haga caso omiso de determinadas líneas en consultas o consultas de documentos.
**Ejemplo: consulta**
Cuando se ejecuta la siguiente consulta, se hace caso omiso de la segunda línea.
```
fields @timestamp, @message, accountId
# | filter accountId not like "7983124201998"
| sort @timestamp desc
| limit 20
```
# Introducción al lenguaje de consulta de Información de registros: tutoriales de consultas
En las secciones siguientes se incluyen tutoriales de consultas de ejemplo para ayudarlo a familiarizarse con Logs Insights QL.
**Topics**
+ [Tutorial: ejecutar y modificar una consulta de muestra](CWL_AnalyzeLogData_RunSampleQuery.md)
+ [Tutorial: ejecutar una consulta con una función de agregación](CWL_AnalyzeLogData_AggregationQuery.md)
+ [Tutorial: Ejecutar una consulta que produce una visualización agrupada por campos de registro](CWL_AnalyzeLogData_VisualizationFieldQuery.md)
+ [Tutorial: Ejecutar una consulta que produce una visualización de serie temporal](CWL_AnalyzeLogData_VisualizationQuery.md)
# Tutorial: ejecutar y modificar una consulta de muestra
El siguiente tutorial le ayuda a empezar a utilizar CloudWatch Logs Insights. Se ejecute una consulta de muestra en Logs Insights QL y, a continuación, verá cómo modificarla y volverla a ejecutar.
Para ejecutar una consulta, ya debe tener los registros almacenados en CloudWatch Logs. Si ya utiliza CloudWatch los registros y ha configurado grupos de registros y flujos de registros, está listo para empezar. También es posible que ya tenga registros si utiliza servicios como AWS CloudTrail Amazon Route 53 o Amazon VPC y ha configurado los registros de esos servicios para que vayan a CloudWatch Logs. Para obtener más información sobre el envío de CloudWatch registros a Logs, consulte[Cómo empezar con CloudWatch los registros](CWL_GettingStarted.md).
Las consultas en CloudWatch Logs Insights devuelven un conjunto de campos de eventos de registro o el resultado de una agregación matemática u otra operación realizada en los eventos de registro. Este tutorial muestra una consulta que devuelve una lista de eventos de registro.
## Ejecutar una consulta de muestra
**Para ejecutar una consulta de ejemplo CloudWatch de Logs Insights**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Registros** y, luego, **Información de registros**.
En la página **Información de registros**, el editor de consultas contiene una consulta predeterminada en Logs Insights QL que devuelve los 20 eventos de registro más recientes.
1. En el menú desplegable **Select log group(s)** (Seleccionar grupos de registro), elija uno o varios grupos de registro que va a consultar.
Si se trata de una cuenta de monitorización en CloudWatch condiciones de observación multicuenta, puede seleccionar grupos de registros en las cuentas de origen, así como en la cuenta de supervisión. Una sola consulta puede ejecutarse en registros de diferentes cuentas a la vez.
Puede filtrar los grupos de registro por nombre de grupo de registro, ID de cuenta o etiqueta de cuenta.
Al seleccionar un grupo de registros en la clase de registro estándar, CloudWatch Logs Insights detecta automáticamente los campos de datos del grupo. Para ver estos campos detectados, seleccione el menú **Fields** (Campos) cerca de la parte superior derecha de la página.
**nota**
Los campos detectados solo son compatibles con los grupos de registro de la clase de registro Estándar. Para obtener más información acerca de las clases de registros, consulte [Clases de registro](CloudWatch_Logs_Log_Classes.md).
1. (Opcional) Utilice el selector de tiempo para seleccionar el periodo de tiempo que desea consultar.
Puede elegir entre intervalos de 5 a 30 minutos; intervalos de 1, 3 y 12 horas; o un marco temporal personalizado.
1. Elija **Run** (Ejecutar) para ver los resultados.
En este tutorial, los resultados incluyen los 20 eventos de registro agregados más recientemente.
CloudWatch Logs muestra un gráfico de barras con los eventos de registro del grupo de registros a lo largo del tiempo. Este gráfico de barras muestra no solo los eventos de la tabla, sino también la distribución de eventos del grupo de registro que coincide con la consulta y el intervalo de tiempo.
1. Para ver todos los campos de un evento de registro devuelto, elija el icono desplegable triangular a la izquierda del evento numerado.
## Modificar la consulta de muestra
En este tutorial, debe modificar la consulta de muestra para mostrar los 50 eventos de registro más recientes.
Si aún no ha ejecutado el tutorial anterior, hágalo ahora. Este tutorial comienza donde finaliza el tutorial anterior.
**nota**
Algunas consultas de ejemplo que se proporcionan con CloudWatch Logs Insights utilizan `tail` comandos `head` o comandos en lugar de`limit`. Estos comandos están obsoletos y se han sustituido por `limit`. Utilice `limit` en lugar de `head` o `tail` en todas las consultas que escriba.
**Para modificar la consulta de ejemplo CloudWatch de Logs Insights**
1. En el editor de consultas, cambie **20** a **50** y, a continuación, elija **Ejecutar**.
Aparecen los resultados de la nueva consulta. Suponiendo que haya suficientes datos en el grupo de registro en el intervalo de tiempo predeterminado, ahora hay 50 eventos de registro en la lista.
1. (Opcional) Puede guardar las consultas que haya creado. Para guardar esta consulta, elija **Save (Guardar)**. Para obtener más información, consulte [Guarde y vuelva a ejecutar CloudWatch las consultas de Logs Insights](CWL_Insights-Saving-Queries.md).
## Agregar un comando de filtro a la consulta de muestra
En este tutorial se muestra cómo realizar un cambio más potente en la consulta en el editor de consultas. En este tutorial, se filtran los resultados de la consulta anterior en función de un campo de los eventos de registro recuperados.
Si aún no ha ejecutado los tutoriales anteriores, hágalo ahora. Este tutorial comienza donde finaliza el tutorial anterior.
**Para añadir un comando de filtro a la consulta anterior**
1. Decida un campo que filtrar. Para ver los campos más comunes que CloudWatch Logs ha detectado en los eventos de registro contenidos en los grupos de registros seleccionados en los últimos 15 minutos y el porcentaje de esos eventos de registro en los que aparece cada campo, seleccione **Campos** en la parte derecha de la página.
Para ver los campos contenidos en un evento de registro determinado, elija el icono que aparece a la izquierda de dicha fila.
El campo **awsRegion** podría aparecer en su evento de registro, en función de los eventos que se encuentren en sus registros. En el resto de este tutorial, utilizaremos **awsRegion** como campo de filtro, pero puede utilizar un campo diferente si ese campo no está disponible.
1. En el editor de consultas, coloque el cursor después de **50** y pulse Intro.
1. En la nueva línea, introduzca \$1 (la barra vertical) y un espacio. Los comandos de una consulta de CloudWatch Logs Insights deben estar separados por una barra vertical.
1. Escriba **filter awsRegion="us-east-1"**.
1. Seleccione **Ejecutar**.
La consulta se ejecuta de nuevo, y ahora muestra el 50 resultados más recientes que coinciden con el nuevo filtro.
Si filtra en otro campo diferente y recibe un resultado erróneo, es posible que sea necesario aplicar escape al nombre de campo. Si el nombre de campo incluye caracteres no alfanuméricos, debe volver a poner acentos graves (') antes y después del nombre de campo: por ejemplo, **`error-code`="102"**).
Debe utilizar los caracteres graves para los nombres de campo que contengan caracteres no alfanuméricos, pero no para los valores. Los valores siempre van entre comillas (“”).
Logs Insights QL incluye potentes capacidades de consulta, incluidos varios comandos y compatibilidad con expresiones regulares, operaciones matemáticas y operaciones estadísticas. Para obtener más información, consulte [CloudWatch Registra la sintaxis de consulta del lenguaje Insights](CWL_QuerySyntax.md).
# Tutorial: ejecutar una consulta con una función de agregación
Puede utilizar las funciones de agregación con el comando `stats` y como argumentos para otras funciones. En este tutorial, ejecuta un comando de consulta que cuenta el número de eventos de registro que contienen un campo especificado. El comando de consulta devuelve un recuento total agrupado según el valor o los valores del campo especificados. Para obtener más información sobre las funciones de agregación, consulte [Operaciones y funciones compatibles](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html#CWL_QuerySyntax-operations-functions) en la *Guía del usuario de Amazon CloudWatch Logs*.
**Para ejecutar una consulta con una función de agregación**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Registros** y, luego, **Información de registros**.
1. Confirme que esté seleccionada la pestaña **Logs Insights QL**.
1. En el menú desplegable **Select log group(s)** (Seleccionar grupos de registro), elija uno o varios grupos de registro que va a consultar.
Si se trata de una cuenta de monitorización en CloudWatch condiciones de observación multicuenta, puede seleccionar grupos de registros en las cuentas de origen, así como en la cuenta de supervisión. Una sola consulta puede ejecutarse en registros de diferentes cuentas a la vez.
Puede filtrar los grupos de registro por nombre de grupo de registro, ID de cuenta o etiqueta de cuenta.
Al seleccionar un grupo de CloudWatch registros, Logs Insights detecta automáticamente los campos de datos del grupo de registros si se trata de un grupo de registros de clase estándar. Para ver estos campos detectados, seleccione el menú **Fields** (Campos) cerca de la parte superior derecha de la página.
1. Elimine la consulta predeterminada en el editor de consultas e ingrese el siguiente comando:
```
stats count(*) by fieldName
```
1. *fieldName*Sustitúyalos por un campo descubierto del menú **Campos**.
El menú **Campos** se encuentra en la parte superior derecha de la página y muestra todos los campos detectados que CloudWatch Logs Insights detecta en su grupo de registros.
1. Elija **Run** (Ejecutar) para ver los resultados de la consulta.
Los resultados de la consulta muestran el número de registros del grupo de registro que coinciden con el comando de consulta y el recuento total agrupado según el valor o los valores del campo especificados.
# Tutorial: Ejecutar una consulta que produce una visualización agrupada por campos de registro
Si ejecuta una consulta que utiliza la función `stats` para agrupar los resultados devueltos según los valores de uno o varios campos de las entradas de registro, se pueden ver los resultados como un gráfico de barras, un gráfico circular, un gráfico de líneas o un gráfico de áreas apiladas. De este modo, podrá consultar de un modo más eficaz las tendencias de los registros.
**Para ejecutar una consulta para visualización**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs** (Registros) y, luego, **Logs Insights** (Registros de Insights).
1. En el menú desplegable **Select log group(s)** (Seleccionar grupos de registro), elija uno o varios grupos de registro que va a consultar.
Si se trata de una cuenta de monitorización en CloudWatch condiciones de observación multicuenta, puede seleccionar grupos de registros en las cuentas de origen, así como en la cuenta de supervisión. Una sola consulta puede ejecutarse en registros de diferentes cuentas a la vez.
Puede filtrar los grupos de registro por nombre de grupo de registro, ID de cuenta o etiqueta de cuenta.
1. En el editor de consultas, elimine el contenido actual y escriba la siguiente función `stats`. Después seleccione **Run query (Ejecutar consulta)**.
```
stats count(*) by @logStream
| limit 100
```
Los resultados muestran el número de eventos del grupo de registro por cada secuencia de registro. Los resultados tienen un límite de 100 filas.
1. Elija la pestaña **Visualization (Visualización)**.
1. Seleccione la flecha situada junto a **Line (Línea)** y, a continuación, elija **Bar (Barra)**.
Aparece el gráfico de barras, con una barra por cada secuencia de registro del grupo de registro.
# Tutorial: Ejecutar una consulta que produce una visualización de serie temporal
Cuando se ejecuta una consulta que utiliza la función `bin()` para agrupar los resultados devueltos por un periodo de tiempo, puede ver los resultados como un gráfico de líneas, un gráfico de áreas apiladas, un gráfico circular o un gráfico de barras. De este modo, podrá consultar de un modo más eficaz las tendencias de los eventos de registro a lo largo del tiempo.
**Para ejecutar una consulta para visualización**
1. Abra la CloudWatch consola en. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación, elija **Registros** y, luego, **Información de registros**.
1. Confirme que esté seleccionada la pestaña **Logs Insights QL**.
1. En el menú desplegable **Select log group(s)** (Seleccionar grupos de registro), elija uno o varios grupos de registro que va a consultar.
Si se trata de una cuenta de monitorización en CloudWatch condiciones de observación multicuenta, puede seleccionar grupos de registros en las cuentas de origen, así como en la cuenta de supervisión. Una sola consulta puede ejecutarse en registros de diferentes cuentas a la vez.
Puede filtrar los grupos de registro por nombre de grupo de registro, ID de cuenta o etiqueta de cuenta.
1. En el editor de consultas, elimine el contenido actual y escriba la siguiente función `stats`. Después seleccione **Run query (Ejecutar consulta)**.
```
stats count(*) by bin(30s)
```
Los resultados muestran el número de eventos de registro del grupo de CloudWatch registros recibidos por Logs durante cada período de 30 segundos.
1. Elija la pestaña **Visualization (Visualización)**.
Los resultados se muestran como un gráfico de líneas. Para cambiar a un gráfico de áreas apiladas o a un gráfico de barras, elija la flecha situada junto a **Line (Línea)** en la parte superior derecha del gráfico.
# Consultas de ejemplo
Esta sección contiene una lista de comandos de consulta generales y útiles que puede ejecutar en la [CloudWatchconsola](https://console.aws.amazon.com/cloudwatch/). Para obtener información sobre cómo ejecutar un comando de consulta, consulte el [Tutorial: Ejecutar y modificar una consulta de ejemplo](https://docs.aws.amazon.com/en_us/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_RunSampleQuery.html) en la *Guía del usuario de Amazon CloudWatch Logs*.
Para obtener más información sobre la sintaxis de la consulta, consulte [CloudWatch Registra la sintaxis de consulta del lenguaje Insights](CWL_QuerySyntax.md).
**Topics**
+ [Consultas generales](#CWL_QuerySyntax-examples-general)
+ [Consultas de registros de Lambda](#CWL_QuerySyntax-examples-Lambda)
+ [Consultas de registros de flujo de Amazon VPC](#CWL_QuerySyntax-examples-VPC)
+ [Consultas de registros de Route 53](#CWL_QuerySyntax-examples-Route53)
+ [Consultas de CloudTrail registros](#CWL_QuerySyntax-examples-CloudTrail)
+ [Consultas para Amazon API Gateway](#CWL_QuerySyntax-examples-APIGateway)
+ [Consultas para la puerta de enlace NAT](#CWL_QuerySyntax-examples-NATGateway)
+ [Consultas para registros del servidor Apache](#CWL_QuerySyntax-examples-Apache)
+ [Consultas para Amazon EventBridge](#CWL_QuerySyntax-examples-EventBridge)
+ [Ejemplos del comando para analizar](#CWL_QuerySyntax-examples-parse)
## Consultas generales
**Buscar los 25 eventos de registro agregados más recientes.**
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
**Obtener una lista del número de excepciones por hora.**
```
filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
```
**Obtener una lista de los eventos de registro que no son excepciones.**
```
fields @message | filter @message not like /Exception/
```
**Obtener el evento de registro más reciente para cada valor único del campo `server`.**
```
fields @timestamp, server, severity, message
| sort @timestamp asc
| dedup server
```
**Obtener el evento de registro más reciente para cada valor único del campo `server` para cada tipo `severity`.**
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server, severity
```
## Consultas de registros de Lambda
**Determinar la cantidad de memoria sobreaprovisionada.**
```
filter @type = "REPORT"
| stats max(@memorySize / 1000 / 1000) as provisonedMemoryMB,
min(@maxMemoryUsed / 1000 / 1000) as smallestMemoryRequestMB,
avg(@maxMemoryUsed / 1000 / 1000) as avgMemoryUsedMB,
max(@maxMemoryUsed / 1000 / 1000) as maxMemoryUsedMB,
provisonedMemoryMB - maxMemoryUsedMB as overProvisionedMB
```
**Crear un informe de latencia.**
```
filter @type = "REPORT" |
stats avg(@duration), max(@duration), min(@duration) by bin(5m)
```
**Buscar invocaciones de funciones lentas y eliminar las solicitudes duplicadas que puedan surgir de los reintentos o del código del lado del cliente. En esta consulta, `@duration` está en milisegundos.**
```
fields @timestamp, @requestId, @message, @logStream
| filter @type = "REPORT" and @duration > 1000
| sort @timestamp desc
| dedup @requestId
| limit 20
```
## Consultas de registros de flujo de Amazon VPC
**Buscar las 15 primeras transferencias de paquete en hosts:**
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
**Buscar las 15 primeras transferencias de bytes para los hosts de una subred determinada.**
```
filter isIpv4InSubnet(srcAddr, "192.0.2.0/24")
| stats sum(bytes) as bytesTransferred by dstAddr
| sort bytesTransferred desc
| limit 15
```
**Buscar las direcciones IP que utilizan UDP como protocolo de transferencia de datos.**
```
filter protocol=17 | stats count(*) by srcAddr
```
**Buscar las direcciones IP donde los registros de flujo se omitieron durante la ventana de captura.**
```
filter logStatus="SKIPDATA"
| stats count(*) by bin(1h) as t
| sort t
```
**Buscar un registro único para cada conexión, para ayudar a solucionar problemas de conectividad de red.**
```
fields @timestamp, srcAddr, dstAddr, srcPort, dstPort, protocol, bytes
| filter logStream = 'vpc-flow-logs' and interfaceId = 'eni-0123456789abcdef0'
| sort @timestamp desc
| dedup srcAddr, dstAddr, srcPort, dstPort, protocol
| limit 20
```
## Consultas de registros de Route 53
**Buscar la distribución de registros por hora por tipo de consulta.**
```
stats count(*) by queryType, bin(1h)
```
**Buscar los 10 solucionadores de DNS con el mayor número de solicitudes.**
```
stats count(*) as numRequests by resolverIp
| sort numRequests desc
| limit 10
```
**Buscar el número de registros por dominio y subdominio donde el servidor no pudo completar la solicitud de DNS.**
```
filter responseCode="SERVFAIL" | stats count(*) by queryName
```
## Consultas de CloudTrail registros
**Busque el número de entradas de registro para cada servicio, tipo de evento y AWS región.**
```
stats count(*) by eventSource, eventName, awsRegion
```
**Busque los hosts de Amazon EC2 que se iniciaron o se detuvieron en una región determinada AWS .**
```
filter (eventName="StartInstances" or eventName="StopInstances") and awsRegion="us-east-2"
```
**Busque las AWS regiones, los nombres de usuario y los usuarios ARNs de IAM recién creados.**
```
filter eventName="CreateUser"
| fields awsRegion, requestParameters.userName, responseElements.user.arn
```
**Buscar el número de registros en los que se ha producido una excepción al invocar a la API `UpdateTrail`.**
```
filter eventName="UpdateTrail" and ispresent(errorCode)
| stats count(*) by errorCode, errorMessage
```
**Buscar entradas de registro en las que se usó TLS 1.0 o 1.1**
```
filter tlsDetails.tlsVersion in [ "TLSv1", "TLSv1.1" ]
| stats count(*) as numOutdatedTlsCalls by userIdentity.accountId, recipientAccountId, eventSource, eventName, awsRegion, tlsDetails.tlsVersion, tlsDetails.cipherSuite, userAgent
| sort eventSource, eventName, awsRegion, tlsDetails.tlsVersion
```
**Buscar la cantidad de llamadas por servicio que usaron las versiones de TLS 1.0 o 1.1**
```
filter tlsDetails.tlsVersion in [ "TLSv1", "TLSv1.1" ]
| stats count(*) as numOutdatedTlsCalls by eventSource
| sort numOutdatedTlsCalls desc
```
## Consultas para Amazon API Gateway
Buscar los últimos 10 errores de 4XX
```
fields @timestamp, status, ip, path, httpMethod
| filter status>=400 and status<=499
| sort @timestamp desc
| limit 10
```
Identifique las 10 Amazon API Gateway solicitudes que llevan más tiempo ejecutándose en su grupo de registros de Amazon API Gateway acceso
```
fields @timestamp, status, ip, path, httpMethod, responseLatency
| sort responseLatency desc
| limit 10
```
Devolver la lista de las rutas de API más populares de su grupo de registro de acceso de Amazon API Gateway
```
stats count(*) as requestCount by path
| sort requestCount desc
| limit 10
```
Crear un informe de latencia de integración para su grupo de registro de acceso de Amazon API Gateway
```
filter status=200
| stats avg(integrationLatency), max(integrationLatency),
min(integrationLatency) by bin(1m)
```
## Consultas para la puerta de enlace NAT
Si observa costos más altos de lo normal en su AWS factura, puede usar CloudWatch Logs Insights para encontrar a los principales contribuyentes. Para obtener más información sobre los siguientes comandos de consulta, consulte [¿Cómo puedo encontrar los principales contribuyentes al tráfico a través de la puerta de enlace NAT en mi VPC?](https://aws.amazon.com/premiumsupport/knowledge-center/vpc-find-traffic-sources-nat-gateway/) en la página AWS de soporte premium.
**nota**
En los siguientes comandos de consulta, sustituya “x.x.x.x” por la IP privada de la puerta de enlace NAT y sustituya “y.y” por los dos primeros octetos del rango CIDR de la VPC.
**Buscar las instancias que envían más tráfico a través de su puerta de enlace de NAT**
```
filter (dstAddr like 'x.x.x.x' and srcAddr like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
**Determinar el tráfico de entrada y salida de las instancias de las puertas de enlace de NAT**
```
filter (dstAddr like 'x.x.x.x' and srcAddr like 'y.y.') or (srcAddr like 'xxx.xx.xx.xx' and dstAddr like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
**Determinar los destinos de Internet con los que las instancias de la VPC se comunican con mayor frecuencia para las cargas y descargas.**
*****Para cargas*****
```
filter (srcAddr like 'x.x.x.x' and dstAddr not like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
*****Para descargas*****
```
filter (dstAddr like 'x.x.x.x' and srcAddr not like 'y.y.')
| stats sum(bytes) as bytesTransferred by srcAddr, dstAddr
| sort bytesTransferred desc
| limit 10
```
## Consultas para registros del servidor Apache
Puede usar CloudWatch Logs Insights para consultar los registros del servidor Apache. Para obtener más información sobre las siguientes consultas, consulte [Simplificar los registros del servidor Apache con CloudWatch Logs Insights](https://aws.amazon.com/blogs/mt/simplifying-apache-server-logs-with-amazon-cloudwatch-logs-insights/) en el blog AWS Cloud Operations & Migrations.
**Buscar los campos más relevantes para que pueda revisar sus registros de acceso y comprobar si hay tráfico en la ruta */admin* de su aplicación**
```
fields @timestamp, remoteIP, request, status, filename| sort @timestamp desc
| filter filename="/var/www/html/admin"
| limit 20
```
**Buscar el número de solicitudes GET únicas que han accedido a su página principal con el código de estado “200” (correcta).**
```
fields @timestamp, remoteIP, method, status
| filter status="200" and referrer= http://34.250.27.141/ and method= "GET"
| stats count_distinct(remoteIP) as UniqueVisits
| limit 10
```
**Buscar el número de veces que se ha reiniciado el servicio Apache.**
```
fields @timestamp, function, process, message
| filter message like "resuming normal operations"
| sort @timestamp desc
| limit 20
```
## Consultas para Amazon EventBridge
Obtenga el número de EventBridge eventos agrupados por tipo de detalle del evento
```
fields @timestamp, @message
| stats count(*) as numberOfEvents by `detail-type`
| sort numberOfEvents desc
```
## Ejemplos del comando para analizar
**Utilice una expresión glob para extraer los campos `@user`, `@method` y `@latency` del campo de registro `@message` y devolver la latencia promedio para cada combinación única de `@method` y `@user`.**
```
parse @message "user=*, method:*, latency := *" as @user,
@method, @latency | stats avg(@latency) by @method,
@user
```
**Utilice una expresión regular para extraer los campos `@user2`, `@method2` y `@latency2` del campo de registro `@message` y devolver la latencia promedio para cada combinación única de `@method2` y `@user2`.**
```
parse @message /user=(?.*?), method:(?.*?),
latency := (?.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Extrae los campos `loggingTime`, `loggingType` y `loggingMessage`, filtra hasta los eventos de registro que contienen cadenas `ERROR` o `INFO` y, a continuación, muestra solo los campos `loggingMessage` y `loggingType` para los eventos que contienen una cadena `ERROR`.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# Comparación (diferencia) con intervalos de tiempo anteriores
Puede usar CloudWatch Logs Insights con Logs Insights QL para comparar los cambios en sus eventos de registro a lo largo del tiempo. Puede comparar los eventos de registro incorporados durante un intervalo de tiempo reciente con los registros del período inmediatamente anterior. Como alternativa, puede compararlos con períodos anteriores similares. Esto puede ayudarle a determinar si un error en sus registros se introdujo recientemente o si ya se estaba produciendo; también puede ayudarle a buscar otras tendencias.
Las consultas de comparación solo muestran patrones en los resultados y no eventos de registro sin procesar. Los patrones devueltos le ayudarán a detectar rápidamente las tendencias y los cambios en los eventos del registro a lo largo del tiempo. Tras realizar una consulta comparativa y obtener los resultados de los patrones, podrá ver ejemplos de eventos de registro sin procesar correspondientes a los patrones que le interesen. Para obtener más información sobre el uso de patrones de registro, consulte [Análisis del patrón](CWL_AnalyzeLogData_Patterns.md).
Cuando ejecute una consulta de comparación, esta se analiza en función de dos períodos de tiempo diferentes: el período de consulta original que seleccionó y el período de comparación. El período de comparación siempre tiene la misma duración que el período de consulta original. Los intervalos de tiempo predeterminados de las comparaciones son los siguientes.
+ **Período anterior**: se compara con el período inmediatamente anterior al período de consulta.
+ **Período anterior**: se compara con el período de un día anterior al período de consulta.
+ **Período anterior**: se compara con el período de una semana anterior al período de consulta.
+ **Período anterior**: se compara con el período de un mes anterior al período de consulta.
**nota**
Las consultas que utilizan comparaciones tienen un coste similar al de ejecutar una sola consulta de CloudWatch Logs Insights durante el intervalo de tiempo combinado. Para obtener más información, consulte [Precios de Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/).
**Ejecución de una consulta de comparación**
1. Abra la CloudWatch consola en. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación, elija **Registros** y luego, **Información de registros**.
Aparece una consulta predeterminada en el cuadro de consulta.
1. Confirme que esté seleccionada la pestaña **Logs Insights QL**.
1. Mantenga la consulta predeterminada o introduzca una consulta diferente.
1. En el menú desplegable **Seleccionar grupos de registro**, elija uno o varios grupos de registro que va a consultar.
1. (Opcional) Utilice el selector de tiempo para seleccionar el periodo de tiempo que desea consultar. La consulta predeterminada corresponde a la hora anterior del registro de datos.
1. En el selector de intervalos de tiempo, seleccione **Comparar**. A continuación, elija el período de tiempo anterior con el que desee comparar los registros originales y seleccione **Aplicar**.
1. Elija **Ejecutar consulta**.
Para que la consulta obtenga los datos del período de comparación, el comando `diff` se adjunta a la consulta.
1. Seleccione la pestaña **Patrones** para ver los resultados.
La tabla muestra la siguiente información:
+ Cada **Patrón**, con partes variables del patrón sustituidas por el símbolo dinámico del token ``. *string*Es una descripción del tipo de datos que representa el token. *number*Muestra en qué parte del patrón aparece este token, en comparación con los otros tokens dinámicos. Para obtener más información, consulte [Análisis del patrón](CWL_AnalyzeLogData_Patterns.md).
+ **Recuento de eventos** es el número de eventos de registro que tienen ese patrón en el período de tiempo original, más el período actual.
+ **Diferencia en el recuento de eventos** es la diferencia entre el número de eventos de registro coincidentes en el período de tiempo actual y el período de comparación. Una diferencia positiva significa que hay más eventos de este tipo en el período de tiempo actual.
+ **Descripción de la diferencia** resume brevemente el cambio en ese patrón entre el período de tiempo actual y el período de comparación.
+ **Tipo de gravedad** es la gravedad probable de los eventos de registro con este patrón, basada en las palabras que se encontraron en el registro de eventos, como `FATAL`, `ERROR` y `WARN`.
1. Para seguir analizando alguno de los patrones de la lista, elija el icono de la columna **Inspeccionar** correspondiente a uno de los patrones.
Aparecerá el panel **Inspección de patrones**, que muestra lo siguiente:
+ El **Patrón**. Seleccione un token dentro del patrón para analizar los valores de ese token.
+ Un histograma que muestra el número de veces que aparece el patrón en el intervalo de tiempo consultado. Esto puede ayudarle a identificar tendencias interesantes, como un aumento repentino de la aparición de un patrón.
+ La pestaña **Muestras de registro** muestra algunos de los eventos de registro que coinciden con el patrón seleccionado.
+ La pestaña **Valores del token** muestra los valores del token dinámico seleccionado, si es que seleccionó uno.
**nota**
Se captura un máximo de 10 valores de token por cada token. Es posible que los recuentos de fichas no sean precisos. CloudWatch Logs utiliza un contador probabilístico para generar el recuento de fichas, no el valor absoluto.
+ La pestaña **Patrones relacionados** muestra otros patrones que se han producido con frecuencia casi al mismo tiempo que el patrón que está analizando. Por ejemplo, si el patrón de un mensaje de `ERROR` solía ir acompañado de otro evento de registro marcado como `INFO` con detalles adicionales, ese patrón se muestra aquí.
# Visualización de los datos de registro en gráficos
Puede usar visualizaciones como gráficos de barras, gráficos de líneas y gráficos de áreas apiladas para identificar de manera más eficiente los patrones en sus datos de registro. CloudWatch Logs Insights genera visualizaciones para las consultas que utilizan la `stats` función y una o más funciones de agregación. Para obtener más información, consulte [stats](CWL_QuerySyntax-Stats.md).
# OpenSearch Lenguaje de procesamiento canalizado (PPL)
Esta sección contiene una introducción básica a la consulta de CloudWatch registros mediante PPL. OpenSearch Con el PPL se pueden recuperar, consultar y analizar datos mediante comandos que están canalizados juntos, lo que facilita la comprensión y la redacción de consultas complejas. Su sintaxis se basa en las canalizaciones de Unix y permite encadenar comandos para transformar y procesar datos. Con el PPL, se pueden filtrar y agregar datos, así como utilizar un amplio conjunto de funciones matemáticas, de cadenas, de fecha, condicionales y de otro tipo para el análisis.
Incluirlo `SOURCE` en una consulta de PPL es una forma útil de especificar los grupos de registros, los índices de campos y las fuentes de datos que se van a incluir en una consulta cuando se utiliza la API AWS CLI o la API para crear una consulta. El `SOURCE` comando solo se admite en la API AWS CLI and, no en la CloudWatch consola. Cuando utiliza la CloudWatch consola para iniciar una consulta, utiliza la interfaz de la consola para especificar los grupos de registros y el nombre y el tipo de la fuente de datos.
Se usa `aws:fieldIndex` para devolver solo datos indexados, mediante el forzado de una consulta a analizar solo los grupos de registros que están indexados en un campo que se especifique en la consulta. Los grupos de registros relevantes se seleccionan automáticamente en función de los campos especificados en el `filterIndex` comando. Esto reduce el volumen escaneado, ya que se omiten los grupos de registro que no tienen ningún evento de registro que contenga el campo especificado en la consulta y se escanean únicamente los grupos de registro que coincidan con el valor especificado en la consulta para este índice de campos. Se utiliza `aws:fieldIndex` para especificar el nombre del campo, junto con el nombre y el valor del campo en el comando source para consultar únicamente los datos indexados que contienen el campo y el valor especificados. Para obtener más información, consulte [Creación de índices de campo para mejorar el rendimiento de las consultas y reducir el volumen de análisis](CloudWatchLogs-Field-Indexing.md)
Puede usar el OpenSearch PPL para consultas de grupos de registros de la clase de registro estándar.
**nota**
Para obtener información sobre todos los comandos de consulta de OpenSearch PPL compatibles con CloudWatch los registros e información detallada sobre la sintaxis y las restricciones, consulte los [comandos de PPL compatibles](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-ppl.html) en la Guía para desarrolladores de OpenSearch servicios.
Para obtener información sobre otros lenguajes de consulta que puede utilizar, consulte [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), [OpenSearch Service SQL](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_SQL.html) y [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html)
| Comando o función | Consulta de ejemplo | Description (Descripción) |
| --- | --- | --- |
| campos | `fields field1, field2` | Muestra un conjunto de campos que necesitan ser proyectados. |
| unirse | `LEFT JOIN left=l, right=r on l.id = r.id `join_right_lg` \| fields l.field_1, r.field_2` | Une dos conjuntos de datos. |
| donde | `where field1="success" \| where field2 != "i-023fe0a90929d8822" \| fields field3, field4, field5,field6 \| head 1000` | Filtra los datos en función de las condiciones que especifique. |
| AWS: índice de campos | `source = [`aws:fieldIndex`="region", `region` = "us-west-2"] \| where status = 200 \| head 10` | Devuelve únicamente datos indexados, obligando a una consulta a analizar únicamente los grupos de registros que están indexados en un campo que usted especifique en la consulta. |
| stats | `stats count(), count(field1), min(field1), max(field1), avg(field1) by field2 \| head 1000` | Realiza agregaciones y cálculos. |
| parse | `parse field1 ".*/(?[^/]+$)" \| where field2 = "requestId" \| fields field1, field2 \| head 1000` | Extrae un patrón de expresión regular (regex) de una cadena y muestra el patrón extraído. El patrón extraído se puede utilizar además para crear nuevos campos o filtrar datos. |
| sort | `stats count(), count(field1), min(field1) as field1Alias, max(`field1`), avg(`field1`) by field2 \| sort -field1Alias \| head 1000` | Ordena los resultados mostrados por un nombre de campo. Use ordenar: FieldName para ordenar en orden descendente. |
| eval | `eval field2 = field1 * 2 \| fields field1, field2 \| head 20` | Modifica o procesa el valor de un campo y lo almacena en un campo diferente. Esto resulta útil para modificar matemáticamente una columna, aplicar funciones de cadena a una columna o aplicar funciones de fecha a una columna. |
| rename | `rename field2 as field1 \| fields field1;` | Cambia el nombre de uno o más campos del resultado de la búsqueda. |
| head | `fields `@message` \| head 20` | Limita los resultados de la consulta a las N primeras filas. |
| top | `top 2 field1 by field2` | Busca los valores más frecuentes de un campo. |
| dedup | `dedup field1 \| fields field1, field2, field3` | Elimina entradas duplicadas en función de los campos que especifique. |
| rare | `rare field1 by field2` | Busca los valores menos frecuentes de todos los campos de la lista de campos. |
| subquery | `where field_1 IN [ search source= `subquery_lg` \| fields field_2 ] \| fields id, field_1 ` | Realiza consultas anidadas y complejas en las instrucciones de PPL. |
| trendline | `trendline sma(2, field1) as field1Alias` | Calcula los promedios móviles de los campos. |
| eventStats | `eventstats sum(field1) by field2` | Enriquece los datos del evento con estadísticas resumidas calculadas. Analiza los campos específicos de sus eventos, calcula varias medidas estadísticas y, a continuación, agrega estos resultados a cada evento original como campos nuevos. |
| expandir | `eval tags_array_string = json_extract(`@message`, '$.tags')\| eval tags_array = json_array(json_extract(tags_string, '$[0]'), json_extract(tags_string, '$[1]'))\| expand tags_array as color_tags` | Divide un campo que contiene varios valores en filas independientes, creando una nueva fila para cada valor del campo especificado. |
| fillnull | `fields `@timestamp`, error_code, status_code \| fillnull using status_code = "UNKNOWN", error_code = "UNKNOWN"` | Rellena los campos nulos con el valor que proporcione. Se puede usar en uno o más campos. |
| flatten | `eval metadata_struct = json_object('size', json_extract(metadata_string, '$.size'), 'color', json_extract(metadata_string, '$.color')) \| flatten metadata_struct as (meta_size, meta_color) ` | Aplana un campo. El campo debe ser de este tipo: `struct` o `array>`. |
| cidrmatch | `where cidrmatch(ip, '2003:db8::/32') \| fields ip ` | Verifica si la dirección IP especificada está dentro del rango de CIDR dado. |
| fieldsummary | `where field1 != 200 \| fieldsummary includefields= field1 nulls=true` | Calcula las estadísticas básicas de cada campo (recuento, recuento distinto, mínimo, máximo, promedio, stddev y media). |
| grok | `grok email '.+@%{HOSTNAME:host}' \| fields email, host` | Analiza un campo de texto con un patrón grok y agrega los resultados al resultado de la búsqueda. |
| Funciones de cadena | `eval field1Len = LENGTH(field1) \| fields field1Len` | Funciones integradas en PPL que pueden manipular y transformar datos de texto y cadenas de texto dentro de las consultas de PPL. Por ejemplo, convertir mayúsculas y minúsculas, combinar cadenas, extraer partes y limpiar el texto. |
| Funciones de fecha y hora | `eval newDate = ADDDATE(DATE('2020-08-26'), 1) \| fields newDate ` | Funciones integradas para administrar y transformar los datos de fecha y hora en las consultas PPL. Por ejemplo, date\$1add, date\$1format, datediff, date-sub, timestampadd, timestampdiff, current\$1timezone, utc\$1timestamp y current\$1date. |
| Funciones de condiciones | `eval field2 = isnull(field1) \| fields field2, field1, field3` | Funciones integradas que verifican condiciones de campo específicas y evalúan las expresiones de forma condicional. Por ejemplo, si field1 es nulo, devuelve el field2. |
| Funciones matemáticas | `eval field2 = ACOS(field1) \| fields field1` | Funciones integradas para realizar cálculos matemáticos y transformaciones en consultas PPL. Por ejemplo, abs (valor absoluto), round (redondea números), sqrt (raíz cuadrada), pow (cálculo de potencia) y ceil (redondea al entero más cercano). |
| CryptoGraphic funciones | `eval crypto = MD5(field)\| head 1000` | Para calcular el hash de un campo determinado |
| Funciones JSON | `eval valid_json = json('[1,2,3,{"f1":1,"f2":[5,6]},4]') \| fields valid_json` | Funciones integradas para el manejo de JSON, incluidas las matrices, la extracción y la validación. Por ejemplo, json\$1object, json\$1array, to\$1json\$1string, json\$1array\$1length, json\$1extract, json\$1keys y json\$1valid. |
## Alcance de la consulta
Incluir SOURCE en una consulta es una forma útil de especificar los grupos de registros que se van a incluir en una consulta cuando se utiliza la API AWS CLI o para crear una consulta. El comando SOURCE solo se admite en la API AWS CLI and, no en la CloudWatch consola. Cuando utiliza la CloudWatch consola para iniciar una consulta, utiliza la interfaz de la consola para especificar los grupos de registros y el nombre y el tipo de la fuente de datos.
El comando source de PPL ahora admite varias formas de especificarlos:
1. Grupo de registro
1. Índices de campo: nuevos
1. Fuente y tipo de datos: nuevos
### Grupo de registros
La selección de fuentes de grupos de registros se puede utilizar cuando los clientes saben en qué grupos de registros exactos deben buscarse
```
source = [lg:`/aws/lambda/my-function`] | where status = 200 | head 10
```
### Índices de campo
La selección de fuentes basada en índices de campos reduce la cantidad de datos consultados al limitar los resultados solo a los datos indexados cuando filtra los campos de destino que se han indexado. Los grupos de registros relevantes se seleccionan automáticamente en función de los campos especificados en el comando. `filterIndex` Para obtener más información sobre los índices de campos y cómo crearlos, consulte [Crear índices de campos para mejorar el rendimiento de las consultas y reducir el volumen de digitalización](CloudWatchLogs-Field-Indexing.md).
Se usa `aws:fieldIndex` para devolver solo datos indexados, mediante el forzado de una consulta a analizar solo los grupos de registros que están indexados en un campo que se especifique en la consulta. Para los grupos de registros que están indexados en este campo, se optimiza aún más la consulta al omitir los grupos de registros que no tienen ningún evento de registro que contenga el campo especificado en la consulta del campo indexado. Se reduce aún más el volumen analizado al intentar analizar solo los eventos de registro de estos grupos de registros que coincidan con el valor especificado en la consulta para este índice de campos. Para obtener más información sobre los índices de campo y cómo crearlos, consulte Crear índices de campo para mejorar el rendimiento de las consultas y reducir el volumen de digitalización.
En PPL, `aws:fieldIndex` se usa para especificar qué pares de valores clave deben tratarse como índices. La sintaxis es la siguiente
```
source = [`aws:fieldIndex`="region", `region` = "us-west-2"] | where status = 200 | head 10
```
donde,
1. ``aws:fieldIndex`="region"`identifica la región como índice de campo.
1. Nota: En lugar de =, los clientes pueden usar IN para especificar varios índices (ejemplo siguiente)
1. ``region`="us-west-2"`identifica la condición de filtro que se va a aplicar
1. Nota: En lugar de =, los clientes pueden usar IN para especificar varios valores (ejemplo siguiente)
Los clientes pueden especificar varios índices de campos de la siguiente manera
```
source = [`aws:fieldIndex` IN ("status", "region"), `status` = 200, `region` IN ("us-west-2", "us-east-1")] | head 10
```
### Fuente y tipo de datos
La selección de fuentes basadas en fuentes y tipos de datos se puede utilizar cuando los clientes saben qué fuentes de datos exactas deben consultarse. Esta consulta se ejecuta en uno o más grupos de registros que contienen la fuente y el tipo de datos especificados.
```
source = [ds:`data_source.type`] | where status = 200 | head 10
```
#### PPL compatible para consultas de fuentes de datos
Para respaldar el caso de uso de la consulta de fuentes de datos en PPL, puede utilizar la cláusula de selección dinámica de fuentes. Con esta sintaxis, puede consultar las fuentes de datos especificándolas en el comando de búsqueda. Puede especificar hasta 10 fuentes de datos.
**Sintaxis**
```
source=[ds:`DataSource1.Type1`, ds:`DataSource2.Type2`, ...ds:`DataSourcen.Typen`]
```
**Consulta de ejemplo**
```
search source=[ds:`DataSource1.Type1`, ds:`DataSource2.Type2`] | fields field1, field2
```
### Ejemplo combinado
Los clientes pueden especificar todos los operadores de selección de fuentes en cualquier orden y el resultado sería la intersección de todas las condiciones aplicadas.
Por ejemplo,/aws/lambda/my-function-1 puede contener varios tipos y fuentes de datos, incluida una amplia variedad de índices. Cuando se ejecutó la siguiente consulta, los resultados devueltos solo tendrán eventos de origen y tipo DataSource 1.Type1 y que coincidan con el criterio de «estado» = 200.
```
search source=[
ds:`DataSource1.Type1`,
lg:`/aws/lambda/my-function-1`,
`aws:fieldIndex` IN ("status"), `status` = 200
]
```
## Restricciones
Cuando se utiliza OpenSearch PPL para realizar consultas en Logs Insights, se aplican las siguientes restricciones. CloudWatch
+ No puede usar comandos de unión o subconsulta con las consultas de fuentes de datos.
# OpenSearch Lenguaje de consulta estructurado (SQL)
Esta sección contiene una introducción básica a la consulta de CloudWatch registros mediante OpenSearch SQL. Ofrece una opción que es conocida si se está acostumbrado a trabajar con bases de datos relacionales. OpenSearch SQL ofrece un subconjunto de funciones de SQL, lo que lo convierte en una buena opción para realizar consultas ad hoc y tareas de análisis de datos. Con OpenSearch SQL, puede usar comandos como SELECT, FROM, WHERE, GROUP BY, HAVING y varios otros comandos y funciones de SQL. Puede ejecutar JOINs en grupos de registros, correlacionar datos entre grupos de registros mediante subconsultas y utilizar el amplio conjunto de funciones JSON, matemáticas, de cadenas, condicionales y otras funciones de SQL para realizar análisis eficaces de los datos de registro y de seguridad.
Se usa `filterIndex` para devolver solo datos indexados, mediante el forzado de una consulta a analizar solo los grupos de registros que están indexados en un campo que se especifique en la consulta. Reduzca el volumen escaneado omitiendo los grupos de registros que no tienen eventos de registro que contengan el campo especificado en la consulta y escaneando únicamente los grupos de registro que coincidan con el valor especificado en la consulta para este índice de campos. Se utiliza `filterIndex` para especificar el nombre del campo, junto con el nombre y el valor del campo para consultar únicamente los datos indexados que contienen el campo y el valor especificados.
Puede usar OpenSearch SQL para consultas de grupos de registros de la clase de registro estándar. SQL también admite consultas mediante el nombre y el tipo de fuente de datos.
**nota**
En la siguiente tabla se enumeran los comandos y funciones de SQL compatibles con CloudWatch los registros. Para obtener información sobre todos los comandos de OpenSearch SQL, incluida la sintaxis, consulte los [comandos de SQL compatibles](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/supported-directquery-sql.html) en la Guía para desarrolladores de OpenSearch servicios.
Para obtener información sobre otros lenguajes de consulta que puede utilizar, consulte [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), [OpenSearch Service PPL](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_PPL.html) y [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html).
## Comandos SQL compatibles
**nota**
En la columna de comandos de la consulta de muestra, reemplace `` según sea necesario en función del origen de datos que esté consultando.
| Comando o función | Consulta de ejemplo | Description (Descripción) |
| --- | --- | --- |
| SELECT | `SELECT `@message`, Operation FROM `LogGroupA`` | Muestra los valores proyectados. |
| FROM | `SELECT `@message`, Operation FROM `LogGroupA`` | Cláusula integrada que especifica las tablas o las vistas de origen desde las que se van a recuperar los datos y admite varios tipos de uniones y subconsultas. |
| WHERE | `SELECT * FROM `LogGroupA` WHERE Operation = 'x'` | Filtra los eventos del registro en función de los criterios de campo proporcionados. |
| filterIndex | `SELECT * FROM `filterIndex('region' = 'us-east-1')` WHERE status = 200 LIMIT 10;` | Devuelve únicamente datos indexados, obligando a la consulta a analizar únicamente los grupos de registros que están indexados en un campo que se especifique en la consulta. |
| GROUP BY | `SELECT `@logStream`, COUNT(*) as log_count FROM `LogGroupA` GROUP BY `@logStream`` | Los grupos registran los eventos según la categoría y encuentran el promedio en función de las estadísticas. |
| HAVING | `SELECT `@logStream`, COUNT(*) as log_count FROM `LogGroupA` GROUP BY `@logStream` HAVING log_count > 100` | Filtra los resultados en función de las condiciones de agrupación. |
| ORDER BY | `SELECT * FROM `LogGroupA` ORDER BY `@timestamp` DESC` | Ordena los resultados en función de los campos de la cláusula ORDER BY. Puede especificar un orden tanto ascendente como descendente. |
| JOIN | `SELECT A.`@message`, B.`@timestamp`FROM `LogGroupA` as A INNER JOIN `LogGroupB` as B ON A.`requestId` = B.`requestId`` | Une los resultados de dos tablas en función de los campos en común. Debe especificarse Inner JOIN o Left Outer Join |
| LIMIT | `Select * from `LogGroupA` limit 10` | Limita los resultados de la consulta a las N primeras filas. |
| Funciones de cadena | `SELECT upper(Operation) , lower(Operation), Operation FROM `LogGroupA`` | Funciones integradas en SQL que pueden manipular y transformar cadenas y datos de texto en consultas SQL. Por ejemplo, convertir mayúsculas y minúsculas, combinar cadenas, extraer partes y limpiar el texto. |
| Funciones de datos | `SELECT current_date() as today, date_add(current_date(), 30) as thirty_days_later, last_day(current_date()) as month_end FROM `LogGroupA`` | Funciones integradas para administrar y transformar los datos de fecha y hora en las consultas de SQL. Por ejemplo, date\$1add, date\$1format, datediff y current\$1date. |
| Funciones condicionales | `SELECT Operation, IF(Error > 0, 'High', 'Low') as error_category FROM `LogGroupA`;` | Funciones integradas que realizan acciones en función de condiciones específicas o que evalúan las expresiones de forma condicional. Por ejemplo, CASE e IF. |
| Funciones de agregación | `SELECT AVG(bytes) as bytesWritten FROM `LogGroupA`` | Funciones integradas que realizan cálculos en varias filas para generar un único valor resumido. Por ejemplo, SUM, COUNT, AVG, MAX y MIN. |
| Funciones JSON | `SELECT get_json_object(json_column, '$.name') as name FROM `LogGroupA`` | Funciones integradas para analizar, extraer, modificar y consultar datos con formato JSON en consultas SQL (por ejemplo, from\$1json, to\$1json, get\$1json\$1object, json\$1tuple) que permiten manipular las estructuras JSON en los conjuntos de datos. |
| Funciones de matriz | `SELECT scores, size(scores) as length, array_contains(scores, 90) as has_90 FROM `LogGroupA`;` | Funciones integradas para trabajar con columnas de tipo matriz en consultas SQL, lo que permite realizar operaciones como acceder, modificar y analizar los datos de la matriz (p. ej., size, explode, array\$1contains). |
| Funciones de ventana | `SELECT field1, field2, RANK() OVER (ORDER BY field2 DESC) as field2Rank FROM `LogGroupA`;` | Funciones integradas que realizan cálculos en un conjunto específico de filas relacionadas con la fila (ventana) actual, lo que permite realizar operaciones como la clasificación, los totales acumulados y los promedios móviles. Por ejemplo, ROW\$1NUMBER, RANK, LAG y LEAD |
| Funciones de conversión | `SELECT CAST('123' AS INT) as converted_number, CAST(123 AS STRING) as converted_string FROM `LogGroupA`` | Funciones integradas para convertir datos de un tipo a otro en las consultas SQL, lo que permite la transformación de los tipos de datos y las conversiones de formato. Por ejemplo, CAST, TO\$1DATE, TO\$1TIMESTAMP y BINARY. |
| Funciones de predicados | `SELECT scores, size(scores) as length, array_contains(scores, 90) as has_90 FROM `LogGroupA`;` | Funciones integradas que evalúan las condiciones y devuelven valores booleanos (verdadero/falso) en función de criterios o patrones específicos. Por ejemplo, IN, LIKE, BETWEEN, IS NULL y EXISTS. |
| Selección de varios grupos de registros | `SELECT lg1.field1, lg1.field2 from `logGroups( logGroupIdentifier: ['LogGroup1', 'LogGroup2'])` as lg1 where lg1.field3= "Success"` | Permite la especificación de varios grupos de registros en una sentencia SELECT |
| Seleccione varias fuentes de datos | `SELECT ds1.field1, ds1.field2 from `dataSource(['DataSource1', 'DataSource2'])` as ds1 where ds1.field3= "Success"` | Permite especificar varias fuentes de datos en una sentencia SELECT |
## SQL compatible para multi-log-group las consultas
Para respaldar el caso de uso de la consulta de varios grupos de registros en SQL, puede usar el comando `logGroups`. Con esta sintaxis, puede consultar varios grupos de registros al especificarlos en el comando FROM.
Sintaxis:
```
`logGroups(
logGroupIdentifier: ['LogGroup1','LogGroup2', ...'LogGroupn']
)
```
En esta sintaxis, puede especificar hasta 50 grupos de registros en el parámetro `logGroupIdentifier`. Para hacer referencia a los grupos de registros de una cuenta de supervisión, ARNs utilícelo en lugar de `LogGroup` nombres.
Consulta de ejemplo:
```
SELECT LG1.Column1, LG1.Column2 from `logGroups(
logGroupIdentifier: ['LogGroup1', 'LogGroup2']
)` as LG1 WHERE LG1.Column1 = 'ABC'
```
La siguiente sintaxis, que incluye varios grupos de registros después de la `FROM` sentencia, NO se admite al consultar CloudWatch los registros.
```
SELECT Column1, Column2 FROM 'LogGroup1', 'LogGroup2', ...'LogGroupn'
WHERE Column1 = 'ABC'
```
## SQL compatible para consultas de fuentes de datos
Para respaldar el caso de uso de la consulta de fuentes de datos en SQL, puede usar el comando DataSource. Con esta sintaxis, puede consultar las fuentes de datos especificándolas en el comando. `FROM` Puede especificar hasta 10 fuentes de datos.
**Sintaxis**
```
`dataSource(
['DataSource1', 'DataSource2', ...'DataSourcen']
)`
```
**Ejemplo de consulta**
```
SELECT DS1.Column1, DS1.Column2 from `dataSource(
['DataSource1', 'DataSource2']
)` as DS1 WHERE DS1.Column1 = 'ABC'
```
## Alcance de la consulta
En la API AWS CLI y, puede especificar qué registros consultar mediante el grupo de registros, la fuente y el tipo de datos y los índices de campo.
### Grupo de registros
La selección de fuentes de los grupos de registros se puede utilizar cuando los clientes saben en qué grupos de registros exactos deben buscarse
```
SELECT * FROM `logGroups(logGroupIdentifier: ['/aws/lambda/my-function'])`;
```
### Fuente y tipo de datos
Los clientes pueden consultar sus registros mediante el nombre y el tipo de fuente de datos.
La selección de fuentes basada en la fuente y el tipo de datos se puede utilizar cuando los clientes saben qué fuentes de datos exactas deben consultarse. Esta consulta se ejecuta en uno o más grupos de registros que contienen la fuente y el tipo de datos especificados.
Para respaldar el caso de uso de la consulta de fuentes de datos en SQL, puede usar el comando DataSource. Con esta sintaxis, puede consultar las fuentes de datos especificándolas en el comando FROM. Puede especificar hasta 10 fuentes de datos.
Sintaxis:
```
`dataSource(
['DataSource1.Type1', 'DataSource2.Type2', ...'DataSourcen.Typen']
)`
```
Consulta de ejemplo:
```
SELECT DS1.Column1, DS1.Column2 from `dataSource(
['DataSource1.Type1', 'DataSource2.Type2']
)` as DS1 WHERE DS1.Column1 = 'ABC'
```
Para obtener más información sobre las consultas por fuentes de datos, consulte[Utilice facetas para agrupar y explorar los registros](CloudWatchLogs-Facets.md).
### Ejemplo combinado
Los clientes pueden especificar todos los operadores de selección de fuentes dentro de las comillas invertidas en cualquier orden y los resultados se basarán en la intersección de todas las condiciones aplicadas.
Por ejemplo,/aws/lambda/my-function-1 puede contener varios tipos y fuentes de datos, incluidos una amplia variedad de índices. Cuando se ejecutó la siguiente consulta, los resultados devueltos solo incluirán eventos de origen y tipo DataSource 1.Type1 que coincidan con el criterio de «estado» = 200.
```
SELECT * FROM `
logGroups(logGroupIdentifier: ['/aws/lambda/my-function'])
filterIndex('status' = 200)
dataSource(['DataSource1.Type1'])
`;
```
### Índices de campo
La selección de fuentes basada en índices de campos identifica automáticamente los grupos de registros relevantes cuando los filtros se centran en los campos indexados, lo que reduce el volumen de digitalización y el tiempo de ejecución de las consultas.
Se usa `filterIndex` para devolver solo datos indexados, mediante el forzado de una consulta a analizar solo los grupos de registros que están indexados en un campo que se especifique en la consulta. Para los grupos de registros que están indexados en este campo, se optimiza aún más la consulta al omitir los grupos de registros que no tienen ningún evento de registro que contenga el campo especificado en la consulta del campo indexado. Se reduce aún más el volumen analizado al intentar analizar solo los eventos de registro de estos grupos de registros que coincidan con el valor especificado en la consulta para este índice de campos. Para obtener más información sobre los índices de campos y cómo crearlos, consulte [Crear índices de campos para mejorar el rendimiento de las consultas y reducir](CloudWatchLogs-Field-Indexing.md) el volumen de digitalización.
En SQL, FilterIndex se usa para especificar qué pares de valores clave deben tratarse como índices. La sintaxis es la siguiente
```
SELECT * FROM `filterIndex('region' = 'us-east-1')`;
```
donde,
1. FilterIndex (...) especifica y trata los valores clave que contienen como índices de campo. Cada par de valores clave está separado por una coma (ejemplo siguiente)
1. 'region' = 'us-east-1' especifica la condición real que debe aplicarse
1. Nota: En lugar de =, los clientes pueden usar IN para especificar varios valores (ejemplo siguiente)
El uso de varios FilterIndex combinaría las condiciones utilizando «AND». En el ejemplo, se consultarían los registros que coincidan con el estado = 200 y la región en us-east-1 o us-west-2.
```
SELECT * FROM `filterIndex('status' = 200, 'region' IN ['us-east-1', 'us-west-2'])`;
```
## Restricciones
Las siguientes restricciones se aplican cuando se utiliza SQL para realizar consultas en Logs Insights. OpenSearch CloudWatch
+ Solo se puede usar una JOIN en una sentencia SELECT.
+ No puede usar JOIN ni subconsultas con consultas de fuentes de datos.
+ Solo se admite un nivel de subconsultas anidadas.
+ No se admiten consultas de varias sentencias separadas por punto y coma (;).
+ No se admiten consultas que contengan nombres de campo idénticos pero que solo difieran en mayúsculas y minúsculas (como field1 y FIELD1).
Por ejemplo, no se admite la siguiente consulta.
```
Select AWSAccountId, AwsAccountId from LogGroup
```
Sin embargo, se admite la siguiente consulta porque el nombre del campo (`@logStream`) es idéntico en ambos grupos de registros:
```
Select a.`@logStream`, b.`@logStream` from Table A INNER Join Table B on a.id = b.id
```
+ Las funciones y expresiones deben funcionar con los nombres de los campos y formar parte de una sentencia SELECT con un grupo de registros especificado en la cláusula FROM.
Por ejemplo, no se admite esta consulta:
```
SELECT cos(10) FROM LogGroup
```
Se admite esta consulta:
```
SELECT cos(field1) FROM LogGroup
```
+ Cuando utilice comandos SQL o PPL, encierre determinados campos entre comillas invertidas para consultarlos correctamente. Las comillas simples son necesarias para los campos con caracteres especiales (no alfabéticos ni numéricos). Por ejemplo, incluya `@message`, `Operation.Export` y `Test::Field` entre acentos graves. No es necesario incluir los campos con nombres exclusivamente alfabéticos entre comillas simples.
Ejemplo de consulta con campos sencillos:
```
SELECT SessionToken, Operation, StartTime FROM `LogGroup-A`
LIMIT 1000;
```
Consulta similar con comillas invertidas agregadas:
```
SELECT `@SessionToken`, `@Operation`, `@StartTime` FROM `LogGroup-A` LIMIT 1000;
```
# Utilice un lenguaje natural para generar y actualizar las consultas de CloudWatch Logs Insights
CloudWatch Logs admite una función de consulta en lenguaje natural que le ayuda a generar y actualizar consultas para [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html), [OpenSearch Service PPL](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_PPL.html), [OpenSearch Service SQL](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_AnalyzeLogData_SQL.html) y [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html).
Con esta función, puede hacer preguntas sobre los datos de CloudWatch Logs que busca o describirlos en un lenguaje sencillo. La función de lenguaje natural genera una consulta basada en un mensaje que usted introduce y proporciona una line-by-line explicación de cómo funciona la consulta. También puede actualizar la consulta para investigar más a fondo los datos.
Según el entorno, puede introducir peticiones como “¿Cuáles son las 100 direcciones IP principales de origen por bytes transferidos?” y “Busque las 10 solicitudes de función de Lambda más lentas”.
**nota**
La característica de consulta en lenguaje natural es un servicio regional. En algunas regiones, esta característica realiza llamadas interregionales a regiones de Estados Unidos para procesar las solicitudes de consulta. Para obtener más información, consulte [Amazon CloudWatch amplía el soporte regional para el resumen de resultados de consultas en lenguaje natural y la generación de consultas](https://aws.amazon.com/about-aws/whats-new/2025/08/amazon-cloudwatch-region-support-query-result-summarization-query-generation/).
Para generar una consulta de CloudWatch Logs Insights con esta capacidad, abra el editor de consultas de CloudWatch Logs Insights, seleccione el grupo de registros que desee consultar y elija **Generar consulta**.
**importante**
Para utilizar la función de consulta en lenguaje natural, debe iniciar sesión con las políticas [CloudWatchLogsFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsFullAccess.html), [CloudWatchLogsReadOnlyAccess[AdministratorAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AdministratorAccess.html)](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchLogsReadOnlyAccess.html), o de [ReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html)IAM, o tener el `cloudwatch:GenerateQuery` permiso correspondiente.
## Consultas de ejemplo
Los ejemplos en esta sección describen cómo generar y actualizar consultas mediante la función de lenguaje natural.
**nota**
Para obtener más información sobre el editor de consultas y la sintaxis de CloudWatch Logs Insights, consulte [Sintaxis de consultas de CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html).
### Ejemplos: generar una consulta en lenguaje natural
Para generar una consulta en lenguaje natural, introduzca una petición y seleccione **Generar nueva consulta**. En estos ejemplos, se muestran las consultas que realizan una búsqueda básica.
**Petición**
A continuación, se muestra un ejemplo de una petición que indica la función de buscar las 10 invocaciones más lentas de la función de Lambda.
```
Find the 10 slowest requests
```
**Consultar**
La siguiente es la consulta que utiliza el lenguaje de consultas CloudWatch Logs Insights que la capacidad de lenguaje natural generó en función de la solicitud. Observe cómo se muestra la petición en un comentario antes de la consulta. Tras la consulta, puede leer una explicación que describe cómo funciona la consulta.
```
# Find the 10 slowest requests
fields @timestamp, @message, @duration
| sort @duration desc
| limit 10
# This query retrieves the timestamp, message and duration fields from the logs and sorts them in descending order by duration to find the 10 slowest requests.
```
**nota**
Para desactivar el aspecto de la petición y la explicación de cómo funciona la consulta, use el icono de engranaje del editor.
**Petición**
Para generar una consulta OpenSearch SQL, seleccione la pestaña OpenSearch SQL y, a continuación, abra el cuadro de diálogo del generador de consultas para introducir la solicitud en lenguaje natural. A continuación, se muestra un ejemplo de un mensaje que utiliza la función de lenguaje natural para generar una consulta OpenSearch SQL.
```
Give me the number of errors and exceptions per hour
```
**Consultar**
La siguiente es la consulta de SQL generada por esa petición, que se puede utilizar para encontrar el número de errores y excepciones agregados por hora:
```
SELECT DATE_FORMAT(`@timestamp`, 'yyyy-MM-dd HH') AS hour,
COUNT(*) AS error_count
FROM `/aws/lambda/CloudWatchOdysseyQueryGen`
WHERE `@message` LIKE '%error%'
OR `@message` LIKE '%exception%'
GROUP BY DATE_FORMAT(`@timestamp`, 'yyyy-MM-dd HH')
ORDER BY hour
```
**Petición**
Para generar una consulta OpenSearch PPL, seleccione la pestaña OpenSearch PPL y, a continuación, abra el cuadro de diálogo del generador de consultas para introducir la solicitud en lenguaje natural. A continuación, se muestra un ejemplo de un mensaje que utiliza la función de lenguaje natural para generar una consulta OpenSearch PPL.
```
Give me all unique exception messages
```
**Consultar**
La siguiente es la consulta de PPL generada por esa petición, que puede utilizar para buscar los mensajes de excepción únicos en sus registros:
```
dedup @message
| fields @message
```
### Ejemplo: actualizar una consulta en lenguaje natural
Puede actualizar una consulta al editar la petición inicial y, a continuación, seleccionar **Actualizar consulta**.
**Petición actualizada**
El siguiente ejemplo muestra una versión actualizada de la petición anterior. En lugar de una petición que busca las 10 invocaciones de funciones de Lambda más lentas, esta petición ahora indica la capacidad de buscar las 20 invocaciones de funciones de Lambda más lentas e incluye otra columna para eventos de registro adicionales.
```
Show top 20 slowest requests instead and display requestId as a column
```
**Consulta actualizada**
A continuación, se muestra un ejemplo de la consulta actualizada que utiliza el lenguaje de consultas CloudWatch Logs Insights. Observe cómo se muestra la petición actualizada en un comentario antes de la consulta actualizada. Tras la consulta, puede leer una explicación que describe cómo se actualizó la consulta original.
```
# Show top 20 slowest requests instead and display requestId as a column
fields @timestamp, @message, @requestId, @duration
| sort @duration desc
| limit 20
# This query modifies the original query by replacing the @message field with the @requestId field and changing the limit from 10 to 20 to return the top 20 log events by duration instead of the top 10.
```
## Desactivación del uso de los datos para mejorar el servicio
Los datos de la petición en lenguaje natural que proporciona para entrenar el modelo de IA y generar consultas relevantes se utilizan únicamente para proporcionar y mantener su servicio. Estos datos pueden usarse para mejorar la calidad de CloudWatch Logs Insights. La confianza y privacidad, como así también la seguridad de su contenido, son nuestra máxima prioridad. Para obtener más información, consulte [Condiciones del servicio de AWS](https://aws.amazon.com/service-terms/) y [Política de IA responsable de AWS](https://aws.amazon.com/machine-learning/responsible-ai/policy/).
Puede optar por que su contenido no se utilice para desarrollar o mejorar la calidad de las consultas en lenguaje natural mediante la creación de una política de exclusión de los servicios de IA. Para excluirse de la recopilación de datos para todas las funciones de CloudWatch Logs AI, incluida la capacidad de generación de consultas, debe crear una política de exclusión para CloudWatch Logs. Para obtener más información, consulte [Políticas de exclusión de servicios de IA](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html) en la *Guía del usuario de AWS Organizations *.
# Registros y campos detectados compatibles
CloudWatch Logs Insights admite diferentes tipos de registros. Por cada registro que se envía a un grupo de CloudWatch registros de clase estándar en Amazon Logs, CloudWatch Logs Insights genera automáticamente cinco campos del sistema:
+ `@message` contiene el evento de registro sin analizar ni procesar. Es el equivalente al `message` campo de [InputLogevent](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_InputLogEvent.html).
+ `@timestamp` contiene la marca temporal del evento incluida en el campo `timestamp` del evento de registro. Es el equivalente al `timestamp` campo de [InputLogevent](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_InputLogEvent.html).
+ `@ingestionTime`contiene la hora en que CloudWatch Logs recibió el evento de registro.
+ `@logStream` contiene el nombre del flujo de registros al que se añadió el evento de registro. Las transmisiones de registro agrupan los registros a través del mismo proceso que los generó.
+ `@log` es un identificador de grupo de registro con el formato `account-id:log-group-name`. Puede ser útil en consultas de varios grupos de registro para identificar a qué grupo de registro pertenece un evento determinado.
+ `@entity` contiene JSON aplanada relacionada con entidades para la característica [Telemetría relacionada con Explore](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ExploreRelated.html).
Por ejemplo, esta JSON puede representar una entidad.
```
{
"Entity": {
"KeyAttributes": {
"Type": "Service",
"Name": "PetClinic"
},
"Attributes": {
"PlatformType": "AWS::EC2",
"EC2.InstanceId": "i-1234567890123"
}
}
}
```
Para esta entidad, los campos del sistema extraídos serían los siguientes:
```
@entity.KeyAttributes.Type = Service
@entity.KeyAttributes.Name = PetClinic
@entity.Attributes.PlatformType = AWS::EC2
@entity.Attributes.EC2.InstanceId = i-1234567890123
```
**nota**
La detección de campos solo se admite para los grupos de registro de la clase de registro Estándar. Para obtener más información acerca de las clases de registros, consulte [Clases de registro](CloudWatch_Logs_Log_Classes.md).
CloudWatch Logs Insights inserta el símbolo **@** al principio de los campos que genera.
En muchos tipos de CloudWatch registros, Logs también descubre automáticamente los campos de registro contenidos en los registros. Estos campos de detección automática se muestran en la siguiente tabla.
Para otros tipos de registros con campos que CloudWatch Logs Insights no descubre automáticamente, puede usar el `parse` comando para extraer y crear campos extraídos para usarlos en esa consulta. Para obtener más información, consulte [CloudWatch Registra la sintaxis de consulta del lenguaje Insights](CWL_QuerySyntax.md).
Si el nombre de un campo de registro descubierto comienza por el `@` carácter, CloudWatch Logs Insights lo muestra con un `@` elemento adicional añadido al principio. Por ejemplo, si un nombre de campo de registro es `@example.com`, este nombre de campo se muestra como `@@example.com`.
**nota**
Excepto en el caso de `@message`, `@timestamp` o `@log`, se pueden crear índices de campos para los campos descubiertos. Para obtener más información sobre los índices de campo, consulte [Creación de índices de campo para mejorar el rendimiento de las consultas y reducir el volumen de análisis](CloudWatchLogs-Field-Indexing.md).
| Tipo de registro | Campos de registro detectados |
| --- | --- |
| Registros de flujo de Amazon VPC | `@timestamp`, `@logStream`, `@message`, `accountId`, `endTime`, `interfaceId`, `logStatus`, `startTime`, `version`, `action`, `bytes`, `dstAddr`, `dstPort`, `packets`, `protocol`, `srcAddr`, `srcPort` |
| Registros de Route 53 | `@timestamp`, `@logStream`, `@message`, `edgeLocation`, `ednsClientSubnet`, `hostZoneId`, `protocol`, `queryName`, `queryTimestamp`, `queryType`, `resolverIp`, `responseCode`, `version` |
| Registros de Lambda | `@timestamp`, `@logStream`, `@message`, `@requestId`, `@duration, ``@billedDuration`, `@type`, `@maxMemoryUsed`, `@memorySize` Si una línea de registro de Lambda contiene un ID de seguimiento de X-Ray, también incluye los siguientes campos: `@xrayTraceId` y `@xraySegmentId`. CloudWatch Logs Insights descubre automáticamente los campos de registro en los registros Lambda, pero solo para el primer fragmento de JSON incrustado en cada evento de registro. Si un evento de registro de Lambda contiene varios fragmentos JSON, puede analizar y extraer los campos de registro con el comando `parse`. Para obtener más información, consulte [Campos de registros JSON](#CWL_AnalyzeLogData-discoverable-JSON-logs). |
| CloudTrail registros Registros en formato JSON | Para obtener más información, consulte [Campos de registros JSON](#CWL_AnalyzeLogData-discoverable-JSON-logs). |
| Otros tipos de registros | `@timestamp`, `@ingestionTime`, `@logStream`, `@message`, `@log`. |
## Campos de registros JSON
Con CloudWatch Logs Insights, se utiliza la notación de puntos para representar los campos JSON. Esta sección contiene un ejemplo de evento JSON y fragmento de código que muestra cómo acceder a los campos JSON mediante la notación de puntos.
**Ejemplo de evento JSON**
```
{
"eventVersion": "1.0",
"userIdentity": {
"type": "IAMUser",
"principalId": "EX_PRINCIPAL_ID",
"arn": "arn: aws: iam: : 123456789012: user/Alice",
"accessKeyId": "EXAMPLE_KEY_ID",
"accountId": "123456789012",
"userName": "Alice"
},
"eventTime": "2014-03-06T21: 22: 54Z",
"eventSource": "ec2.amazonaws.com",
"eventName": "StartInstances",
"awsRegion": "us-east-2",
"sourceIPAddress": "192.0.2.255",
"userAgent": "ec2-api-tools1.6.12.2",
"requestParameters": {
"instancesSet": {
"items": [
{
"instanceId": "i-abcde123"
}
]
}
},
"responseElements": {
"instancesSet": {
"items": [
{
"instanceId": "i-abcde123",
"currentState": {
"code": 0,
"name": "pending"
},
"previousState": {
"code": 80,
"name": "stopped"
}
}
]
}
}
}
```
El evento JSON de ejemplo contiene un objeto denominado `userIdentity`. `userIdentity`contiene un campo que se llama `type`. Para representar el valor de `type` usando una notación de puntos, use `userIdentity.type`.
El evento JSON de ejemplo contiene matrices que se aplanan en listas de nombres y valores de campo anidados. Para representar el valor de `instanceId` para el primer elemento de `requestParameters.instancesSet`, utilice `requestParameters.instancesSet.items.0.instanceId`. El número `0` que se coloca antes del campo `instanceID` hace referencia a la posición de los valores para el campo `items`. El siguiente ejemplo contiene un fragmento de código que muestra cómo puede acceder a los campos JSON anidados en un evento de registro JSON.
**Ejemplo: consulta**
```
fields @timestamp, @message
| filter requestParameters.instancesSet.items.0.instanceId="i-abcde123"
| sort @timestamp desc
```
El fragmento de código muestra una consulta que utiliza la notación de puntos con el comando `filter` para acceder al valor del campo JSON anidado `instanceId`. La consulta se filtra en los mensajes donde el valor de `instanceId` es igual a `"i-abcde123"` y devuelve todos los eventos de registro que contienen el valor especificado.
**nota**
CloudWatch Logs Insights puede extraer un máximo de 200 campos de eventos de registro de un registro JSON. Para campos adicionales que no se extraen, puede utilizar el comando `parse` para extraer estos campos desde el evento de registro sin analizar en el campo de mensaje. Para obtener más información sobre el `parse` comando, consulte [Sintaxis de consultas](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html) en la Guía del CloudWatch usuario de Amazon.
# Creación de índices de campo para mejorar el rendimiento de las consultas y reducir el volumen de análisis
Se pueden crear *índices de campo* de los campos de los eventos de registro para realizar búsquedas eficientes y basadas en la igualdad. Cuando, a continuación, utilizas un índice de campos en una consulta de CloudWatch Logs Insights, la consulta intenta omitir el procesamiento de los eventos de registro que se sabe que no incluyen el campo indexado. Esto reduce el volumen de análisis de las consultas que emplean índices de campo, lo que permite devolver resultados con mayor rapidez. Esto puede ayudar a buscar rápidamente petabytes del total de registros en miles de grupos de registros y a centrarse más rápidamente en los registros pertinentes. Los campos adecuados para indexar son aquellos que se necesitan consultar con frecuencia. Los campos que tienen una alta cardinalidad de valores también son buenos candidatos para los índices de campo, ya que una consulta que utilice estos índices de campo se completará más rápido, dado que limita los eventos de registro que coinciden con el valor objetivo.
Supongamos que se ha creado un índice de campo para `requestId`. Luego, cualquier consulta de CloudWatch Logs Insights sobre ese grupo de registros que incluya `requestId = value` o `requestId IN [value, value, ...]` intente procesar solo los eventos de registro que se sabe que contienen ese campo indexado y el valor consultado, y que CloudWatch Logs haya detectado un valor para ese campo en el pasado.
También se pueden aprovechar los índices de campos para crear consultas eficientes de un mayor número de grupos de registros. Si utiliza el comando `filterIndex` en la consulta en lugar del comando `filter`, la consulta se ejecutará en grupos de registros seleccionados en los eventos de registro que tengan índices de campo. Estas consultas pueden analizar hasta 10 000 grupos de registros, que se eligen al especificar hasta cinco prefijos de nombre de grupos de registros. Si se trata de una cuenta de monitorización mediante la observación CloudWatch multicuenta, puede elegir todas las cuentas de origen o especificar cuentas de origen individuales para seleccionar los grupos de registros».
Los campos indexados distinguen entre mayúsculas y minúsculas. Por ejemplo, un índice de campo de `RequestId` no coincidirá con un evento de registro que contenga `requestId`.
Los índices de campos solo se admiten para los formatos de registro estructurado de JSON y los registros de servicio.
CloudWatch Los registros proporcionan índices de campo predeterminados para todos los grupos de registros de la clase de registros estándar. Los índices de campo predeterminados están disponibles automáticamente para los siguientes campos:
+ `@logStream`
+ `@aws.region`
+ `@aws.account`
+ `@source.log`
+ `@data_source_name`
+ `@data_source_type`
+ `@data_format`
+ `traceId`
+ `severityText`
+ `attributes.session.id`
CloudWatch Los registros también proporcionan índices de campo predeterminados para determinadas combinaciones de nombres y tipos de fuentes de datos. Los índices de campo predeterminados están disponibles automáticamente para las siguientes combinaciones de nombre y tipo de fuente de datos:
| Nombre y tipo de fuente de datos | Índices de campo predeterminados |
| --- | --- |
| `amazon_vpc.flow` | `action` `logStatus` `region` `flowDirection` `type` |
| `amazon_route53.resolver_query` | `query_type` `transport` `rcode` |
| `aws_waf.access` | `action` `httpRequest.country` |
| `aws_cloudtrail.data` ` aws_cloudtrail.management` | `eventSource` `eventName` `awsRegion` `userAgent` `errorCode` `eventType` `managementEvent` `readOnly` `eventCategory` `requestId` |
Los índices de campos predeterminados se suman a cualquier índice de campo personalizado que defina en su política. Los índices de campo predeterminados no se incluyen en la [cuota de índices de campo](CloudWatchLogs-Field-Indexing-Syntax.md).
CloudWatch Los registros indexan solo los eventos de registro ingeridos después de crear una política de indexación. No indexa los eventos de registro ingeridos antes de que se creara la política. Tras crear un índice de campos, cada evento de registro coincidente permanece indexado durante 30 días a partir del momento de la ingesta del evento de registro.
**nota**
Si se crea una política de indexación de campos en una cuenta de supervisión, esa política no se utilizará para los grupos de registros de las cuentas de origen vinculadas. Una política de índice de campos solo se aplica a la cuenta en la que se creó.
En el resto de los temas de esta sección se explica cómo crear índices de campo. Para obtener información sobre cómo hacer referencia a los índices de campo en las consultas, consulte [filterIndex](CWL_QuerySyntax-FilterIndex.md) y [filter](CWL_QuerySyntax-Filter.md).
**Topics**
+ [Sintaxis y cuotas del índice de campos](CloudWatchLogs-Field-Indexing-Syntax.md)
+ [Creación de una política de indexación de campos a nivel de cuenta](CloudWatchLogs-Field-Indexing-CreateAccountLevel.md)
+ [Creación de una política de indexación de campos a nivel de grupo de registros](CloudWatchLogs-Field-Indexing-CreateLogGroupLevel.md)
+ [Selección de grupos de registros al crear una consulta](Field-Indexing-Selection.md)
+ [Efectos de eliminar una política de indexación de campos](CloudWatchLogs-Field-Indexing-Deletion.md)
# Sintaxis y cuotas del índice de campos
Los índices de campos se crean mediante la creación de *políticas de índices de campos*. Se pueden crear políticas de indexación de cuenta que se apliquen a toda la cuenta y también se pueden crear políticas que se apliquen solo a un grupo de registros. Para las políticas de indexación para toda la cuenta, se puede tener una que se aplique a todos los grupos de registro de la cuenta. También se pueden crear políticas de indexación de cuenta que se apliquen a un subconjunto de grupos de registros de la cuenta, seleccionados por los prefijos de sus nombres de grupos de registro. Si se tienen varias políticas a nivel de cuenta en la misma cuenta, los prefijos de los nombres de los grupos de registros de estas políticas no pueden superponerse. Del mismo modo, puede crear políticas de indexación a nivel de cuenta que se apliquen a una combinación de nombre y tipo de fuente de datos específica. Solo se puede crear una política de cuenta por combinación de nombre y tipo de fuente de datos.
Las políticas de indexación de campos a nivel de grupo de registros anulan las políticas de índice de campos a nivel de cuenta, que se aplican al grupo de registros en su conjunto (por ejemplo, las políticas a nivel de cuenta sin criterios de selección o con criterios de selección basados en el prefijo del nombre del grupo de registros). Las políticas a nivel de cuenta que coincidan a nivel de eventos de registro (por ejemplo, para una combinación de nombre y tipo de fuente de datos determinada) se aplicarán además de las políticas que coincidan con el grupo de registro en su conjunto. Si crea una política de índice a nivel de grupo de registros, ese grupo de registros no utilizará políticas a nivel de cuenta que coincidan a nivel de grupo de registros.
Las coincidencias de los eventos de registro con los nombres de los índices de campo distinguen mayúsculas de minúsculas. Por ejemplo, un índice de campo de `RequestId` no coincidirá con un evento de registro que contenga `requestId`.
Puede tener hasta 40 políticas de indexación a nivel de cuenta, de las cuales 20 pueden usar criterios de selección de prefijos de nombres de grupos de registros y 20 pueden usar criterios de selección basados en la fuente de datos. Si se tienen varias políticas de indexación a nivel de cuenta filtradas para incluir prefijos de nombres de grupos de registros, ninguna de ellas podrá utilizar prefijos de nombres de grupos de registros iguales o superpuestos. Por ejemplo, si se tiene una política filtrada para registrar los grupos que comienzan por `my-log`, no se puede tener otra política de indexación de campos filtrada a `my-logpprod` o `my-logging`. Del mismo modo, si tiene varias políticas de indexación a nivel de cuenta filtradas por combinaciones de nombre y tipo de fuente de datos, ninguna de ellas podrá utilizar el mismo nombre y tipo de fuente de datos. Por ejemplo, si tiene una política filtrada por el nombre `amazon_vpc` y el tipo de fuente de datos, no `flow` podrá crear otra política con esta combinación.
Si tiene una política de indexación a nivel de cuenta que no tiene prefijos de nombre y se aplica a todos los grupos de registros, no se puede crear ninguna otra política de indexación a nivel de cuenta con filtros de prefijos de nombres de grupos de registros; puede crear políticas de índice a nivel de cuenta que utilicen filtros de nombre y tipo de fuente de datos.
Cada política de indexación dispone de las siguientes cuotas y restricciones:
+ Se pueden incluir hasta 20 campos en la política.
+ Cada nombre de campo puede incluir hasta 100 caracteres.
+ Para crear un índice de un campo personalizado en sus grupos de registros que comience por `@`, se debe especificar el campo con un `@` extra al principio del nombre del campo. Por ejemplo, si los eventos de registro incluyen un campo denominado `@userId`, se debe especificar `@@userId` a fin de crear un índice para este campo.
En el caso de las políticas de indexación a nivel de cuenta con criterios de selección basados en el nombre y el tipo de la fuente de datos, se aplica una restricción adicional: todos los campos deben ser tipos de datos primitivos; las primitivas anidadas solo se admiten para las estructuras.
**Campos generados y campos reservados**
CloudWatch Logs Insights genera automáticamente los campos del sistema en cada evento de registro. Estos campos generados llevan el prefijo `@`. Si se desea obtener más información sobre los campos generados, consulte [Registros y campos detectados compatibles](CWL_AnalyzeLogData-discoverable-fields.md).
De estos campos generados, se admiten los siguientes para su uso como índices de campos:
+ `@logStream`
+ `@ingestionTime`
+ `@requestId`
+ `@type`
+ `@initDuration`
+ `@duration`
+ `@billedDuration`
+ `@memorySize`
+ `@maxMemoryUsed`
+ `@xrayTraceId`
+ `@xraySegmentId`
Para indexar estos campos generados, no es necesario añadir un `@` extra cuando se los especifica, como ocurre con los campos personalizados que comienzan por `@`. Por ejemplo, para crear un índice de campos `@logStream`, basta con especificar `@logStream` como índice de campo.
CloudWatch Logs proporciona índices de campos predeterminados para todos los grupos de registros de la clase de registro estándar. Los índices de campo predeterminados están disponibles automáticamente para los siguientes campos:
+ `@logStream`
+ `@aws.region`
+ `@aws.account`
+ `@source.log`
+ `@data_source_name`
+ `@data_source_type`
+ `@data_format`
+ `traceId`
+ `severityText`
+ `attributes.session.id`
CloudWatch Los registros también proporcionan índices de campo predeterminados para determinadas combinaciones de nombres y tipos de fuentes de datos. Los índices de campo predeterminados están disponibles automáticamente para las siguientes combinaciones de nombre y tipo de fuente de datos:
| Nombre y tipo de fuente de datos | Índices de campo predeterminados |
| --- | --- |
| `amazon_vpc.flow` | `action` `logStatus` `region` `flowDirection` `type` |
| `amazon_route53.resolver_query` | `query_type` `transport` `rcode` |
| `aws_waf.access` | `action` `httpRequest.country` |
| `aws_cloudtrail.data` ` aws_cloudtrail.management` | `eventSource` `eventName` `awsRegion` `userAgent` `errorCode` `eventType` `managementEvent` `readOnly` `eventCategory` `requestId` |
Los índices de campos predeterminados se suman a cualquier índice de campo personalizado que defina en su política. Los índices de campo predeterminados no se incluyen en la [cuota de índices de campo](#CloudWatchLogs-Field-Indexing-Syntax).
**Campos secundarios y campos de matriz en los registros JSON**
Se pueden indexar campos que sean secundarios anidados o campos de matriz en los registros JSON.
Por ejemplo, se puede crear un índice del campo `accessKeyId` secundario dentro del campo `userIdentity` de este registro:
```
{
"eventVersion": "1.0",
"userIdentity": {
"type": "IAMUser",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn: aws: iam: : 123456789012: user/Alice",
"accessKeyId": "11112222",
"accountId": "123456789012",
"userName": "Alice"
},
"eventTime": "2014-03-06T21: 22: 54Z",
"eventSource": "ec2.amazonaws.com",
"eventName": "StartInstances",
"awsRegion": "us-east-2",
"sourceIPAddress": "192.0.2.255",
"userAgent": "ec2-api-tools1.6.12.2",
"requestParameters": {
"instancesSet": {
"items": [{
"instanceId": "i-abcde123",
"currentState": {
"code": 0,
"name": "pending"
},
"previousState": {
"code": 80,
"name": "stopped"
}
}]
}
}
}
```
Si se desea crear este campo, utilice la notación de puntos (`userIdentity.accessKeyId`) tanto al crear el índice de campos como al especificarlo en una consulta. La consulta tendría el siguiente aspecto:
```
fields @timestamp, @message
| filterIndex userIdentity.accessKeyId = "11112222"
```
En el caso del ejemplo anterior, el campo `instanceId` está en una matriz dentro de `requestParameters.instancesSet.items`. Para representar este campo tanto al crear el índice de campos como al realizar consultas, consúltelo como `requestParameters.instancesSet.items.0.instanceId`. El 0 se refiere a la posición de ese campo en la matriz.
Por lo tanto, una consulta para este campo podría ser la siguiente:
```
fields @timestamp, @message
| filterIndex requestParameters.instancesSet.items.0.instanceId="i-abcde123"
```
# Creación de una política de indexación de campos a nivel de cuenta
Se utilizan los pasos de esta sección para crear una política de indexación de campos que se aplique a todos los grupos de registros de la cuenta o a varios grupos de registros que tengan nombres de grupos de registros que comiencen por la misma cadena.
**Creación de una política de indexación de campos a nivel de cuenta**
1. Abra la CloudWatch consola en. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación izquierdo, elija **Configuración** y, a continuación, la pestaña **Registros**.
1. En la sección **Políticas de indexación a nivel de cuenta**, seleccione **Administrar**.
1. Elija **Crear política de índice**.
1. En **Nombre de la política**, introduzca un nombre para la nueva política.
1. En **Seleccione el ámbito de la política**, realice una de las siguientes acciones:
+ Seleccione **Todos los grupos de registros estándar** para que la política de indexación se aplique a todos los grupos de registros de clase Estándar de la cuenta.
+ Elija **Grupos de registros por coincidencia de prefijos** para aplicar la política a un subconjunto de grupos de registros que tengan todos nombres que comiencen por la misma cadena. A continuación, introduzca el prefijo de estos grupos de registros en **Introduzca un nombre de prefijo**.
Después de introducir el prefijo, puede elegir **Vista previa de los grupos de registros coincidentes con los prefijos** para confirmar que el prefijo coincide con los grupos de registros que esperaba.
Elija **Registrar datos por fuente de datos** para aplicar la política a una combinación de nombre y tipo de fuente de datos específica. A continuación, puede seleccionar la **fuente de datos** **y el tipo** de datos en el menú desplegable.
Tras seleccionar el nombre y el tipo de la fuente de datos, puede seleccionar **Obtener campos** para rellenar la sección **Configurar índices y facetas de los campos** con información relevante, como los campos disponibles, los grupos de registros incluidos y los índices de campos predeterminados y personalizados.
1. En el caso de **Configuración de un campo de indexación personalizado**, elija **Agregación de ruta de campo** para introducir el primer campo que se va a indexar.
A continuación, introduzca la cadena que desee utilizar como valor del nombre del campo o seleccione un campo en el menú desplegable. Debe coincidir exactamente con las mayúsculas y minúsculas que aparecen en los eventos de registro. Por ejemplo, si sus eventos de registro incluyen `requestId`, se debe ingresar `requestId` aquí. `RequestId`, `requestID` y `request Id` no coincidirían.
Si se desea indexar un campo de registro personalizado que comience por el carácter `@`, se debe incluir un carácter `@` adicional al introducir la cadena de índice. Por ejemplo, si se tiene un campo de registro personalizado `@emailname`, se debe introducir `@@emailname` en el cuadro **Agregar ruta de campo**.
También puede crear índices para los `@logStream` campos `@ingestionTime` y que CloudWatch Logs genera automáticamente. Si lo hace, no tiene que añadir un `@` extra al especificarlos.
1. (Opcional) Además de especificar la ruta del campo, puede seleccionar **Establecer como una faceta** para crear el campo como una faceta.
1. Repita el paso anterior para agregar hasta 20 índices de campo.
1. Cuando haya terminado, seleccione **Create (Crear)**.
# Creación de una política de indexación de campos a nivel de grupo de registros
Se deben seguir los pasos de esta sección para crear una política de indexación de campos que se aplique a un único grupo de registros.
**Creación de una política de indexación de campos a nivel de grupo de registros**
1. Abra la CloudWatch consola en. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación izquierdo, elija **Logs (Registros)**, **Log groups (Grupos de registros)**.
1. Elija el nombre del grupo de registro.
1. Seleccione la pestaña **Índices de campo**.
1. Elija **Administración de índices de campos para este grupo de registros**
1. En **Administración de índices de campos a nivel de grupo de registros**, elija **Agregación de ruta de campo** para introducir el primer campo que se va a indexar.
A continuación, introduzca la cadena que desee utilizar como valor del nombre del campo. Debe coincidir exactamente con las mayúsculas y minúsculas que aparecen en los eventos de registro. Por ejemplo, si sus eventos de registro incluyen `requestId`, se debe ingresar `requestId` aquí. `RequestId`, `requestID` y `request Id` no coincidirían.
Si se desea indexar un campo de registro personalizado que comience por el carácter `@`, se debe incluir un carácter `@` adicional al introducir la cadena de índice. Por ejemplo, si se tiene un campo de registro personalizado `@emailname`, se debe introducir `@@emailname` en el cuadro **Agregar ruta de campo**.
También puede crear índices para los `@logStream` campos `@ingestionTime` y que CloudWatch Logs genera automáticamente. Si lo hace, no tiene que añadir un `@` extra al especificarlos.
1. (Opcional) Además de especificar la ruta del campo, puede seleccionar **Establecer como una faceta** para crear el campo como una faceta.
1. Repita el paso anterior para agregar hasta 20 índices de campo.
1. Cuando haya terminado, elija **Save**.
# Selección de grupos de registros al crear una consulta
En esta sección se explican las diversas formas en que se pueden seleccionar grupos de registros para incluirlos en una consulta.
**Selección de grupos de registros para una consulta en la consola**
1. Abra la CloudWatch consola en. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación, elija **Registros** y luego, **Información de registros**.
1. Seleccione el idioma de consulta que desea utilizar en esta consulta. Puede elegir entre: **Logs Insights QL**, **OpenSearchPPL** o **OpenSearch SQL**.
1. Hay tres formas de seleccionar grupos de registro para la consulta:
+ Utilice el cuadro de **nombre del grupo de registros**. Este es el método de selección predeterminada. Puede introducir hasta 50 nombres de grupos de registro con este método. Si se trata de una cuenta de supervisión en CloudWatch condiciones de observación multicuenta, puede seleccionar grupos de registros en las cuentas de origen y en la cuenta de supervisión. Una sola consulta puede ejecutarse en registros de diferentes cuentas a la vez.
+ Utilice la sección **Criterios de grupos de registros**. En esta sección, se pueden elegir grupos de registros en función del prefijo de los nombres de los grupos de registros. Se pueden incluir hasta cinco prefijos en una consulta. Se seleccionarán los grupos de registros que tengan estos prefijos en sus nombres. Como alternativa, la opción **Todos los grupos de registro** selecciona todos los grupos de registro de la cuenta.
+ Si se trata de una cuenta de monitorización mediante la observación CloudWatch multicuenta, puede seleccionar **Todas las cuentas en el menú desplegable de cuentas** para seleccionar los grupos de registros de todas las cuentas vinculadas. Como alternativa, puede seleccionar de manera individual qué cuentas deben incluirse en esta consulta.
Si las opciones coinciden con más de 10 000 grupos de registros, aparecerá un error que pedirá que se restrinja la selección.
1. La clase de registro predeterminada para una consulta es **Estándar**. Puede usar **Clase de registro** para cambiarla a **Infrequent access**.
**Usando el AWS CLI**
Para realizar este tipo de selecciones al iniciar una consulta desde la línea de comandos, se puede usar el comando `source` en la consulta. Para obtener más información y ejemplos, consulta [SOURCE](CWL_QuerySyntax-Source.md).
# Efectos de eliminar una política de indexación de campos
Si se elimina una política de indexación de campos que ha estado en vigor durante un tiempo, ocurre lo siguiente:
+ Hasta 30 días después de la eliminación de la política, las consultas pueden seguir beneficiándose de los eventos de registro indexado.
+ Si se elimina una política de indexación a nivel de grupo de registros y ya existe una política a nivel de cuenta que se aplicaría a ese grupo de registros, la política a nivel de cuenta finalmente se aplicará a ese grupo de registros.
# Utilice facetas para agrupar y explorar los registros
Las facetas son útiles para analizar los registros, ya que permiten filtrar y agrupar los datos de forma interactiva sin ejecutar consultas. Una faceta es un campo de los registros (por ejemplo, `ServiceName` o`StatusCode`) que permite filtrar, agregar y analizar los distintos grupos de registros. Puede ver la lista de campos facetados en la consola de CloudWatch Logs Insights, junto con el recuento de eventos de registro para cada valor de faceta en función del intervalo de tiempo seleccionado. A medida que selecciona distintas facetas y valores, los valores y recuentos de las facetas se actualizan en tiempo real, lo que le permite explorar sus registros de forma interactiva.
Cada faceta muestra los valores y recuentos disponibles, que se extraen automáticamente de los campos de los registros en función del intervalo de tiempo y el alcance de la consulta seleccionados, y se conservan durante 30 días. Los recuentos de facetas que se muestran son aproximados. Puede usar las facetas predeterminadas, como el nombre o el tipo de fuente de datos, para explorar sus registros o crear facetas personalizadas en cualquiera de los campos de sus registros. El nombre de la fuente de datos es un servicio o aplicación de AWS que genera los registros (por ejemplo, Route 53, Amazon VPC o CloudTrail) y el tipo de fuente de datos es el tipo específico de registro generado por ese servicio. Las facetas predeterminadas las crea CloudWatch e incluyen`@aws.region`, `@data_source_name``@data_source_type`, y. `@data_format` Para obtener más información, consulte [Administración de registros:](LogManagement.md). Las facetas solo están disponibles para los registros que se ingieren en la cuenta. Si ha configurado la observabilidad entre cuentas, la cuenta de supervisión no podrá ver las facetas en función de los registros de las cuentas de origen.
Para crear facetas adicionales, seleccione los campos de sus registros que sean relevantes para la solución de problemas y configúrelos mediante las políticas de indexación. Para las facetas personalizadas, recomendamos crearlas en campos de baja cardinalidad (campos con menos de 100 valores únicos por día, como Status y). ApplicationName Las facetas con más de 100 valores únicos por día se clasifican como de cardinalidad alta y los valores de estas facetas no se muestran. Seleccione una o más facetas y haga clic para ejecutar consultas en sus registros.
Para empezar con las facetas de CloudWatch Logs Insights:
1. Abra la CloudWatch consola en. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación, elija **Registros** y luego, **Información de registros**.
1. (Opcional) Utilice el selector de intervalo de tiempo para seleccionar el período de tiempo que desee analizar. Para el intervalo de tiempo seleccionado, las facetas y los valores disponibles se muestran en el panel.
1. Seleccione las facetas para explorar sus datos y ver actualizaciones en tiempo real de las distribuciones de valores entre las facetas.
No se muestran las facetas con más de 100 valores únicos. Para consultar valores específicos, utilice filtros en la consulta.
## Para ejecutar una consulta basada en facetas
1. Seleccione uno o más valores en todas las facetas.
1. El recuento de eventos se actualizará en función de las facetas y los valores seleccionados.
1. A medida que se seleccionan los valores de las facetas, el ámbito de la consulta se actualiza para reflejar la selección.
1. Tras seleccionar los valores de las facetas, haga clic en ejecutar para ejecutar la consulta.
1. El número máximo de valores únicos admitidos por faceta es 100. Por ejemplo, si hay más de 100 valores para una faceta, todos los recuentos se muestran como «-», lo que indica que se desconocen los valores.
## Para guardar una consulta basada en facetas
1. Cree la consulta con uno o más valores de faceta.
1. El resto de los pasos son los mismos que para guardar una consulta de Logs Insights. Consulte [Guardar consultas de CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_Insights-Saving-Queries.html).
1. Las consultas guardadas están disponibles en la sección Consultas guardadas. Al recuperar una consulta guardada, incluirá automáticamente las facetas y los valores utilizados en la consulta, lo que facilitará el análisis de los registros.
## Para crear una faceta a nivel de cuenta
1. Para crear facetas, primero debe crear el campo como un índice y configurarlo como una faceta. En el panel de navegación, seleccione **Configuración**, **Registros** y Políticas de **índice a nivel de cuenta**. Como alternativa, puede seleccionar **Administrar facetas** en el panel de facetas.
1. Elija **Crear nueva política de indexación**. Para obtener más información sobre la creación de políticas de índice, consulte[Creación de una política de indexación de campos a nivel de cuenta](CloudWatchLogs-Field-Indexing-CreateAccountLevel.md).
1. Para crear una faceta, active **Definir como faceta** para el campo seleccionado en la página de creación de políticas de indexación.
## Gestión de facetas mediante APIs
La gestión de facetas se puede realizar mediante la política de indexación de campos. Para obtener más información, consulte [https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FieldIndex.html](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_FieldIndex.html) APIs .
**Índice de campos APIs**
| No. | Name | Description (Descripción) |
| --- | --- | --- |
| 1 | PutIndexPolicy | Crea o actualiza una política de índice de campos para el grupo de registros específico |
| 2 | PutAccountPolicy | Crea una política de protección de datos a nivel de cuenta, una política de filtro de suscripciones, una política de índice de campos, una política de transformadores o una política de extracción de métricas que se aplica a todos los grupos de registros o a un subconjunto de grupos de registros de la cuenta |
| 3 | DeleteIndexPolicy | Elimina una política de indexación de campos a nivel de grupo de registros que se aplicó a un único grupo de registros |
| 4 | DeleteAccountPolicy | Elimina una política de cuentas de Logs CloudWatch |
# Análisis del patrón
CloudWatch Logs Insights utiliza algoritmos de aprendizaje automático para encontrar *patrones* cuando consultas tus registros. Un patrón es una estructura de texto compartida que se repite entre los campos de registro. Al ver los resultados de una consulta, puedes elegir la pestaña **Patrones** para ver los patrones que encontró CloudWatch Logs a partir de una muestra de tus resultados. Como alternativa, puede añadir el comando `pattern` a la consulta para analizar los patrones de todo el conjunto de eventos de registro coincidentes.
Los patrones son útiles para analizar conjuntos de registros grandes porque, a menudo, una gran cantidad de eventos de registro se pueden comprimir en unos pocos patrones.
Estudie el siguiente ejemplo de tres eventos de registro.
```
2023-01-01 19:00:01 [INFO] Calling DynamoDB to store for resource id 12342342k124-12345
2023-01-01 19:00:02 [INFO] Calling DynamoDB to store for resource id 324892398123-12345
2023-01-01 19:00:03 [INFO] Calling DynamoDB to store for resource id 3ff231242342-12345
```
En el ejemplo anterior, los tres eventos de registro siguen un patrón:
```
[INFO] Calling DynamoDB to store for resource id
```
Los campos dentro de un patrón se denominan *tokens*. Los campos que varían dentro de un patrón, como un ID de solicitud o una marca de tiempo, son *tokens dinámicos*. Cada token dinámico está representado por ``. *string*Es una descripción del tipo de datos que representa el token. *number*Muestra en qué parte del patrón aparece este token, en comparación con los otros tokens dinámicos.
Algunos ejemplos comunes de tokens dinámicos son los códigos de error, las marcas de tiempo y las solicitudes. IDs El *valor de un token* representa un valor concreto de un token dinámico. Por ejemplo, si un token dinámico representa un código de error HTTP, entonces el valor del token podría ser `501`.
La detección de patrones también se utiliza en el detector de anomalías de CloudWatch Logs y en las funciones de comparación. Para obtener más información, consulte [Detección de anomalías en registros](LogsAnomalyDetection.md) y [Comparación (diferencia) con intervalos de tiempo anteriores](CWL_AnalyzeLogData_Compare.md).
## Introducción al análisis de patrones
La detección de patrones se realiza automáticamente en cualquier consulta de CloudWatch Logs Insights. Las consultas que no incluyen el comando `pattern` registran tanto los eventos como los patrones en los resultados.
Si incluye el comando `pattern` en la consulta, el análisis de patrones se realiza en todo el conjunto de eventos de registro coincidentes. Esto proporciona resultados de patrones más precisos, pero recuerde que los eventos de registro sin procesar no se devuelven cuando se utiliza el comando `pattern`. Cuando una consulta no incluye `pattern`, los resultados del patrón se basan en los primeros 1000 eventos de registro devueltos o en el valor límite que utilizó en la consulta. Si lo incluye `pattern` en la consulta, los resultados que se muestran en la pestaña **Patrones** se derivan de todos los eventos de registro que hizo coincidir la consulta.
**Para empezar con el análisis de patrones en CloudWatch Logs Insights**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Registros** y luego, **Información de registros**.
En la página **Información de registros**, el editor de consultas contiene una consulta predeterminada que devuelve los 20 eventos de registro más recientes.
1. Elimine la línea `| limit 20` del cuadro de consulta para que la consulta tenga el siguiente aspecto:
```
fields @timestamp, @message, @logStream, @log
| sort @timestamp desc
```
1. En el menú desplegable **Seleccionar grupos de registro**, elija uno o varios grupos de registro que va a consultar.
1. (Opcional) Utilice el selector de tiempo para seleccionar el periodo de tiempo que desea consultar.
Puede elegir entre intervalos de 5 a 30 minutos; intervalos de 1, 3 y 12 horas; o un marco temporal personalizado.
1. Seleccione **Ejecutar consulta** para iniciar la consulta.
Cuando la consulta termina de ejecutarse, la pestaña **Registros** muestra una tabla con los eventos de registro que ha devuelto la consulta. Encima de la tabla hay un mensaje que indica el número de registros que coinciden con la consulta, similar a **Mostrando 10 000 de 71 101 registros coincidentes**.
1. Seleccione la pestaña **Patrones**.
1. La tabla muestra ahora los patrones que se encontraron en la consulta. Como la consulta no incluía el comando `pattern`, en esta pestaña solo se muestran los patrones detectados entre los 10 000 eventos de registro que se muestran en la tabla en la pestaña **Registros**.
En cada patrón se muestra la siguiente información:
+ El **Patrón**, en el que cada token dinámico se muestra como ``. *string*Es una descripción del tipo de datos que representa el token. *number*Muestra en qué parte del patrón aparece este token, en comparación con los otros tokens dinámicos.
+ El **Recuento de eventos**, que es el número de veces que el patrón apareció en el registro de eventos consultado. Elija el encabezado de columna **Recuento de eventos** para ordenar los patrones por frecuencia.
+ La **Proporción de eventos**, que es el porcentaje de eventos del registro consultados que contienen este patrón.
+ El **Tipo de gravedad**, que será uno de los siguientes:
+ **ERROR** si el patrón contiene la palabra **Error**.
+ **ADVERTENCIA** si el patrón contiene la palabra **Advertencia**, pero no contiene **Error**.
+ **INFORMACIÓN** si el patrón no contiene las palabras **Advertencia** ni **Error**.
Elija el encabezado de columna **Información sobre la gravedad** para ordenar los patrones por gravedad.
1. A continuación, cambie la consulta. Sustituya la línea `| sort @timestamp desc` de la consulta por `| pattern @message`, de modo que la consulta completa quede de la siguiente manera:
```
fields @timestamp, @message, @logStream, @log
| pattern @message
```
1. Elija **Ejecutar consulta**.
Cuando finalice la consulta, no habrá resultados en la pestaña **Registros**. Sin embargo, es probable que la pestaña **Patrones** muestre un mayor número de patrones, en función del número total de eventos de registro que se hayan consultado.
1. Independientemente de si ha incluido `pattern` en la consulta, puede inspeccionar con más detalle los patrones que devuelve la consulta. Para ello, elija el icono de uno de los patrones en la columna **Inspeccionar**.
Aparecerá el panel **Inspección de patrones**, que muestra lo siguiente:
+ El **Patrón**. Seleccione un token dentro del patrón para analizar los valores de ese token.
+ Un histograma que muestra el número de veces que aparece el patrón en el intervalo de tiempo consultado. Esto puede ayudarle a identificar tendencias interesantes, como un aumento repentino de la aparición de un patrón.
+ La pestaña **Muestras de registro** muestra algunos de los eventos de registro que coinciden con el patrón seleccionado.
+ La pestaña **Valores del token** muestra los valores del token dinámico seleccionado, si es que seleccionó uno.
**nota**
Se captura un máximo de 10 valores de token por cada token. Es posible que los recuentos de fichas no sean precisos. CloudWatch Logs utiliza un contador probabilístico para generar el recuento de fichas, no el valor absoluto.
+ La pestaña **Patrones relacionados** muestra otros patrones que se han producido con frecuencia casi al mismo tiempo que el patrón que está analizando. Por ejemplo, si el patrón de un mensaje de `ERROR` solía ir acompañado de otro evento de registro marcado como `INFO` con detalles adicionales, ese patrón se muestra aquí.
## Detalles sobre el comando pattern
Esta sección contiene más detalles sobre el comando `pattern` y sus usos.
+ En el tutorial anterior, eliminamos el comando `sort` cuando agregamos `pattern`, porque una consulta no es válida si incluye un comando `pattern` después de un comando `sort`. Puede tener un comando `pattern` antes de `sort`.
Para obtener más detalles acerca de la sintaxis `pattern`, consulte [pattern](CWL_QuerySyntax-Pattern.md).
+ Cuando se utiliza `pattern` en una consulta, `@message` debe ser uno de los campos seleccionados en el comando `pattern`.
+ Puede incluir el comando `filter` antes de un comando `pattern` para que solo el conjunto filtrado de eventos de registro se utilice como entrada para el análisis de patrones.
+ Para ver los resultados del patrón de un campo concreto, como un campo derivado del comando `parse`, utilice `pattern @fieldname`.
+ Las consultas con un resultado que no sea de registro, como las consultas realizadas con el comando `stats`, no devuelven resultados de patrones.
# Guarde y vuelva a ejecutar CloudWatch las consultas de Logs Insights
Cuando haya creado una consulta, puede guardarla para volver a ejecutarla más adelante. Las consultas se guardan en una estructura de carpetas para que pueda mantenerlas organizadas. Puede guardar hasta 1000 consultas por región y cuenta.
Las consultas se guardan en un nivel específico de la región, no en un nivel específico del usuario. Si crea y guarda una consulta, otros usuarios con acceso a los CloudWatch registros de la misma región podrán ver todas las consultas guardadas y sus estructuras de carpetas en la región.
Para guardar una consulta, debe haber iniciado sesión en un rol que tenga el permiso `logs:PutQueryDefinition`. Para ver una lista de consultas guardadas, debe haber iniciado sesión en un rol que tenga el permiso `logs:DescribeQueryDefinitions`.
**nota**
Puede crear y guardar consultas con parámetros: plantillas reutilizables con marcadores de posición con nombre. En lugar de guardar varias variantes de la misma consulta con valores diferentes, cree una plantilla y proporcione valores de parámetros diferentes al ejecutarla. Actualmente, esta funcionalidad solo se admite para consultas que utilizan el lenguaje de consultas de Logs Insights. Para obtener más información, consulte [Uso de consultas guardadas con parámetros](#CWL_Insights-Parameterized-Queries).
------
#### [ Console ]
**Para guardar una consulta**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs** (Registros) y, luego, **Logs Insights** (Registros de Insights).
1. En el editor de consultas, cree una consulta.
1. Seleccione **Save**.
1. Escriba un nombre para la consulta.
1. (Opcional) Elija una carpeta en la que desee guardar la consulta. Seleccione **Create new (Crear nueva)** para crear una carpeta. Si crea una carpeta nueva, puede utilizar caracteres de barra (/) en el nombre de la carpeta para definir una estructura de carpetas. Por ejemplo, poner nombre a una carpeta nueva **folder-level-1/folder-level-2** crea una carpeta de nivel superior llamada **folder-level-1**, con otra carpeta llamada **folder-level-2** dentro de esa carpeta. La consulta se guarda en **folder-level-2**.
1. (Opcional) Cambie los grupos de registro de la consulta o el texto de la consulta.
1. (Opcional) Para usar los parámetros en la consulta, siga estos pasos adicionales:
1. **Añada parámetros a la consulta.** Sustituya los valores estáticos por marcadores de posición utilizando la `{{parameter}}` sintaxis (corchetes dobles antes y después del nombre del parámetro).
Ejemplo: consulta original con valores estáticos:
```
fields @timestamp, @message
| filter level = "Error"
| filter applicationName = "OrderService"
```
Consulta actualizada con parámetros:
```
fields @timestamp, @message
| filter level = {{logLevel}}
| filter applicationName = {{applicationName}}
```
1. **Defina los parámetros utilizados en la consulta.** Para cada parámetro marcador de posición, especifique:
+ **Nombre**: debe coincidir exactamente con el nombre del marcador de posición (por ejemplo,`logLevel`,`applicationName`).
+ **Valor predeterminado** (opcional): el valor que se utilizará si no se proporciona ningún valor de parámetro.
+ **Descripción** (opcional): explica el propósito del parámetro.
1. Las consultas con parámetros se pueden ejecutar utilizando el nombre de la consulta con un `$` prefijo y pasando los nombres de los parámetros como pares clave-valor. Consulte **Para ejecutar una consulta guardada** para obtener más información.
1. Seleccione **Save**.
------
#### [ AWS CLI ]
**Para guardar una consulta**, utilice`put-query-definition`:
```
aws logs put-query-definition \
--name "ErrorsByLevel" \
--query-string "fields @timestamp, @message | filter level = \"ERROR\"" \
--log-group-names "/aws/lambda/my-function" \
--region us-east-1
```
(Opcional) Para guardar una consulta con parámetros, añada la `--parameters` opción y utilice `{{parameterName}}` marcadores de posición en la cadena de consulta:
```
aws logs put-query-definition \
--name "ErrorsByLevel" \
--query-string "fields @timestamp, @message | filter level = {{logLevel}} | filter applicationName = {{applicationName}}" \
--parameters '[{"name":"logLevel","defaultValue":"ERROR","description":"Log level to filter"},{"name":"applicationName","defaultValue":"OrderService","description":"Application name to filter"}]' \
--log-group-names "/aws/lambda/my-function" \
--region us-east-1
```
Para guardar una consulta en una carpeta, añada al nombre de la consulta la ruta de la carpeta:
```
aws logs put-query-definition \
--name "my-folder/ErrorsByLevel" \
--query-string "fields @timestamp, @message | filter level = {{logLevel}}" \
--parameters '[{"name":"logLevel","defaultValue":"ERROR","description":"Log level to filter"}]' \
--log-group-names "/aws/lambda/my-function" \
--region us-east-1
```
------
#### [ API ]
**Para guardar una consulta**, llama a [PutQueryDefinition](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutQueryDefinition.html):
```
{
"name": "ErrorsByLevel",
"queryString": "fields @timestamp, @message | filter level = \"ERROR\"",
"logGroupNames": ["/aws/lambda/my-function"]
}
```
(Opcional) Para guardar una consulta con parámetros, incluye el `parameters` campo y utiliza `{{parameterName}}` marcadores de posición en la cadena de consulta:
```
{
"name": "ErrorsByLevel",
"queryString": "fields @timestamp, @message | filter level = {{logLevel}} | filter applicationName = {{applicationName}}",
"logGroupNames": ["/aws/lambda/my-function"],
"parameters": [
{
"name": "logLevel",
"defaultValue": "ERROR",
"description": "Log level to filter"
},
{
"name": "applicationName",
"defaultValue": "OrderService",
"description": "Application name to filter"
}
]
}
```
------
**sugerencia**
Puede crear una carpeta para las consultas guardadas con `PutQueryDefinition`. Con el fin de crear una carpeta para las consultas guardadas, utilice una barra diagonal (/) a fin de anteponer el nombre de la consulta deseada con el nombre de la carpeta deseada: `/`. Para obtener más información sobre esta acción, consulte [PutQueryDefinition](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_PutQueryDefinition.html).
------
#### [ Console ]
**Para ejecutar una consulta guardada**
1. Abra la CloudWatch consola en. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación, elija **Logs** (Registros) y, luego, **Logs Insights** (Registros de Insights).
1. A la derecha, elija **Queries (Consultas)**.
1. Seleccione la consulta en la lista de **consultas guardadas**. El texto de la consulta aparece en el editor de consultas.
1. (Opcional) Para usar una consulta con parámetros:
1. Seleccione el icono **\$1** situado junto al nombre de la consulta en el panel lateral de **consultas guardadas**.
1. La consulta con los parámetros aparece en el editor de consultas. Por ejemplo, si selecciona el icono **\$1** situado junto a`ErrorsByLevel`, el editor de consultas aparecerá con: `$ErrorsByLevel(level=, applicationName=)`
1. Proporcione los valores de los parámetros (level, ApplicationName) y ejecute la consulta. Por ejemplo: `$ErrorsByLevel(level= "ERROR", applicationName= "OrderService")`
1. Seleccione **Ejecutar**.
------
#### [ AWS CLI ]
**Para ejecutar una consulta guardada con parámetros**
`start-query`Utilícela con la `$QueryName()` siguiente sintaxis:
```
aws logs start-query \
--log-group-names "/aws/lambda/my-function" \
--start-time 1707566400 --end-time 1707570000 \
--query-string '$ErrorsByLevel(level= "ERROR", applicationName= "OrderService")' \
--region us-east-1
```
------
#### [ API ]
**Para ejecutar una consulta guardada con parámetros**
Llame [StartQuery](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_StartQuery.html)con la `$QueryName()` sintaxis del `queryString` campo:
```
{
"logGroupNames": ["/aws/lambda/my-function"],
"startTime": 1707566400,
"endTime": 1707570000,
"queryString": "$ErrorsByLevel(level=\"ERROR\", applicationName= \"OrderService\")"
}
```
------
**Para guardar una nueva versión de una consulta guardada**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs** (Registros) y, luego, **Logs Insights** (Registros de Insights).
1. A la derecha, elija **Queries (Consultas)**.
1. Seleccione la consulta de la lista **Saved queries (Consultas guardadas)** . Aparece en el editor de consultas.
1. Modifique la consulta. Si necesita ejecutarla para comprobar su trabajo, elija **Run query (Ejecutar consulta)**.
1. Cuando esté listo para guardar la nueva versión, elija **Actions (Acciones)**, **Save as (Guardar como)**.
1. Escriba un nombre para la consulta.
1. (Opcional) Elija una carpeta en la que desee guardar la consulta. Seleccione **Create new (Crear nueva)** para crear una carpeta. Si crea una carpeta nueva, puede utilizar caracteres de barra (/) en el nombre de la carpeta para definir una estructura de carpetas. Por ejemplo, poner nombre a una carpeta nueva **folder-level-1/folder-level-2** crea una carpeta de nivel superior llamada **folder-level-1**, con otra carpeta llamada **folder-level-2** dentro de esa carpeta. La consulta se guarda en **folder-level-2**.
1. (Opcional) Cambie los grupos de registro de la consulta o el texto de la consulta.
1. Seleccione **Save**.
Para eliminar una consulta, debe haber iniciado sesión en un rol que tenga el permiso `logs:DeleteQueryDefinition`.
**Para editar o eliminar una consulta guardada**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs** (Registros) y, luego, **Logs Insights** (Registros de Insights).
1. A la derecha, elija **Queries (Consultas)**.
1. Seleccione la consulta de la lista **Saved queries (Consultas guardadas)** . Aparece en el editor de consultas.
1. Elija **Actions (Acciones)**, **Edit (Editar)** o **Actions (Acciones)**, **Delete (Eliminar)**.
## Uso de consultas guardadas con parámetros
Las consultas guardadas con parámetros son plantillas de consulta reutilizables con marcadores de posición con nombre. En lugar de mantener varias copias de consultas prácticamente idénticas, puede guardar una plantilla y proporcionar valores de parámetros diferentes al ejecutar la consulta. Los parámetros solo se admiten en el lenguaje de consultas de CloudWatch Logs Insights.
**Cómo funciona**
Al guardar una consulta, los marcadores de posición identifican los valores que puede proporcionar en el momento de la ejecución de la consulta. Los marcadores de posición utilizan la `{{parameterName}}` sintaxis. A continuación se muestra un ejemplo de una consulta guardada denominada `ErrorsByLevel` con dos parámetros `logLevel` y`applicationName`.
```
fields @timestamp, @message
| filter level = {{logLevel}}
| filter applicationName = {{applicationName}}
```
Para ejecutar una consulta guardada, puede invocarla utilizando el nombre de la consulta con el prefijo `$` y pasando los valores de los parámetros. El motor de consultas CloudWatch de Logs Insights reemplaza cada marcador de posición. Si un parámetro contiene valores predeterminados, esos valores se utilizan si no se proporcionan otros valores.
```
# Run query by using query name and passing parameter values explicitly
$ErrorsByLevel(logLevel = "WARN", applicationName = "OrderService")
# Run query without specifying parameter values - default values are used in this case.
$ErrorsByLevel()
```
Los nombres de consulta guardados que contengan espacios o caracteres especiales deben estar entre comillas invertidas:
```
$`Errors By Level`(logLevel = "WARN")
```
### Ejemplos de consultas guardadas con parámetros
**Añadir un límite de resultados como parámetro**
Nombre de consulta: `ErrorsByLevel` con parámetros `logLevel` (predeterminado:`"ERROR"`), `applicationName` (predeterminado:`"OrderService"`) y `maxResults` (predeterminado:`50`)
```
fields @timestamp, @message, @logStream
| filter level = {{logLevel}}
| filter applicationName = {{applicationName}}
| sort @timestamp desc
| limit {{maxResults}}
```
```
# Run the query using the query name and passing parameter values
$ErrorsByLevel(logLevel = "WARN", applicationName = "OrderService", maxResults = 100)
```
**Uso de varias consultas guardadas con parámetros**
En el ejemplo siguiente se utiliza `ErrorsByLevel` una segunda consulta guardada `RecentN` que se define como `sort @timestamp desc | limit {{count}}` (con parámetro`count`, predeterminado`20`). El motor de consultas de CloudWatch Logs Insights expande cada consulta antes de ejecutarla.
```
# Using multiple queries with parameters in sequence
$ErrorsByLevel(logLevel = "WARN", applicationName = "OrderService")
| $RecentN(count = 10)
# Each of the queries is expanded, resulting in the following query when it is run.
fields @timestamp, @message
| filter level = "WARN"
| filter applicationName = "OrderService"
| sort @timestamp desc
| limit 10
```
### Cuotas y gestión de errores
**nota**
Cada consulta guardada puede tener un máximo de 20 parámetros.
La cadena de consulta expandida no puede superar los 10 000 caracteres. Los nombres de los parámetros deben empezar por una letra o un guión bajo. Una consulta guardada no puede hacer referencia a otra consulta guardada (no se admiten las invocaciones anidadas).
**Errores comunes**
| Error | Causa |
| --- | --- |
| Los parámetros solo se admiten en el lenguaje de consultas CWLI | Los parámetros solo se admiten en el lenguaje de consultas CloudWatch de Logs Insights. |
| No se encontraron los parámetros necesarios en QueryString | El nombre de un parámetro no `--parameters` coincide con el nombre de un parámetro `{{placeholder}}` en la cadena de consulta. |
| El recuento de parámetros supera el máximo de 20 | Las consultas guardadas actualmente solo admiten 20 parámetros. |
| Nombre de parámetro duplicado | La definición de consulta contiene parámetros duplicados`parameters`. |
**nota**
Para crear o actualizar una consulta guardada con parámetros, necesita el `logs:PutQueryDefinition` permiso. Para ejecutar una, necesita `logs:StartQuery` y`logs:DescribeQueryDefinitions`.
# Agregar consulta al panel o exportar resultados de consultas
Después de ejecutar una consulta, puede añadirla a un CloudWatch panel o copiar los resultados al portapapeles.
Las consultas agregadas a los paneles se ejecutan automáticamente cada vez que carga el panel y cada vez que el panel se actualiza. Estas consultas cuentan para el límite de 100 consultas simultáneas de CloudWatch Logs Insights.
**Para añadir resultados de consultas a un panel**
1. Abra la CloudWatch consola en. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación, elija **Logs** (Registros) y, luego, **Logs Insights** (Registros de Insights).
1. Elija uno o varios grupos de registro y ejecute una consulta.
1. Elija **Add to dashboard (Añadir a panel)**.
1. Seleccione el panel o elija **Create new (Crear nuevo)** para crear un nuevo panel para los resultados de la consulta.
1. Seleccione el tipo de widget que desea utilizar para los resultados de la consulta.
1. Escriba un nombre para el widget.
1. Elija **Add to dashboard (Añadir a panel)**.
**Para copiar los resultados de la consulta en el portapapeles o descargar los resultados de la consulta**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs** (Registros) y, luego, **Logs Insights** (Registros de Insights).
1. Elija uno o varios grupos de registro y ejecute una consulta.
1. Elija **Export results (Exportar resultados)** y, a continuación, elija la opción que desee.
# Ver consultas en marcha o historial de consultas
Puede ver las consultas en curso, así como su historial de consultas recientes.
Las consultas que se están ejecutando actualmente incluyen consultas añadidas a un panel. Está limitado a 100 consultas simultáneas de CloudWatch Logs Insights por cuenta, incluidas las consultas añadidas a los paneles. Además, puede ejecutar 15 consultas simultáneas para OpenSearch Service PPL o Service SQL. OpenSearch
**Para ver su historial de consultas recientes**
1. Abra la CloudWatch consola en. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. En el panel de navegación, elija **Registros** y, luego, **Información de registros**.
1. Elija **Historial** si utiliza el nuevo diseño de la consola CloudWatch Logs. Si está utilizando el diseño antiguo, elija **Actions (Acciones)**, **View query history for this account (Ver historial de consultas de esta cuenta)**.
Aparece una lista de consultas recientes. Puede volver a ejecutar cualquiera de ellas seleccionando la consulta y eligiendo **Run (Ejecutar)**.
En **Estado**, CloudWatch los registros muestran **En curso** para todas las consultas que se estén ejecutando actualmente.
# Cifre los resultados de la consulta con AWS Key Management Service
De forma predeterminada, CloudWatch Logs cifra los resultados almacenados de sus consultas de CloudWatch Logs Insights mediante el método de cifrado predeterminado del servidor de CloudWatch Logs. En su lugar, puede optar por utilizar una AWS KMS clave para cifrar estos resultados. Si asocias una AWS KMS clave a los resultados de cifrado, CloudWatch Logs utilizará esa clave para cifrar los resultados almacenados de todas las consultas de la cuenta.
Si posteriormente desasocias la clave de los resultados de la consulta, CloudWatch Logs volverá al método de cifrado predeterminado para consultas posteriores. Sin embargo, las consultas que se ejecutaron mientras la clave estaba asociada siguen cifradas con esa clave. CloudWatch Los registros pueden seguir devolviendo esos resultados una vez desasociada la clave de KMS, ya que CloudWatch los registros pueden seguir haciendo referencia a la clave. Sin embargo, si la clave se deshabilita posteriormente, CloudWatch Logs no podrá leer los resultados de la consulta que se cifraron con esa clave.
**importante**
CloudWatch Logs solo admite claves KMS simétricas. No utilice una clave asimétrica para cifrar los resultados de la consulta. Para obtener más información, consulte [Utilización de claves simétricas y asimétricas](https://docs.aws.amazon.com/kms/latest/developerguide/symmetric-asymmetric.html).
## Límites
+ Para realizar los siguientes pasos, debe tener los siguientes permisos: `kms:CreateKey`, `kms:GetKeyPolicy` y `kms:PutKeyPolicy`.
+ Después de asociar una clave a los resultados de la consulta o desasociarla de ellos, la operación puede tardar hasta cinco minutos en surtir efecto.
+ Si revoca el acceso de CloudWatch los registros a una clave asociada o elimina una clave de KMS asociada, los datos cifrados de los CloudWatch registros ya no se podrán recuperar.
+ No puedes usar la CloudWatch consola para asociar una clave, debes usar la API AWS CLI o CloudWatch Logs.
## Paso 1: Crea una AWS KMS key
Para crear una clave de KMS, utilice el siguiente comando [create-key](https://docs.aws.amazon.com/cli/latest/reference/kms/create-key.html):
```
aws kms create-key
```
La salida contiene la ID de clave y el nombre de recurso de Amazon (ARN) de la clave. A continuación, se muestra un ejemplo de la salida:
```
{
"KeyMetadata": {
"Origin": "AWS_KMS",
"KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
"Description": "",
"KeyManager": "CUSTOMER",
"Enabled": true,
"CustomerMasterKeySpec": "SYMMETRIC_DEFAULT",
"KeyUsage": "ENCRYPT_DECRYPT",
"KeyState": "Enabled",
"CreationDate": 1478910250.94,
"Arn": "arn:aws:kms:us-west-2:123456789012:key/6f815f63-e628-448c-8251-e40cb0d29f59",
"AWSAccountId": "123456789012",
"EncryptionAlgorithms": [
"SYMMETRIC_DEFAULT"
]
}
}
```
## Paso 2: establecer permisos en la clave de KMS
De forma predeterminada, todas las claves de KMS son privadas. Solo el propietario del recurso puede utilizarla para cifrar y descifrar datos. Sin embargo, el propietario del recurso puede conceder permisos para que otros usuarios y recursos accedan a la clave. Con este paso, le das permiso al director del servicio de CloudWatch registros para usar la clave. El principal de este servicio debe estar en la misma AWS región en la que se almacena la clave.
Como práctica recomendada, le recomendamos que restrinja el uso de la clave solo a las AWS cuentas que especifique.
En primer lugar, guarde la política predeterminada para su clave KMS `policy.json` mediante el siguiente [get-key-policy](https://docs.aws.amazon.com/cli/latest/reference/kms/get-key-policy.html)comando:
```
aws kms get-key-policy --key-id key-id --policy-name default --output text > ./policy.json
```
Abra el archivo `policy.json` en un editor de texto y agregue la sección en negrita desde una de las instrucciones siguientes. Separe la instrucción existente de la nueva instrucción con una coma. Estas instrucciones utilizan `Condition` secciones para mejorar la seguridad de la AWS KMS clave. Para obtener más información, consulte [AWS KMS claves y contexto de cifrado](encrypt-log-data-kms.md#encrypt-log-data-kms-policy).
La `Condition` sección de este ejemplo limita el uso de la AWS KMS clave para los resultados de la consulta de CloudWatch Logs Insights en la cuenta especificada.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "key-default-1",
"Statement": [
{
"Sid": "Enable IAM User Permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "kms:*",
"Resource": "*"
},
{
"Effect": "Allow",
"Principal": {
"Service": "logs.region.amazonaws.com"
},
"Action": [
"kms:Encrypt*",
"kms:Decrypt*",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:Describe*"
],
"Resource": "*",
"Condition": {
"ArnEquals": {
"aws:SourceArn": "arn:aws:logs:us-east-1:111122223333:query-result:*"
},
"StringEquals": {
"aws:SourceAccount": "111122223333"
}
}
}
]
}
```
------
Por último, añada la política actualizada mediante el siguiente [put-key-policy](https://docs.aws.amazon.com/cli/latest/reference/kms/put-key-policy.html)comando:
```
aws kms put-key-policy --key-id key-id --policy-name default --policy file://policy.json
```
## Paso 3: asociar una clave de KMS a los resultados de la consulta
**Para asociar la clave de KMS a los resultados de la consulta en la cuenta**
Utilice el comando [disassociate-kms-key](https://docs.aws.amazon.com/cli/latest/reference/logs/disassociate-kms-key.html) como se indica a continuación:
```
aws logs associate-kms-key --resource-identifier "arn:aws:logs:region:account-id:query-result:*" --kms-key-id "key-arn"
```
## Paso 4: desasociar una clave de los resultados de la consulta en la cuenta
Para desasociar la clave KMS asociada a los resultados de la consulta, utilice el siguiente [disassociate-kms-key](https://docs.aws.amazon.com/cli/latest/reference/logs/disassociate-kms-key.html)comando:
```
aws logs disassociate-kms-key --resource-identifier "arn:aws:logs:region:account-id:query-result:*"
```
# Genere un resumen en lenguaje natural a partir de CloudWatch los resultados de la consulta de Logs Insights
Analizar los datos de registro es fundamental para comprender el comportamiento de sus aplicaciones, pero interpretar grandes volúmenes de entradas de registro puede llevar mucho tiempo. CloudWatch Logs Insights ahora ofrece una función de resumen en lenguaje natural que transforma los resultados de consultas complejas en resúmenes claros y concisos. Esta capacidad ayuda a identificar rápido los problemas y a obtener información útil a partir de los datos de registro.
## Funcionamiento
CloudWatch Logs Insights puede generar un resumen legible para las personas a partir de los resultados de su consulta mediante Amazon Bedrock. La función es compatible con todos los lenguajes de consulta de CloudWatch Logs Insights y proporciona información clara y procesable a partir de sus datos de registro.
## Disponibilidad regional y procesamiento de datos
**importante**
Al utilizar esta característica, es posible que los resultados de la consulta se procesen en una Región de AWS diferente. Por ejemplo, si se ejecuta una consulta en Este de EE. UU. (Norte de Virginia), el resumen podría tener lugar en Oeste de EE. UU. (Oregón).
En la siguiente tabla se muestra el posible procesamiento Región de AWS para las diferentes geografías en las que está disponible la función de resultados de la consulta:
| Geografía de CloudWatch registros admitida | Posible región de procesamiento |
| --- | --- |
| Estados Unidos (EE. UU.) | Región Este de EE. UU. (Norte de Virginia) US East (Ohio) Region Región oeste de EE. UU (Oregón) |
| Europa | Europe (Frankfurt) Region Región de Europa (Irlanda) Región de Europa (París) Región Europa (Estocolmo) Región de Europa (Londres) |
| Asia Pacífico | Región Este de EE. UU. (Norte de Virginia) US East (Ohio) Region Región oeste de EE. UU (Oregón) |
| América del Sur | Región Este de EE. UU. (Norte de Virginia) US East (Ohio) Region Región oeste de EE. UU (Oregón) |
## Introducción
**Creación de un resumen en lenguaje natural**
1. Ejecute su consulta CloudWatch de Logs Insights.
1. Una vez completada la consulta, seleccione **Resumen de los resultados**.
## Permisos
Se debe disponer de una de las siguientes:
+ Permiso de `CloudWatchLogsFullAccess`
+ Permiso de `CloudWatchLogsReadOnlyAccess`
+ Política de IAM personalizada que incluye las acciones `cloudwatch:GenerateQueryResultsSummary`, `logs:GetQueryResults`, `logs:DescribeQueries` y `logs:FilterLogEvents`
## Privacidad de datos
Los resultados de su consulta se procesan de forma segura y no se utilizan para entrenar o mejorar CloudWatch Logs Insights o Amazon Bedrock. Si opta por enviar comentarios sobre el resumen de los resultados de la consulta mediante los botones de comentarios, sus comentarios indican su nivel de satisfacción con la capacidad proporcionada en CloudWatch Logs Insights.