Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Interrogez vos CloudWatch indicateurs avec CloudWatch Metrics Insights
CloudWatch Metrics Insights est un puissant moteur de requêtes SQL très performant que vous pouvez utiliser pour interroger vos métriques à grande échelle. Vous pouvez identifier les tendances et les modèles au sein de tous vos CloudWatch indicateurs en temps réel, en accédant à deux semaines de données historiques pour une analyse complète des tendances.
Vous pouvez également définir des alarmes sur toutes les requêtes Metrics Insights qui renvoient une seule série temporelle. Cela peut être particulièrement utile pour créer des alarmes qui surveillent des métriques agrégées sur une flotte de votre infrastructure ou de vos applications. Créez l'alarme une fois, et elle s'ajuste dynamiquement au fur et à mesure que des ressources sont ajoutées ou retirées de la flotte.
Vous pouvez effectuer une requête CloudWatch Metrics Insights dans la console à l'aide de l'éditeur de requêtes CloudWatch Metrics Insights. Vous pouvez également effectuer une requête CloudWatch Metrics Insights avec le AWS CLI ou un AWS SDK en exécutant `GetMetricData` ou`PutDashboard`. Les requêtes que vous exécutez avec l'éditeur de requêtes CloudWatch Metrics Insights sont gratuites. Pour plus d'informations sur CloudWatch les tarifs, consultez [Amazon CloudWatch Pricing](https://aws.amazon.com/cloudwatch/pricing/).
Avec l'éditeur de requêtes CloudWatch Metrics Insights, vous pouvez choisir parmi une variété d'exemples de requêtes prédéfinis et également créer vos propres requêtes. Lorsque vous créez vos requêtes, vous pouvez utiliser une vue du générateur pour parcourir vos statistiques et dimensions existantes. Vous pouvez également utiliser une vue d’éditeur pour écrire des requêtes manuellement.
Avec Metrics Insights, vous pouvez exécuter des requêtes à grande échelle. En utilisant la clause **GROUP BY**, vous pouvez regrouper de manière flexible vos métriques en temps réel dans des séries temporelles distinctes par valeur de dimension spécifique, en fonction de vos cas d’utilisation. Comme les requêtes Metrics Insights incluent une fonctionnalité **ORDER BY**, vous pouvez utiliser Metrics Insights pour effectuer des requêtes de type « Top N ». Par exemple, les requêtes de type « Top N » peuvent analyser des millions de métriques de votre compte et renvoyer les 10 instances qui consomment le plus de processeur. Cela peut vous aider à identifier et à résoudre les problèmes de latence dans vos applications. Pour utiliser des balises avec des alarmes, inscrivez-vous via CloudWatch les paramètres. Une fois les balises activées, vous pouvez également filtrer et regrouper les métriques à l'aide de balises de AWS ressources, ce qui vous permet d'interroger les métriques alignées sur la structure de votre organisation, par exemple par application, environnement ou équipe.
**Topics**
+ [Création de vos requêtes dans CloudWatch Metrics Insights](cloudwatch-metrics-insights-buildquery.md)
+ [Composants et syntaxe des requêtes dans CloudWatch Metrics Insights](cloudwatch-metrics-insights-querylanguage.md)
+ [Alarmes sur CloudWatch les requêtes Metrics Insights dans CloudWatch](cloudwatch-metrics-insights-alarms.md)
+ [Utiliser des requêtes Metrics Insights avec des mathématiques appliquées aux métriques](cloudwatch-metrics-insights-math.md)
+ [Utiliser le langage naturel pour générer et mettre à jour CloudWatch les requêtes Metrics Insights](cloudwatch-metrics-insights-query-assist.md)
+ [Inférence SQL](cloudwatch-metrics-insights-inference.md)
+ [Quotas de Metrics Insights](cloudwatch-metrics-insights-limits.md)
+ [Exemples de requêtes Metrics Insights](cloudwatch-metrics-insights-queryexamples.md)
+ [Glossaire de Metrics Insights](cloudwatch-metrics-insights-glossary.md)
+ [Dépannage Metrics Insights](cloudwatch-metrics-insights-troubleshooting.md)
# Création de vos requêtes dans CloudWatch Metrics Insights
Vous pouvez exécuter une requête CloudWatch Metrics Insights à l'aide de la CloudWatch console, du AWS CLI, ou du AWS SDKs. Les requêtes exécutées dans la console sont gratuites. Pour plus d'informations sur CloudWatch les tarifs, consultez [Amazon CloudWatch Pricing](https://aws.amazon.com/cloudwatch/pricing/).
Avec CloudWatch Metrics Insights, vous pouvez analyser les données métriques sur des périodes prolongées allant jusqu'à deux semaines, ce qui permet une analyse historique et une identification des tendances plus complètes par rapport à des périodes de conservation plus courtes. Pour des performances optimales lorsque vous effectuez des requêtes sur des plages de temps plus longues, envisagez d’utiliser des périodes plus importantes (telles que 5 minutes ou 1 heure) pour réduire le nombre de points de données renvoyés. Lorsque vous analysez des tendances sur une période complète de deux semaines, utilisez des fonctions d’agrégation telles que AVG() ou MAX() dans vos clauses ORDER BY afin d’identifier efficacement des modèles.
Pour plus d'informations sur l'utilisation du AWS SDKs pour effectuer une requête Metrics Insights, consultez [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html).
Pour exécuter une requête à l'aide de la CloudWatch console, procédez comme suit :
**Pour interroger vos métriques à l'aide de Metrics Insights**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le panneau de navigation, sélectionnez **Métriques**, **Toutes les métriques**.
1. (Facultatif) Pour exécuter un exemple de requête préétablie, choisissez **Add query** (Ajouter une requête) et sélectionnez la requête à exécuter. Si vous êtes satisfait de cette requête, vous pouvez ignorer le reste de cette procédure. Ou, vous pouvez choisir **Editor** (Éditeur) pour modifier l'exemple de requête, puis choisir **Run** (Exécuter) pour exécuter la requête modifiée.
1. Pour créer votre propre requête, sélectionnez **Requête multi-sources**. Vous pouvez ensuite utiliser la vue **Constructeur** (par défaut) pour obtenir une expérience guidée ou la vue **Éditeur** si vous préférez voir la syntaxe de la requête. Vous pouvez passer d'une vue à l'autre à tout moment et voir votre travail en cours dans les deux vues.
Dans la vue **Constructeur**, cliquez sur les champs Espace de noms, Nom de la métrique, Filtre, Groupe, Ordre et Limite pour parcourir et sélectionner les valeurs possibles. Vous pouvez commencer à taper n’importe quelle partie de la valeur que vous recherchez pour filtrer la liste présentée par le constructeur. Vous pouvez faire référence à des balises de ressources dans les entrées de filtre et de groupe.
Dans la vue **Éditeur**, vous pouvez écrire la requête en utilisant le sous-ensemble de SQL pris en charge par Metrics Insights. L’éditeur propose des options d’auto-complétion basées sur les caractères que vous avez tapés jusqu’à présent, y compris le nom des balises de ressources pour les métriques qui les prennent en charge.
CloudWatch Metrics Insights permet d'interroger les métriques par balises de AWS ressources. Vous pouvez utiliser les balises pour filtrer et regrouper vos données de métriques pour une surveillance et une analyse plus ciblées.
Les exemples suivants montrent comment vous pouvez utiliser des requêtes avec des balises.
Pour connaître l’utilisation du processeur des instances Amazon EC2 dans votre environnement de production :
```
SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") WHERE tag.env='prod'
```
Pour regrouper les métriques par environnement à l’aide de la clause GROUP BY :
```
SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") GROUP BY tag.env
```
Pour utiliser la clause GROUP BY dans laquelle vous spécifiez le nom du tag :
```
SELECT AVG(CPUUtilization) FROM "AWS/EC2" GROUP BY tag."aws:cloudformation:stack-name"
```
Pour combiner les requêtes sur les balises avec les dimensions de métriques existantes :
```
SELECT MAX(CPUUtilization) FROM SCHEMA("AWS/EC2") WHERE tag.env='prod' AND InstanceId='i-1234567890abcdef0'
```
1. Lorsque vous êtes satisfait de votre requête, sélectionnez **Run** (Exécuter).
1. (Facultatif) Une autre façon de modifier une requête que vous avez représentée graphiquement consiste à choisir l'onglet **Graphed metrics** (Graphique des métriques) et choisir l'icône de modification à côté de la formule de requête dans la colonne **Details** (Détails).
1. (Facultatif) Pour supprimer une requête du graphique, choisissez **Graphed metrics** (Graphique des métriques) et choisissez l‘icône **X** à droite de la ligne qui affiche votre requête.
# Composants et syntaxe des requêtes dans CloudWatch Metrics Insights
CloudWatch La syntaxe de Metrics Insights est la suivante.
```
SELECT FUNCTION(metricName)
FROM namespace | SCHEMA(...)
[ WHERE labelKey OPERATOR labelValue [AND ... ] ]
[ GROUP BY labelKey [ , ... ] ]
[ ORDER BY FUNCTION() [ DESC | ASC ] ]
[ LIMIT number ]
```
Les clauses possibles dans une requête Metrics Insights sont les suivantes. Aucun des mots-clés n'est sensible à la casse, mais les identificateurs tels que les noms des métriques, des espaces de noms et des dimensions sont sensibles à la casse.
**SELECT**
Obligatoire. Spécifie la fonction à utiliser pour agréger les observations dans chaque compartiment temporel (déterminé par la période fournie). Spécifie également le nom de la métrique à interroger.
Les valeurs valides pour **FUNCTION** (FONCTION) sont `AVG`, `COUNT`, `MAX`, `MIN` et `SUM`.
+ `AVG` calcule la moyenne des observations correspondant à la requête.
+ `COUNT` renvoie le nombre d'observations correspondant à la requête.
+ `MAX` renvoie la valeur maximale des observations correspondant à la requête.
+ `MIN` renvoie la valeur minimale des observations correspondant à la requête.
+ `SUM` calcule la somme des observations correspondant à la requête.
**FROM**
Obligatoire. Spécifie la source de la métrique. Vous pouvez spécifier soit l'espace de noms de métrique qui contient la métrique à interroger, soit une fonction de table **SCHEMA** (SCHÉMA). Voici des exemples d'espaces de noms de métriques : `"AWS/EC2"`, `"AWS/Lambda"`, et des espaces de noms de métriques que vous avez créés pour vos métriques personnalisées.
Les espaces de noms de métriques qui incluent **/** ou tout autre caractère qui n'est pas une lettre, un chiffre ou un tiret bas doivent être entourés de guillemets doubles. Pour de plus amples informations, consultez [Qu'est-ce qui nécessite des guillemets ou des caractères d'échappement ?](#cloudwatch-metrics-insights-syntaxdetails).
**SCHEMA** (SCHÉMA)
Une fonction de table facultative pouvant être utilisée dans une clause **FROM** (À PARTIR DE). Utilisez **SCHEMA** (SCHÉMA) pour réduire les résultats de la requête aux métriques qui correspondent parfaitement à une liste de dimensions, ou aux métriques qui n'ont pas de dimensions.
Si vous utilisez une clause **SCHEMA** (SCHÉMA), elle doit contenir au moins un argument, et ce premier argument doit être l'espace de noms de la métrique interrogée. Si vous spécifiez **SCHEMA** (SCHÉMA) avec cet argument d'espace de noms uniquement, les résultats sont limités à des métriques qui n'ont aucune dimension.
Si vous spécifiez **SCHEMA** (SCHÉMA) avec des arguments supplémentaires, les arguments supplémentaires après l'argument d'espace de noms doivent être des clés d'*étiquette*. Les clés d'étiquette doivent être des noms de dimension. Si vous spécifiez une ou plusieurs de ces clés d'étiquette, les résultats sont limités uniquement aux métriques qui possèdent cet ensemble exact de dimensions. L'ordre de ces clés d'étiquette n'a pas d'importance.
Par exemple :
+ **SELECT AVG(CPUUtilization) FROM "AWS/EC2"** correspond à toutes les métriques `CPUUtilization` dans l'espace de noms `AWS/EC2`, quelles que soient leurs dimensions, et renvoie une série temporelle agrégée unique.
+ **SELECT AVG(CPUUtilization) FROM SCHEMA("AWS/EC2")** ne correspond qu'aux métriques `CPUUtilization` dans l'espace de noms `AWS/EC2` pour lequel aucune dimension n'est définie.
+ **SELECT AVG (CPUUtilization) FROM SCHEMA (« AWS/EC2 », InstanceId)** ne correspond qu'aux `CPUUtilization` CloudWatch métriques signalées avec exactement une dimension,. `InstanceId`
+ **SELECT SUM (RequestCount) FROM SCHEMA (« AWS/ApplicationElb » LoadBalancer,, AvailabilityZone)** correspond uniquement aux `RequestCount` métriques signalées à CloudWatch from `AWS/ApplicationELB` avec exactement deux dimensions, et. `LoadBalancer` `AvailabilityZone`
**WHERE**
Facultatif. Filtre les résultats en ne retenant que les métriques qui correspondent à l'expression spécifiée à l'aide de valeurs d'étiquette spécifiques pour une ou plusieurs clés d'étiquette. **Par exemple, **WHERE InstanceType = 'c3.4xlarge'** filtre les résultats uniquement pour les types d'`c3.4xlarge`instances, et WHERE \$1 InstanceType = 'c3.4xlarge'** filtre les résultats pour tous les types d'instances sauf. `c3.4xlarge`
Lorsque vous exécutez une requête dans un compte de surveillance, vous pouvez l’utiliser `WHERE AWS.AccountId` pour limiter les résultats au compte que vous spécifiez. Par exemple, `WHERE AWS.AccountId=444455556666` n’interroge les métriques que pour le compte `444455556666`. Pour limiter votre requête aux seuls indicateurs du compte de surveillance lui-même, utilisez `WHERE AWS.AccountId=CURRENT_ACCOUNT_ID()`.
Les valeurs des étiquettes doivent toujours être entourées de guillemets simples.
**Utilisation des balises dans les clauses WHERE**
Vous pouvez filtrer les résultats par balises de AWS ressources à l'aide de la syntaxe`tag.keyName`. Les filtres de balises suivent les mêmes règles d’opérateur que les filtres de dimension. Par exemple :
+ WHERE `tag.env = 'prod'` filtre les métriques des ressources balisées avec *env=prod*
+ WHERE `tag.department != 'test'` exclut les métriques des ressources balisées avec *department=test*
Les filtres de balises peuvent être combinés avec des filtres de dimension :
`WHERE tag.env = 'prod' AND InstanceType = 'm5.large'`
**Opérateurs pris en charge**
La clause **WHERE** (OÙ) prend en charge les opérateurs suivants :
+ **=** La valeur de l'étiquette doit correspondre à la chaîne spécifiée.
+ **\$1=** La valeur de l'étiquette ne doit pas correspondre à la chaîne spécifiée.
+ **AND** (ET) Les deux conditions spécifiées doivent être vraies pour correspondre. Vous pouvez utiliser plusieurs mots-clés **AND** (ET) afin de spécifier deux conditions ou plus.
**GROUP BY**
Facultatif. Regroupe les résultats de la requête en plusieurs séries temporelles, chacune correspondant à une valeur différente pour la ou les clés d'étiquette spécifiées. Par exemple, l'utilisation de `GROUP BY InstanceId` renvoie une série temporelle différente pour chaque valeur de `InstanceId`. L'utilisation de `GROUP BY ServiceName, Operation` crée une série temporelle différente pour chaque combinaison possible des valeurs de `ServiceName` et `Operation`.
Avec une clause **GROUP BY** (REGROUPER PAR), les résultats sont classés par ordre alphabétique croissant par défaut, en utilisant la séquence d'étiquettes spécifiée dans la clause **GROUP BY** (REGROUPER PAR). Pour modifier l'ordre des résultats, ajoutez une clause **ORDER BY** (CLASSER PAR) à votre requête.
Lorsque vous exécutez une requête dans un compte de surveillance, vous pouvez l’utiliser `GROUP BY AWS.AccountId` pour regrouper les résultats en fonction des comptes dont ils proviennent.
**Utilisation de balises dans les clauses GROUP BY**
Vous pouvez regrouper les résultats par valeurs de balise de AWS ressource à l'aide de la syntaxe`tag.keyName`. Par exemple :
+ *GROUP BY tag.environment* crée des séries temporelles distinctes pour chaque valeur de balise d’environnement
+ *GROUPER PAR TAG.team, InstanceType* groupes par balise et par valeurs de dimension
+ *GROUPER PAR tag.team, AWS. AccountId*groupes à la fois par tag et par compte source lié IDs
Si certaines des métriques correspondantes n'incluent pas de clé d'étiquette spécifique spécifiée dans la clause **GROUP BY** (REGROUPER PAR), un groupe nul nommé `Other` est renvoyé. Par exemple, si vous spécifiez `GROUP BY ServiceName, Operation` et que certaines des métriques renvoyées ne comprennent pas `ServiceName` en tant que dimension, alors ces métriques sont affichées comme ayant `Other` comme valeur pour `ServiceName`.
**ORDER BY**
Facultatif. Spécifie l'ordre à utiliser pour les séries temporelles renvoyées si la requête renvoie plusieurs séries temporelles. L'ordre est basé sur les valeurs trouvées par la clause **FUNCTION** (FONCTION) que vous spécifiez dans la clause **ORDER BY** (CLASSER PAR). La clause **FUNCTION** (FONCTION) est utilisée pour calculer une valeur scalaire unique à partir de chaque série temporelle renvoyée, et cette valeur est utilisée pour déterminer l'ordre.
Vous spécifiez également s'il faut utiliser l'ordre croissant **ASC** ou décroissant **DESC**. Si vous l'omettez, la valeur par défaut est croissante, **ASC**.
Par exemple, l'ajout d'une clause `ORDER BY MAX() DESC` classe les résultats en fonction du point de données maximal observé dans la plage temporelle, dans l'ordre décroissant. En d'autres mots, la série temporelle ayant le point de données maximal le plus élevé est renvoyée en premier.
Les fonctions valides à utiliser dans une clause **ORDER BY** (CLASSER PAR) sont `AVG()`, `COUNT()`, `MAX()`, `MIN()` et `SUM()`.
Si vous utilisez une clause **ORDER BY** (CLASSER PAR) avec une clause **LIMIT** (LIMITE), la requête résultante est une requête « Top N ». **ORDER BY** (CLASSER PAR) est également utile pour les requêtes qui peuvent renvoyer un grand nombre de métriques, car chaque requête ne peut pas renvoyer plus de 500 séries temporelles. Si une requête correspond à plus de 500 séries temporelles et que vous utilisez une clause **ORDER BY** (CLASSER PAR), les séries temporelles sont triées, puis les 500 séries temporelles qui arrivent en premier dans l'ordre de tri sont celles qui sont renvoyées.
**LIMIT**
Facultatif. Limite le nombre de séries temporelles renvoyées par la requête à la valeur que vous spécifiez. La valeur maximale que vous pouvez spécifier est 500, et une requête qui ne spécifie pas de **LIMIT** (LIMITE) ne peut pas non plus renvoyer plus de 500 séries temporelles.
L'utilisation d'une clause **LIMIT** (LIMITE) avec une clause **ORDER BY** (CLASSER PAR) vous donne une requête « Top N ».
## Qu'est-ce qui nécessite des guillemets ou des caractères d'échappement ?
Dans une requête, les valeurs d'étiquette doivent toujours être entourées de guillemets simples. Par exemple, **SELECT MAX (CPUUtilization) FROM « AWS/EC2"** WHERE = « ». AutoScalingGroupName my-production-fleet
Les espaces de noms de métriques, les noms de métriques et les clés d'étiquette contenant des caractères autres que des lettres, des chiffres et des tirets bas (\$1) doivent être entourés de guillemets doubles. Par exemple, **SELECT MAX("My.Metric")**.
Si l'un d'entre eux contient un guillemet double ou un guillemet simple lui-même (par exemple : `Bytes"Input"`), vous devez séparer chaque guillemet par une barre oblique inverse, comme dans **SELECT AVG("Bytes\$1"Input\$1"")**.
Si un espace de noms de métrique, un nom de métrique ou une clé d'étiquette contient un mot qui est un mot-clé réservé dans Metrics Insights, ceux-ci doivent également être entre guillemets doubles. Par exemple, si vous disposez d'une métrique nommée `LIMIT`, vous devez utiliser `SELECT AVG("LIMIT")`. Il est également valable de placer n'importe quel espace de noms, nom de métrique ou étiquette entre guillemets doubles, même s'il n'inclut pas de mot-clé réservé.
Pour obtenir la liste complète des mots-clés réservés, consultez [Mots-clés réservés](cloudwatch-metrics-insights-reserved-keywords.md).
## Créer une requête riche étape par étape
Cette section illustre la création d'un exemple complet qui utilise toutes les clauses possibles, étape par étape.
Vous pouvez commencer par la requête suivante, qui agrège toutes les métriques de l’Application Load Balancer `RequestCount` collectées avec les dimensions `LoadBalancer` et `AvailabilityZone`.
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
```
Pour ne voir que les métriques d’un équilibreur de charge spécifique, vous pouvez ajouter une clause **WHERE** pour limiter les métriques renvoyées aux seules métriques pour lesquelles la valeur de la dimension `LoadBalancer` est `app/load-balancer-1`.
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
```
La requête précédente agrège les métriques `RequestCount` de toutes les zones de disponibilité de cet équilibreur de charge en une seule série temporelle. Si vous voulez voir des séries temporelles différentes pour chaque zone de disponibilité, nous pouvons ajouter une clause **GROUP BY**.
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
```
Vous pouvez ensuite ordonner les résultats de manière à afficher d’abord les valeurs les plus élevées. La clause **ORDER BY** (CLASSER PAR) suivante classe les séries temporelles par ordre décroissant, en fonction de la valeur maximale signalée par chaque série temporelle pendant la période de requête :
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
ORDER BY MAX() DESC
```
Vous pouvez également utiliser des balises pour filtrer davantage les résultats. Par exemple, si vous voulez voir les résultats uniquement pour les équilibreurs de charge balisés avec un environnement spécifique, nous pouvons ajouter le filtrage par balise à la clause 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
```
Vous pouvez également regrouper les résultats en fonction des valeurs des balises au lieu (ou en plus) des dimensions. Par exemple, le regroupement par le balisage de l’application :
```
SELECT SUM(RequestCount) FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone) WHERE tag.Environment = 'prod' GROUP BY tag.Application ORDER BY MAX() DESC
```
Enfin, si nous sommes avant tout intéressés par un type de requête « Top N », nous pouvons utiliser une clause **LIMIT** (LIMITE). Cet exemple final limite les résultats aux séries temporelles avec les cinq valeurs `MAX` les plus élevées.
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer, AvailabilityZone)
WHERE LoadBalancer = 'app/load-balancer-1'
GROUP BY AvailabilityZone
ORDER BY MAX() DESC
LIMIT 5
```
## Exemple de requête entre comptes
Ces exemples sont valides lorsqu'ils sont exécutés dans un compte configuré en tant que compte de surveillance dans le cadre de l' CloudWatchobservabilité entre comptes.
L’exemple suivant montre comment rechercher toutes les instances Amazon EC2 du compte source 123456789012 et en afficher la moyenne.
```
SELECT AVG(CpuUtilization)
FROM "AWS/EC2"
WHERE AWS.AccountId ='123456789012'
```
L’exemple suivant interroge la métrique `CPUUtilization` dans `AWS/EC2` pour tous les comptes source liés et regroupe les résultats par ID de compte et type d’instance.
```
SELECT AVG(CpuUtilization)
FROM "AWS/EC2"
GROUP BY AWS.AccountId, InstanceType
```
L’exemple suivant interroge le `CPUUtilization` dans le compte de surveillance lui-même.
```
SELECT AVG(CpuUtilization)
FROM "AWS/EC2"
WHERE AWS.AccountId = CURRENT_ACCOUNT_ID()
```
# Mots-clés réservés
Les mots clés suivants sont réservés dans CloudWatch Metrics Insights. Si l'un de ces mots se trouve dans un espace de noms, un nom de métrique ou une clé d'étiquette dans une requête, vous devez les placer entre guillemets doubles. Les mots-clés réservés ne respectent pas la casse.
```
"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 sur CloudWatch les requêtes Metrics Insights dans CloudWatch
Vous pouvez créer des alarmes sur des requêtes Metrics Insights. Cela vous permet d'avoir des alarmes qui suivent plusieurs ressources sans avoir besoin d'être mises à jour ultérieurement. La requête capte les nouvelles ressources et les ressources qui changent. Par exemple, vous pouvez créer une alerte qui surveille l'utilisation du CPU de votre flotte, et l'alerte évalue automatiquement les nouvelles instances que vous lancez après avoir créé l'alerte.
Dans un compte de surveillance configuré pour l'observabilité CloudWatch entre comptes, vos alarmes Metrics Insights peuvent surveiller les ressources des comptes sources et du compte de surveillance lui-même. Pour plus d’informations sur la façon de limiter vos requêtes d’alarme à un compte spécifique ou de regrouper les résultats par identifiant de compte, veuillez consulter les sections `WHERE` et `GROUP BY` dans [Composants et syntaxe des requêtes dans CloudWatch Metrics Insights](cloudwatch-metrics-insights-querylanguage.md).
**Utilisation des balises dans les requêtes d’alarme**
Vous pouvez créer des alarmes sur les requêtes Metrics Insights qui utilisent AWS des balises de ressources pour filtrer et regrouper les métriques. Pour utiliser des balises avec des alarmes, sur le [https://console.aws.amazon.com/connect/](https://console.aws.amazon.com/connect/), choisissez **Paramètres**. **Sur la page **CloudWatch Paramètres**, sous **Activer les balises de ressources en télémétrie**, choisissez Activer.** Les alarmes contextuelles surveillent automatiquement des applications, des environnements ou des équipes spécifiques au fur et à mesure que les ressources changent.
Par exemple, vous pouvez créer une alarme qui surveille l’utilisation de l’UC pour toutes les instances Amazon EC2 balisées avec une application spécifique.
```
SELECT MAX(CPUUtilization) FROM "AWS/EC2" WHERE tag.Application = 'Orders' AND tag.Environment = 'Prod'
```
Les alarmes basées sur des balises s’adaptent automatiquement lorsque vous ajoutez ou supprimez des ressources avec des balises correspondantes, offrant ainsi une surveillance dynamique alignée sur votre structure opérationnelle.
**Contents**
+ [Création d'une CloudWatch alarme Metrics Insights](cloudwatch-metrics-insights-alarm-create.md)
# Création d'une CloudWatch alarme Metrics Insights
**Pour créer une alarme sur une requête Metrics Insights à l'aide de la console**
1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Dans le panneau de navigation, sélectionnez **Métriques**, **Toutes les métriques**.
1. (Facultatif) Pour exécuter un exemple de requête préétablie, choisissez **Add query** (Ajouter une requête) et sélectionnez la requête à exécuter. Ou, vous pouvez choisir **Editor** (Éditeur) pour modifier l'exemple de requête, puis choisir **Run** (Exécuter) pour exécuter la requête modifiée.
1. Pour créer votre propre requête, sélectionnez **Requête multi-sources**. Vous pouvez ensuite utiliser la vue **Constructeur**, la vue **Éditeur** ou une combinaison des deux. Vous pouvez passer d'une vue à l'autre à tout moment et voir votre travail en cours dans les deux vues.
Dans la vue **Builder** (Générateur), vous pouvez parcourir et sélectionner l'espace de noms des métriques, le nom de la métrique, le filtre, le groupe et les options de commande. Pour chacune de ces options, le générateur de requêtes vous propose une liste de sélections possibles de votre environnement parmi lesquelles choisir.
Dans la vue **Editor** (Éditeur), vous pouvez commencer à écrire votre requête. Au fur et à mesure que vous tapez, l'éditeur propose des suggestions basées sur les caractères que vous avez saisis jusqu'à présent.
Par exemple, lorsque vous créez votre requête Metrics Insights pour l’alarme, vous pouvez utiliser des balises pour filtrer et regrouper les métriques pour une surveillance plus ciblée.
+ Filtrer par balises : utilisez `WHERE tag.keyName = 'value'` pour surveiller les ressources avec des balises spécifiques
```
SELECT MAX(CPUUtilization) FROM "AWS/EC2" WHERE tag.Environment = 'Prod'
```
+ Combiner les balises avec les dimensions : mélangez les filtres de balises avec les dimensions de métriques existantes
```
SELECT AVG(Duration) FROM "AWS/Lambda" WHERE tag.Application = 'OrderService' AND FunctionName = 'process%'
```
**Note**
Lorsque vous utilisez des balises, les alarmes ne correspondent aux métriques que si les balises spécifiées existaient sur les ressources associées pendant la période évaluée.
1. Lorsque vous êtes satisfait de votre requête, sélectionnez **Run** (Exécuter).
1. Sélectionnez **Créer une alerte**.
1. Sous **Conditions**, spécifiez les éléments suivants :
1. Pour ***metric*Whenever is**, spécifiez si la métrique doit être supérieure, inférieure ou égale au seuil. Dans **than... (à...)**, spécifiez la valeur de seuil.
1. Sélectionnez **Additional configuration (Configuration supplémentaire)**. Pour **Datapoints to alarm (Points de données avant l'alerte)**, spécifiez le nombre de périodes d'évaluation (points de données) devant être à l'état `ALARM` pour déclencher l'alerte. Si les deux valeurs sont compatibles, vous créez une alerte qui passe à l'état `ALARM` lorsque le nombre de périodes consécutives dépasse ces valeurs.
Pour créer une alerte M sur N, spécifiez pour la première valeur un nombre inférieur à celui de la seconde valeur. Pour plus d'informations, consultez . [Évaluation des alarmes](alarm-evaluation.md).
1. Pour **Missing data treatment (traitement des données manquantes)**, choisissez comment l'alerte doit se comporter lorsqu'il manque certains points de données. Pour plus d'informations, consultez . [Configuration de la façon dont les CloudWatch alarmes traitent les données manquantes](alarms-and-missing-data.md).
1. Choisissez **Next (Suivant)**.
1. Sous **Notification**, sélectionnez la rubrique SNS qui doit recevoir une notification lorsque l'alerte passe à l'état `ALARM`, `OK` ou `INSUFFICIENT_DATA`.
Pour que l'alerte envoie plusieurs notifications pour le même état d'alerte ou pour les différents états d'alerte, choisissez **Add notification (Ajouter une notification)**.
Pour que l'alerte n'envoie pas de notifications, choisissez **Remove (Supprimer)**.
1. Pour que l'alerte exécute Auto Scaling, EC2 ou des actions du Systems Manager, cliquez sur le bouton approprié, puis choisissez l'état de l'alerte et l'action à effectuer. Les alertes peuvent effectuer des actions du Systems Manager uniquement lorsqu'elles passent à l'état ALARM. Pour plus d'informations sur les actions de Systems Manager, consultez les sections [Configuration CloudWatch pour créer à OpsItems partir d'alarmes](https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-create-OpsItems-from-CloudWatch-Alarms.html) et [Création d'incidents](https://docs.aws.amazon.com/incident-manager/latest/userguide/incident-creation.html).
**Note**
Pour créer une alerte qui exécute une action SSM Incident Manager, vous devez disposer de certaines autorisations. Pour plus d'informations, consultez les [exemples de politiques basées sur l'identité pour AWS Systems Manager Incident Manager](https://docs.aws.amazon.com/incident-manager/latest/userguide/security_iam_id-based-policy-examples.html).
1. Lorsque vous avez terminé, choisissez **Suivant**.
1. Saisissez un nom et une description pour l'alerte. Le nom ne doit contenir que des caractères ASCII. Sélectionnez ensuite **Next (Suivant)**.
1. Dans **Preview and create (Prévisualiser et créer)**, confirmez que les informations et les conditions sont telles que vous les voulez, puis choisissez **Create alarm (Créer une alerte)**.
**Pour créer une alarme sur une requête Metrics Insights à l'aide du AWS CLI**
Utilisez la commande `put-metric-alarm` et spécifiez une requête Metrics Insights dans le paramètre `metrics`. Par exemple, la commande suivante définit une alarme qui passe à l'état ALARM si l'une de vos instances dépasse 50 % d'utilisation du 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
```
# Utiliser des requêtes Metrics Insights avec des mathématiques appliquées aux métriques
Vous pouvez utiliser une requête Metrics Insights en entrée dans une fonction mathématique de métrique. Pour plus d'informations sur les mathématiques appliquées aux métriques, consultez [Utilisation d'expressions mathématiques avec des CloudWatch métriques](using-metric-math.md).
Une requête Metrics Insights qui n'inclut pas de clause **GROUP BY** (REGROUPER PAR) renvoie une seule série temporelle. Par conséquent, les résultats renvoyés peuvent être utilisés avec n'importe quelle fonction mathématique de métrique qui prend une seule série temporelle en entrée.
Une requête Metrics Insights qui inclut une clause **GROUP BY** (REGROUPER PAR) renvoie plusieurs séries temporelles. Par conséquent, les résultats renvoyés peuvent être utilisés avec n'importe quelle fonction mathématique de métrique qui prend en entrée un tableau de séries temporelles.
Par exemple, la requête suivante renvoie le nombre total d'octets téléchargés pour chaque compartiment de la région, sous forme de tableau de séries temporelles :
```
SELECT SUM(BytesDownloaded)
FROM SCHEMA("AWS/S3", BucketName, FilterId)
WHERE FilterId = 'EntireBucket'
GROUP BY BucketName
```
Sur un graphique de la console ou lors d'une [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html)opération, les résultats de cette requête sont`q1`. Cette requête renvoie le résultat en octets. Par conséquent, si vous souhaitez voir le résultat en Mo, vous pouvez utiliser la fonction mathématique suivante :
```
q1/1024/1024
```
# Utiliser le langage naturel pour générer et mettre à jour CloudWatch les requêtes Metrics Insights
CloudWatch prend en charge une fonctionnalité de requête en langage naturel pour vous aider à générer et à mettre à jour des requêtes pour [CloudWatchMetrics Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/query_with_cloudwatch-metrics-insights.html) et [CloudWatch Logs Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html).
Grâce à cette fonctionnalité, vous pouvez poser des questions ou décrire les CloudWatch données que vous recherchez dans un langage simple. La fonctionnalité de langage naturel génère une requête en fonction d'une invite que vous entrez et fournit une line-by-line explication du fonctionnement de la requête. Vous pouvez également mettre à jour votre requête pour examiner plus en détail vos données.
En fonction de votre environnement, vous pouvez saisir des messages tels que « Which Amazon Elastic Compute Cloud instance has the highest network out? » et « Show me the top 10 Amazon DynamoDB Tables by consumed reads ».
**Note**
La fonctionnalité de requête en langage naturel est généralement disponible dans 10 régions. Pour certaines régions, la fonction effectue des appels interrégionaux vers des régions des États-Unis pour traiter les invites de requête. Le tableau suivant répertorie les régions prises en charge et indique où chaque région traite ses invites.
| Région prise en charge | Région où l’invite est traitée |
| --- | --- |
| USA Est (Virginie du Nord) | USA Est (Virginie du Nord) |
| USA Est (Ohio) | USA Est (Virginie du Nord) |
| USA Ouest (Oregon) | USA Ouest (Oregon) |
| Asie-Pacifique (Hong Kong) | US West (Oregon) |
| Asie-Pacifique (Singapour) | USA Ouest (Oregon) |
| Asie-Pacifique (Sydney) | USA Ouest (Oregon) |
| Asie Pacifique (Tokyo) | Asie-Pacifique (Tokyo) |
| Europe (Francfort) | Europe (Francfort) |
| Europe (Irlande) | USA Est (Virginie du Nord) |
| Europe (Stockholm) | USA Est (Virginie du Nord) |
Pour générer une requête CloudWatch Metrics Insights avec cette fonctionnalité, ouvrez l'éditeur de requêtes CloudWatch Metrics Insights dans la vue du *générateur* ou de l'*éditeur* et choisissez **Generate query**.
**Important**
Pour utiliser la fonctionnalité de requête en langage naturel, vous devez utiliser la [CloudWatchFullAccess[ReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/ReadOnlyAccess.html)](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchFullAccess.html)politique, [AdministratorAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AdministratorAccess.html), [CloudWatchFullAccessV2](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchFullAccessV2.html) ou. [CloudWatchReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/CloudWatchReadOnlyAccess.html)
Vous pouvez également inclure l’action `cloudwatch:GenerateQuery` dans une politique en ligne ou gérée par le client, qu’elle soit nouvelle ou existante.
## Exemples de requêtes
Les exemples de cette section décrivent comment générer et mettre à jour des requêtes à l’aide de la fonctionnalité de langage naturel.
**Note**
Pour plus d'informations sur l'éditeur de requêtes et la syntaxe de CloudWatch [CloudWatch Metrics Insights, voir Composants et syntaxe des requêtes](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-metrics-insights-querylanguage.html) Metrics Insights.
### Exemple : générer une requête en langage naturel
Pour générer une requête en langage naturel, saisissez une invite et choisissez **Générer une nouvelle requête**. Cet exemple montre une requête qui effectue une recherche de base.
**Invite**
Voici un exemple d’invite qui indique à la fonctionnalité de rechercher les 10 tables DynamoDB les plus gourmandes en capacité de lecture.
```
Show top 10 DynamoDB Tables by consumed reads
```
**Query**
Voici un exemple de requête générée par la fonctionnalité de langage naturel en fonction de l’invite. Remarquez comment l’invite apparaît dans un commentaire avant la requête. Après la requête, vous pouvez lire une explication qui décrit son fonctionnement.
```
# 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.
```
**Note**
Pour désactiver l’affichage de votre invite et de l’explication du fonctionnement de la requête, utilisez l’icône en forme de roue dentée dans votre éditeur.
### Exemple : mettre à jour une requête en langage naturel
Vous pouvez mettre à jour une requête en modifiant l’invite initiale, puis en choisissant **Mettre à jour la requête**.
**Invite mise à jour**
L’exemple suivant présente une version mise à jour de la requête précédente. Au lieu d’une invite qui recherche les 10 principales tables DynamoDB consommant le plus de capacité de lecture, cette invite indique désormais la possibilité de trier les résultats en fonction du nombre d’octets renvoyés.
```
Sort by bytes returned instead
```
**Requête mise à jour**
Voici un exemple de la requête mise à jour. Remarquez comment l’invite mise à jour apparaît dans un commentaire avant la requête mise à jour. Après la requête, vous pouvez lire une explication qui décrit comment la requête d’origine a été mise à jour.
```
# 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.
```
## Refus d’utiliser vos données pour améliorer le service
Les données d’invite en langage naturel que vous fournissez pour entraîner le modèle d’IA et générer des requêtes pertinentes ne sont utilisées que pour fournir et maintenir votre service. Ces données peuvent être utilisées pour améliorer la qualité de CloudWatch Metrics Insights. Votre confiance, la confidentialité et la sécurité de votre contenu constituent nos priorités N° 1. Pour plus d’informations, veuillez consulter les rubriques [Conditions de service AWS](https://aws.amazon.com/service-terms/) et [AWS responsible AI policy](https://aws.amazon.com/machine-learning/responsible-ai/policy/).
Vous pouvez refuser que votre contenu soit utilisé pour développer ou améliorer la qualité des requêtes en langage naturel en créant une politique de désinscription des services d’IA. Pour désactiver la collecte de données pour toutes les fonctionnalités de l' CloudWatch IA, y compris la capacité de génération de requêtes, vous devez créer une politique de désinscription pour CloudWatch. Pour plus d’informations, veuillez consulter la rubrique [Politiques de désactivation des services IA](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html) dans le *Guide de l’utilisateur AWS Organizations *.
# Inférence SQL
CloudWatch Metrics Insights utilise plusieurs mécanismes pour déduire l'intention d'une requête SQL donnée.
**Topics**
+ [Segmentation temporelle](#cloudwatch-metrics-insights-inference-timebucketing)
+ [Projection des champs](#cloudwatch-metrics-insights-inference-fieldsprojection)
+ [Agrégation globale ORDER BY (CLASSER PAR)](#cloudwatch-metrics-insights-inference-OrderBy)
## Segmentation temporelle
Les données en séries chronologiques résultant d'une requête sont regroupées dans des compartiments de temps en fonction de la période demandée. Pour agréger des valeurs dans SQL standard, une clause GROUP BY (REGROUPER PAR) explicite doit être définie pour collecter toutes les observations d'une période donnée. Comme il s'agit de la méthode standard pour interroger des données de séries chronologiques, CloudWatch Metrics Insights en déduit le découpage temporel sans qu'il soit nécessaire d'exprimer une clause **GROUP BY** explicite.
Par exemple, lorsqu'une requête est exécutée avec une période d'une minute, toutes les observations appartenant à cette minute jusqu'à la prochaine (exclue) sont cumulées jusqu'à l'heure de démarrage du compartiment temporel. Cela rend les instructions SQL de Metrics Insights plus concises et moins détaillées.
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
```
La requête précédente renvoie une seule série temporelle (paires horodatage-valeurs), représentant l'utilisation moyenne de CPU de toutes les instances Amazon EC2. En supposant que la période demandée soit d'une minute, chaque point de données renvoyé représente la moyenne de toutes les observations mesurées dans un intervalle spécifique d'une minute (heure de démarrage incluse, heure de fin exclue). L'horodatage lié au point de données spécifique est l'heure de démarrage du compartiment
## Projection des champs
Les requêtes Metrics Insights renvoient toujours la projection de l'horodatage. Vous n'avez pas besoin de spécifier de colonne d'horodatage dans la clause **SELECT** (SÉLECTIONNER) pour obtenir l'horodatage de chaque valeur de point de données correspondante. Pour plus d'informations sur le calcul de l'horodatage, consultez [Segmentation temporelle](#cloudwatch-metrics-insights-inference-timebucketing).
Lorsque vous utilisez **GROUP BY** (REGROUPER PAR), chaque nom de groupe est également déduit et projeté dans le résultat, de sorte que vous pouvez regrouper la série temporelle renvoyée.
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
```
La requête précédente renvoie une série temporelle pour chaque instance EC2 d'Amazon. Chaque série temporelles est étiquetée après la valeur de l’ID d’instance.
## Agrégation globale ORDER BY (CLASSER PAR)
Lorsque vous utilisez **ORDER BY** (CLASSER PAR), **FUNCTION()** (FONCTION ()) détermine la fonction d'agrégation que vous souhaitez classer (les valeurs des points de données des métriques interrogées). L'opération d'agrégation est effectuée sur tous les points de données correspondants de chaque série temporelle individuelle dans la fenêtre temporelle interrogée.
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
ORDER BY MAX()
LIMIT 10
```
La requête précédente renvoie l'utilisation de CPU pour chaque instance Amazon EC2, ce qui limite le jeu de résultats à 10 entrées. Les résultats sont classés en fonction de la valeur maximale des séries temporelles individuelles dans la fenêtre de temps interrogée. La clause **ORDER BY** (CLASSER PAR) est appliquée avant **LIMIT** (LIMITE), de sorte que la commande est calculée sur plus de 10 séries temporelles.
# Quotas de Metrics Insights
CloudWatch Metrics Insights dispose actuellement des quotas suivants :
+ Interrogez jusqu’à deux semaines de données pour les visualiser dans vos métriques, widgets et graphiques d’alarme. Vous pouvez interroger les trois heures de données les plus récentes pour l’évaluation des conditions d’alarme.
+ Une seule requête ne peut traiter plus de 10 000 métriques. Cela signifie que si les clauses **SELECT** (SÉLECTIONNER), **FROM** (À PARTIR DE), et **WHERE** (OÙ) correspondent à plus de 10 000 métriques, la requête ne traite que les 10 000 premières métriques trouvées.
+ Une seule requête ne peut pas renvoyer plus de 500 séries temporelles. Cela signifie que si la requête renvoie plus de 500 métriques, toutes les métriques ne seront pas renvoyées dans les résultats de la requête. Si vous utilisez une clause **ORDER BY** (CLASSER PAR), alors toutes les métriques en cours de traitement sont triées, et les 500 qui ont les valeurs les plus élevées ou les plus basses selon votre clause **ORDER BY** (CLASSER PAR) sont renvoyées.
Si vous n'incluez pas de clause **ORDER BY** (CLASSER PAR), vous ne pouvez pas contrôler les 500 métriques correspondantes qui sont renvoyées.
+ Vous pouvez avoir jusqu’à 200 alarmes Metrics Insights par région.
+ Metrics Insights ne prend pas en charge les données haute résolution, c'est-à-dire les données de métriques rapportées avec une granularité inférieure à une minute. Si vous demandez des données haute résolution, la demande n'échoue pas, mais la sortie est agrégée à une granularité d'une minute.
+ Chaque [GetMetricData](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricData.html)opération ne peut comporter qu'une seule requête, mais vous pouvez avoir plusieurs widgets dans un tableau de bord qui incluent chacun une requête.
+ Si une requête utilisant des balises avec un **GROUP BY** ou **WHERE** correspond à une métrique comportant plus de 10 mises à jour de balises, seules les 10 versions balisées les plus récentes de la métrique seront incluses dans les résultats de la requête.
# Exemples de requêtes Metrics Insights
Cette section contient des exemples de requêtes CloudWatch Metrics Insights utiles que vous pouvez copier et utiliser directement ou copier et modifier dans l'éditeur de requêtes. Certains de ces exemples sont déjà disponibles dans la console et vous pouvez y accéder en choisissant **Add query** (Ajouter une requête) dans la vue **Metrics** (Métriques).
## Application Load Balancer
**Nombre total de requêtes pour tous les équilibreurs de charge**
```
SELECT SUM(RequestCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer)
```
**Top 10 des équilibreurs de charge les plus actifs **
```
SELECT MAX(ActiveConnectionCount)
FROM SCHEMA("AWS/ApplicationELB", LoadBalancer)
GROUP BY LoadBalancer
ORDER BY SUM() DESC
LIMIT 10
```
## AWS Exemples d'utilisation de l'API
**Top 20 AWS APIs selon le nombre d'appels sur votre compte**
```
SELECT COUNT(CallCount)
FROM SCHEMA("AWS/Usage", Class, Resource, Service, Type)
WHERE Type = 'API'
GROUP BY Service, Resource
ORDER BY COUNT() DESC
LIMIT 20
```
**CloudWatch APIs triés par appels**
```
SELECT COUNT(CallCount)
FROM SCHEMA("AWS/Usage", Class, Resource, Service, Type)
WHERE Type = 'API' AND Service = 'CloudWatch'
GROUP BY Resource
ORDER BY COUNT() DESC
```
## Exemples DynamoDB
**Top 10 des tables par lectures consommées**
```
SELECT SUM(ProvisionedWriteCapacityUnits)
FROM SCHEMA("AWS/DynamoDB", TableName)
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```
**Top 10 des tables par octets renvoyés**
```
SELECT SUM(ReturnedBytes)
FROM SCHEMA("AWS/DynamoDB", TableName)
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```
**Top 10 des tables par erreurs utilisateur**
```
SELECT SUM(UserErrors)
FROM SCHEMA("AWS/DynamoDB", TableName)
GROUP BY TableName
ORDER BY MAX() DESC LIMIT 10
```
## Exemples Amazon Elastic Block Store
**Top 10 des volumes Amazon EBS par octets écrits**
```
SELECT SUM(VolumeWriteBytes)
FROM SCHEMA("AWS/EBS", VolumeId)
GROUP BY VolumeId
ORDER BY SUM() DESC
LIMIT 10
```
**Temps d'écriture moyen du volume Amazon EBS**
```
SELECT AVG(VolumeTotalWriteTime)
FROM SCHEMA("AWS/EBS", VolumeId)
```
## Exemples Amazon EC2
**Utilisation de CPU des instances EC2 triées par niveau le plus élevé **
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
ORDER BY AVG() DESC
```
**Utilisation moyenne de CPU sur l'ensemble de la flotte**
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
```
**Top 10 des instances selon l'utilisation de CPU la plus élevée**
```
SELECT MAX(CPUUtilization)
FROM SCHEMA("AWS/EC2", InstanceId)
GROUP BY InstanceId
ORDER BY MAX() DESC
LIMIT 10
```
**Dans ce cas, l' CloudWatch agent collecte une `CPUUtilization` métrique par application. Cette requête filtre la moyenne de cette métrique pour un nom d'application spécifique.**
```
SELECT AVG(CPUUtilization)
FROM "AWS/CWAgent"
WHERE ApplicationName = 'eCommerce'
```
## Exemples Amazon Elastic Container Service
**Utilisation moyenne de CPU sur tous les clusters ECS **
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/ECS", ClusterName)
```
**Top 10 des clusters par utilisation de la mémoire**
```
SELECT AVG(MemoryUtilization)
FROM SCHEMA("AWS/ECS", ClusterName)
GROUP BY ClusterName
ORDER BY AVG() DESC
LIMIT 10
```
**Top 10 des services par utilisation de CPU**
```
SELECT AVG(CPUUtilization)
FROM SCHEMA("AWS/ECS", ClusterName, ServiceName)
GROUP BY ClusterName, ServiceName
ORDER BY AVG() DESC
LIMIT 10
```
**Top 10 des services par exécution des tâches (Container Insights)**
```
SELECT AVG(RunningTaskCount)
FROM SCHEMA("ECS/ContainerInsights", ClusterName, ServiceName)
GROUP BY ClusterName, ServiceName
ORDER BY AVG() DESC
LIMIT 10
```
## Exemples de conteneur Insights Amazon Elastic Kubernetes Service
**Utilisation moyenne de CPU dans tous les clusters EKS **
```
SELECT AVG(pod_cpu_utilization)
FROM SCHEMA("ContainerInsights", ClusterName)
```
**Top 10 des clusters par utilisation de CPU des nœuds**
```
SELECT AVG(node_cpu_utilization)
FROM SCHEMA("ContainerInsights", ClusterName)
GROUP BY ClusterName
ORDER BY AVG() DESC LIMIT 10
```
**Top 10 des clusters par utilisation de la mémoire des pods**
```
SELECT AVG(pop_memory_utilization)
FROM SCHEMA("ContainerInsights", ClusterName)
GROUP BY ClusterName
ORDER BY AVG() DESC LIMIT 10
```
**Top 10 des nœuds par utilisation de CPU**
```
SELECT AVG(node_cpu_utilization)
FROM SCHEMA("ContainerInsights", ClusterName, NodeName)
GROUP BY ClusterName, NodeName
ORDER BY AVG() DESC LIMIT 10
```
**Top 10 des pods par utilisation de la mémoire**
```
SELECT AVG(pod_memory_utilization)
FROM SCHEMA("ContainerInsights", ClusterName, PodName)
GROUP BY ClusterName, PodName
ORDER BY AVG() DESC LIMIT 10
```
## EventBridge exemples
**Top 10 des règles par invocations**
```
SELECT SUM(Invocations)
FROM SCHEMA("AWS/Events", RuleName)
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```
**Top 10 des règles par échec des invocations**
```
SELECT SUM(FailedInvocations)
FROM SCHEMA("AWS/Events", RuleName)
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```
**Top 10 des règles par règles correspondantes**
```
SELECT SUM(MatchedEvents)
FROM SCHEMA("AWS/Events", RuleName)
GROUP BY RuleName
ORDER BY MAX() DESC LIMIT 10
```
## Exemples Kinesis
**Top 10 des flux par octets écrits**
```
SELECT SUM("PutRecords.Bytes")
FROM SCHEMA("AWS/Kinesis", StreamName)
GROUP BY StreamName
ORDER BY SUM() DESC LIMIT 10
```
**Top 10 des flux par les premiers éléments du flux**
```
SELECT MAX("GetRecords.IteratorAgeMilliseconds")
FROM SCHEMA("AWS/Kinesis", StreamName)
GROUP BY StreamName
ORDER BY MAX() DESC LIMIT 10
```
## Exemples Lambda
**Fonctions Lambda classées en fonction du nombre d'invocations**
```
SELECT SUM(Invocations)
FROM SCHEMA("AWS/Lambda", FunctionName)
GROUP BY FunctionName
ORDER BY SUM() DESC
```
**Top 10 des fonctions Lambda par exécution la plus longue**
```
SELECT AVG(Duration)
FROM SCHEMA("AWS/Lambda", FunctionName)
GROUP BY FunctionName
ORDER BY MAX() DESC
LIMIT 10
```
**Top 10 des fonctions Lambda par nombre d'erreurs**
```
SELECT SUM(Errors)
FROM SCHEMA("AWS/Lambda", FunctionName)
GROUP BY FunctionName
ORDER BY SUM() DESC
LIMIT 10
```
## CloudWatch Exemples de journaux
**Top 10 des groupes de journaux par événements entrants**
```
SELECT SUM(IncomingLogEvents)
FROM SCHEMA("AWS/Logs", LogGroupName)
GROUP BY LogGroupName
ORDER BY SUM() DESC LIMIT 10
```
**Top 10 des groupes de journaux par octets écrits**
```
SELECT SUM(IncomingBytes)
FROM SCHEMA("AWS/Logs", LogGroupName)
GROUP BY LogGroupName
ORDER BY SUM() DESC LIMIT 10
```
## Exemples Amazon RDS
**Top 10 des instances Amazon RDS par utilisation de CPU la plus élevée**
```
SELECT MAX(CPUUtilization)
FROM SCHEMA("AWS/RDS", DBInstanceIdentifier)
GROUP BY DBInstanceIdentifier
ORDER BY MAX() DESC
LIMIT 10
```
**Top 10 des clusters Amazon RDS par écritures**
```
SELECT SUM(WriteIOPS)
FROM SCHEMA("AWS/RDS", DBClusterIdentifier)
GROUP BY DBClusterIdentifier
ORDER BY MAX() DESC
LIMIT 10
```
## Exemples Amazon Simple Storage Service
**Latence moyenne par compartiment**
```
SELECT AVG(TotalRequestLatency)
FROM SCHEMA("AWS/S3", BucketName, FilterId)
WHERE FilterId = 'EntireBucket'
GROUP BY BucketName
ORDER BY AVG() DESC
```
**Top 10 des compartiments par octets téléchargés**
```
SELECT SUM(BytesDownloaded)
FROM SCHEMA("AWS/S3", BucketName, FilterId)
WHERE FilterId = 'EntireBucket'
GROUP BY BucketName
ORDER BY SUM() DESC
LIMIT 10
```
## Exemples Amazon Simple Notification Service
**Nombre total de messages publiés par les rubriques SNS**
```
SELECT SUM(NumberOfMessagesPublished)
FROM SCHEMA("AWS/SNS", TopicName)
```
**Top 10 des rubriques par messages publiés**
```
SELECT SUM(NumberOfMessagesPublished)
FROM SCHEMA("AWS/SNS", TopicName)
GROUP BY TopicName
ORDER BY SUM() DESC
LIMIT 10
```
**Top 10 des rubriques par échecs de livraison des messages**
```
SELECT SUM(NumberOfNotificationsFailed)
FROM SCHEMA("AWS/SNS", TopicName)
GROUP BY TopicName
ORDER BY SUM() DESC
LIMIT 10
```
## Exemples Amazon SQS
**Les 10 premières files d’attente par nombre de messages visibles**
```
SELECT AVG(ApproximateNumberOfMessagesVisible)
FROM SCHEMA("AWS/SQS", QueueName)
GROUP BY QueueName
ORDER BY AVG() DESC
LIMIT 10
```
**Top 10 des files d'attente les plus actives**
```
SELECT SUM(NumberOfMessagesSent)
FROM SCHEMA("AWS/SQS", QueueName)
GROUP BY QueueName
ORDER BY SUM() DESC
LIMIT 10
```
**Top 10 des files d'attente par âge du premier message**
```
SELECT AVG(ApproximateAgeOfOldestMessage)
FROM SCHEMA("AWS/SQS", QueueName)
GROUP BY QueueName
ORDER BY AVG() DESC
LIMIT 10
```
# Glossaire de Metrics Insights
**étiquette**
Dans Metrics Insights, une étiquette est une paire valeur-clé utilisée pour étendre une requête afin de renvoyer un ensemble de données particulier, ou pour définir des critères selon lesquels les résultats de la requête doivent être séparés en séries temporelles distinctes. Une clé d'étiquette est similaire à un nom de colonne dans SQL. Les étiquettes doivent être de dimensions CloudWatch métriques.
**observation**
Une observation est une valeur enregistrée pour une métrique donnée à un moment donné.
# Dépannage Metrics Insights
## Les résultats incluent « Autre », mais je n'ai pas cela comme dimension
Cela signifie que la requête inclut une clause **GROUP BY** (REGROUPER PAR) qui spécifie une clé d'étiquette qui n'est pas utilisée dans certaines des métriques qui sont renvoyées par la requête. Dans ce cas, un groupe nul nommé `Other` est renvoyé. Les métriques qui n'incluent pas cette clé d'étiquette sont probablement des métriques agrégées qui renvoient des valeurs agrégées sur toutes les valeurs de cette clé d'étiquette.
Par exemple, supposons que nous ayons la requête suivante :
```
SELECT AVG(Faults)
FROM MyCustomNamespace
GROUP BY Operation, ServiceName
```
Si certaines des métriques renvoyées ne comprennent pas `ServiceName` en tant que dimension, alors ces métriques sont affichées comme ayant `Other` comme valeur pour `ServiceName`.
Pour éviter de voir « Autre » dans vos résultats, utilisez **SCHEMA** (SCHÉMA) dans votre clause **FROM** (À PARTIR DE), comme dans l'exemple suivant :
```
SELECT AVG(Faults)
FROM SCHEMA(MyCustomNamespace, Operation)
GROUP BY Operation, ServiceName
```
Cela limite les résultats renvoyés aux métriques qui ont à la fois les dimensions `Operation` et `ServiceName`.
## L'horodatage le plus ancien de mon graphique a une valeur de métrique inférieure à celle des autres
CloudWatch Metrics Insights prend en charge jusqu'à deux semaines de données historiques. Lorsque vous effectuez un graphique avec une période supérieure à une minute, il peut arriver que le point de données le plus ancien diffère de la valeur attendue. Cela est dû au fait que les requêtes CloudWatch Metrics Insights renvoient uniquement des données pendant la période de conservation de deux semaines. Dans ce cas, le point de données le plus ancien de la requête renvoie uniquement les observations qui ont été mesurées dans la limite des deux semaines, au lieu de renvoyer toutes les observations dans la période de ce point de données.
## Valeurs métriques incohérentes sur différentes périodes lors de l'utilisation de requêtes basées sur des balises
Lorsque vous utilisez des `GROUP BY` clauses `WHERE` ou comportant des balises dans des requêtes CloudWatch Metrics Insights, vous pouvez voir des valeurs métriques différentes en fonction de la période sélectionnée. Par exemple, une période de 6 heures peut afficher une valeur maximale de 20, tandis qu'une période d'une heure n'en affiche que 2 pour la même fenêtre horaire.
Cela se produit parce que les horodatages des balises sont stockés avec une résolution de second niveau, tandis que les points de données métriques sont alignés sur les limites des périodes (par exemple, le début de chaque minute ou heure). Pour déterminer quels points de données correspondent à une plage temporelle d'étiquette, CloudWatch ajuste le début de la plage en soustrayant un point. Avec des périodes plus longues, cet ajustement crée un écart plus important entre l'horodatage de l'étiquette et le premier point de données inclus, ce qui peut entraîner l'exclusion de points de données situés près du début de la plage.
L'exemple suivant montre comment cela affecte les résultats des requêtes. Une métrique possède deux valeurs de balise : `env=beta` (de 00:00 à 01:30) et `env=gamma` (de 01:30 à 03:00). Chaque balise couvre 90 minutes de données avec une somme de 270.
![\[Deux graphiques CloudWatch métriques comparant les résultats de requêtes basés sur des balises à des périodes de 1 minute et de 3 heures.\]](http://docs.aws.amazon.com/fr_fr/AmazonCloudWatch/latest/monitoring/images/metrics-insights-tag-alignment.png)
| **env=beta avec une période d'une minute** | Statistique | Expected | Retourné | Différence |
| --- | --- | --- | --- | --- |
| SUM | 270 | 271 | \$11 |
| AVG | 3.0 | 3.0 | 0 |
| MIN | 1 | 1 | 0 |
| MAX | 5 | 5 | 0 |
| NOMBRE D'ÉCHANTILLONS | 90 | 91 | \$11 |
| **env=gamma avec une période d'une minute** | Statistique | Expected | Retourné | Différence |
| --- | --- | --- | --- | --- |
| SUM | 270 | 275 | 5\$1 |
| AVG | 3.0 | 3.0 | 0 |
| MIN | 1 | 1 | 0 |
| MAX | 5 | 5 | 0 |
| NOMBRE D'ÉCHANTILLONS | 90 | 91 | \$11 |
Sur une période d'une minute, le réglage de l'alignement est faible (1 minute), de sorte qu'un seul point de données supplémentaire est inclus par étiquette. Sur une période de 3 heures, l'ajustement couvre l'ensemble de la plage de requêtes :
| **env=beta avec une période de 3 heures** | Statistique | Expected | Retourné | Différence |
| --- | --- | --- | --- | --- |
| SUM | 270 | 540 | \$1270 |
| AVG | 3.0 | 3.0 | 0 |
| MIN | 1 | 1 | 0 |
| MAX | 5 | 5 | 0 |
| NOMBRE D'ÉCHANTILLONS | 90 | 180 | \$190 |
| **env=gamma avec une période de 3 heures** | Statistique | Expected | Retourné | Différence |
| --- | --- | --- | --- | --- |
| SUM | 270 | 540 | \$1270 |
| AVG | 3.0 | 3.0 | 0 |
| MIN | 1 | 1 | 0 |
| MAX | 5 | 5 | 0 |
| NOMBRE D'ÉCHANTILLONS | 90 | 180 | \$190 |
Avec la période de 3 heures, les deux balises renvoient l'ensemble de données (SUM=540, SAMPLE\$1COUNT=180) car l'horodatage du point de données agrégé unique se situe dans les deux plages ajustées. La limite du tag est effectivement effacée.
Pour réduire l'impact de ce comportement, essayez les approches suivantes :
+ **Utilisez des périodes d'agrégation plus courtes.** Les périodes plus courtes (1 minute ou 5 minutes, par exemple) correspondent mieux à la résolution de deuxième niveau des horodatages des balises, ce qui minimise l'écart d'alignement et augmente la probabilité que tous les points de données pertinents soient inclus.
+ **Utilisez un filtrage basé sur les dimensions plutôt que des balises.** Si votre cas d'utilisation le permet, filtrez par dimensions plutôt que par balises. Les requêtes basées sur des dimensions ne sont pas affectées par ce comportement. Par exemple, utilisez `WHERE InstanceId = 'i-1234567890abcdef0'` plutôt que `WHERE tag."my-tag" = 'my-value'`.
+ **Interrogez avec une granularité constante.** Lorsque vous comparez des données métriques sur différentes fenêtres temporelles, utilisez la même période pour éviter les différences inattendues causées par le réglage de l'alignement.