# Consulta suas métricas do CloudWatch com o CloudWatch Metrics Insights
<a name="query_with_cloudwatch-metrics-insights"></a>

O CloudWatch Metrics Insights é um poderoso mecanismo de consulta SQL de alta performance que você pode usar para consultar suas métricas em escala. É possível identificar tendências e padrões em todas as métricas do CloudWatch em tempo real, com acesso a até duas semanas de dados históricos para uma análise abrangente de tendências.

Você também pode definir alarmes em qualquer consulta ao Metrics Insights que retorne uma única série temporal. Isso pode ser especialmente útil para criar alarmes que monitorem métricas agregadas em toda uma frota da sua infraestrutura ou das suas aplicações. Crie o alarme uma vez e ele se ajustará dinamicamente à medida que recursos forem adicionados ou removidos da frota.

 Você pode realizar uma consulta do CloudWatch Metrics Insights no console com o editor de consultas do CloudWatch Metrics Insights. Você também pode realizar uma consulta do CloudWatch Metrics Insights com a AWS CLI ou um SDK da AWS executando `GetMetricData` ou `PutDashboard`. Não há cobrança pelas consultas que você executa com o editor de consultas do CloudWatch Metrics Insights. Para obter mais informações sobre os preços do CloudWatch, consulte [Preço do Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/). 

 Com o editor de consultas do CloudWatch Metrics Insights, você pode escolher entre uma variedade de consultas de amostra pré-criadas e também criar suas próprias consultas. Ao criar suas consultas, você pode usar uma visualização do construtor para pesquisar as métricas e dimensões atuais. Como alternativa, use uma visualização de editor para escrever consultas manualmente. 

Com o Metrics Insights, você pode executar consultas em escala. Com a cláusula **GROUP BY**, você pode agrupar as métricas em tempo real em séries temporais separadas por valor de dimensão específico. Como as consultas do Metrics Insights incluem a capacidade **ORDER BY**, você pode usar o Metrics Insights para fazer consultas do tipo “N principais”. Por exemplo, consultas do tipo “N principais” podem verificar milhões de métricas na sua conta e retornar as dez instâncias que consomem mais CPU. Isso pode ajudar você a identificar e corrigir problemas de latência nas suas aplicações. Para usar tags com alarmes, faça essa opção nas configurações do CloudWatch. Depois que as tags são habilitadas, é possível também filtrar e agrupar métricas usando tags de recurso da AWS, o que permite consultar métricas alinhadas com sua estrutura organizacional, como por aplicação, ambiente ou equipe.

**Topics**
+ [Elaboração de consultas no CloudWatch Metrics Insights](cloudwatch-metrics-insights-buildquery.md)
+ [Componentes e sintaxe de consulta no CloudWatch Metrics Insights](cloudwatch-metrics-insights-querylanguage.md)
+ [Alarmes em consultas do CloudWatch Metrics Insights no CloudWatch](cloudwatch-metrics-insights-alarms.md)
+ [Usar consultas do Metrics Insights com matemática métrica](cloudwatch-metrics-insights-math.md)
+ [Usar linguagem natural para gerar e atualizar as consultas do CloudWatch Metrics Insights](cloudwatch-metrics-insights-query-assist.md)
+ [Inferência SQL](cloudwatch-metrics-insights-inference.md)
+ [Cotas do Metrics Insights](cloudwatch-metrics-insights-limits.md)
+ [Consultas de exemplo do Metrics Insights](cloudwatch-metrics-insights-queryexamples.md)
+ [Glossário do Metrics Insights](cloudwatch-metrics-insights-glossary.md)
+ [Solução de problemas do métricas do Metrics Insights](cloudwatch-metrics-insights-troubleshooting.md)

# Elaboração de consultas no CloudWatch Metrics Insights
<a name="cloudwatch-metrics-insights-buildquery"></a>

Você pode executar uma consulta do CloudWatch Metrics Insights usando o console do CloudWatch, a AWS CLI ou os AWS SDKs. As consultas executadas no console são oferecidas gratuitamente. Para obter mais informações sobre os preços do CloudWatch, consulte [Preço do Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/).

Com o CloudWatch Metrics Insights, você pode analisar dados de métricas para períodos prolongados de até duas semanas, permitindo uma análise histórica mais abrangente e a identificação de tendências em comparação com períodos de retenção mais curtos. Para obter uma performance ideal ao consultar intervalos de tempo maiores, considere usar períodos maiores (como 5 minutos ou 1 hora) para reduzir o número de pontos de dados retornados. Ao analisar tendências durante todo o período de duas semanas, use funções agregadas como AVG() ou MAX() em suas cláusulas ORDER BY para identificar padrões com eficiência.

Para obter mais informações sobre como usar os AWS SDKs para executar uma consulta do Metrics Insights, consulte [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html).

Para executar uma consulta usando o console do CloudWatch, siga estas etapas:

**Para consultar suas métricas usando o Metrics Insights**

1. Abra o console CloudWatch em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. No painel de navegação, escolha **Metrics** (Métricas), **All metrics** (Todas as métricas).

1. (Opcional) Para executar uma consulta de amostra pré-criada, escolha **Add query** (Adicionar consulta) e selecione a consulta a ser executada. Se estiver contente com essa consulta, poderá ignorar o restante deste procedimento. Caso contrário, você pode escolher **Editor** para editar a consulta de exemplo e, em seguida, escolher **Run** (Executar) para executar a consulta modificada. 

1. Para criar sua própria consulta, escolha **Consulta a várias fontes**. Depois, você pode usar a visão **Construtor** (padrão) para ter uma experiência guiada ou a visão **Editor**, se preferir ver a sintaxe de consulta. Você pode alternar entre as duas visualizações a qualquer momento e ver o trabalho em andamento em ambas. 

   No **Construtor**, clique nos campos de namespace, nome da métrica, filtro, grupo, ordem e limite para ver e selecionar os valores possíveis. Comece a digitar uma parte do valor que estiver procurando para filtrar a lista apresentada pelo construtor. É possível referenciar tags de recurso nas entradas de filtro e grupo.

   Na visão **Editor**, você pode escrever a consulta usando o subconjunto SQL compatível com o Metrics Insights. O editor oferece opções de preenchimento automático com base nos caracteres digitados até o momento, incluindo o nome das tags de recurso para métricas compatíveis com elas.

   O CloudWatch Metrics Insights é compatível com consultas de métricas por tags de recurso da AWS. Você pode usar tags para filtrar e agrupar os dados das métricas para garantir monitoramento e análise mais direcionados.

   Os exemplos a seguir mostram como usar consultas com tags.

   Para ver a utilização da CPU para instâncias do Amazon EC2 no ambiente de produção:

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

   Para agrupar as métricas por ambiente usando a cláusula GROUP BY:

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

   Para usar a cláusula GROUP BY na qual você especifica o nome da tag:

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

   Para combinar consultas de tags com as dimensões de métricas existentes:

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

1. Quando você estiver contente com sua consulta escolha **Run** (Executar).

1. (Opcional) Outra maneira de editar uma consulta que você tenha representada em gráfico é escolher a guia **Graphed metrics** (Métricas em gráficos) e escolher o ícone de edição ao lado da fórmula de consulta na coluna **Details** (Detalhes).

1. (Opcional) Para remover uma consulta do gráfico, escolha **Graphed metrics** (Métricas em gráficos) e escolha o ícone **X** no lado direito da linha que exibe a consulta.

# Componentes e sintaxe de consulta no CloudWatch Metrics Insights
<a name="cloudwatch-metrics-insights-querylanguage"></a>

A sintaxe do CloudWatch Metrics Insights é a seguinte.

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

As cláusulas possíveis em uma consulta do Metrics Insights são as seguintes. Nenhuma das palavras-chave diferencia maiúsculas de minúsculas, mas os identificadores como os nomes de métricas, namespaces e dimensões sim.

**SELECT**  
Obrigatório. Especifica a função a ser usada para agregar observações em cada bucket de tempo (determinado pelo período fornecido). Também especifica o nome da métrica a ser consultada.  
Os valores válidos para **FUNCTION** são `AVG`, `COUNT`, `MAX`, `MIN` e `SUM`.  
+ `AVG` calcula a média das observações correspondidas pela consulta.
+ `COUNT` retorna a contagem das observações correspondidas pela consulta.
+ `MAX` retorna o valor máximo das observações correspondidas pela consulta.
+ `MIN` retorna o valor mínimo das observações correspondidas pela consulta.
+ `SUM` calcula a soma das observações correspondidas pela consulta.

**FROM**  
Obrigatório. Especifica a fonte da métrica. Você pode especificar o namespace da métrica que contém a métrica a ser consultada ou uma função de tabela **SCHEMA**. Exemplos de namespaces de métrica incluem `"AWS/EC2"`, `"AWS/Lambda"` e namespaces de métrica criados para suas métricas personalizadas.  
Namespaces de métrica que incluem **/** ou qualquer outro caractere que não seja letra, número ou sublinhado devem ser cercados por aspas duplas. Para obter mais informações, consulte [Quando é necessário usar aspas ou caracteres de escape?](#cloudwatch-metrics-insights-syntaxdetails).  
**SCHEMA**  
Uma função de tabela opcional que pode ser usada dentro de uma cláusula **FROM**. Use **SCHEMA** para reduzir o escopo dos resultados da consulta apenas para as métricas que correspondem exatamente a uma lista de dimensões ou para métricas que não têm dimensões.   
Se você usar uma cláusula **SCHEMA**, ela deve conter pelo menos um argumento, e o primeiro deles deve ser o namespace de métrica que está sendo consultado. Se você especificar **SCHEMA** só com o argumento de namespace, os resultados são reduzidos para somente as métricas que não têm dimensões.  
Se você especificar **SCHEMA** com argumentos adicionais, os argumentos adicionais após o argumento de namespace devem ser chaves de *rótulo*. As chaves de rótulo devem ser nomes de dimensão. Se você especificar uma ou mais chaves de rótulo, os resultados serão definidos apenas para as métricas que têm esse conjunto exato de dimensões. A ordem das chaves de rótulo não tem importância.  
Por exemplo:  
+ **SELECT AVG(CPUUtilization) FROM "AWS/EC2"** corresponde a todas as métricas `CPUUtilization` do namespace `AWS/EC2`, independentemente de suas dimensões, e retorna uma única série temporal agregada. 
+ **SELECT AVG(CPUUtilization) FROM SCHEMA("AWS/EC2")** corresponde apenas às métricas de `CPUUtilization` no namespace `AWS/EC2` que não têm nenhuma dimensão definida.
+ **SELECT AVG(CPUUtilization) FROM SCHEMA("AWS/EC2", InstanceId)** corresponde apenas às métricas `CPUUtilization` que foram relatadas ao CloudWatch com exatamente uma dimensão, `InstanceId`.
+ **SELECT SUM(RequestCount) FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)** corresponde apenas às métricas `RequestCount` que foram relatadas ao CloudWatch pelo `AWS/ApplicationELB` com exatamente duas dimensões, `LoadBalancer` e `AvailabilityZone`.

**WHERE**  
Opcional. Filtra os resultados apenas para as métricas que correspondem à expressão especificada usando valores de rótulo específicos para uma ou mais chaves de rótulo. Por exemplo, **WHERE InstanceType = 'c3.4xlarge'** filtra os resultados somente para os tipos de instância `c3.4xlarge`, e **WHERE InstanceType \$1= 'c3.4xlarge'** filtra os resultados para todos os tipos de instância, exceto `c3.4xlarge`.  
Ao executar uma consulta em uma conta de monitoramento, você pode usar `WHERE AWS.AccountId` para limitar os resultados somente à conta que você especificar. Por exemplo, `WHERE AWS.AccountId=444455556666` só consulta métricas da conta `444455556666`. Para limitar sua consulta somente a métricas na própria conta de monitoramento, use `WHERE AWS.AccountId=CURRENT_ACCOUNT_ID()`.  
Os valores do rótulo devem sempre ser incluídos com aspas simples.  
**Usar tags em cláusulas WHERE**  
Você pode filtrar os resultados por tags de recurso da AWS usando a sintaxe `tag.keyName`. Os filtros de tag seguem as mesmas regras de operador que os filtros de dimensão. Por exemplo:  
+ WHERE `tag.env = 'prod'` filtra as métricas de recursos marcadas com *env=prod*
+ *WHERE `tag.department != 'test'` exclui as métricas de recursos marcados com department=test*
Os filtros de tag podem ser combinados com os filtros de dimensão:  
`WHERE tag.env = 'prod' AND InstanceType = 'm5.large'`  
**Operadores compatíveis**  
A cláusula **WHERE** é compatível com os seguintes operadores:  
+ **=** O valor do rótulo deve corresponder à string especificada.
+ **\$1=** O valor do rótulo não deve ser correspondente à string especificada.
+ **AND** Ambas as condições especificadas devem ser verdadeiras para serem correspondentes. Você pode usar várias palavras-chave **AND** para especificar duas ou mais condições.

**GROUP BY**  
Opcional. Agrupa os resultados da consulta em várias séries temporais, cada uma correspondendo a um valor diferente para a chave de rótulo ou chaves especificadas. Por exemplo, o uso de `GROUP BY InstanceId` retorna uma série temporal diferente para cada valor de `InstanceId`. O uso do `GROUP BY ServiceName, Operation` cria uma série temporal diferente para cada combinação possível de valores de `ServiceName` e `Operation`.  
Com uma cláusula **GROUP BY**, os resultados são ordenados alfabeticamente em ordem crescente por padrão usando a sequência de rótulos especificada na cláusula **GROUP BY**. Para alterar a ordem dos resultados, adicione uma cláusula **ORDER BY** à sua consulta.   
Ao executar uma consulta em uma conta de monitoramento, você pode usar `GROUP BY AWS.AccountId` para agrupar os resultados com base nas contas das quais eles se originam.  
**Usar tags em cláusulas GROUP BY**  
É possível filtrar os resultados por tags de recurso da AWS usando a sintaxe `tag.keyName`. Por exemplo:  
+ *GROUP BY tag.environment* cria séries temporais separadas para cada valor de tag de ambiente
+ *GROUP BY tag.team, InstanceType* agrupa por valores de tag e de dimensão
+ *GROUP BY tag.team, AWS.AccountId* agrupa por tag e por AccountIDs de origem vinculadas
Se algumas das métricas correspondentes não especificarem uma chave de rótulo específica na cláusula **GROUP BY**, é retornado um grupo nulo denominado `Other`. Por exemplo, se você especificar `GROUP BY ServiceName, Operation` e algumas das métricas retornadas não incluem `ServiceName` como uma dimensão, essas métricas são exibidas com `Other` como o valor para `ServiceName`.

**ORDER BY**  
Opcional. Especifica a ordem a ser usada para a série temporal retornada, se a consulta retornar mais de uma série temporal. A ordem é baseada nos valores encontrados pela **FUNCTION** que você especifica na cláusula **ORDER BY**. A **FUNCTION** é usada para calcular um único valor escalar de cada série temporal retornada, e esse valor é usado para determinar a ordem.  
Você também especifica se deve-se usar a ordem crescente **ASC** ou decrescente **DESC**. Se você omitir isso, o padrão será crescente **ASC**.  
Por exemplo, adicionar uma cláusula `ORDER BY MAX() DESC` ordena os resultados pelo ponto de dados máximo observado dentro do intervalo de tempo em ordem decrescente: o que significa que a série temporal que tem o ponto de dados máximo mais alto é retornada primeiro.  
As funções válidas para serem usadas em uma cláusula **ORDER BY** são `AVG()`, `COUNT()`, `MAX()`, `MIN()` e `SUM()`.  
Se você usar uma cláusula **ORDER BY** com uma cláusula **LIMIT**, a consulta resultante é uma consulta “Top N”. **ORDER BY** também é útil para consultas que podem retornar um grande número de métricas, porque cada consulta não pode retornar mais de 500 séries temporais. Se uma consulta corresponder a mais de 500 séries temporais e você usar uma cláusula **ORDER BY**, as séries temporais são classificadas e, em seguida, as 500 que aparecem primeiro na ordem de classificação são as que são retornadas.

**LIMIT**  
Opcional. Limita o número de séries temporais retornadas pela consulta ao valor que você especificar. O valor máximo que você pode especificar é 500, e uma consulta que não especifica um **LIMIT** também pode retornar até 500 séries temporais.  
O uso de uma cláusula **LIMIT** com uma cláusula **ORDER BY** fornece uma consulta “Top N”.

## Quando é necessário usar aspas ou caracteres de escape?
<a name="cloudwatch-metrics-insights-syntaxdetails"></a>

Em uma consulta, os valores de rótulo devem sempre estar cercados por aspas simples. Por exemplo, **SELECT MAX(CPUUtilization) FROM "AWS/EC2" WHERE AutoScalingGroupName = 'my-production-fleet'**. 

Namespaces de métricas, nomes de métricas e chaves de rótulo que contenham caracteres diferentes de letras, números e sublinhado (\$1) devem ser cercados por aspas duplas. Por exemplo, **SELECT MAX("My.Metric")**.

Se um deles contiver aspas duplas ou aspas simples (como `Bytes"Input"`), você deve fazer o escape de cada aspa com uma barra invertida, como em **SELECT AVG("Bytes\$1"Input\$1"")**. 

Se um namespace de métrica, nome da métrica ou chave de rótulo contiver uma palavra que seja palavra-chave reservada no Metrics Insights, eles também deverão estar entre aspas duplas. Por exemplo, se você tiver uma métrica chamada `LIMIT`, você pode usar `SELECT AVG("LIMIT")`. Também é válido colocar qualquer namespace, nome da métrica ou rótulo entre aspas duplas, mesmo que não inclua uma palavra-chave reservada.

(Para obter uma lista completa de palavras-chave reservadas, consulte [Palavras-chave reservadas](cloudwatch-metrics-insights-reserved-keywords.md).

## Construir uma consulta avançada passo a passo
<a name="cloudwatch-metrics-insights-syntaxexample"></a>

Esta seção ilustra a criação de um exemplo completo que usa todas as cláusulas possíveis, passo a passo.

Você pode começar com a consulta a seguir, que agrega todas as métricas `RequestCount` do Application Load Balancer coletadas com as dimensões `LoadBalancer` e `AvailabilityZone`.

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

Para ver apenas as métricas de um balanceador de carga específico, adicione uma cláusula **WHERE** para limitar as métricas retornadas apenas àquelas em que o valor da dimensão `LoadBalancer` é `app/load-balancer-1`.

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

A consulta anterior agrega as métricas `RequestCount` de todas as zonas de disponibilidade para esse balanceador de carga em uma série temporal. Se quiser ver séries temporais diferentes para cada zona de disponibilidade, adicione uma cláusula **GROUP BY**.

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

Depois, ordene esses resultados para os valores mais altos serem exibidos primeiro. A seguinte cláusula **ORDER BY** ordena a série temporal em ordem decrescente pelo valor máximo relatado por cada série temporal durante o intervalo de tempo da consulta:

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

Também é possível usar tags para filtrar ainda mais os resultados. Por exemplo, se você quiser ver resultados somente para balanceadores de carga marcados com um ambiente específico, adicione filtragem de tags à 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
```

Também é possível agrupar os resultados por valores de tag em vez de (ou além de) por dimensões. Por exemplo, agrupar pela tag Application:

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

Finalmente, se estivermos interessados principalmente em um tipo de consulta "Top N", podemos usar uma cláusula **LIMIT**. Este exemplo final limita os resultados apenas às séries temporais com os cinco maiores valores `MAX`.

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

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

Esses exemplos são válidos quando executados em uma conta configurada como conta de monitoramento na observabilidade entre contas do CloudWatch. 

O exemplo a seguir pesquisa todas as instâncias do Amazon EC2 na conta de origem 123456789012 e retorna a média.

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

O exemplo a seguir consulta a métrica `CPUUtilization` no `AWS/EC2` em todas as contas de origem vinculadas e agrupa os resultados por ID da conta e tipo de instância.

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

O exemplo a seguir consulta a `CPUUtilization` na própria conta de monitoramento.

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

# Palavras-chave reservadas
<a name="cloudwatch-metrics-insights-reserved-keywords"></a>

A seguir, veja as palavras-chave reservadas no CloudWatch Metrics Insights. Se alguma dessas palavras estiver em um namespace, nome da métrica ou chave de rótulo em uma consulta, você deverá colocá-las entre aspas duplas. As palavras-chave reservadas não diferenciam letras maiú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"
```

# Alarmes em consultas do CloudWatch Metrics Insights no CloudWatch
<a name="cloudwatch-metrics-insights-alarms"></a>

Você pode criar alarmes nas consultas ao Metrics Insights. Isso ajuda você a ter alarmes que rastreiam vários recursos sem ser necessário atualizá-los posteriormente. A consulta captura os novos recursos e os recursos que sofrem alteações. Por exemplo, é possível criar um alarme que monitore a utilização de CPU da sua frota, e o alarme avaliará automaticamente as novas instâncias que você iniciar após criar o alarme.

Em uma conta de monitoramento configurada para observabilidade entre contas do CloudWatch, os alarmes do Metrics Insights podem observar recursos nas contas de origem e na própria conta de monitoramento. Para obter mais informações sobre como limitar suas consultas de alarme a uma conta específica ou agrupar os resultados por ID da conta, consulte as seções `WHERE` e `GROUP BY` em [Componentes e sintaxe de consulta no CloudWatch Metrics Insights](cloudwatch-metrics-insights-querylanguage.md).

**Usar tags em consultas de alarme**

Você pode criar alarmes em consultas do Metrics Insights que usam tags de recurso da AWS para filtrar e agrupar métricas. Para usar tags com alarmes, em [https://console.aws.amazon.com/connect/](https://console.aws.amazon.com/connect/), escolha **Configurações**. Na página **Configurações do CloudWatch**, em **Habilitar tags de recurso em telemetria**, escolha **Habilitar**. Alarmes sensíveis a contexto monitoram aplicações, ambientes ou equipes específicos automaticamente à medida que os recursos mudam.

Por exemplo, você pode criar um alarme que monitore a utilização de CPU para todas as instâncias do Amazon EC2 marcadas com uma aplicação específica.

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

Os alarmes baseados em tags se adaptam automaticamente à medida que você adiciona ou remove recursos com as tags correspondentes, o que permite monitoramento dinâmico alinhado com a estrutura operacional.

**Contents**
+ [Criação de um alarme do CloudWatch com o Metrics Insights](cloudwatch-metrics-insights-alarm-create.md)

# Criação de um alarme do CloudWatch com o Metrics Insights
<a name="cloudwatch-metrics-insights-alarm-create"></a>

**Para criar um alarme em uma consulta ao Metrics Insights usando o console**

1. Abra o console do CloudWatch, em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. No painel de navegação, escolha **Metrics** (Métricas), **All metrics** (Todas as métricas).

1. (Opcional) Para executar uma consulta de amostra pré-criada, escolha **Add query** (Adicionar consulta) e selecione a consulta a ser executada. Caso contrário, você pode escolher **Editor** para editar a consulta de exemplo e, em seguida, escolher **Run** (Executar) para executar a consulta modificada. 

1. Para criar sua própria consulta, escolha **Consulta a várias fontes**. É possível usar as visualizações **Criador** e **Editor** e também uma combinação de ambas. Você pode alternar entre as duas visualizações a qualquer momento e ver o trabalho em andamento em ambas. 

   No **Builder** (Criador), você pode procurar e selecionar o namespace da métrica, o nome da métrica, o filtro, o grupo e as opções de ordem. Para cada uma dessas opções, o criador de consultas oferece uma lista de possíveis seleções do seu ambiente para escolher.

   Na visualização de **Editor**, você pode começar a gravar sua consulta. À medida que você digita, o editor oferece sugestões com base nos caracteres digitados até o momento.

   Por exemplo, ao criar a consulta do Metrics Insights para o alarme, use tags para filtrar e agrupar as métricas e ter um monitoramento mais direcionado.
   + Filtrar por tags: use `WHERE tag.keyName = 'value'` para monitorar recursos com tags específicas

     ```
     SELECT MAX(CPUUtilization) FROM "AWS/EC2" WHERE tag.Environment = 'Prod'
     ```
   + Combinar tags com dimensões: combine filtros de tags com as dimensões de métricas existentes

     ```
     SELECT AVG(Duration) FROM "AWS/Lambda" WHERE tag.Application = 'OrderService' AND FunctionName = 'process%'
     ```
**nota**  
Ao usar tags, os alarmes atenderão às métricas somente se as tags especificadas existirem nos recursos associados durante o período avaliado.

1. Quando você estiver contente com sua consulta escolha **Run** (Executar).

1. Selecione **Criar alarme**.

1. Em **Conditions (Condições)**, especifique o seguinte:

   1. Em **Whenever *metric* is (Sempre que a métrica for)**, especifique se a métrica deve ser maior que, menor que ou igual ao limite. Em **than... (que...)**, especifique o valor limite.

   1. Escolha **Additional configuration (Configuração adicional)**. Em **Datapoints to alarm (Pontos de dados para alarme)**, especifique quantos períodos de avaliação (pontos de dados) devem estar no estado `ALARM` para disparar o alarme. Se os dois valores forem correspondentes, você criará um alarme que passa para o estado `ALARM` se esses períodos consecutivos estiverem violando.

      Para criar um alarme M de N, especifique um número menor para o primeiro valor que especificar para o segundo valor. Para obter mais informações, consulte [Avaliação de alarme](alarm-evaluation.md).

   1. Para o **Missing data treatment (Tratamento de dados ausentes)**, escolha como deseja que o alarme se comporte quando alguns pontos de dados estiverem ausentes. Para obter mais informações, consulte [Configurar como os alarmes do CloudWatch tratam dados ausentes](alarms-and-missing-data.md).

1. Escolha **Próximo**.

1. Em **Notification (Notificação)**, selecione um tópico do SNS para notificar quando o alarme estiver no estado `ALARM`, `OK` ou `INSUFFICIENT_DATA`.

   Para que o alarme envie várias notificações para o mesmo estado de alarme ou para diferentes estados de alarme, escolha **Add notification (Adicionar notificação)**.

   Para que o alarme não envie notificações, escolha **Remove (Remover)**.

1. Para que o alarme execute ações do Auto Scaling, do EC2 ou do Systems Manager, escolha o botão apropriado, o estado do alarme e a ação a ser executada. Os alarmes só poderão executar ações do Systems Manager ao entrarem no estado ALARM. Para obter mais informações sobre ações do Systems Manager, consulte [Configurar o CloudWatch para criar OpsItems a partir de alarmes](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-create-OpsItems-from-CloudWatch-Alarms.html) e [Criação de incidentes](https://docs.aws.amazon.com/incident-manager/latest/userguide/incident-creation.html).
**nota**  
Para criar um alarme que executa uma ação do SSM Incident Manager, é necessário ter determinadas permissões. Para obter mais informações, consulte [Exemplos de políticas baseadas em identidade para o AWS Systems Manager Incident Manager](https://docs.aws.amazon.com/incident-manager/latest/userguide/security_iam_id-based-policy-examples.html).

1. Quando terminar, escolha **Next** (Próximo).

1. Digite um nome e uma descrição para o alarme. O nome deve conter somente caracteres ASCII. Escolha **Próximo**.

1. Em **Preview and create (Visualizar e criar)**, confirme se as informações e condições são o que você deseja e escolha **Create alarm (Criar alarme)**.

**Para criar um alarme em uma consulta ao Metrics Insights usando a AWS CLI**

Use o comando `put-metric-alarm` e especifique uma consulta ao Metrics Insights no parâmetro `metrics`. Por exemplo, o comando a seguir define um alarme que entra no estado ALARM (ALARME) se alguma das instâncias ultrapassar 50% de utilização da 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
```

# Usar consultas do Metrics Insights com matemática métrica
<a name="cloudwatch-metrics-insights-math"></a>

Você pode usar uma consulta do Metrics Insights como entrada para uma função matemática métrica. Para obter mais informações sobre matemática métrica, consulte [Uso de expressões matemáticas com as métricas do CloudWatch](using-metric-math.md).

Uma consulta do Metrics Insights que não inclui uma cláusula **GROUP BY** retorna uma única série temporal. Portanto, seus resultados retornados podem ser usados com qualquer função matemática métrica que tenha uma única série temporal como entrada.

Uma consulta do Metrics Insights que inclui uma cláusula **GROUP BY** retorna várias séries temporais. Portanto, seus resultados retornados podem ser usados com qualquer função matemática métrica que tenha uma matriz de séries temporais como entrada.

Por exemplo, a seguinte consulta retorna o número total de bytes baixados para cada bucket na região, como uma matriz de séries temporais:

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

Em um gráfico no console ou em uma operação [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html), os resultados desta consulta são `q1`. Essa consulta retorna o resultado em bytes. Portanto, se você quiser ver o resultado como MB, você pode usar a seguinte função matemática:

```
q1/1024/1024
```

# Usar linguagem natural para gerar e atualizar as consultas do CloudWatch Metrics Insights
<a name="cloudwatch-metrics-insights-query-assist"></a>

 O CloudWatch é compatível com um recurso de consulta em linguagem natural para ajudar você a gerar e atualizar consultas para o [CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html) e o [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html). 

 Com esse recurso, você pode fazer perguntas ou descrever os dados do CloudWatch que está procurando em inglês simples. O recurso de linguagem natural gera uma consulta com base em um prompt que você envia e fornece uma explicação detalhada de como a consulta funciona. Você também pode atualizar a consulta para investigar melhor seus dados. 

 Dependendo do ambiente, você pode inserir solicitações, como “Qual instância do Amazon Elastic Compute Cloud tem a maior saída de rede?” e “Mostre-me as dez principais tabelas do Amazon DynamoDB por leituras consumidas”. 

**nota**  
O recurso de consulta em linguagem natural geralmente está disponível em dez regiões. Para algumas regiões, o recurso faz chamadas entre regiões para regiões nos Estados Unidos para processar os prompts de consulta. A tabela a seguir lista as regiões compatíveis e mostra onde cada região processa os prompts.  


| Regiões compatíveis | Região em que o prompt é processado | 
| --- | --- | 
|  Leste dos EUA (Norte da Virgínia)  |  Leste dos EUA (Norte da Virgínia)  | 
|  Leste dos EUA (Ohio)  |  Leste dos EUA (N. da Virgínia)  | 
|  Oeste dos EUA (Oregon)  |  Oeste dos EUA (Oregon)  | 
|  Ásia-Pacífico (Hong Kong)  |  Oeste dos EUA (Oregon)  | 
|  Ásia-Pacífico (Singapura)  |  Oeste dos EUA (Oregon)  | 
|  Ásia-Pacífico (Sydney)  |  Oeste dos EUA (Oregon)  | 
|  Ásia-Pacífico (Tóquio)  |  Ásia-Pacífico (Tóquio)  | 
|  Europa (Frankfurt)  |  Europa (Frankfurt)  | 
|  Europa (Irlanda)  |  Leste dos EUA (Norte da Virgínia)  | 
|  Europa (Estocolmo)  |  Leste dos EUA (Norte da Virgínia)  | 

 Para gerar uma consulta do CloudWatch Metrics Insights com esse recurso, abra o editor de consultas do CloudWatch Metrics Insights na visualização do *construtor* ou do *editor* e escolha **Gerar consulta**. 

**Importante**  
 Para usar o recurso de consulta em linguagem natural, você deve usar a 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) ou [ReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html).   
 Você também pode incluir a ação `cloudwatch:GenerateQuery` em uma política nova ou atual gerenciada pelo cliente ou em uma política em linha. 

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

 Os exemplos nesta seção descrevem como gerar e atualizar consultas usando o recurso de linguagem natural. 

**nota**  
 Para obter mais informações sobre o editor de consultas e a sintaxe do CloudWatch Metrics Insights, consulte [Componentes e sintaxe de consulta do CloudWatch Metrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-metrics-insights-querylanguage.html). 

### Exemplo: gerar uma consulta em linguagem natural
<a name="cloudwatch-metrics-insights-query-assist-example-1"></a>

 Para gerar uma consulta usando linguagem natural, insira um prompt e escolha **Gerar nova consulta**. Este exemplo mostra uma consulta que executa uma pesquisa básica. 

**Prompt**  
 Veja a seguir um exemplo de um prompt que direciona o recurso para pesquisar as dez principais tabelas do DynamoDB que consomem a maior capacidade de leitura. 

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

**Consulta**  
 Veja a seguir um exemplo de consulta que o recurso de linguagem natural gera com base no prompt. Observe como o prompt aparece em um comentário antes da consulta. Depois da consulta, você pode ler uma explicação que descreve como a consulta funciona. 

```
# 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 desativar o surgimento do prompt e a explicação de como a consulta funciona, use o ícone de engrenagem no editor. 

### Exemplo: atualizar uma consulta em linguagem natural
<a name="cloudwatch-metrics-insights-query-assist-example-2"></a>

 Você pode atualizar uma consulta editando o prompt inicial e escolhendo **Atualizar consulta**. 

**Prompt atualizado**  
 O exemplo a seguir mostra uma versão atualizada do prompt anterior. Em vez de um prompt que pesquisa as dez principais tabelas do DynamoDB que consomem a maior capacidade de leitura, esse prompt agora direciona o recurso para classificar os resultados pelo número de bytes retornados. 

```
Sort by bytes returned instead
```

**Consulta atualizada**  
 Veja a seguir um exemplo da consulta atualizada. Observe como o prompt atualizado aparece em um comentário antes da consulta atualizada. Depois da consulta, você pode ler uma explicação que descreve como a consulta original foi atualizada. 

```
# 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 não usar seus dados para melhorar o serviço
<a name="cloudwatch-metrics-insights-query-assist-service-data"></a>

 Os dados dos prompts em linguagem natural que você fornece para treinar o modelo de IA e gerar consultas relevantes são usados exclusivamente para fornecer e manter seu serviço. Esses dados podem ser usados para melhorar a qualidade do CloudWatch Metrics Insights. Sua confiança e privacidade, além da segurança do seu conteúdo, são nossas maiores prioridades. Para obter mais informações, consulte [Termos de Serviço da AWS](https://aws.amazon.com/service-terms/) e [AWS responsible AI policy](https://aws.amazon.com/machine-learning/responsible-ai/policy/). 

 Você pode se recusar a ter seu conteúdo usado para desenvolver ou melhorar a qualidade das consultas em linguagem natural ao criar uma política de rejeição de serviços de IA. Para recusar a coleta de dados de todos os recursos de IA do CloudWatch, incluindo a geração de consultas, você deve criar uma política de recusa para o CloudWatch. Para obter mais informações, consulte [Políticas de exclusão dos serviços de IA](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html) no *Guia do usuário do AWS Organizations*. 

# Inferência SQL
<a name="cloudwatch-metrics-insights-inference"></a>

O CloudWatch Metrics Insights utiliza vários mecanismos para inferir a intenção de determinada consulta SQL.

**Topics**
+ [Intervalo de tempo](#cloudwatch-metrics-insights-inference-timebucketing)
+ [Projeção de campos](#cloudwatch-metrics-insights-inference-fieldsprojection)
+ [Agregação global ORDER BY](#cloudwatch-metrics-insights-inference-OrderBy)

## Intervalo de tempo
<a name="cloudwatch-metrics-insights-inference-timebucketing"></a>

Os pontos de dados de séries temporais resultantes de uma consulta são agrupados em intervalos de tempo com base no período solicitado. Para agregar valores no SQL padrão, deve-se definir uma cláusula GROUP BY explícita para coletar todas as observações de um determinado período juntas. Como essa é a forma padrão de consultar dados de séries temporais, o CloudWatch Metrics Insights infere o intervalo de tempo sem a necessidade de expressar uma cláusula **GROUP BY** explícita. 

Por exemplo, quando uma consulta é realizada com um período de um minuto, todas as observações pertencentes a esse minuto até o próximo (excluído) são acumuladas até a hora de início do bucket de tempo. Isso torna as instruções SQL do Metrics Insights mais concisas e menos detalhadas. 

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

A consulta anterior retorna uma única série temporal (pares de valores de timestamp), representando a utilização média da CPU de todas as instâncias do Amazon EC2. Supondo que o período solicitado seja de um minuto, cada ponto de dados retornado representa a média de todas as observações medidas dentro do intervalo específico de um minuto (incluindo a hora de início e excluindo a hora de término). O timestamp relacionado ao ponto de dados específico é a hora de início do bucket

## Projeção de campos
<a name="cloudwatch-metrics-insights-inference-fieldsprojection"></a>

As consultas do Metrics Insights sempre retornam a projeção de timestamp. Não é necessário especificar uma coluna timestamp na cláusula **SELECT** para obter o timestamp de cada valor de ponto de dados correspondente. Para obter detalhes sobre como o timestamp é calculado, consulte [Intervalo de tempo](#cloudwatch-metrics-insights-inference-timebucketing).

Ao usar **GROUP BY**, cada nome de grupo também é inferido e projetado no resultado, para que você possa agrupar a série temporal retornada. 

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

A consulta anterior retorna uma série temporal para cada instância do Amazon EC2. Cada série temporal é rotulada com base no valor do ID da instância.

## Agregação global ORDER BY
<a name="cloudwatch-metrics-insights-inference-OrderBy"></a>

Ao usar a **ORDER BY**, a **FUNCTION()** infere por qual função agregada você deseja ordenar os valores dos pontos de dados das métricas consultadas. A operação agregada é executada em todos os pontos de dados correspondentes de cada série temporal individual na janela de tempo consultada. 

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

A consulta anterior retorna a utilização da CPU para cada instância do Amazon EC2, limitando o conjunto de resultados a 10 entradas. Os resultados são ordenados com base no valor máximo da série temporal individual na janela de tempo solicitada. A cláusula **ORDER BY** é aplicada antes de **LIMIT**, para que se calcule o ordenamento com relação a mais de dez séries temporais.

# Cotas do Metrics Insights
<a name="cloudwatch-metrics-insights-limits"></a>

No momento, o CloudWatch Metrics Insights tem as seguintes cotas:
+ Consulte até duas semanas de dados para visualização em suas métricas, widgets e grafos de alarmes. É possível consultar os dados das três últimas horas para avaliações de condições de alarme.
+ Uma consulta única não pode processar mais de 10.000 métricas. Isto significa que se as cláusulas **SELECT**, **FROM** e **WHERE** correspondem a mais de 10.000 métricas, a consulta processa apenas as primeiras 10.000 entre as métricas encontradas.
+ Uma consulta única não pode retornar mais de 500 séries temporais. Isso significa que, se a consulta puder retornar mais de 500 métricas, nem todas as métricas serão retornadas nos resultados da consulta. Se você usar uma cláusula **ORDER BY**, todas as métricas que estão sendo processadas serão classificadas, e as 500 que têm os valores mais altos ou mais baixos de acordo com sua cláusula **ORDER BY** serão retornadas.

  Se você não incluir uma cláusula **ORDER BY**, não poderá controlar quais 500 métricas correspondentes serão retornadas.
+ Você pode ter até 200 alarmes do Metrics Insights por região. 
+ O Metrics Inights não é compatível com dados de alta resolução, que são dados métricos relatados com uma granularidade de menos de um minuto. Se você solicitar dados de alta resolução, a solicitação não falhará, mas a saída será agregada com a granularidade de um minuto.
+ Cada operação [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html) pode ter apenas uma consulta. No entanto, você pode ter vários widgets em um painel para que cada um inclua uma consulta.
+ Se uma consulta usando tags com um **GROUP BY** ou **WHERE** corresponder a uma métrica com mais de 10 atualizações de tags, somente as 10 versões marcadas com tags mais recentes da métrica serão incluídas nos resultados da consulta.

# Consultas de exemplo do Metrics Insights
<a name="cloudwatch-metrics-insights-queryexamples"></a>

Esta seção contém exemplos de consultas úteis do CloudWatch Metrics Insights que você pode copiar e usar diretamente ou copiar e modificar no editor de consultas. Alguns desses exemplos já estão disponíveis no console, e você pode acessá-los escolhendo **Add query** (Adicionar consulta) na visualização de **Metrics** (Métricas).

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

**Total de solicitações em todos os balanceadores de carga**

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

**Os dez balanceadores de carga mais ativos **

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

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

**As 20 principais APIs da AWS pelo número de chamadas em sua conta**

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

**APIs do CloudWatch classificadas por chamadas**

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

## Exemplos do DynamoDB
<a name="cloudwatch-metrics-insights-queryexamples-DynamoDB"></a>

**As dez principais tabelas por leituras consumidas**

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

**As dez principais tabelas por bytes retornados**

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

**As dez principais tabelas por erros do usuário**

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

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

**Os dez principais volumes do Amazon EBS por bytes gravados**

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

**Tempo médio de gravação do volume do Amazon EBS**

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

## Exemplos do Amazon EC2
<a name="cloudwatch-metrics-insights-queryexamples-EC2"></a>

**Utilização da CPU por instâncias EC2 classificadas pela mais alta **

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

**Utilização média da CPU em toda a frota**

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

**As dez principais instâncias por maior utilização da CPU**

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

**Nesse caso, o atendente do CloudWatch está coletando uma métrica `CPUUtilization` por aplicação. Esta consulta filtra a média dessa métrica por um nome de aplicação específico.**

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

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

**Utilização média da CPU em todos os clusters do ECS **

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

**Os dez principais clusters por utilização de memória**

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

**Os dez principais serviços por utilização da CPU**

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

**Os dez principais serviços por tarefas em execução (Container Insights)**

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

## Exemplos do Amazon Elastic Kubernetes Service Container Insights
<a name="cloudwatch-metrics-insights-queryexamples-EKSCI"></a>

**Utilização média da CPU em todos os clusters EKS **

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

**Os dez principais clusters por utilização de nó de CPU**

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

**Os dez principais clusters por utilização de memória de pod**

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

**Os dez principais nós por utilização da CPU**

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

**Os dez principais pods por utilização de memória**

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

## Exemplos do EventBridge
<a name="cloudwatch-metrics-insights-queryexamples-EventBridge"></a>

**As dez principais regras por invocações**

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

**As dez principais regras por invocações que falharam**

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

**As dez principais regras por regras correspondentes**

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

## Exemplos do Kinesis
<a name="cloudwatch-metrics-insights-queryexamples-Kinesis"></a>

**Os dez principais fluxos por bytes gravados**

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

**Os dez principais fluxos pelos primeiros itens no fluxo**

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

## Exemplos do Lambda
<a name="cloudwatch-metrics-insights-queryexamples-Lambda"></a>

**Funções do Lambda ordenadas por número de invocações**

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

**As dez principais funções do Lambda por runtime mais longo**

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

**As dez principais funções do Lambda por contagem de erros**

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

## Exemplos do CloudWatch Logs
<a name="cloudwatch-metrics-insights-queryexamples-CloudWatchLogs"></a>

**Os dez principais grupos de logs por eventos recebidos**

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

**Os dez principais grupos de logs por bytes gravados**

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

## Exemplos do Amazon RDS
<a name="cloudwatch-metrics-insights-queryexamples-RDS"></a>

**As dez principais instâncias do Amazon RDS pela maior utilização da CPU**

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

**Os dez principais clusters do Amazon RDS por gravações**

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

## Exemplos do Amazon Simple Storage Service para PHP
<a name="cloudwatch-metrics-insights-queryexamples-S3"></a>

**Latência média por bucket**

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

**Os dez principais buckets por bytes baixados**

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

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

**Total de mensagens publicadas por tópicos do SNS**

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

**Os dez principais tópicos por mensagens publicadas**

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

**Os dez principais tópicos por falhas na entrega de mensagens**

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

## Exemplos do Amazon SQS
<a name="cloudwatch-metrics-insights-queryexamples-SQS"></a>

**As dez principais filas por número de mensagens visíveis**

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

**As dez principais filas mais ativas**

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

**As dez principais filas por idade da primeira mensagem**

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

# Glossário do Metrics Insights
<a name="cloudwatch-metrics-insights-glossary"></a>

**rótulo**  
No Metrics Insights, um rótulo é um par de chave-valor usado na definição do escopo de uma consulta para que ela retorne um determinado conjunto de dados ou na definição de critérios pelos quais os resultados da consulta devem ser separados em séries temporais distintas. Uma chave de rótulo é semelhante ao nome de uma coluna no SQL. Os rótulos devem ser dimensões métricas do CloudWatch. 

**observação**  
Uma observação é um valor registrado para uma determinada métrica em um determinado momento.

# Solução de problemas do métricas do Metrics Insights
<a name="cloudwatch-metrics-insights-troubleshooting"></a>

## Os resultados incluem “Outros”, mas não tenho esse valor como uma dimensão
<a name="cloudwatch-metrics-insights-troubleshooting-other"></a>

Isso significa que a consulta inclui uma cláusula **GROUP BY** que especifica uma chave de rótulo que não está sendo usada em algumas das métricas retornadas pela consulta. Nesse caso, um grupo nulo denominado `Other` é retornado. As métricas que não incluem essa chave de rótulo provavelmente são métricas agregadas que retornam valores agregados em todos os valores dessa chave de rótulo.

 Por exemplo, suponha que tenhamos a seguinte consulta:

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

Se algumas das métricas retornadas não incluírem `ServiceName` como uma dimensão, elas são exibidas tendo `Other` como o valor para `ServiceName`.

Para evitar ver “Outros” em seus resultados, use **SCHEMA** na sua cláusula **FROM**, como no seguinte exemplo:

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

Isso limita os resultados retornados apenas às métricas que têm ambas as dimensões `Operation` e `ServiceName`.

## O timestamp mais antigo no meu gráfico tem um valor de métrica menor do que os outros
<a name="cloudwatch-metrics-insights-troubleshooting-oldest"></a>

O CloudWatch Metrics Insights oferece suporte a até duas semanas de dados históricos. Quando você faz um gráfico com um período maior que um minuto, pode haver casos em que o ponto de dados mais antigo difere do valor esperado. Isso ocorre porque as consultas do CloudWatch Metrics Insights retornam somente dados dentro do período de retenção de duas semanas. Nesse caso, o ponto de dados mais antigo na consulta retorna somente as observações que foram mensuradas no período de duas semanas, em vez de retornar todas as observações no período desse ponto de dados.

## Valores inconsistentes de métricas em diferentes períodos de tempo ao usar consultas baseadas em tags
<a name="cloudwatch-metrics-insights-troubleshooting-tag-mutations"></a>

Ao usar as cláusulas `WHERE` ou `GROUP BY` com tags nas consultas do CloudWatch Metrics Insights, você pode ver valores diferentes de métricas, dependendo do período de tempo selecionado. Por exemplo, um período de 6 horas pode mostrar um valor de pico de 20, enquanto um período de 1 hora mostra apenas 2 para a mesma janela de tempo.

Isso ocorre porque os carimbos de data e hora das tags são armazenados com resolução de segundo nível, enquanto os pontos de dados de métricas são alinhados aos limites do período (por exemplo, o início de cada minuto ou hora). Para determinar quais pontos de dados correspondem a um intervalo de tempo de tags, o CloudWatch ajusta o início do intervalo subtraindo um período. Com períodos maiores, esse ajuste cria uma lacuna maior entre o carimbo de data e hora de tags e o primeiro ponto de dados incluído, o que pode fazer com que pontos de dados próximos ao início do intervalo sejam excluídos.

O exemplo a seguir mostra como isso afeta os resultados da consulta. Uma métrica tem dois valores de tag: `env=beta` (de 00:00 a 01:30) e `env=gamma` (de 01:30 a 03:00). Cada tag abrange 90 minutos de dados com um SUM de 270.

![\[Dois grafos de métricas do CloudWatch comparando os resultados de consultas baseadas em tags com períodos de 1 minuto e 3 horas.\]](http://docs.aws.amazon.com/pt_br/AmazonCloudWatch/latest/monitoring/images/metrics-insights-tag-alignment.png)



| **env=beta com período de 1 minuto** | Estatística | Esperados | Returned | Diferença | 
| --- | --- | --- | --- | --- | 
| 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 com período de 1 minuto** | Estatística | Esperados | Returned | Diferença | 
| --- | --- | --- | --- | --- | 
| SUM | 270 | 275 | 5\$1 | 
| AVG | 3.0 | 3.0 | 0 | 
| MIN | 1 | 1 | 0 | 
| MAX | 5 | 5 | 0 | 
| SAMPLE\$1COUNT | 90 | 91 | \$11 | 

Com um período de 1 minuto, o ajuste do alinhamento é pequeno (1 minuto), portanto, apenas 1 ponto de dados extra é incluído por tag. Com um período de 3 horas, o ajuste abrange todo o intervalo de consultas:


| **env=beta com período de 3 horas** | Estatística | Esperados | Returned | Diferença | 
| --- | --- | --- | --- | --- | 
| 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 com período de 3 horas** | Estatística | Esperados | Returned | Diferença | 
| --- | --- | --- | --- | --- | 
| SUM | 270 | 540 | \$1270 | 
| AVG | 3.0 | 3.0 | 0 | 
| MIN | 1 | 1 | 0 | 
| MAX | 5 | 5 | 0 | 
| SAMPLE\$1COUNT | 90 | 180 | \$190 | 

Com o período de 3 horas, as duas tags retornam o conjunto de dados inteiro (SUM=540, SAMPLE\$1COUNT=180) porque o carimbo de data e hora do único ponto de dados agregado está dentro dos dois intervalos ajustados. O limite de tags é efetivamente apagado.

Para reduzir o impacto desse comportamento, tente as seguintes abordagens:
+ **Use períodos de agregação menores.** Períodos menores (como 1 minuto ou 5 minutos) alinham-se melhor à resolução de segundo nível dos carimbos de data e hora de tags, o que minimiza a lacuna de alinhamento e aumenta a probabilidade de que todos os pontos de dados relevantes sejam incluídos.
+ **Use filtragem baseada em dimensões em vez de tags.** Se seu caso de uso permitir, filtre por dimensões em vez de por tags. As consultas baseadas em dimensões não são afetadas por esse comportamento. Por exemplo, use `WHERE InstanceId = 'i-1234567890abcdef0'` em vez de `WHERE tag."my-tag" = 'my-value'`.
+ **Consulte com uma granularidade consistente.** Ao comparar dados de métricas em diferentes janelas de tempo, use o mesmo período para evitar diferenças inesperadas causadas pelo ajuste de alinhamento.