# Consulta de métricas de CloudWatch con Información de métricas de CloudWatch
<a name="query_with_cloudwatch-metrics-insights"></a>

Información de métricas de CloudWatch es un potente motor de consultas SQL de alto rendimiento que puede utilizar para consultar sus métricas a escala. Puede identificar tendencias y patrones dentro de todas las métricas de CloudWatch, con acceso a hasta dos semanas de datos históricos para un análisis exhaustivo de las tendencias.

También puede configurar alarmas en cualquier consulta de Información de métricas que devuelva una sola serie temporal. Esto puede resultar especialmente útil para crear alarmas que controlen las métricas agregadas de una flota de su infraestructura o aplicaciones. Cree la alarma una vez y verá que se ajusta dinámicamente a medida que se agreguen o se eliminen recursos de la flota.

 Puede realizar una consulta de Información de métricas de CloudWatch en la consola con el editor de consultas de la Información de métricas de CloudWatch. También puede realizar una consulta de Información de métricas de CloudWatch con la AWS CLI o SDK de AWS al ejecutar `GetMetricData` o `PutDashboard`. Las consultas que ejecute con el editor de consultas de Información de métricas de CloudWatch son gratuitas. Para obtener más información sobre los precios de CloudWatch, consulte [Precios de Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/). 

 Con el editor de consultas de Información de métricas de CloudWatch, puede elegir entre una variedad de consultas de ejemplo prediseñadas y también crear sus propias consultas. Al crear las consultas, puede utilizar una vista de generador para examinar las métricas y dimensiones existentes. También puede usar una vista de editor para escribir las consultas de forma manual. 

Puede ejecutar consultas a escala con Información de métricas. Con la cláusula **AGRUPAR POR**, puede agrupar sus métricas en tiempo real, en series temporales separadas por valor de dimensión específico. Como las consultas de Información de métricas incluyen la función **ORDENAR POR**, puede utilizar Información de métricas para realizar consultas del tipo “N principales”. Por ejemplo, las consultas del tipo “N principales” pueden analizar millones de métricas de su cuenta y arrojar las 10 instancias que consumen más CPU. Esto puede ayudarlo a identificar y solucionar los problemas de latencia en sus aplicaciones. Para usar etiquetas con alarmas, active la opción a través de la configuración de CloudWatch. Una vez activadas las etiquetas, también puede filtrar y agrupar las métricas mediante etiquetas de recursos de AWS, lo que le permite consultar las métricas alineadas con su estructura organizativa, por ejemplo, por aplicación, entorno o equipo.

**Topics**
+ [Creación de consultas en Información de métricas de CloudWatch](cloudwatch-metrics-insights-buildquery.md)
+ [Componentes de consulta y sintaxis de Información de métricas de CloudWatch](cloudwatch-metrics-insights-querylanguage.md)
+ [Alarmas en las consultas de Información de métricas de CloudWatch en CloudWatch](cloudwatch-metrics-insights-alarms.md)
+ [Uso de consultas de Información de métricas con matemáticas de métricas](cloudwatch-metrics-insights-math.md)
+ [Uso de lenguaje natural para generar y actualizar consultas de Información de métricas de CloudWatch](cloudwatch-metrics-insights-query-assist.md)
+ [Inferencia en SQL](cloudwatch-metrics-insights-inference.md)
+ [Cuotas de Información de métricas](cloudwatch-metrics-insights-limits.md)
+ [Consultas de ejemplo de Información de métricas](cloudwatch-metrics-insights-queryexamples.md)
+ [Glosario de Información de métricas](cloudwatch-metrics-insights-glossary.md)
+ [Solución de problemas de Información de métricas](cloudwatch-metrics-insights-troubleshooting.md)

# Creación de consultas en Información de métricas de CloudWatch
<a name="cloudwatch-metrics-insights-buildquery"></a>

Puede ejecutar una consulta de Información de métricas de CloudWatch mediante la consola de CloudWatch, AWS CLI o SDK de AWS. Las consultas que se realizan en la consola son gratuitas. Para obtener más información sobre los precios de CloudWatch, consulte [Precios de Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/).

Con Información de métricas de CloudWatch, puede analizar los datos de las métricas en periodos prolongados de hasta dos semanas, lo que hace posible un análisis histórico y una identificación de tendencias más exhaustivos en comparación con los periodos de retención más cortos. Para obtener un rendimiento óptimo al consultar intervalos de tiempo más largos, considere la posibilidad de utilizar periodos más prolongados (como 5 minutos o 1 hora) para reducir la cantidad de puntos de datos que se devuelvan. Al analizar las tendencias durante un periodo completo de dos semanas, utilice funciones agregadas, como AVG() o MAX(), en las cláusulas ORDER BY para detectar los patrones de manera eficiente.

Para obtener más información acerca del uso de SDK de AWS para realizar una consulta de Información de métricas, consulte [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html).

Para ejecutar una consulta mediante la consola de CloudWatch, siga estos pasos:

**Para consultar las métricas mediante Información de métricas**

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, seleccione **Métricas** y, a continuación, **Todas las métricas**.

1. (Opcional) Para ejecutar una consulta de ejemplo prediseñada, elija **Add query** (Agregar consulta) y seleccione la consulta que se va a ejecutar. Si está satisfecho con esta consulta, puede omitir el resto del procedimiento. De lo contrario, puede elegir **Editor** para editar la consulta de ejemplo y luego, **Run** (Ejecutar) para ejecutar la consulta modificada. 

1. Para crear su propia consulta, seleccione **Consulta de varios orígenes**. A continuación, puede utilizar la vista **Creador** (predeterminada) para obtener una experiencia guiada, o la vista **Editor** si prefiere ver la sintaxis de la consulta. Puede cambiar entre las dos vistas en cualquier momento y ver su trabajo en curso en ambas vistas. 

   En la vista **Creador**, haga clic en los campos de espacio de nombres, nombre de la métrica, filtro, grupo, orden y límite para explorar y seleccionar los valores posibles. Puede comenzar a escribir cualquier parte del valor que busca para filtrar la lista presentada por el creador. Puede hacer referencia a las etiquetas de recursos en el filtro y agrupar las entradas.

   En la vista **Editor**, puede escribir la consulta con el subconjunto de SQL compatible con Información de métricas. El editor ofrece opciones de autocompletar en función de los caracteres que ha escrito hasta ahora, como el nombre de las etiquetas de recursos para las métricas que las admiten.

   Información de métricas de CloudWatch permite consultar métricas por etiquetas de recursos de AWS. Puede usar etiquetas para filtrar y agrupar los datos de las métricas para una supervisión y un análisis más segmentados.

   En los siguientes ejemplos, se muestra cómo puede utilizar consultas con etiquetas.

   Visualización del uso de la CPU de las instancias de Amazon EC2 en el entorno de producción:

   ```
   SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") WHERE tag.env='prod'
   ```

   Agrupación de las métricas por entorno mediante la cláusula GROUP BY:

   ```
   SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") GROUP BY tag.env
   ```

   Uso de la cláusula GROUP BY, en la que se especifica el nombre de la etiqueta:

   ```
   SELECT AVG(CPUUtilization) FROM "AWS/EC2" GROUP BY tag."aws:cloudformation:stack-name"
   ```

   Combinación de consultas de etiquetas con dimensiones de métricas existentes:

   ```
   SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") WHERE tag.env='prod' AND InstanceId='i-1234567890abcdef0'
   ```

1. Cuando esté satisfecho con la consulta, elija **Save** (Guardar).

1. (Opcional) Otra forma de editar una consulta que haya representado es seleccionar la pestaña **Graphed metrics** (Representación gráfica de métricas) y elegir el icono de edición junto a la fórmula de consulta en la columna **Details** (Detalles).

1. (Opcional) Para quitar una consulta del gráfico, elija **Graphed metrics** (Representación gráfica de métricas) y, luego, el ícono de **X** en la parte derecha de la fila en la que se muestra la consulta.

# Componentes de consulta y sintaxis de Información de métricas de CloudWatch
<a name="cloudwatch-metrics-insights-querylanguage"></a>

La sintaxis de Información de métricas de CloudWatch se detalla a continuación.

```
SELECT FUNCTION(metricName)
FROM namespace | SCHEMA(...)
[ WHERE labelKey OPERATOR labelValue [AND ... ] ]
[ GROUP BY labelKey [ , ... ] ]
[ ORDER BY FUNCTION() [ DESC | ASC ] ]
[ LIMIT number ]
```

Las cláusulas posibles de una consulta de Información de métricas se detallan a continuación. Ninguna de las palabras clave distingue mayúsculas de minúsculas, al contrario de los identificadores como los nombres de las métricas, los espacios de nombres y las dimensiones.

**SELECT**  
Obligatorio. Especifica la función que se va a utilizar para agregar observaciones en cada bucket de tiempo (determinada por el periodo proporcionado). También especifica el nombre de la métrica que se va a consultar.  
Los valores válidos de **FUNCTION** (FUNCIÓN) son `AVG`, `COUNT`, `MAX`, `MIN`, y `SUM`.  
+ `AVG` calcula el promedio de las observaciones que coinciden con la consulta.
+ `COUNT` devuelve el recuento de las observaciones que coinciden con la consulta.
+ `MAX` devuelve el valor máximo de las observaciones que coinciden con la consulta.
+ `MIN` devuelve el valor mínimo de las observaciones que coinciden con la consulta.
+ `SUM` calcula la suma de las observaciones que coinciden con la consulta.

**FROM**  
Obligatorio. Especifica el origen de la métrica. Puede especificar el espacio de nombres de métrica que contiene la métrica que se va a consultar o una función de tabla de **SCHEMA** (ESQUEMA). Algunos ejemplos de espacios de nombres de métrica incluyen `"AWS/EC2"`, `"AWS/Lambda"` y los espacios de nombres de métricas que usted creó para sus métricas personalizadas.  
Los espacios de nombres de métrica que incluyen **/** o cualquier otro carácter que no sea una letra, un número o un guion bajo debe estar rodeado de comillas dobles. Para obtener más información, consulte [¿Dónde se deben colocar comillas o caracteres de escape?](#cloudwatch-metrics-insights-syntaxdetails).  
**SCHEMA**  
Función de tabla opcional que se puede utilizar dentro de una cláusula de **FROM** (DESDE). Use **SCHEMA** (ESQUEMA) para reducir el alcance de los resultados de la consulta solo a las métricas que coinciden exactamente con una lista de dimensiones o métricas que no tienen dimensiones.   
Si usa una cláusula de **SCHEMA** (ESQUEMA), esta debe contener al menos un argumento y este primer argumento debe ser el espacio de nombres de métrica que se consulta. Si especifica el **SCHEMA** (ESQUEMA) solo con este argumento de espacio de nombres, los resultados se reducen únicamente a métricas que no tienen dimensiones.  
Si especifica **SCHEMA** (ESQUEMA) con argumentos adicionales, los argumentos adicionales posteriores al argumento de espacio de nombres deben ser claves de *etiqueta*. Las claves de etiqueta deben ser nombres de dimensión. Si especifica una o más de estas claves de etiqueta, los resultados se reducen únicamente a las métricas que tienen ese conjunto exacto de dimensiones. El orden de estas claves de etiqueta no es importante.  
Por ejemplo:  
+ **SELECCIONAR AVG(CPUUtilization) DESDE “AWS/EC2”** coincide con todas las métricas de `CPUUtilization` en el espacio de nombres de `AWS/EC2`, independientemente de sus dimensiones, y devuelve una única serie temporal acumulada. 
+ **SELECCIONAR AVG(CPUUtilization) DESDE ESQUEMA DE (“AWS/EC2”)** solo coincide con las métricas de `CPUUtilization` en el espacio de nombres de `AWS/EC2` que no tiene ninguna dimensión definida.
+ **SELECCIONAR AVG(CPUUtilization) DESDE ESQUEMA DE (“AWS/EC2”, InstanceId)** solo coincide con las métricas de `CPUUtilization` que se notificaron a CloudWatch con exactamente una dimensión, `InstanceId`.
+ **SELECCIONAR SUM(RequestCount) DESDE ESQUEMA DE (“AWS/ApplicationELB”, LoadBalancer, AvailabilityZone)** solo coincide con las métricas de `RequestCount` que se han notificado a CloudWatch desde `AWS/ApplicationELB` con exactamente dos dimensiones, `LoadBalancer` y `AvailabilityZone`.

**WHERE**  
Opcional. Filtra los resultados solo a aquellas métricas que coinciden con la expresión especificada mediante valores de etiqueta específicos para una o más claves de etiqueta. Por ejemplo, **WHERE InstanceType = 'c3.4xlarge'** (DONDE InstanceType = 'c3.4xlarge') filtra los resultados únicamente a los tipos de instancia `c3.4xlarge` y **WHERE InstanceType \$1= 'c3.4xlarge'** (DONDE InstanceType \$1= 'c3.4xlarge') filtra los resultados en todos los tipos de instancias, excepto `c3.4xlarge`.  
Cuando ejecute una consulta en una cuenta de supervisión, puede utilizar `WHERE AWS.AccountId` para limitar los resultados únicamente a la cuenta que especifique. Por ejemplo, las métricas de consulta `WHERE AWS.AccountId=444455556666` únicamente de la cuenta `444455556666`. Para limitar la consulta solo a las métricas de la propia cuenta de supervisión, utilice `WHERE AWS.AccountId=CURRENT_ACCOUNT_ID()`.  
Los valores de etiqueta siempre deben rodearse de comillas simples.  
**Uso de etiquetas en cláusulas WHERE**  
Puede filtrar los resultados por etiquetas de recursos de AWS mediante la sintaxis `tag.keyName`. Los filtros de etiquetas siguen las mismas reglas de operador que los filtros de dimensiones. Por ejemplo:  
+ WHERE `tag.env = 'prod'` filtra las métricas de recursos etiquetados con *env=prod*.
+ WHERE `tag.department != 'test'` excluye las métricas de recursos etiquetados con *department=test*.
Los filtros de etiquetas se pueden combinar con filtros de dimensiones:  
`WHERE tag.env = 'prod' AND InstanceType = 'm5.large'`  
**Operadores admitidos**  
La cláusula **WHERE** (DONDE) es compatible con los siguientes operadores:  
+ **=** El valor de etiqueta debe coincidir con la cadena especificada.
+ **\$1=** El valor de etiqueta no debe coincidir con la cadena especificada.
+ **AND** (Y) Ambas condiciones especificadas deben ser verdaderas para que coincidan. Puede usar varias palabras clave **AND** (Y) para especificar dos o más condiciones.

**GROUP BY**  
Opcional. Agrupa los resultados de la consulta en varias series temporales y cada una de ellas corresponde a un valor diferente para la clave o claves de etiqueta especificadas. Por ejemplo, si utiliza `GROUP BY InstanceId`, devuelve una serie temporal diferente para cada valor de `InstanceId`. El uso de `GROUP BY ServiceName, Operation` crea una serie temporal diferente para cada combinación posible de los valores de `ServiceName` y `Operation`.  
Si utiliza la cláusula **GROUP BY** (AGRUPAR POR), los resultados se ordenan en orden alfabético ascendente de forma predeterminada, a través de la secuencia de etiquetas especificada en la cláusula **GROUP BY** (AGRUPAR POR). Para cambiar el orden de los resultados, agregue una cláusula **ORDER BY** (AGRUPAR POR) a su consulta.   
Cuando ejecuta una consulta en una cuenta de supervisión, puede utilizar `GROUP BY AWS.AccountId` para agrupar los resultados en función de las cuentas de las que provienen.  
**Uso de etiquetas en cláusulas GROUP BY**  
Puede agrupar los resultados por valores de etiquetas de recursos de AWS mediante la sintaxis `tag.keyName`. Por ejemplo:  
+ *GROUP BY tag.environment* crea series temporales separadas para cada valor de etiqueta de entorno.
+ *GROUP BY tag.team, InstanceType* agrupa tanto por valor de dimensión como etiqueta.
+ *GROUP BY tag.team, AWS.AccountId* agrupa tanto por AccountID de origen vinculado como etiqueta.
Si algunas de las métricas coincidentes no incluyen una clave de etiqueta especificada en la cláusula **GROUP BY** (AGRUPAR POR), esto devuelve un grupo nulo denominado `Other`. Por ejemplo, si especifica `GROUP BY ServiceName, Operation` y algunas de las métricas devueltas no incluyen `ServiceName` como dimensión, entonces esas métricas se muestran con el valor `Other` para `ServiceName`.

**ORDER BY**  
Opcional. Especifica el orden que se va a utilizar para la serie temporal devuelta, si la consulta devuelve más de una serie temporal. El orden se basa en los valores que encuentra la **FUNCTION** (FUNCIÓN) que usted especifique en la cláusula **ORDER BY** (AGRUPAR POR). La **FUNCTION** (FUNCIÓN) se utiliza para calcular un único valor escalar de cada serie temporal devuelta y ese valor se utiliza para determinar el orden.  
También debe especificar si se va a utilizar orden ascendente **ASC** o descendente **DESC**. Si omite esto, el valor predeterminado es ascendente **ASC**.  
Por ejemplo, al agregar una cláusula `ORDER BY MAX() DESC`, los resultados se ordenan según el punto de datos máximo observado dentro del intervalo de tiempo, en orden descendente, lo que significa que la serie temporal que tiene el punto de datos máximo más alto se devuelve primero.  
Las funciones válidas que se deben utilizar dentro de una cláusula **ORDER BY** (AGRUPAR POR) son `AVG()`, `COUNT()`, `MAX()`, `MIN()`, y `SUM()`.  
Si usa una cláusula de **AGRUPAR POR** con una cláusula de **LÍMITE**, la consulta resultante será una consulta “Top N”. **ORDER BY** (AGRUPAR POR) también es útil para consultas que pueden devolver un gran número de métricas porque cada consulta no puede devolver más de 500 series temporales. Si una consulta coincide con más de 500 series temporales y usted utiliza una cláusula de **ORDER BY** (AGRUPAR POR), las series temporales se ordenan y luego se devuelven las 500 series temporales que aparecen primero en el orden de clasificación.

**LIMIT**  
Opcional. Limita la cantidad de series temporales devueltas según la consulta al valor especificado. El valor máximo que puede especificar es 500 y una consulta que no especifica un **LIMIT** (LÍMITE) también puede devolver hasta 500 series temporales.  
El uso de una cláusula de **LÍMITE** con una de **AGRUPAR POR** le proporcionará una consulta “Top N”.

## ¿Dónde se deben colocar comillas o caracteres de escape?
<a name="cloudwatch-metrics-insights-syntaxdetails"></a>

En una consulta, los valores de etiqueta siempre deben estar rodeados de comillas simples. Por ejemplo, **SELECCIONAR MAX(CPUUtilization) DESDE “AWS/EC2” DONDE AutoScalingGroupName = 'my-production-fleet'**. 

Los espacios de nombres de métrica, los nombres de métricas y las claves de etiqueta que contienen caracteres que no son letras, números y guiones bajos (\$1) deben estar rodeados de comillas dobles. Por ejemplo, **SELECCIONAR MAX(“My.Metric”)**.

Si uno de ellos contiene comillas dobles o comillas simples en sí (como `Bytes"Input"`), debe escapar cada comilla con una barra invertida, como en **SELECCIONAR AVG(“Bytes\$1“Input\$1””)**. 

Si un espacio de nombres de métrica, un nombre de métrica o una clave de etiqueta contienen una palabra que es una palabra clave reservada en Información de métricas, también debe rodearse de comillas dobles. Por ejemplo, si tiene una métrica denominada `LIMIT`, utilizaría `SELECT AVG("LIMIT")`. También es válido incluir cualquier espacio de nombres, nombre de métrica o etiqueta entre comillas dobles, incluso si no contiene una palabra clave reservada.

Para obtener una lista completa de palabras clave reservadas, consulte [Palabras clave reservadas](cloudwatch-metrics-insights-reserved-keywords.md).

## Crear una consulta enriquecida paso a paso
<a name="cloudwatch-metrics-insights-syntaxexample"></a>

En esta sección se ilustra la creación de un ejemplo completo en el que se utilizan todas las cláusulas posibles, paso a paso.

Puede comenzar con la siguiente consulta, que agrega todas las métricas de `RequestCount` del equilibrador de carga de aplicación que se recopilan con las dimensiones `LoadBalancer` y `AvailabilityZone`.

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
```

Para ver métricas solo de un equilibrador de carga específico, podemos agregar una cláusula **WHERE** para limitar las métricas devueltas solo a aquellas métricas donde el valor de la dimensión `LoadBalancer` es `app/load-balancer-1`.

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
```

La consulta mencionada acumula las métricas `RequestCount` de todas las zonas de disponibilidad para este equilibrador de carga en una serie temporal. Si quiere ver series temporales diferentes para cada zona de disponibilidad, podemos agregar una cláusula **GROUP BY**.

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
```

A continuación, puede ordenar estos resultados para ver los valores más altos en primer lugar. La siguiente cláusula **ORDER BY** (AGRUPAR POR) ordena la serie temporal en orden descendente, según el valor máximo notificado por cada serie temporal durante el intervalo de tiempo de consulta:

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
ORDER BY MAX() DESC
```

Puede usar etiquetas para filtrar más los resultados. Por ejemplo, si quiere ver los resultados solo para los equilibradores de carga etiquetados con un entorno específico, podemos agregar el filtrado de etiquetas a la cláusula WHERE:

```
SELECT SUM(RequestCount) FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone) WHERE LoadBalancer = 'app/load-balancer-1' AND tag.Environment = 'prod' GROUP BY AvailabilityZone ORDER BY MAX() DESC
```

También puede agrupar los resultados por valores de etiqueta en lugar de (o además de) dimensiones. Por ejemplo, puede agrupar por etiqueta de aplicación:

```
SELECT SUM(RequestCount) FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone) WHERE tag.Environment = 'prod' GROUP BY tag.Application ORDER BY MAX() DESC
```

Por último, si nuestro interés principal es un tipo de consulta “Top N”, podemos utilizar una cláusula **LÍMITE**. Este último ejemplo limita los resultados únicamente a las series temporales con los cinco valores `MAX` más altos.

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
ORDER BY MAX() DESC
LIMIT 5
```

## Ejemplos de consultas entre cuentas
<a name="cloudwatch-metrics-insights-crossaccount"></a>

Estos ejemplos son válidos cuando se ejecutan en una cuenta configurada como cuenta de supervisión en la observabilidad entre cuentas de CloudWatch. 

En el siguiente ejemplo se buscan todas las instancias de Amazon EC2 de la cuenta de origen 123456789012 y se indica un promedio.

```
SELECT AVG(CpuUtilization) 
FROM "AWS/EC2" 
WHERE AWS.AccountId ='123456789012'
```

En el siguiente ejemplo, se consulta la métrica de `CPUUtilization` en `AWS/EC2` en todas las cuentas de origen vinculadas y se agrupan los resultados por ID de cuenta y tipo de instancia.

```
SELECT AVG(CpuUtilization) 
FROM "AWS/EC2" 
GROUP BY AWS.AccountId, InstanceType
```

En el siguiente ejemplo, se consulta `CPUUtilization` en la propia cuenta de supervisión.

```
SELECT AVG(CpuUtilization) 
FROM "AWS/EC2" 
WHERE AWS.AccountId = CURRENT_ACCOUNT_ID()
```

# Palabras clave reservadas
<a name="cloudwatch-metrics-insights-reserved-keywords"></a>

Las siguientes son palabras clave reservadas en Información de métricas de CloudWatch. Si alguna de estas palabras se encuentra en un espacio de nombres, un nombre de métrica o una clave de etiqueta de una consulta, debe rodearlas de comillas dobles. Las palabras clave reservadas no distinguen mayúsculas y minúsculas.

```
"ABORT" "ABORTSESSION" "ABS" "ABSOLUTE" "ACCESS" "ACCESSIBLE" "ACCESS_LOCK" "ACCOUNT" "ACOS" "ACOSH" "ACTION" "ADD" "ADD_MONTHS"
"ADMIN" "AFTER" "AGGREGATE" "ALIAS" "ALL" "ALLOCATE" "ALLOW" "ALTER" "ALTERAND" "AMP" "ANALYSE" "ANALYZE" "AND" "ANSIDATE" "ANY" "ARE" "ARRAY",
"ARRAY_AGG" "ARRAY_EXISTS" "ARRAY_MAX_CARDINALITY" "AS" "ASC" "ASENSITIVE" "ASIN" "ASINH" "ASSERTION" "ASSOCIATE" "ASUTIME" "ASYMMETRIC" "AT",
"ATAN" "ATAN2" "ATANH" "ATOMIC" "AUDIT" "AUTHORIZATION" "AUX" "AUXILIARY" "AVE" "AVERAGE" "AVG" "BACKUP" "BEFORE" "BEGIN" "BEGIN_FRAME" "BEGIN_PARTITION",
"BETWEEN" "BIGINT" "BINARY" "BIT" "BLOB" "BOOLEAN" "BOTH" "BREADTH" "BREAK" "BROWSE" "BT" "BUFFERPOOL" "BULK" "BUT" "BY" "BYTE" "BYTEINT" "BYTES" "CALL",
"CALLED" "CAPTURE" "CARDINALITY" "CASCADE" "CASCADED" "CASE" "CASESPECIFIC" "CASE_N" "CAST" "CATALOG" "CCSID" "CD" "CEIL" "CEILING" "CHANGE" "CHAR",
"CHAR2HEXINT" "CHARACTER" "CHARACTERS" "CHARACTER_LENGTH" "CHARS" "CHAR_LENGTH" "CHECK" "CHECKPOINT" "CLASS" "CLASSIFIER" "CLOB" "CLONE" "CLOSE" "CLUSTER",
"CLUSTERED" "CM" "COALESCE" "COLLATE" "COLLATION" "COLLECT" "COLLECTION" "COLLID" "COLUMN" "COLUMN_VALUE" "COMMENT" "COMMIT" "COMPLETION" "COMPRESS" "COMPUTE",
"CONCAT" "CONCURRENTLY" "CONDITION" "CONNECT" "CONNECTION" "CONSTRAINT" "CONSTRAINTS" "CONSTRUCTOR" "CONTAINS" "CONTAINSTABLE" "CONTENT" "CONTINUE" "CONVERT",
"CONVERT_TABLE_HEADER" "COPY" "CORR" "CORRESPONDING" "COS" "COSH" "COUNT" "COVAR_POP" "COVAR_SAMP" "CREATE" "CROSS" "CS" "CSUM" "CT" "CUBE" "CUME_DIST",
"CURRENT" "CURRENT_CATALOG" "CURRENT_DATE" "CURRENT_DEFAULT_TRANSFORM_GROUP" "CURRENT_LC_CTYPE" "CURRENT_PATH" "CURRENT_ROLE" "CURRENT_ROW" "CURRENT_SCHEMA",
"CURRENT_SERVER" "CURRENT_TIME" "CURRENT_TIMESTAMP" "CURRENT_TIMEZONE" "CURRENT_TRANSFORM_GROUP_FOR_TYPE" "CURRENT_USER" "CURRVAL" "CURSOR" "CV" "CYCLE" "DATA",
"DATABASE" "DATABASES" "DATABLOCKSIZE" "DATE" "DATEFORM" "DAY" "DAYS" "DAY_HOUR" "DAY_MICROSECOND" "DAY_MINUTE" "DAY_SECOND" "DBCC" "DBINFO" "DEALLOCATE" "DEC",
"DECFLOAT" "DECIMAL" "DECLARE" "DEFAULT" "DEFERRABLE" "DEFERRED" "DEFINE" "DEGREES" "DEL" "DELAYED" "DELETE" "DENSE_RANK" "DENY" "DEPTH" "DEREF" "DESC" "DESCRIBE",
"DESCRIPTOR" "DESTROY" "DESTRUCTOR" "DETERMINISTIC" "DIAGNOSTIC" "DIAGNOSTICS" "DICTIONARY" "DISABLE" "DISABLED" "DISALLOW" "DISCONNECT" "DISK" "DISTINCT",
"DISTINCTROW" "DISTRIBUTED" "DIV" "DO" "DOCUMENT" "DOMAIN" "DOUBLE" "DROP" "DSSIZE" "DUAL" "DUMP" "DYNAMIC" "EACH" "ECHO" "EDITPROC" "ELEMENT" "ELSE" "ELSEIF",
"EMPTY" "ENABLED" "ENCLOSED" "ENCODING" "ENCRYPTION" "END" "END-EXEC" "ENDING" "END_FRAME" "END_PARTITION" "EQ" "EQUALS" "ERASE" "ERRLVL" "ERROR" "ERRORFILES",
"ERRORTABLES" "ESCAPE" "ESCAPED" "ET" "EVERY" "EXCEPT" "EXCEPTION" "EXCLUSIVE" "EXEC" "EXECUTE" "EXISTS" "EXIT" "EXP" "EXPLAIN" "EXTERNAL" "EXTRACT" "FALLBACK
"FALSE" "FASTEXPORT" "FENCED" "FETCH" "FIELDPROC" "FILE" "FILLFACTOR" "FILTER" "FINAL" "FIRST" "FIRST_VALUE" "FLOAT" "FLOAT4" "FLOAT8" "FLOOR" 
"FOR" "FORCE" "FOREIGN" "FORMAT" "FOUND" "FRAME_ROW" "FREE" "FREESPACE" "FREETEXT" "FREETEXTTABLE" "FREEZE" "FROM" "FULL" "FULLTEXT" "FUNCTION" 
"FUSION" "GE" "GENERAL" "GENERATED" "GET" "GIVE" "GLOBAL" "GO" "GOTO" "GRANT" "GRAPHIC" "GROUP" "GROUPING" "GROUPS" "GT" "HANDLER" "HASH" 
"HASHAMP" "HASHBAKAMP" "HASHBUCKET" "HASHROW" "HAVING" "HELP" "HIGH_PRIORITY" "HOLD" "HOLDLOCK" "HOUR" "HOURS" "HOUR_MICROSECOND" "HOUR_MINUTE" 
"HOUR_SECOND" "IDENTIFIED" "IDENTITY" "IDENTITYCOL" "IDENTITY_INSERT" "IF" "IGNORE" "ILIKE" "IMMEDIATE" "IN" "INCLUSIVE" "INCONSISTENT" "INCREMENT" 
"INDEX" "INDICATOR" "INFILE" "INHERIT" "INITIAL" "INITIALIZE" "INITIALLY" "INITIATE" "INNER" "INOUT" "INPUT" "INS" "INSENSITIVE" "INSERT" "INSTEAD" 
"INT" "INT1" "INT2" "INT3" "INT4" "INT8" "INTEGER" "INTEGERDATE" "INTERSECT" "INTERSECTION" "INTERVAL" "INTO" "IO_AFTER_GTIDS" "IO_BEFORE_GTIDS" 
"IS" "ISNULL" "ISOBID" "ISOLATION" "ITERATE" "JAR" "JOIN" "JOURNAL" "JSON_ARRAY" "JSON_ARRAYAGG" "JSON_EXISTS" "JSON_OBJECT" "JSON_OBJECTAGG" 
"JSON_QUERY" "JSON_TABLE" "JSON_TABLE_PRIMITIVE" "JSON_VALUE" "KEEP" "KEY" "KEYS" "KILL" "KURTOSIS" "LABEL" "LAG" "LANGUAGE" "LARGE" "LAST" 
"LAST_VALUE" "LATERAL" "LC_CTYPE" "LE" "LEAD" "LEADING" "LEAVE" "LEFT" "LESS" "LEVEL" "LIKE" "LIKE_REGEX" "LIMIT" "LINEAR" "LINENO" "LINES" 
"LISTAGG" "LN" "LOAD" "LOADING" "LOCAL" "LOCALE" "LOCALTIME" "LOCALTIMESTAMP" "LOCATOR" "LOCATORS" "LOCK" "LOCKING" "LOCKMAX" "LOCKSIZE" "LOG" 
"LOG10" "LOGGING" "LOGON" "LONG" "LONGBLOB" "LONGTEXT" "LOOP" "LOWER" "LOW_PRIORITY" "LT" "MACRO" "MAINTAINED" "MAP" "MASTER_BIND" 
"MASTER_SSL_VERIFY_SERVER_CERT" "MATCH" "MATCHES" "MATCH_NUMBER" "MATCH_RECOGNIZE" "MATERIALIZED" "MAVG" "MAX" "MAXEXTENTS" "MAXIMUM" "MAXVALUE" 
"MCHARACTERS" "MDIFF" "MEDIUMBLOB" "MEDIUMINT" "MEDIUMTEXT" "MEMBER" "MERGE" "METHOD" "MICROSECOND" "MICROSECONDS" "MIDDLEINT" "MIN" "MINDEX" 
"MINIMUM" "MINUS" "MINUTE" "MINUTES" "MINUTE_MICROSECOND" "MINUTE_SECOND" "MLINREG" "MLOAD" "MLSLABEL" "MOD" "MODE" "MODIFIES" "MODIFY" 
"MODULE" "MONITOR" "MONRESOURCE" "MONSESSION" "MONTH" "MONTHS" "MSUBSTR" "MSUM" "MULTISET" "NAMED" "NAMES" "NATIONAL" "NATURAL" "NCHAR" "NCLOB" 
"NE" "NESTED_TABLE_ID" "NEW" "NEW_TABLE" "NEXT" "NEXTVAL" "NO" "NOAUDIT" "NOCHECK" "NOCOMPRESS" "NONCLUSTERED" "NONE" "NORMALIZE" "NOT" "NOTNULL" 
"NOWAIT" "NO_WRITE_TO_BINLOG" "NTH_VALUE" "NTILE" "NULL" "NULLIF" "NULLIFZERO" "NULLS" "NUMBER" "NUMERIC" "NUMPARTS" "OBID" "OBJECT" "OBJECTS" 
"OCCURRENCES_REGEX" "OCTET_LENGTH" "OF" "OFF" "OFFLINE" "OFFSET" "OFFSETS" "OLD" "OLD_TABLE" "OMIT" "ON" "ONE" "ONLINE" "ONLY" "OPEN" "OPENDATASOURCE" 
"OPENQUERY" "OPENROWSET" "OPENXML" "OPERATION" "OPTIMIZATION" "OPTIMIZE" "OPTIMIZER_COSTS" "OPTION" "OPTIONALLY" "OR" "ORDER" "ORDINALITY" "ORGANIZATION" 
"OUT" "OUTER" "OUTFILE" "OUTPUT" "OVER" "OVERLAPS" "OVERLAY" "OVERRIDE" "PACKAGE" "PAD" "PADDED" "PARAMETER" "PARAMETERS" "PART" "PARTIAL" "PARTITION" 
"PARTITIONED" "PARTITIONING" "PASSWORD" "PATH" "PATTERN" "PCTFREE" "PER" "PERCENT" "PERCENTILE" "PERCENTILE_CONT" "PERCENTILE_DISC" "PERCENT_RANK" "PERIOD" "PERM" 
"PERMANENT" "PIECESIZE" "PIVOT" "PLACING" "PLAN" "PORTION" "POSITION" "POSITION_REGEX" "POSTFIX" "POWER" "PRECEDES" "PRECISION" "PREFIX" "PREORDER" 
"PREPARE" "PRESERVE" "PREVVAL" "PRIMARY" "PRINT" "PRIOR" "PRIQTY" "PRIVATE" "PRIVILEGES" "PROC" "PROCEDURE" "PROFILE" "PROGRAM" "PROPORTIONAL" 
"PROTECTION" "PSID" "PTF" "PUBLIC" "PURGE" "QUALIFIED" "QUALIFY" "QUANTILE" "QUERY" "QUERYNO" "RADIANS" "RAISERROR" "RANDOM" "RANGE" "RANGE_N" "RANK" 
"RAW" "READ" "READS" "READTEXT" "READ_WRITE" "REAL" "RECONFIGURE" "RECURSIVE" "REF" "REFERENCES" "REFERENCING" "REFRESH" "REGEXP" "REGR_AVGX" "REGR_AVGY" 
"REGR_COUNT" "REGR_INTERCEPT" "REGR_R2" "REGR_SLOPE" "REGR_SXX" "REGR_SXY" "REGR_SYY" "RELATIVE" "RELEASE" "RENAME" "REPEAT" "REPLACE" "REPLICATION" 
"REPOVERRIDE" "REQUEST" "REQUIRE" "RESIGNAL" "RESOURCE" "RESTART" "RESTORE" "RESTRICT" "RESULT" "RESULT_SET_LOCATOR" "RESUME" "RET" "RETRIEVE" "RETURN" 
"RETURNING" "RETURNS" "REVALIDATE" "REVERT" "REVOKE" "RIGHT" "RIGHTS" "RLIKE" "ROLE" "ROLLBACK" "ROLLFORWARD" "ROLLUP" "ROUND_CEILING" "ROUND_DOWN" 
"ROUND_FLOOR" "ROUND_HALF_DOWN" "ROUND_HALF_EVEN" "ROUND_HALF_UP" "ROUND_UP" "ROUTINE" "ROW" "ROWCOUNT" "ROWGUIDCOL" "ROWID" "ROWNUM" "ROWS" "ROWSET" 
"ROW_NUMBER" "RULE" "RUN" "RUNNING" "SAMPLE" "SAMPLEID" "SAVE" "SAVEPOINT" "SCHEMA" "SCHEMAS" "SCOPE" "SCRATCHPAD" "SCROLL" "SEARCH" "SECOND" "SECONDS" 
"SECOND_MICROSECOND" "SECQTY" "SECTION" "SECURITY" "SECURITYAUDIT" "SEEK" "SEL" "SELECT" "SEMANTICKEYPHRASETABLE" "SEMANTICSIMILARITYDETAILSTABLE" 
"SEMANTICSIMILARITYTABLE" "SENSITIVE" "SEPARATOR" "SEQUENCE" "SESSION" "SESSION_USER" "SET" "SETRESRATE" "SETS" "SETSESSRATE" "SETUSER" "SHARE" "SHOW" 
"SHUTDOWN" "SIGNAL" "SIMILAR" "SIMPLE" "SIN" "SINH" "SIZE" "SKEW" "SKIP" "SMALLINT" "SOME" "SOUNDEX" "SOURCE" "SPACE" "SPATIAL" "SPECIFIC" "SPECIFICTYPE" 
"SPOOL" "SQL" "SQLEXCEPTION" "SQLSTATE" "SQLTEXT" "SQLWARNING" "SQL_BIG_RESULT" "SQL_CALC_FOUND_ROWS" "SQL_SMALL_RESULT" "SQRT" "SS" "SSL" "STANDARD" 
"START" "STARTING" "STARTUP" "STAT" "STATE" "STATEMENT" "STATIC" "STATISTICS" "STAY" "STDDEV_POP" "STDDEV_SAMP" "STEPINFO" "STOGROUP" "STORED" "STORES" 
"STRAIGHT_JOIN" "STRING_CS" "STRUCTURE" "STYLE" "SUBMULTISET" "SUBSCRIBER" "SUBSET" "SUBSTR" "SUBSTRING" "SUBSTRING_REGEX" "SUCCEEDS" "SUCCESSFUL" 
"SUM" "SUMMARY" "SUSPEND" "SYMMETRIC" "SYNONYM" "SYSDATE" "SYSTEM" "SYSTEM_TIME" "SYSTEM_USER" "SYSTIMESTAMP" "TABLE" "TABLESAMPLE" "TABLESPACE" "TAN" 
"TANH" "TBL_CS" "TEMPORARY" "TERMINATE" "TERMINATED" "TEXTSIZE" "THAN" "THEN" "THRESHOLD" "TIME" "TIMESTAMP" "TIMEZONE_HOUR" "TIMEZONE_MINUTE" "TINYBLOB" 
"TINYINT" "TINYTEXT" "TITLE" "TO" "TOP" "TRACE" "TRAILING" "TRAN" "TRANSACTION" "TRANSLATE" "TRANSLATE_CHK" "TRANSLATE_REGEX" "TRANSLATION" "TREAT" 
"TRIGGER" "TRIM" "TRIM_ARRAY" "TRUE" "TRUNCATE" "TRY_CONVERT" "TSEQUAL" "TYPE" "UC" "UESCAPE" "UID" "UNDEFINED" "UNDER" "UNDO" "UNION" "UNIQUE" 
"UNKNOWN" "UNLOCK" "UNNEST" "UNPIVOT" "UNSIGNED" "UNTIL" "UPD" "UPDATE" "UPDATETEXT" "UPPER" "UPPERCASE" "USAGE" "USE" "USER" "USING" "UTC_DATE" 
"UTC_TIME" "UTC_TIMESTAMP" "VALIDATE" "VALIDPROC" "VALUE" "VALUES" "VALUE_OF" "VARBINARY" "VARBYTE" "VARCHAR" "VARCHAR2" "VARCHARACTER" "VARGRAPHIC" 
"VARIABLE" "VARIADIC" "VARIANT" "VARYING" "VAR_POP" "VAR_SAMP" "VCAT" "VERBOSE" "VERSIONING" "VIEW" "VIRTUAL" "VOLATILE" "VOLUMES" "WAIT" "WAITFOR" 
"WHEN" "WHENEVER" "WHERE" "WHILE" "WIDTH_BUCKET" "WINDOW" "WITH" "WITHIN" "WITHIN_GROUP" "WITHOUT" "WLM" "WORK" "WRITE" "WRITETEXT" "XMLCAST" "XMLEXISTS" 
"XMLNAMESPACES" "XOR" "YEAR" "YEARS" "YEAR_MONTH" "ZEROFILL" "ZEROIFNULL" "ZONE"
```

# Alarmas en las consultas de Información de métricas de CloudWatch en CloudWatch
<a name="cloudwatch-metrics-insights-alarms"></a>

Puede crear alarmas en las consultas de Información de métricas Esto le permite tener alarmas que rastreen varios recursos sin necesidad de actualizarlas más adelante. La consulta detecta los nuevos recursos y aquellos que cambien. Por ejemplo, puede crear una alarma que controle el uso de la CPU de la flota y que evalúe automáticamente las nuevas instancias que lance después de crearla.

En una cuenta de supervisión que esté configurada para la observabilidad entre cuentas de CloudWatch, sus alarmas de Información de métricas pueden supervisar los recursos en las cuentas de origen y en la propia cuenta de supervisión. Para obtener más información sobre cómo limitar las consultas de alarmas a una cuenta específica o cómo agrupar los resultados por ID de cuenta, consulte las secciones `WHERE` y `GROUP BY` de [Componentes de consulta y sintaxis de Información de métricas de CloudWatch](cloudwatch-metrics-insights-querylanguage.md).

**Uso de etiquetas en consultas de alarma**

Puede crear alarmas en las consultas de Información de métricas que utilizan etiquetas de recursos de AWS para filtrar y agrupar métricas. Para usar etiquetas con alarmas, en [https://console.aws.amazon.com/connect/](https://console.aws.amazon.com/connect/), elija **Configuración**. En la página **Configuración de CloudWatch**, en **Habilitar etiquetas de recursos para la telemetría**, elija **Habilitar**. Las alarmas basadas en el contexto supervisan aplicaciones, entornos o equipos específicos de forma automática a medida que cambian los recursos.

Por ejemplo, puede crear una alarma que supervise el uso de la CPU para todas las instancias de Amazon EC2 etiquetadas con una aplicación específica.

```
SELECT MAX(CPUUtilization) FROM "AWS/EC2" WHERE tag.Application = 'Orders' AND tag.Environment = 'Prod'
```

Las alarmas basadas en etiquetas se adaptan automáticamente a medida que agrega o elimina recursos con etiquetas coincidentes, lo que proporciona una supervisión dinámica alineada con su estructura operativa.

**Contents**
+ [Creación de una alarma de Información de métricas de CloudWatch](cloudwatch-metrics-insights-alarm-create.md)

# Creación de una alarma de Información de métricas de CloudWatch
<a name="cloudwatch-metrics-insights-alarm-create"></a>

**Creación de una alarma en una consulta de Información de métricas mediante la consola**

1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, seleccione **Métricas** y, a continuación, **Todas las métricas**.

1. (Opcional) Para ejecutar una consulta de ejemplo prediseñada, elija **Add query** (Agregar consulta) y seleccione la consulta que se va a ejecutar. De lo contrario, puede elegir **Editor** para editar la consulta de ejemplo y luego, **Run** (Ejecutar) para ejecutar la consulta modificada. 

1. Para crear su propia consulta, seleccione **Consulta de varios orígenes**. A continuación, puede usar la vista **Generador**, la vista **Editor** y una combinación de ambas. Puede cambiar entre las dos vistas en cualquier momento y ver su trabajo en curso en ambas vistas. 

   En la vista **Builder** (Generador), puede examinar y seleccionar el espacio de nombre de métrica, el nombre de métrica, el filtro, el grupo y las opciones de pedido. Para cada una de estas opciones, el generador de consultas le ofrece una lista de posibles selecciones de su entorno de donde puede elegir.

   En la vista **Editor**, puede comenzar a escribir su consulta. A medida que escribe, el editor ofrece sugerencias basadas en los caracteres que ha escrito hasta el momento.

   Por ejemplo, al crear una consulta de Información de métricas para la alarma, puede usar etiquetas para filtrar y agrupar métricas para una supervisión más segmentada.
   + Filtrar por etiqueta: utilice `WHERE tag.keyName = 'value'` para supervisar recursos con etiquetas específicas.

     ```
     SELECT MAX(CPUUtilization) FROM "AWS/EC2" WHERE tag.Environment = 'Prod'
     ```
   + Combinar etiquetas con dimensiones: mezcle filtros de etiqueta con dimensiones de métrica existentes.

     ```
     SELECT AVG(Duration) FROM "AWS/Lambda" WHERE tag.Application = 'OrderService' AND FunctionName = 'process%'
     ```
**nota**  
Al usar etiquetas, las alarmas coincidirán con las métricas solo si las etiquetas especificadas existían en los recursos asociados durante el periodo de tiempo evaluado.

1. Cuando esté satisfecho con la consulta, elija **Save** (Guardar).

1. Elija **Crear alarma**.

1. En **Conditions (Condiciones)**, especifique lo siguiente:

   1. En **Whenever *metric* is (Siempre que la métrica sea)**, especifique si la métrica debe ser mayor que, menor que o igual al umbral. En **than... (que...)**, especifique el valor de umbral.

   1. Elija **Configuración adicional**. Para **Puntos de datos para alarma**, especifique el número de periodos de evaluación (puntos de datos) que deben tener el estado `ALARM` para que se active la alarma. Si estos dos valores coinciden, creerá una alarma que pasará al estado `ALARM` si se infringen muchos periodos consecutivos.

      Para crear una alarma M de N, especifique un número menor para el primer valor que el especificado para el segundo valor. Para obtener más información, consulte [Evaluación de alarmas](alarm-evaluation.md).

   1. En **Missing data treatment (Tratamiento de datos que faltan)**, elija cómo debe comportarse la alarma cuando falten algunos puntos de datos. Para obtener más información, consulte [Configuración de la forma en la que las alarmas de CloudWatch tratan los datos que faltan](alarms-and-missing-data.md).

1. Elija **Siguiente**.

1. En **Notification (Notificación)**, seleccione el tema de SNS al que desee enviar la notificación cuando la alarma tenga el estado `ALARM`, `OK` o `INSUFFICIENT_DATA`.

   Para que la alarma envíe varias notificaciones para el mismo estado de alarma o para estados de alarma diferentes, seleccione **Add notificación (Añadir notificación)**.

   Para que la alarma no envíe notificaciones, elija **Remove (Eliminar)**.

1. Para que la alarma realice acciones de Auto Scaling, EC2 o de Systems Manager, elija el botón correspondiente y elija el estado de la alarma y la acción que se debe realizar. Las alarmas solo pueden realizar acciones de Systems Manager cuando entran en el estado ALARMA. Para obtener más información sobre las acciones de Systems Manager, consulte [Configuración de CloudWatch para crear OpsItems desde alarmas](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-create-OpsItems-from-CloudWatch-Alarms.html) y [Creación de incidentes](https://docs.aws.amazon.com/incident-manager/latest/userguide/incident-creation.html).
**nota**  
Para crear una alarma que realice una acción de SSM Incident Manager, debe contar con determinados permisos. Para obtener más información, consulte [Ejemplos de políticas basadas en identidades del Administrador de incidentes de AWS Systems Manager](https://docs.aws.amazon.com/incident-manager/latest/userguide/security_iam_id-based-policy-examples.html).

1. Cuando haya terminado, elija **Next (Siguiente)**.

1. Escriba un nombre y la descripción de la alarma. El nombre solo debe contener caracteres ASCII. A continuación, elija **Siguiente**.

1. En **Obtener vista previa y crear**, confirme que la información y las condiciones son las que desea y, a continuación, elija **Crear alarma**.

**Creación de una alarma en una consulta de Información de métricas mediante AWS CLI**

Utilice el comando `put-metric-alarm` y especifique una consulta de Información de métricas en el parámetro `metrics`. Por ejemplo, el siguiente comando establece una alarma que pase al estado ALARM si alguna de las instancias supera el 50 % de uso de la CPU.

```
aws cloudwatch put-metric-alarm —alarm-name Prod-App-CPU-Alarm —evaluation-periods 1 —comparison-operator GreaterThanThreshold —metrics '[{"Id":"m1","Expression":"SELECT MAX(CPUUtilization) FROM \"AWS/EC2\" WHERE tag.Environment = '\''Prod'\'' AND tag.Application = '\''OrderService'\''", "Period":60}]' —threshold 80
```

# Uso de consultas de Información de métricas con matemáticas de métricas
<a name="cloudwatch-metrics-insights-math"></a>

Puede utilizar una consulta de Información de métricas como entrada de una función matemática métrica. Para obtener más información acerca de las matemáticas de métricas, consulte [Uso de expresiones matemáticas con métricas de CloudWatch](using-metric-math.md).

Una consulta de Información de métricas que no incluye una cláusula **GROUP BY** (AGRUPAR POR) devuelve una sola serie temporal. Por lo tanto, los resultados devueltos se pueden utilizar con cualquier función matemática métrica que tome como entrada una única serie temporal.

Una consulta de Información de métricas que incluye una cláusula **GROUP BY** (AGRUPAR POR) devuelve varias series temporales. Por lo tanto, los resultados devueltos se pueden utilizar con cualquier función matemática métrica que tome como entrada una matriz de series temporales.

Por ejemplo, la siguiente consulta devuelve el número total de bytes descargados para cada bucket de la región como una matriz de series temporales:

```
SELECT SUM(BytesDownloaded) 
FROM SCHEMA("AWS/S3", BucketName, FilterId) 
WHERE FilterId = 'EntireBucket'
GROUP BY BucketName
```

En un gráfico de la consola o en una operación de [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html), los resultados de esta consulta son `q1`. Esta consulta devuelve el resultado en bytes, por lo que si desea ver el resultado como MB, puede utilizar la siguiente función matemática:

```
q1/1024/1024
```

# Uso de lenguaje natural para generar y actualizar consultas de Información de métricas de CloudWatch
<a name="cloudwatch-metrics-insights-query-assist"></a>

 CloudWatch admite la función de consulta en lenguaje natural que le ayuda a generar y actualizar consultas para [Información de métricas de CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html) e [Información de registros de CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html). 

 Con esta función, puede hacer preguntas o describir los datos de CloudWatch que busca en un lenguaje sencillo. Esta función de lenguaje natural genera una consulta según una petición presentada y proporciona una explicación línea por línea sobre 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 “¿Qué instancia de Amazon Elastic Compute Cloud presenta la mayor salida de red?” y “Mostrarme las 10 tablas principales de Amazon DynamoDB por lecturas consumidas”. 

**nota**  
Por lo general, la característica de consulta en lenguaje natural está disponible en 10 regiones. En algunas regiones, esta característica realiza llamadas interregionales a regiones de Estados Unidos para procesar las solicitudes de consulta. En la siguiente tabla se enumeran las regiones compatibles y se muestra dónde procesa las solicitudes cada región.  


| Región admitida | Región donde se procesa la solicitud | 
| --- | --- | 
|  Este de EE. UU. (Norte de Virginia)  |  Este de EE. UU. (Norte de Virginia)  | 
|  Este de EE. UU. (Ohio)  |  Este de EE. UU. (Norte de Virginia)  | 
|  Oeste de EE. UU. (Oregón)  |  Oeste de EE. UU. (Oregón)  | 
|  Asia-Pacífico (Hong Kong)  |  Oeste de EE. UU. (Oregón)  | 
|  Asia-Pacífico (Singapur)  |  Oeste de EE. UU. (Oregón)  | 
|  Asia-Pacífico (Sídney)  |  Oeste de EE. UU. (Oregón)  | 
|  Asia-Pacífico (Tokio)  |  Asia-Pacífico (Tokio)  | 
|  Europa (Fráncfort)  |  Europa (Fráncfort)  | 
|  Europa (Irlanda)  |  Este de EE. UU. (Norte de Virginia)  | 
|  Europa (Estocolmo)  |  Este de EE. UU. (Norte de Virginia)  | 

 Para generar una consulta de Información de métricas de CloudWatch con esta función, abra el editor de consultas de Información de métricas de CloudWatch en la vista del *generador* o *editor* y seleccione **Generar consulta**. 

**importante**  
 Para usar la capacidad de consulta en lenguaje natural, debe usar la política [CloudWatchFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchFullAccess.html), [CloudWatchReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchReadOnlyAccess.html), [CloudWatchFullAccessV2](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchFullAccessV2.html), [AdministratorAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AdministratorAccess.html) o [ReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html).   
 También puede incluir la acción `cloudwatch:GenerateQuery` en una política integrada o administrada por el cliente, nueva o existente. 

## Consultas de ejemplo
<a name="cloudwatch-metrics-insights-query-assist-examples"></a>

 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 y la sintaxis de consultas de Información de métricas de CloudWatch, consulte [Componentes y sintaxis de las consultas de Información de métricas de CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-metrics-insights-querylanguage.html). 

### Ejemplo: generar una consulta en lenguaje natural
<a name="cloudwatch-metrics-insights-query-assist-example-1"></a>

 Para generar una consulta en lenguaje natural, introduzca una petición y seleccione **Generar nueva consulta**. En este ejemplo se muestra una consulta que realiza una búsqueda básica. 

**Prompt**  
 A continuación, se muestra un ejemplo de una petición que indica la función de buscar las 10 tablas principales de DynamoDB que consumen más capacidad de lectura. 

```
Show top 10 DynamoDB Tables by consumed reads
```

**Consultar**  
 El siguiente es un ejemplo de una consulta que la función de lenguaje natural genera según la petición. 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. 

```
# Show top 10 DynamoDB Tables by consumed reads
SELECT SUM("ConsumedReadCapacityUnits")
FROM "AWS/DynamoDB"
GROUP BY TableName
ORDER BY SUM() DESC
LIMIT 10
# This query selects the sum of consumed read capacity units for each DynamoDB table, groups the results by table name, orders the results from highest to lowest read capacity consumption, and limits the results to the top 10 tables.
```

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

### Ejemplo: actualizar una consulta en lenguaje natural
<a name="cloudwatch-metrics-insights-query-assist-example-2"></a>

 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 solicitud que busca las 10 tablas principales de DynamoDB que consumen más capacidad de lectura, esta petición ahora indica la capacidad de ordenar los resultados por el número de bytes proporcionados. 

```
Sort by bytes returned instead
```

**Consulta actualizada**  
 A continuación, se muestra un ejemplo de una consulta actualizada. 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. 

```
# Sort by bytes returned instead
SELECT SUM("ReturnedBytes")
FROM "AWS/DynamoDB"
GROUP BY TableName
ORDER BY SUM() DESC
LIMIT 10
# This query modifies the original query to select the sum of returned bytes instead of consumed read capacity units, and orders the results from highest to lowest sum of returned bytes, limiting the results to the top 10 tables.
```

## Optar por no utilizar sus datos para mejorar el servicio
<a name="cloudwatch-metrics-insights-query-assist-service-data"></a>

 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 podrían usarse para mejorar la calidad de Información de métricas de CloudWatch. 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 características de IA de CloudWatch, incluida la función de generación de consultas, debe crear una política de exclusión para CloudWatch. 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*. 

# Inferencia en SQL
<a name="cloudwatch-metrics-insights-inference"></a>

En Información de métricas de CloudWatch se utilizan varios mecanismos para inferir la intención de una consulta en SQL determinada.

**Topics**
+ [Bucket de tiempo](#cloudwatch-metrics-insights-inference-timebucketing)
+ [Proyección de campos](#cloudwatch-metrics-insights-inference-fieldsprojection)
+ [Acumulación global de ORDER BY (AGRUPAR POR)](#cloudwatch-metrics-insights-inference-OrderBy)

## Bucket de tiempo
<a name="cloudwatch-metrics-insights-inference-timebucketing"></a>

Los puntos de datos de serie temporal resultantes de una consulta se acumulan en buckets de tiempo según el periodo solicitado. Para acumular valores en SQL estándar, se debe definir una cláusula GROUP BY explícita para recopilar todas las observaciones de un periodo determinado juntas. Debido a que esta es la forma estándar de consultar datos de serie temporal, Información de métricas de CloudWatch deduce el bucket de tiempo sin necesidad de que se exprese la cláusula **GROUP BY** de forma explícita. 

Por ejemplo, cuando se realiza una consulta con un periodo de un minuto, todas las observaciones pertenecientes a ese minuto hasta el siguiente (excluido) se acumulan hasta la hora de inicio del bucket de tiempo. Esto hace que las sentencias SQL de Información de métricas sean más concisas y menos detalladas. 

```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
```

La consulta previa devuelve una única serie temporal (pares de marca temporal y valor), lo que representa la utilización promedio de la CPU de todas las instancias de Amazon EC2. Suponiendo que el periodo solicitado sea de un minuto, cada punto de datos devuelto representa el promedio de todas las observaciones medidas dentro de un intervalo específico de un minuto (se incluye la hora de inicio y no la hora de finalización). La marca temporal relacionada con el punto de datos específico es la hora de inicio del bucket.

## Proyección de campos
<a name="cloudwatch-metrics-insights-inference-fieldsprojection"></a>

Las consultas de Información de métricas siempre devuelven la proyección de marca temporal. No es necesario especificar una columna de marca temporal en la cláusula **SELECT** para obtener la marca temporal de cada valor de punto de datos correspondiente. Para obtener información detallada acerca de cómo se calcula la marca temporal, consulte [Bucket de tiempo](#cloudwatch-metrics-insights-inference-timebucketing).

Cuando se utiliza **GROUP BY**, el nombre de cada grupo también se deduce y proyecta en el resultado, para que usted pueda agrupar las series temporales devueltas. 

```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
```

La consulta anterior devuelve una serie temporal para cada instancia de Amazon EC2. Cada serie temporal se etiqueta después del valor del ID de instancia.

## Acumulación global de ORDER BY (AGRUPAR POR)
<a name="cloudwatch-metrics-insights-inference-OrderBy"></a>

Cuando se utiliza **ORDER BY** (AGRUPAR POR), **FUNCTION()** (FUNCIÓN) deduce la función de acumulación según la cual desea ordenar (los valores de punto de datos de las métricas consultadas). La operación de acumulación se realiza en todos los puntos de datos coincidentes de cada serie temporal individual en el periodo en el que se realizó la consulta. 

```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
ORDER BY MAX()
LIMIT 10
```

La consulta anterior devuelve la utilización de la CPU para cada instancia de Amazon EC2, lo que limita el conjunto de resultados a 10 entradas. Los resultados se ordenan en función del valor máximo de las series temporales individuales dentro del periodo solicitado. La cláusula **ORDER BY** (AGRUPAR POR) se aplica antes de **LIMIT** (LÍMITE), de modo que el pedido se calcula con más de 10 series temporales.

# Cuotas de Información de métricas
<a name="cloudwatch-metrics-insights-limits"></a>

En la actualidad, Información de métricas de CloudWatch tiene las siguientes cuotas:
+ Consulta de hasta dos semanas de datos para visualizarlos en las métricas, widgets y gráficos de alarmas. Puede consultar las tres horas de datos más recientes para evaluar las condiciones de alarma.
+ Una única consulta puede procesar un máximo de 10 000 métricas. Esto significa que si las cláusulas **SELECT** (SELECCIONAR), **FROM** (DESDE) y **WHERE** (DONDE) coinciden con más de 10 000 métricas, la consulta solo procesa las primeras 10 000 métricas que encuentra.
+ Una única consulta puede devolver un máximo de 500 series temporales. Esto significa que si la consulta devuelve más de 500 métricas, no se devolverán todas las métricas en los resultados de la consulta. Si usa una cláusula de **ORDER BY** (AGRUPAR POR), luego se ordenan todas las métricas que se procesan y se devuelven las 500 que tienen los valores más altos o más bajos según su cláusula de **ORDER BY** (AGRUPAR POR).

  Si no incluye una cláusula de **ORDER BY** (AGRUPAR POR), no puede controlar qué 500 métricas coincidentes se devuelven.
+ Puede tener hasta 200 alarmas de Información de métricas por región. 
+ Información de métricas no admite datos de alta resolución; esto es, datos de métricas que se han notificado con una granularidad de menos de un minuto. Si solicita datos de alta resolución, la solicitud no devuelve un error, pero el resultado se agrega con una granularidad de un minuto.
+ Cada operación de [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html) puede tener solo una consulta, pero puede tener varios widgets en un panel y que cada uno incluya una consulta.
+ Si una consulta que usa etiquetas con los valores **GROUP BY** o **WHERE** coincide con una métrica que tiene más de 10 actualizaciones de etiquetas, solo se incluirán en los resultados de la consulta las 10 versiones etiquetadas más recientes de la métrica.

# Consultas de ejemplo de Información de métricas
<a name="cloudwatch-metrics-insights-queryexamples"></a>

Esta sección contiene ejemplos de consultas útiles de Información de métricas de CloudWatch que puede copiar y utilizar directamente o copiar y modificar en el editor de consultas. Algunos de estos ejemplos ya están disponibles en la consola; para obtener acceso a ellos, elija **Add query** (Agregar consulta) en la vista de **Metrics** (Métricas).

## Ejemplos de Application Load Balancer
<a name="cloudwatch-metrics-insights-queryexamples-applicationloadbalancer"></a>

**Total de solicitudes en todos los balanceadores de carga**

```
SELECT SUM(RequestCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer)
```

**Los 10 balanceadores de carga más activos **

```
SELECT MAX(ActiveConnectionCount) 
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer) 
GROUP BY LoadBalancer 
ORDER BY SUM() DESC 
LIMIT 10
```

## AWSEjemplos de uso de la API de
<a name="cloudwatch-metrics-insights-queryexamples-APIusage"></a>

**Las 20 API principales de AWS según la cantidad de llamadas de su cuenta**

```
SELECT COUNT(CallCount) 
FROM SCHEMA("AWS/Usage", Class, Resource, Service, Type) 
WHERE Type = 'API' 
GROUP BY Service, Resource 
ORDER BY COUNT() DESC 
LIMIT 20
```

**API de CloudWatch ordenadas por llamadas**

```
SELECT COUNT(CallCount) 
FROM SCHEMA("AWS/Usage", Class, Resource, Service, Type) 
WHERE Type = 'API' AND Service = 'CloudWatch' 
GROUP BY Resource 
ORDER BY COUNT() DESC
```

## Ejemplos de DynamoDB
<a name="cloudwatch-metrics-insights-queryexamples-DynamoDB"></a>

**Las 10 tablas principales según lecturas consumidas**

```
SELECT SUM(ProvisionedWriteCapacityUnits)
FROM SCHEMA("AWS/DynamoDB", TableName) 
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```

**Las 10 tablas principales según bytes devueltos**

```
SELECT SUM(ReturnedBytes)
FROM SCHEMA("AWS/DynamoDB", TableName) 
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```

**Las 10 tablas principales según errores de usuario**

```
SELECT SUM(UserErrors)
FROM SCHEMA("AWS/DynamoDB", TableName) 
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```

## Ejemplos de Amazon Elastic Block Store
<a name="cloudwatch-metrics-insights-queryexamples-EBS"></a>

**Los 10 volúmenes principales de Amazon EBS según bytes escritos**

```
SELECT SUM(VolumeWriteBytes) 
FROM SCHEMA("AWS/EBS", VolumeId) 
GROUP BY VolumeId 
ORDER BY SUM() DESC 
LIMIT 10
```

**Tiempo promedio de escritura del volumen de Amazon EBS**

```
SELECT AVG(VolumeTotalWriteTime) 
FROM SCHEMA("AWS/EBS", VolumeId)
```

## Ejemplos de Amazon EC2
<a name="cloudwatch-metrics-insights-queryexamples-EC2"></a>

**Utilización de la CPU de instancias EC2 clasificadas según la más alta **

```
SELECT AVG(CPUUtilization) 
  FROM SCHEMA("AWS/EC2", InstanceId) 
  GROUP BY InstanceId 
  ORDER BY AVG() DESC
```

**Utilización promedio de la CPU en toda la flota**

```
SELECT AVG(CPUUtilization) 
FROM SCHEMA("AWS/EC2", InstanceId)
```

**Las 10 instancias principales según la utilización más alta de la CPU**

```
SELECT MAX(CPUUtilization) 
FROM SCHEMA("AWS/EC2", InstanceId) 
GROUP BY InstanceId 
ORDER BY MAX() DESC 
LIMIT 10
```

**En este caso, el agente de CloudWatch está recopilando una métrica de `CPUUtilization` por aplicación. Esta consulta filtra el promedio de esta métrica para un nombre de aplicación específico.**

```
SELECT AVG(CPUUtilization)
FROM "AWS/CWAgent"
WHERE ApplicationName = 'eCommerce'
```

## Ejemplos de Amazon Elastic Container Service
<a name="cloudwatch-metrics-insights-queryexamples-ECS"></a>

**Utilización promedio de la CPU en todos los clústeres de ECS **

```
SELECT AVG(CPUUtilization) 
FROM SCHEMA("AWS/ECS", ClusterName)
```

**Los 10 clústeres principales según la utilización de memoria**

```
SELECT AVG(MemoryUtilization) 
FROM SCHEMA("AWS/ECS", ClusterName) 
GROUP BY ClusterName 
ORDER BY AVG() DESC
LIMIT 10
```

**Los 10 servicios principales según la utilización de la CPU**

```
SELECT AVG(CPUUtilization) 
FROM SCHEMA("AWS/ECS", ClusterName, ServiceName) 
GROUP BY ClusterName, ServiceName 
ORDER BY AVG() DESC 
LIMIT 10
```

**Los 10 servicios principales según la ejecución de tareas (Información de contenedores)**

```
SELECT AVG(RunningTaskCount) 
FROM SCHEMA("ECS/ContainerInsights", ClusterName, ServiceName) 
GROUP BY ClusterName, ServiceName 
ORDER BY AVG() DESC 
LIMIT 10
```

## Ejemplos de Información de contenedores de Amazon Elastic Kubernetes Service
<a name="cloudwatch-metrics-insights-queryexamples-EKSCI"></a>

**Utilización promedio de la CPU en todos los clústeres de EKS **

```
SELECT AVG(pod_cpu_utilization) 
FROM SCHEMA("ContainerInsights", ClusterName)
```

**Los 10 clústeres principales según la utilización de CPU de nodo**

```
SELECT AVG(node_cpu_utilization) 
FROM SCHEMA("ContainerInsights", ClusterName) 
GROUP BY ClusterName
ORDER BY AVG() DESC LIMIT 10
```

**Los 10 clústeres principales según la utilización de la memoria de pod**

```
SELECT AVG(pop_memory_utilization) 
FROM SCHEMA("ContainerInsights", ClusterName) 
GROUP BY ClusterName
ORDER BY AVG() DESC LIMIT 10
```

**Los 10 nodos principales según la utilización de la CPU**

```
SELECT AVG(node_cpu_utilization) 
FROM SCHEMA("ContainerInsights", ClusterName, NodeName) 
GROUP BY ClusterName, NodeName 
ORDER BY AVG() DESC LIMIT 10
```

**Los 10 pods principales según la utilización de la memoria**

```
SELECT AVG(pod_memory_utilization) 
FROM SCHEMA("ContainerInsights", ClusterName, PodName) 
GROUP BY ClusterName, PodName 
ORDER BY AVG() DESC LIMIT 10
```

## Ejemplos de EventBridge
<a name="cloudwatch-metrics-insights-queryexamples-EventBridge"></a>

**Las 10 reglas principales según invocaciones**

```
SELECT SUM(Invocations)
FROM SCHEMA("AWS/Events", RuleName) 
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```

**Las 10 reglas principales según invocaciones fallidas**

```
SELECT SUM(FailedInvocations)
FROM SCHEMA("AWS/Events", RuleName) 
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```

**Las 10 reglas principales según reglas coincidentes**

```
SELECT SUM(MatchedEvents)
FROM SCHEMA("AWS/Events", RuleName) 
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```

## Ejemplos de Kinesis
<a name="cloudwatch-metrics-insights-queryexamples-Kinesis"></a>

**Las 10 secuencias principales según bytes escritos**

```
SELECT SUM("PutRecords.Bytes") 
FROM SCHEMA("AWS/Kinesis", StreamName) 
GROUP BY StreamName
ORDER BY SUM() DESC LIMIT 10
```

**Las 10 secuencias principales según los primeros elementos de la secuencia**

```
SELECT MAX("GetRecords.IteratorAgeMilliseconds") 
FROM SCHEMA("AWS/Kinesis", StreamName) 
GROUP BY StreamName
ORDER BY MAX() DESC LIMIT 10
```

## Ejemplos de Lambda
<a name="cloudwatch-metrics-insights-queryexamples-Lambda"></a>

**Funciones de Lambda ordenadas por número de invocaciones**

```
SELECT SUM(Invocations) 
FROM SCHEMA("AWS/Lambda", FunctionName) 
GROUP BY FunctionName 
ORDER BY SUM() DESC
```

**Las 10 funciones principales de Lambda según tiempo de ejecución más largo**

```
SELECT AVG(Duration) 
FROM SCHEMA("AWS/Lambda", FunctionName) 
GROUP BY FunctionName 
ORDER BY MAX() DESC 
LIMIT 10
```

**Las 10 funciones principales de Lambda según recuento de errores**

```
SELECT SUM(Errors) 
FROM SCHEMA("AWS/Lambda", FunctionName) 
GROUP BY FunctionName 
ORDER BY SUM() DESC 
LIMIT 10
```

## Ejemplos de CloudWatch
<a name="cloudwatch-metrics-insights-queryexamples-CloudWatchLogs"></a>

**Los 10 grupos principales de registros según eventos entrantes**

```
SELECT SUM(IncomingLogEvents)
FROM SCHEMA("AWS/Logs", LogGroupName) 
GROUP BY LogGroupName
ORDER BY SUM() DESC LIMIT 10
```

**Los 10 grupos principales de registros según bytes escritos**

```
SELECT SUM(IncomingBytes)
FROM SCHEMA("AWS/Logs", LogGroupName) 
GROUP BY LogGroupName
ORDER BY SUM() DESC LIMIT 10
```

## Ejemplos de Amazon RDS
<a name="cloudwatch-metrics-insights-queryexamples-RDS"></a>

**Las 10 instancias principales de Amazon RDS según la mayor utilización de la CPU**

```
SELECT MAX(CPUUtilization)
FROM SCHEMA("AWS/RDS", DBInstanceIdentifier) 
GROUP BY DBInstanceIdentifier
ORDER BY MAX() DESC 
LIMIT 10
```

**Los 10 clústeres principales de Amazon RDS según escrituras**

```
SELECT SUM(WriteIOPS)
FROM SCHEMA("AWS/RDS", DBClusterIdentifier) 
GROUP BY DBClusterIdentifier
ORDER BY MAX() DESC 
LIMIT 10
```

## Ejemplos de Amazon Simple Storage Service
<a name="cloudwatch-metrics-insights-queryexamples-S3"></a>

**Latencia promedio según bucket**

```
SELECT AVG(TotalRequestLatency) 
FROM SCHEMA("AWS/S3", BucketName, FilterId) 
WHERE FilterId = 'EntireBucket' 
GROUP BY BucketName 
ORDER BY AVG() DESC
```

**Los 10 buckets principales según bytes descargados**

```
SELECT SUM(BytesDownloaded) 
FROM SCHEMA("AWS/S3", BucketName, FilterId) 
WHERE FilterId = 'EntireBucket'
GROUP BY BucketName 
ORDER BY SUM() DESC 
LIMIT 10
```

## Ejemplos de Amazon Simple Notification Service
<a name="cloudwatch-metrics-insights-queryexamples-SNS"></a>

**Total de mensajes publicados según temas de SNS**

```
SELECT SUM(NumberOfMessagesPublished) 
FROM SCHEMA("AWS/SNS", TopicName)
```

**Los 10 temas principales según mensajes publicados**

```
SELECT SUM(NumberOfMessagesPublished) 
FROM SCHEMA("AWS/SNS", TopicName) 
GROUP BY TopicName 
ORDER BY SUM() DESC 
LIMIT 10
```

**Los 10 temas principales según fallos en la entrega de mensajes**

```
SELECT SUM(NumberOfNotificationsFailed) 
FROM SCHEMA("AWS/SNS", TopicName)
GROUP BY TopicName 
ORDER BY SUM() DESC 
LIMIT 10
```

## Ejemplos de Amazon SQS
<a name="cloudwatch-metrics-insights-queryexamples-SQS"></a>

**Las 10 colas principales según el número de mensajes visibles**

```
SELECT AVG(ApproximateNumberOfMessagesVisible)
FROM SCHEMA("AWS/SQS", QueueName) 
GROUP BY QueueName
ORDER BY AVG() DESC 
LIMIT 10
```

**Las 10 colas más activas**

```
SELECT SUM(NumberOfMessagesSent)
FROM SCHEMA("AWS/SQS", QueueName) 
GROUP BY QueueName
ORDER BY SUM() DESC 
LIMIT 10
```

**Las 10 colas principales según antigüedad del primer mensaje**

```
SELECT AVG(ApproximateAgeOfOldestMessage)
FROM SCHEMA("AWS/SQS", QueueName) 
GROUP BY QueueName
ORDER BY AVG() DESC 
LIMIT 10
```

# Glosario de Información de métricas
<a name="cloudwatch-metrics-insights-glossary"></a>

**etiqueta**  
En Información de métricas, una etiqueta es un par clave-valor que se utiliza para alcanzar una consulta para devolver un conjunto determinado de datos o para definir criterios según los cuales los resultados de la consulta se deben separar en series temporales independientes. Una clave de etiqueta es similar al nombre de una columna en SQL. Las etiquetas deben ser dimensiones de métricas de CloudWatch. 

**observación**  
Una observación es un valor registrado para una métrica determinada en un momento dado.

# Solución de problemas de Información de métricas
<a name="cloudwatch-metrics-insights-troubleshooting"></a>

## Los resultados incluyen “Otro”, pero no lo tengo como dimensión
<a name="cloudwatch-metrics-insights-troubleshooting-other"></a>

Esto significa que la consulta incluye una cláusula de **GROUP BY** que especifica una clave de etiqueta que no se utiliza en algunas de las métricas devueltas por la consulta. En este caso, se devuelve un grupo nulo denominado `Other` (Otro). Las métricas que no incluyen esa clave de etiqueta probablemente sean métricas acumuladas que devuelven valores acumulados en todos los valores de esa clave de etiqueta.

 Por ejemplo, supongamos que tenemos la siguiente consulta:

```
SELECT AVG(Faults) 
FROM MyCustomNamespace 
GROUP BY Operation, ServiceName
```

Si algunas de las métricas devueltas no incluyen `ServiceName` como dimensión, entonces esas métricas se muestran con el valor `Other` para `ServiceName`.

Para evitar ver “Other” (Otro) en los resultados, use **SCHEMA** (ESQUEMA) en la cláusula de **FROM** (DESDE), como en el siguiente ejemplo:

```
SELECT AVG(Faults) 
FROM SCHEMA(MyCustomNamespace, Operation)
GROUP BY Operation, ServiceName
```

Esto limita los resultados devueltos solo a las métricas que tienen ambas dimensiones: `Operation` y `ServiceName`.

## La marca temporal más antigua de mi gráfica tiene un valor métrico inferior al de las demás
<a name="cloudwatch-metrics-insights-troubleshooting-oldest"></a>

Información de métricas de CloudWatch admite hasta dos semanas de datos históricos. Cuando se realiza un gráfico con un periodo superior a un minuto, puede haber casos en que el punto de datos más antiguo difiera del valor esperado. Esto se debe a que las consultas de Información de métricas de CloudWatch solo devuelven los datos dentro del periodo de retención de dos semanas. En este caso, el punto de datos más antiguo de la consulta devuelve solo las observaciones que se midieron dentro del límite de dos semanas, en lugar de devolver todas las observaciones dentro del periodo de ese punto de datos.

## Valores de métricas inconsistentes en distintos periodos de tiempo al utilizar consultas basadas en etiquetas
<a name="cloudwatch-metrics-insights-troubleshooting-tag-mutations"></a>

Cuando utiliza cláusulas `WHERE` o `GROUP BY` con etiquetas en las consultas de Información de métricas de CloudWatch, es posible que vea distintos valores de métricas en función del periodo de tiempo seleccionado. Por ejemplo, un periodo de 6 horas puede mostrar un valor máximo de 20, mientras que un periodo de 1 hora muestra solo 2 durante el mismo periodo de tiempo.

Esto se debe a que las marcas de tiempo de las etiquetas se almacenan con una resolución de segundo nivel, mientras que los puntos de datos de las métricas se ajustan a los límites de los periodos (por ejemplo, el inicio de cada minuto u hora). Para determinar qué puntos de datos coinciden con un rango de tiempo de etiqueta, CloudWatch ajusta el inicio del rango restando un periodo. Con periodos más largos, este ajuste crea una brecha más amplia entre la marca de tiempo de la etiqueta y el primer punto de datos incluido, lo que puede provocar que se excluyan los puntos de datos cercanos al inicio del rango.

El siguiente ejemplo muestra cómo afecta esto a los resultados de consulta. Una métrica tiene dos valores de etiqueta: `env=beta` (de 00:00 a 01:30) y `env=gamma` (de 01:30 a 03:00). Cada etiqueta cubre 90 minutos de datos con un valor de SUM de 270.

![\[Dos gráficos de métricas de CloudWatch que comparan los resultados de consultas basadas en etiquetas con periodos de 1 minuto y 3 horas.\]](http://docs.aws.amazon.com/es_es/AmazonCloudWatch/latest/monitoring/images/metrics-insights-tag-alignment.png)



| **env=beta con un periodo de 1 minuto** | Estadística | Expected | Returned | Diferencia | 
| --- | --- | --- | --- | --- | 
| SUM | 270 | 271 | \$11 | 
| AVG | 3.0 | 3.0 | 0 | 
| MIN | 1 | 1 | 0 | 
| MAX | 5 | 5 | 0 | 
| SAMPLE\$1COUNT | 90 | 91 | \$11 | 


| **env=gamma con un periodo de 1 minuto** | Estadística | Expected | Returned | Diferencia | 
| --- | --- | --- | --- | --- | 
| SUM | 270 | 275 | 5\$1 | 
| AVG | 3.0 | 3.0 | 0 | 
| MIN | 1 | 1 | 0 | 
| MAX | 5 | 5 | 0 | 
| SAMPLE\$1COUNT | 90 | 91 | \$11 | 

Con un periodo de 1 minuto, el ajuste de alineación es pequeño (1 minuto), por lo que solo se incluye 1 punto de datos adicional por etiqueta. Con un periodo de 3 horas, el ajuste abarca todo el rango de consultas:


| **env=beta con un periodo de 3 horas** | Estadística | Expected | Returned | Diferencia | 
| --- | --- | --- | --- | --- | 
| SUM | 270 | 540 | \$1270 | 
| AVG | 3.0 | 3.0 | 0 | 
| MIN | 1 | 1 | 0 | 
| MAX | 5 | 5 | 0 | 
| SAMPLE\$1COUNT | 90 | 180 | \$190 | 


| **env=gamma con un periodo de 3 horas** | Estadística | Expected | Returned | Diferencia | 
| --- | --- | --- | --- | --- | 
| SUM | 270 | 540 | \$1270 | 
| AVG | 3.0 | 3.0 | 0 | 
| MIN | 1 | 1 | 0 | 
| MAX | 5 | 5 | 0 | 
| SAMPLE\$1COUNT | 90 | 180 | \$190 | 

Con el periodo de 3 horas, ambas etiquetas devuelven el conjunto de datos completo (SUM=540, SAMPLE\$1COUNT=180) porque la marca de tiempo del único punto de datos agregado se encuentra dentro de ambos rangos ajustados. El límite de la etiqueta se borra de forma efectiva.

Para reducir el impacto de este comportamiento, pruebe los siguientes enfoques:
+ **Utilice periodos de agregación más pequeños.** Los periodos más pequeños (como 1 minuto o 5 minutos) se aproximan más a la resolución de nivel de segundos de las marcas de tiempo de las etiquetas, lo que minimiza la brecha de alineación y aumenta la probabilidad de que se incluyan todos los puntos de datos relevantes.
+ **Utilice un filtrado basado en dimensiones en lugar de etiquetas.** Si su caso de uso lo permite, filtre por dimensiones en lugar de por etiquetas. Esto no afecta a las consultas basadas en dimensiones. Por ejemplo, utilice `WHERE InstanceId = 'i-1234567890abcdef0'` en lugar de `WHERE tag."my-tag" = 'my-value'`.
+ **Realice consultas con una granularidad uniforme.** Al comparar datos de métricas en distintos intervalos de tiempo, utilice el mismo periodo para evitar diferencias inesperadas provocadas por el ajuste de alineación.