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.
# Alertes dans la version 10 de Grafana
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Avec Grafana v10, Amazon Managed Grafana inclut l'accès à un système d'alerte mis à jour, Grafana alerting, qui centralise les *informations d'alerte dans une vue* unique consultable. L'alerte Grafana a été introduite en tant que fonctionnalité optionnelle dans Grafana v8 et GrafanaLabs a annoncé la suppression des anciennes alertes dans la version 11.
**Note**
Cette documentation couvre les alertes Grafana. Pour plus d'informations sur les anciennes alertes, consultez[Alertes classiques sur le tableau](old-alerts-overview.md).
Grafana Alerting vous permet de vous renseigner sur les problèmes de vos systèmes quelques instants après leur apparition.
Surveillez vos données de mesures entrantes ou vos entrées de journal et configurez votre système d'alerte pour qu'il surveille des événements ou des circonstances spécifiques, puis envoie des notifications lorsque ces éléments sont détectés.
De cette façon, vous éliminez le besoin de surveillance manuelle et vous offrez une première ligne de défense contre les pannes ou les modifications du système susceptibles de se transformer en incidents majeurs.
Grafana Alerting vous permet de créer des requêtes et des expressions à partir de plusieurs sources de données, quel que soit l'endroit où vos données sont stockées, ce qui vous permet de combiner vos données et d'émettre des alertes sur vos indicateurs et journaux de manière nouvelle et unique. Vous pouvez ensuite créer, gérer et agir sur vos alertes à partir d'une vue consolidée unique, et améliorer la capacité de votre équipe à identifier et à résoudre les problèmes rapidement.
Avec les règles d'alerte Mimir et Loki, vous pouvez exécuter des expressions d'alerte au plus près de vos données et à grande échelle, le tout géré par l'interface utilisateur de Grafana que vous connaissez déjà.
**Note**
Si vous migrez depuis une version antérieure de Grafana, dans laquelle vous utilisiez l'ancienne alerte Grafana, vous trouverez peut-être utile de voir les [différences entre l'ancienne alerte et la nouvelle alerte](v10-alerting-use-grafana-alerts.md#v10-alerting-diff-old-new) Grafana.
## Caractéristiques et avantages clés
**Une seule page pour toutes les alertes**
Une seule page d'alerte Grafana regroupe en un seul endroit les alertes gérées par Grafana et les alertes résidant dans votre source de données compatible avec Prometheus.
**Alertes multidimensionnelles**
Les règles d'alerte peuvent créer plusieurs instances d'alerte individuelles par règle d'alerte, appelées alertes multidimensionnelles, ce qui vous donne la puissance et la flexibilité nécessaires pour obtenir une visibilité sur l'ensemble de votre système avec une seule règle d'alerte. Pour ce faire, ajoutez des étiquettes à votre requête afin de spécifier le composant surveillé et de générer plusieurs instances d'alerte pour une seule règle d'alerte. Par exemple, si vous souhaitez surveiller chaque serveur d'un cluster, une alerte multidimensionnelle alertera sur chaque processeur, tandis qu'une alerte standard alertera sur l'ensemble du serveur.
**Alertes d'itinéraire**
Acheminez chaque instance d'alerte vers un point de contact spécifique en fonction des étiquettes que vous définissez. Les politiques de notification sont un ensemble de règles indiquant où, quand et comment les alertes sont acheminées vers les points de contact.
**Alertes de silence**
Les silences empêchent la création de notifications et ne durent que pendant une période spécifiée. Les silences vous permettent de ne plus recevoir de notifications persistantes provenant d'une ou de plusieurs règles d'alerte. Vous pouvez également suspendre partiellement une alerte en fonction de certains critères. Les silences disposent de leur propre section dédiée pour une meilleure organisation et une meilleure visibilité, afin que vous puissiez analyser les règles relatives aux alertes suspendues sans encombrer la vue principale des alertes.
**Horaire du mode muet**
Un temps de sourdine est un intervalle de temps récurrent pendant lequel aucune nouvelle notification relative à une politique n'est générée ou envoyée. Utilisez-les pour empêcher les alertes de se déclencher pendant une période spécifique et récurrente, par exemple une période de maintenance régulière.
À l'instar des silences, le temps de mise en sourdine n'empêche pas l'évaluation des règles d'alerte, ni l'affichage des instances d'alerte dans l'interface utilisateur. Ils empêchent uniquement la création de notifications.
## Concevez votre système d'alerte
Il est difficile de surveiller des systèmes informatiques complexes et de déterminer si tout fonctionne correctement. La mise en place d'un système de gestion des alertes efficace est donc essentielle pour vous informer en cas de problème avant que cela n'ait un impact sur les résultats de votre entreprise.
La conception et la configuration d'une configuration de gestion des alertes qui fonctionne prennent du temps.
Voici quelques conseils pour créer une configuration de gestion des alertes efficace pour votre entreprise :
**Quels sont les indicateurs clés de votre entreprise que vous souhaitez surveiller et sur lesquels vous souhaitez émettre des alertes ?**
+ Trouvez les événements qu'il est important de connaître et qui ne sont pas anodins ou fréquents au point que les destinataires les ignorent.
+ Les alertes ne doivent être créées que pour les grands événements nécessitant une attention ou une intervention immédiate.
+ Privilégiez la qualité à la quantité.
**Quel type d'alerte souhaitez-vous utiliser ?**
+ Choisissez entre les alertes gérées par Grafana ou les alertes gérées par Grafana Mimir ou Loki, ou les deux.
**Comment souhaitez-vous organiser vos alertes et notifications ?**
+ Soyez sélectif quant aux personnes que vous configurez pour recevoir les alertes. Envisagez de les envoyer à la personne qui vous appelle ou à une chaîne Slack spécifique.
+ Automatisez autant que possible en utilisant l'API d'alerte ou les alertes sous forme de code (Terraform).
**Comment réduire la fatigue liée aux alertes ?**
+ Évitez les alertes bruyantes et inutiles en utilisant des silences, des temporisations muettes ou en interrompant l'évaluation des règles d'alerte.
+ Ajustez en permanence vos règles d'alerte pour vérifier leur efficacité. Supprimez les règles d'alerte pour éviter les doublons ou les alertes inefficaces.
+ Réfléchissez bien aux niveaux de priorité et de gravité.
+ Passez en revue en permanence vos seuils et vos règles d'évaluation.
## Limites des alertes Grafana
+ Lors de l'agrégation de règles provenant d'autres systèmes, le système d'alerte Grafana peut récupérer les règles de toutes les sources de données Amazon Managed Service pour Prometheus, Prometheus, Loki et Alertmanager disponibles. Il se peut qu'il ne soit pas en mesure d'extraire les règles d'autres sources de données prises en charge.
**Topics**
+ [Caractéristiques et avantages clés](#v10-alerting-key-features)
+ [Concevez votre système d'alerte](#v10-alerting-design)
+ [Limites des alertes Grafana](#v10-alerting-limitations)
+ [Présentation de](v10-alerting-overview.md)
+ [Configurer les alertes](v10-alerting-setup.md)
+ [Configuration des alertes](v10-alerting-configure.md)
+ [Gérez vos alertes](v10-alerting-manage.md)
# Présentation de
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Que vous débutiez ou que vous soyez un utilisateur plus expérimenté de Grafana Alerting, découvrez les principes fondamentaux et les fonctionnalités disponibles qui vous aident à créer, gérer et répondre aux alertes, et à améliorer la capacité de votre équipe à résoudre rapidement les problèmes.
## Principes
Dans les systèmes d'alerte basés sur Prometheus, vous disposez d'un générateur d'alertes qui crée des alertes et d'un récepteur d'alertes qui reçoit les alertes. Par exemple, Prometheus est un générateur d'alertes chargé d'évaluer les règles d'alerte, tandis qu'Alertmanager est un récepteur d'alertes chargé de regrouper, d'inhiber, de désactiver et d'envoyer des notifications concernant le déclenchement et la résolution des alertes.
Grafana Alerting est basé sur le modèle Prometheus de conception de systèmes d'alerte. Il dispose d'un générateur d'alertes interne chargé de planifier et d'évaluer les règles d'alerte, ainsi que d'un récepteur d'alertes interne chargé de regrouper, d'inhiber, de désactiver et d'envoyer des notifications. Grafana n'utilise pas Prometheus comme générateur d'alertes car Grafana Alerting doit fonctionner avec de nombreuses autres sources de données en plus de Prometheus. Cependant, il utilise Alertmanager comme récepteur d'alertes.
Les alertes sont envoyées au récepteur d'alertes où elles sont acheminées, groupées, inhibées, réduites au silence et notifiées. Dans Grafana Alerting, le récepteur d'alerte par défaut est le gestionnaire d'alertes intégré à Grafana, appelé Grafana Alertmanager. Cependant, vous pouvez également utiliser d'autres gestionnaires d'alertes, appelés gestionnaires d'alertes [externes](v10-alerting-setup-alertmanager.md).
## Principes fondamentaux
Vous trouverez ci-dessous un aperçu des différentes parties de l'alerte Grafana.
### Règles d'alerte
Une règle d'alerte est un ensemble de critères qui déterminent le moment où une alerte doit être déclenchée. Il comprend une ou plusieurs requêtes et expressions, une condition qui doit être remplie, un intervalle qui détermine la fréquence à laquelle la règle d'alerte est évaluée et une durée pendant laquelle la condition doit être remplie pour qu'une alerte se déclenche.
Les règles d'alerte sont évaluées sur leur intervalle, et chaque règle d'alerte peut être déclenchée par zéro, une ou plusieurs alertes à la fois. L'état de la règle d'alerte est déterminé par le niveau `severe` d'alerte le plus élevé, qui peut être normal, en attente ou en cours de déclenchement. Par exemple, si au moins une des alertes d'une règle d'alerte est déclenchée, la règle d'alerte est également déclenchée. L'état d'une règle d'alerte est déterminé par le statut de sa dernière évaluation. Elles peuvent être OK, Error et NoData.
Une caractéristique très importante des règles d'alerte est qu'elles prennent en charge les annotations et les étiquettes personnalisées. Ils vous permettent d'instrumenter les alertes à l'aide de métadonnées supplémentaires telles que des résumés et des descriptions, et d'ajouter des étiquettes supplémentaires pour acheminer les alertes vers des politiques de notification spécifiques.
### Alerts (Alertes)
Les alertes sont identifiées de manière unique par des ensembles de key/value paires appelés étiquettes. Chaque clé est un nom d'étiquette et chaque valeur est une valeur d'étiquette. Par exemple, une alerte peut avoir les étiquettes `foo=bar` et une autre les avoir`foo=baz`. Une alerte peut avoir plusieurs étiquettes, par exemple`foo=bar,bar=baz`, mais elle ne peut pas avoir deux fois la même étiquette, par exemple`foo=bar,foo=baz`. Deux alertes ne peuvent pas non plus avoir les mêmes étiquettes, et si deux alertes ont les mêmes étiquettes, telles `foo=bar,bar=baz` que `foo=bar,bar=baz` et, l'une des alertes sera supprimée. Les alertes sont résolues lorsque la condition de la règle d'alerte n'est plus remplie ou lorsque la règle d'alerte est supprimée.
Dans Grafana Managed Alerts, les alertes peuvent être en état normal, en attente, en alerte, sans données ou en état d'erreur. Dans les alertes gérées par des sources de données, telles que Mimir et Loki, les alertes peuvent être en mode normal, en attente et en mode alerte, mais pas NoData ou en erreur.
### Points de contact
Les points de contact déterminent où les notifications sont envoyées. Par exemple, vous pouvez avoir un point de contact qui envoie des notifications à une adresse e-mail, à Slack, à un système de gestion des incidents (IRM) tel que Grafana OnCall ou Pagerduty, ou à un webhook.
Les notifications envoyées depuis les points de contact peuvent être personnalisées à l'aide de modèles de notification. Vous pouvez utiliser des modèles de notification pour modifier le titre, le message et la structure de la notification. Les modèles de notification ne sont pas spécifiques à des intégrations ou à des points de contact individuels.
### Politiques de notification
Les politiques de notification regroupent les alertes puis les acheminent vers les points de contact. Ils déterminent à quel moment les notifications sont envoyées et à quelle fréquence les notifications doivent être répétées.
Les alertes sont mises en correspondance avec les politiques de notification à l'aide de correcteurs d'étiquettes. Il s'agit d'expressions lisibles par l'homme qui indiquent si les libellés de l'alerte correspondent exactement, ne correspondent pas exactement, contiennent ou ne contiennent pas le texte attendu. Par exemple, le matcher fait `foo=bar` correspondre les alertes à l'étiquette `foo=bar` tandis qu'il `foo=~[a-zA-Z]+` associe les alertes à n'importe quelle étiquette appelée foo dont la valeur correspond à l'expression régulière. `[a-zA-Z]+`
Par défaut, une alerte ne peut correspondre qu'à une seule politique de notification. Cependant, grâce à `continue` cette fonctionnalité, des alertes peuvent être créées pour correspondre à un certain nombre de politiques de notification en même temps. Pour plus d'informations sur les politiques de notification, consultez la section [Politiques de notification](v10-alerting-explore-notifications-policies-details.md).
### Silences et temps de sourdine
Les silences et les durées de sourdine vous permettent de suspendre les notifications pour des alertes spécifiques ou même pour des politiques de notification complètes. Utilisez le silence pour suspendre les notifications de manière ponctuelle, par exemple lorsque vous travaillez sur le correctif d'une alerte, et utilisez le mode muet pour suspendre les notifications à intervalles réguliers, par exemple pendant les fenêtres de maintenance planifiées régulièrement.
**Topics**
+ [Principes](#v10-alerting-overview-principles)
+ [Principes fondamentaux](#v10-alerting-overview-fundamentals)
+ [Sources de données et alertes Grafana](v10-alerting-overview-datasources.md)
+ [Alertes sur les données numériques](v10-alerting-overview-numeric.md)
+ [Étiquettes et annotations](v10-alerting-overview-labels.md)
+ [À propos des règles d'alerte](v10-alerting-explore-rules.md)
+ [Gestionnaire d'alertes](v10-alerting-explore-alertmanager.md)
+ [Points de contact](v10-alerting-explore-contacts.md)
+ [Notifications](v10-alerting-explore-notifications.md)
+ [Alerter la haute disponibilité](v10-alerting-explore-high-availability.md)
# Sources de données et alertes Grafana
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Un certain nombre de sources de données sont compatibles avec Grafana Alerting. Chaque source de données est prise en charge par un plugin. Les alertes Grafana nécessitent que les plugins de source de données soient des plugins de *backend*, afin d'évaluer les règles à l'aide de la source de données, car le moteur d'évaluation s'exécute sur le backend. Les plugins doivent également spécifier qu'ils sont compatibles avec les alertes Grafana.
Les sources de données sont ajoutées et mises à jour au fil du temps. Les sources de données suivantes sont connues pour être compatibles avec les alertes Grafana.
+ [Connect à une source de CloudWatch données Amazon](using-amazon-cloudwatch-in-AMG.md)
+ [Connectez-vous à une source de données Azure Monitor](using-azure-monitor-in-AMG.md)
+ [Connectez-vous à une source OpenSearch de données Amazon Service](using-Amazon-OpenSearch-in-AMG.md)
+ [Connectez-vous à une source de données Google Cloud Monitoring](using-google-cloud-monitoring-in-grafana.md)
+ [Connectez-vous à une source de données Graphite](using-graphite-in-AMG.md)
+ [Connect à une source de données InfluxDB](using-influxdb-in-AMG.md)
+ [Se connecter à une source de données Loki](using-loki-in-AMG.md)
+ [Connectez-vous à une source de données Microsoft SQL Server](using-microsoft-sql-server-in-AMG.md)
+ [Connect à une source de données MySQL](using-mysql-in-AMG.md)
+ [Connectez-vous à une source de données OpenTSDB](using-opentsdb-in-AMG.md)
+ [Connect à une source de données PostgreSQL](using-postgresql-in-AMG.md)
+ [Connectez-vous à Amazon Managed Service for Prometheus et aux sources de données open source Prometheus](prometheus-data-source.md)
+ [Connectez-vous à une source de données Jaeger](jaeger-data-source.md)
+ [Connect à une source de données Zipkin](zipkin-data-source.md)
+ [Connectez-vous à une source de données Tempo](tempo-data-source.md)
+ [Configuration d'une source TestData de données à des fins de test](testdata-data-source.md)
Pour des informations plus détaillées sur les sources de données et les plug-ins de sources de données dans Amazon Managed Grafana, consultez. [Connexion aux sources de données](AMG-data-sources.md)
# Alertes sur les données numériques
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Cette rubrique décrit comment Grafana gère les alertes basées sur des données numériques plutôt que sur des séries chronologiques.
Parmi certaines sources de données, les données numériques qui ne sont pas des séries chronologiques peuvent être directement alertées ou transmises aux expressions côté serveur (SSE). Cela permet d'améliorer le traitement et l'efficacité qui en résulte au sein de la source de données, tout en simplifiant les règles d'alerte. Lorsque vous lancez une alerte sur des données numériques plutôt que sur des données de séries chronologiques, il n'est pas nécessaire de réduire chaque série chronologique étiquetée en un seul chiffre. Au lieu de cela, les numéros étiquetés sont renvoyés à Grafana.
## Données tabulaires
Cette fonctionnalité est prise en charge par les sources de données principales qui interrogent des données tabulaires :
+ Sources de données SQL telles que MySQL, Postgres, MSSQL et Oracle.
+ Les services basés sur Azure Kusto : Azure Monitor (Logs), Azure Monitor (Azure Resource Graph) et Azure Data Explorer.
Une requête avec des alertes gérées par Grafana ou SSE est considérée comme numérique avec ces sources de données, si :
+ L'option « Format AS » est définie sur « Table » dans la requête de source de données.
+ La réponse de table renvoyée à Grafana par la requête inclut une seule colonne numérique (par exemple int, double, float) et éventuellement des colonnes de chaîne supplémentaires.
S'il existe des colonnes de chaînes, ces colonnes deviennent des étiquettes. Le nom d'une colonne devient le nom de l'étiquette, et la valeur de chaque ligne devient la valeur de l'étiquette correspondante. Si plusieurs lignes sont renvoyées, chaque ligne doit être identifiée de manière unique avec son étiquette.
## Exemple
Pour une table MySQL appelée « DiskSpace » :
| Heure | Host (Hôte) | Disk | PercentFree |
| --- | --- | --- | --- |
| 7 juin 2021 | web1 | /etc | 3 |
| 7 juin 2021 | web2 | /var | 4 |
| 7 juin 2021 | web3 | /var | 8 |
| ... | ... | ... | ... |
Vous pouvez interroger le filtrage des données à temps, mais sans renvoyer les séries chronologiques à Grafana. Par exemple, une alerte qui se déclencherait par hôte et par disque lorsqu'il y a moins de 5 % d'espace libre :
```
SELECT Host , Disk , CASE WHEN PercentFree < 5.0 THEN PercentFree ELSE 0 END FROM (
SELECT
Host,
Disk,
Avg(PercentFree)
FROM DiskSpace
Group By
Host,
Disk
Where __timeFilter(Time)
```
Cette requête renvoie la réponse de table suivante à Grafana :
| Host (Hôte) | Disk | PercentFree |
| --- | --- | --- |
| web1 | /etc | 3 |
| web2 | /var | 4 |
| web3 | /var | 0 |
Lorsque cette requête est utilisée comme **condition** dans une règle d'alerte, une valeur différente de zéro sera signalée. Par conséquent, trois instances d'alerte sont produites :
| Étiquettes | Statut |
| --- | --- |
| \$1Host=Web1, disk=/etc\$1 | Alerte |
| \$1Host=Web2, disk=/var\$1 | Alerte |
| \$1Host=Web3, disk=/var\$1 | Normal |
# Étiquettes et annotations
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Les étiquettes et les annotations contiennent des informations sur une alerte. Les étiquettes et les annotations ont la même structure : un ensemble de valeurs nommées, mais leurs utilisations prévues sont différentes. Un exemple d'étiquette, ou d'annotation équivalente, pourrait être`alertname="test"`.
La principale différence entre une étiquette et une annotation est que les étiquettes sont utilisées pour différencier une alerte de toutes les autres alertes, tandis que les annotations sont utilisées pour ajouter des informations supplémentaires à une alerte existante.
Par exemple, considérez deux alertes de niveau élevé du processeur : une pour `server1` et une autre pour`server2`. Dans un tel exemple, nous pourrions avoir une étiquette appelée `server` où la première alerte possède l'étiquette `server="server1"` et la deuxième alerte possède l'étiquette`server="server2"`. Cependant, nous souhaiterons peut-être également ajouter une description à chaque alerte`"The CPU usage for server1 is above 75%."`, par exemple où `server1` et où `75%` sont remplacés par le nom et l'utilisation du processeur du serveur (veuillez consulter la documentation [Création de modèles d'étiquettes et d'annotations](v10-alerting-overview-labels-templating.md) pour savoir comment procéder). Ce type de description serait plus approprié sous forme d'annotation.
## Étiquettes
Les étiquettes contiennent des informations qui identifient une alerte. Un exemple d'étiquette pourrait être`server=server1`. Chaque alerte peut avoir plusieurs étiquettes, et l'ensemble complet d'étiquettes d'une alerte est appelé son ensemble d'étiquettes. C'est ce jeu d'étiquettes qui identifie l'alerte.
Par exemple, une alerte peut avoir l'étiquette définie `{alertname="High CPU usage",server="server1"}` alors qu'une autre alerte peut avoir l'étiquette définie`{alertname="High CPU usage",server="server2"}`. Il s'agit de deux alertes distinctes, car même si leurs `alertname` étiquettes sont identiques, elles sont différentes. `server`
L'étiquette définie pour une alerte est une combinaison des étiquettes de la source de données, des étiquettes personnalisées de la règle d'alerte et d'un certain nombre d'étiquettes réservées telles que`alertname`.
**Étiquettes personnalisées**
Les libellés personnalisés sont des libellés supplémentaires issus de la règle d'alerte. Tout comme les annotations, les étiquettes personnalisées doivent avoir un nom, et leur valeur peut contenir une combinaison de texte et de code modèle qui est évalué lorsqu'une alerte est déclenchée. La documentation sur la façon de modéliser des étiquettes personnalisées est disponible [ici](v10-alerting-overview-labels-templating.md).
Lorsque vous utilisez des étiquettes personnalisées avec des modèles, il est important de veiller à ce que la valeur de l'étiquette ne change pas entre les évaluations consécutives de la règle d'alerte, car cela finira par créer un grand nombre d'alertes distinctes. Cependant, le modèle peut générer différentes valeurs d'étiquette pour différentes alertes. Par exemple, ne mettez pas la valeur de la requête dans une étiquette personnalisée car cela finira par créer un nouvel ensemble d'alertes chaque fois que la valeur change. Utilisez plutôt des annotations.
Il est également important de s'assurer que l'étiquette définie pour une alerte ne comporte pas deux étiquettes ou plus portant le même nom. Si une étiquette personnalisée porte le même nom qu'une étiquette de la source de données, elle remplacera cette étiquette. Toutefois, si une étiquette personnalisée porte le même nom qu'une étiquette réservée, l'étiquette personnalisée sera omise de l'alerte.
## Annotations
Les annotations sont des paires nommées qui ajoutent des informations supplémentaires aux alertes existantes. Il existe un certain nombre d'annotations suggérées dans Grafana`summary`, `description` telles que,`runbook_url`, `dashboardUId` et. `panelId` Tout comme les étiquettes personnalisées, les annotations doivent avoir un nom, et leur valeur peut contenir une combinaison de texte et de code modèle qui est évalué lorsqu'une alerte est déclenchée. Si une annotation contient un code de modèle, le modèle est évalué une seule fois lorsque l'alerte est déclenchée. Elle n'est pas réévaluée, même lorsque l'alerte est résolue. La documentation sur la façon de modéliser des annotations est disponible [ici](v10-alerting-overview-labels-templating.md).
**Topics**
+ [Étiquettes](#v10-alerting-overview-labels-labels)
+ [Annotations](#v10-alerting-overview-labels-annotations)
+ [Comment fonctionne la correspondance des étiquettes](v10-alerting-overview-labels-matching.md)
+ [Étiquettes dans Grafana Alerting](v10-alerting-overview-labels-alerting.md)
+ [Création de modèles d'étiquettes et d'annotations](v10-alerting-overview-labels-templating.md)
# Comment fonctionne la correspondance des étiquettes
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Utilisez des étiquettes et des outils de comparaison d'étiquettes pour lier les règles d'alerte aux politiques de notification et aux silences. Cela permet de gérer vos instances d'alerte de manière très flexible, de spécifier la politique qui doit les gérer et les alertes à désactiver.
Un analyseur d'étiquettes se compose de 3 parties distinctes : l'**étiquette**, la **valeur** et l'**opérateur**.
+ Le champ **Label** est le nom de l'étiquette à associer. Il doit correspondre exactement au nom de l'étiquette.
+ Le champ **Valeur** correspond à la valeur correspondante pour le nom d'**étiquette** spécifié. La correspondance dépend de la valeur de l'**opérateur**.
+ Le champ **Opérateur** est l'opérateur à comparer à la valeur de l'étiquette. Les opérateurs disponibles sont les suivants :
| Opérateur | Description |
| --- | --- |
| `=` | Sélectionnez des étiquettes exactement égales à la valeur. |
| `!=` | Sélectionnez des étiquettes qui ne sont pas égales à la valeur. |
| `=~` | Sélectionnez les libellés qui correspondent à la valeur par regex. |
| `!~` | Sélectionnez les libellés qui ne correspondent pas à la valeur par regex. |
Si vous utilisez plusieurs correspondants d'étiquettes, ils sont combinés à l'aide de l'opérateur logique AND. Cela signifie que tous les matchers doivent correspondre afin de lier une règle à une politique.
## Exemple
Si vous définissez le jeu d'étiquettes suivant pour votre alerte :
```
{ foo=bar, baz=qux, id=12 }
```
puis :
+ Un comparateur d'étiquettes défini comme `foo=bar` correspond à cette règle d'alerte.
+ Un comparateur d'étiquettes défini comme `foo!=bar` ne correspond *pas* à cette règle d'alerte.
+ Un comparateur d'étiquettes défini comme `id=~[0-9]+` correspond à cette règle d'alerte.
+ Un comparateur d'étiquettes défini comme `baz!~[0-9]+` correspond à cette règle d'alerte.
+ Deux marqueurs d'étiquettes définis `foo=bar` et conformes à `id=~[0-9]+` cette règle d'alerte.
## Exclure les étiquettes
Vous pouvez également écrire des correspondances d'étiquettes pour exclure des étiquettes.
Voici un exemple qui montre comment exclure l'étiquette`team`. Vous pouvez choisir l'une de ces valeurs pour exclure l'étiquette.
+ `team=""`
+ `team!~.+`
+ `team=~^$`
# Étiquettes dans Grafana Alerting
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Cette rubrique explique pourquoi les étiquettes sont un élément fondamental des alertes.
+ L'ensemble complet d'étiquettes pour une alerte est ce qui identifie de manière unique une alerte dans les alertes Grafana.
+ Le gestionnaire d'alertes utilise des étiquettes pour faire correspondre les alertes relatives aux silences et aux groupes d'alertes dans les politiques de notification.
+ L'interface utilisateur d'alerte affiche des étiquettes pour chaque instance d'alerte générée lors de l'évaluation de cette règle.
+ Les points de contact peuvent accéder aux étiquettes pour générer dynamiquement des notifications contenant des informations spécifiques à l'alerte qui entraîne une notification.
+ Vous pouvez ajouter des libellés à une [règle d'alerte](v10-alerting-configure.md). Les étiquettes sont configurables manuellement, utilisent des fonctions de modèle et peuvent faire référence à d'autres étiquettes. Les étiquettes ajoutées à une règle d'alerte ont priorité en cas de collision entre étiquettes (sauf dans le cas des étiquettes réservées Grafana, voir ci-dessous pour plus d'informations).
## Compatibilité avec Alertmanager externe
Le gestionnaire d'alertes intégré de Grafana prend en charge à la fois les clés et les valeurs d'étiquette Unicode. [Si vous utilisez un Prometheus Alertmanager externe, les clés d'étiquette doivent être compatibles avec leur modèle de données.](https://prometheus.io/docs/concepts/data_model/#metric-names-and-labels) Cela signifie que les clés d'étiquette ne doivent contenir que des **lettres ASCII, des** **chiffres** et des traits de **soulignement** et correspondre à l'expression régulière. `[a-zA-Z_][a-zA-Z0-9_]*` Tout caractère non valide sera supprimé ou remplacé par le moteur d'alerte Grafana avant d'être envoyé au gestionnaire d'alertes externe conformément aux règles suivantes :
+ `Whitespace`sera supprimé.
+ `ASCII characters`sera remplacé par`_`.
+ `All other characters`seront remplacés par leur représentation hexadécimale en minuscules. S'il s'agit du premier caractère, il sera préfixé par`_`.
**Note**
Si plusieurs clés d'étiquette sont nettoyées à la même valeur, les doublons porteront un court hachage de l'étiquette d'origine ajouté en tant que suffixe.
## Étiquettes réservées Grafana
**Note**
Les étiquettes préfixées par `grafana_` sont réservées par Grafana pour un usage spécial. Si une étiquette configurée manuellement est ajoutée en commençant par, `grafana_` elle sera remplacée en cas de collision.
Les étiquettes réservées Grafana peuvent être utilisées de la même manière que les étiquettes configurées manuellement. La liste actuelle des labels réservés disponibles est la suivante :
| Étiquette | Description |
| --- | --- |
| dossier grafana | Titre du dossier contenant l'alerte. |
# Création de modèles d'étiquettes et d'annotations
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Vous pouvez utiliser des modèles pour inclure des données issues de requêtes et d'expressions dans des étiquettes et des annotations. Par exemple, vous pouvez définir l'étiquette de gravité d'une alerte en fonction de la valeur de la requête, ou utiliser l'étiquette d'instance de la requête dans une annotation récapitulative afin de savoir quel serveur utilise beaucoup le processeur.
Tous les modèles doivent être écrits en [texte/modèle](https://pkg.go.dev/text/template). Que vous modélisiez une étiquette ou une annotation, vous devez écrire chaque modèle en ligne à l'intérieur de l'étiquette ou de l'annotation que vous modélisez. Cela signifie que vous ne pouvez pas partager de modèles entre les étiquettes et les annotations, mais que vous devez copier les modèles là où vous souhaitez les utiliser.
Chaque modèle est évalué chaque fois que la règle d'alerte est évaluée, et est évalué séparément pour chaque alerte. Par exemple, si votre règle d'alerte comporte un modèle d'annotation récapitulative et qu'elle comporte 10 alertes déclenchées, le modèle sera exécuté 10 fois, une fois pour chaque alerte. Vous devriez essayer d'éviter autant que possible d'effectuer des calculs coûteux dans vos modèles.
## Exemples
Plutôt que d'écrire un didacticiel complet, text/template, the following examples attempt to show the most common use-cases we have seen for templates. You can use these examples verbatim, or adapt them as necessary for your use case. For more information about how to write text/template consultez la documentation [texte/modèle](https://pkg.go.dev/text/template).
**Imprimer toutes les étiquettes, séparées par des virgules**
Pour imprimer toutes les étiquettes, séparées par des virgules, imprimez la `$labels` variable :
```
{{ $labels }}
```
Par exemple, si vous recevez une alerte avec les étiquettes `alertname=High CPU usage``instance=server1`, `grafana_folder=CPU alerts` cela imprimerait :
```
alertname=High CPU usage, grafana_folder=CPU alerts, instance=server1
```
**Note**
Si vous utilisez `$labels` des conditions classiques, la requête ne contiendra aucune étiquette. Reportez-vous à [la variable \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable) pour plus d'informations.
**Imprimez toutes les étiquettes, une par ligne**
Pour imprimer toutes les étiquettes, une par ligne, utilisez a `range` pour itérer sur chaque key/value paire et imprimez-les individuellement. Ici `$k` fait référence au nom et `$v` à la valeur de l'étiquette actuelle :
```
{{ range $k, $v := $labels -}}
{{ $k }}={{ $v }}
{{ end }}
```
Par exemple, si vous recevez une alerte avec les étiquettes `alertname=High CPU usage``instance=server1`, `grafana_folder=CPU alerts` cela imprimerait :
```
alertname=High CPU usage
grafana_folder=CPU alerts
instance=server1
```
**Note**
Si vous utilisez `$labels` des conditions classiques, la requête ne contiendra aucune étiquette. Reportez-vous à [la variable \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable) pour plus d'informations.
**Imprimer une étiquette individuelle**
Pour imprimer une étiquette individuelle, utilisez la `index` fonction avec la `$labels` variable :
```
The host {{ index $labels "instance" }} has exceeded 80% CPU usage for the last 5 minutes
```
Par exemple, étant donné une alerte avec l'étiquette`instance=server1`, cela imprimerait :
```
The host server1 has exceeded 80% CPU usage for the last 5 minutes
```
**Note**
Si vous utilisez `$labels` des conditions classiques, la requête ne contiendra aucune étiquette. Reportez-vous à [la variable \$1labels](#v10-alerting-overview-labels-templating-the-labels-variable) pour plus d'informations.
**Imprimer la valeur d'une requête**
Pour imprimer la valeur d'une requête instantanée, vous pouvez imprimer son ID de référence à l'aide de la `index` fonction et de la `$values` variable :
```
{{ index $values "A" }}
```
Par exemple, étant donné une requête instantanée qui renvoie la valeur 81,2345, ceci affichera :
```
81.2345
```
Pour imprimer la valeur d'une requête par plage, vous devez d'abord la réduire d'une série chronologique à un vecteur instantané avec une expression de réduction. Vous pouvez ensuite imprimer le résultat de l'expression de réduction en utilisant plutôt son ID de référence. Par exemple, si l'expression de réduction prend la moyenne de A et a l'ID de référence B, vous devez écrire :
```
{{ index $values "B" }}
```
**Imprimer la valeur humanisée d'une requête**
Pour imprimer la valeur humanisée d'une requête instantanée, utilisez la `humanize` fonction :
```
{{ humanize (index $values "A").Value }}
```
Par exemple, étant donné une requête instantanée qui renvoie la valeur 81,2345, ceci affichera :
```
81.234
```
Pour imprimer la valeur humanisée d'une requête par plage, vous devez d'abord la réduire d'une série chronologique à un vecteur instantané avec une expression de réduction. Vous pouvez ensuite imprimer le résultat de l'expression de réduction en utilisant plutôt son ID de référence. Par exemple, si l'expression de réduction prend la moyenne de A et a l'ID de référence B, vous devez écrire :
```
{{ humanize (index $values "B").Value }}
```
**Imprimer la valeur d'une requête sous forme de pourcentage**
Pour imprimer la valeur d'une requête instantanée sous forme de pourcentage, utilisez la `humanizePercentage` fonction :
```
{{ humanizePercentage (index $values "A").Value }}
```
Cette fonction s'attend à ce que la valeur soit un nombre décimal compris entre 0 et 1. Si la valeur est plutôt un nombre décimal compris entre 0 et 100, vous pouvez la diviser par 100 dans votre requête ou à l'aide d'une expression mathématique. Si la requête est une requête par plage, vous devez d'abord la réduire d'une série chronologique à un vecteur instantané avec une expression de réduction.
**Définir une sévérité à partir de la valeur d'une requête**
Pour définir une étiquette de gravité à partir de la valeur d'une requête, utilisez une instruction if et la fonction de comparaison supérieure à celle de comparaison. Assurez-vous d'utiliser des décimales (`80.0`,, `50.0``0.0`, etc.) lorsque vous effectuez des comparaisons avec `$values` car cela text/template ne prend pas en charge la coercition de type. Vous trouverez une liste de toutes les fonctions de comparaison prises en charge [ici](https://pkg.go.dev/text/template#hdr-Functions).
```
{{ if (gt $values.A.Value 80.0) -}}
high
{{ else if (gt $values.A.Value 50.0) -}}
medium
{{ else -}}
low
{{- end }}
```
**Imprimez toutes les étiquettes à partir d'un état classique**
Vous ne pouvez pas utiliser `$labels` pour imprimer des étiquettes à partir de la requête si vous utilisez des conditions classiques et vous devez les utiliser à la `$values` place. Cela s'explique par le fait que les conditions classiques suppriment ces étiquettes pour imposer un comportement unidimensionnel (au plus une alerte par règle d'alerte). Si les conditions classiques n'éliminaient pas ces étiquettes, les requêtes renvoyant de nombreuses séries chronologiques provoqueraient des interruptions entre le déclenchement et la résolution constante des alertes, car les étiquettes changeaient à chaque fois que la règle d'alerte était évaluée.
Au lieu de cela, la `$values` variable contient les valeurs réduites de toutes les séries chronologiques pour toutes les conditions qui se déclenchent. Par exemple, si vous avez une règle d'alerte avec une requête A qui renvoie deux séries chronologiques, et une condition B classique avec deux conditions, alors `$values` contiendrait `B0``B1`, `B2` et`B3`. Si la condition B classique ne comportait qu'une seule condition, `$values` elle contiendrait uniquement `B0` et`B1`.
Pour imprimer toutes les étiquettes de toutes les séries chronologiques de cuisson, utilisez le modèle suivant (assurez-vous de remplacer `B` l'expression régulière par l'ID de référence de la condition classique s'il est différent) :
```
{{ range $k, $v := $values -}}
{{ if (match "B[0-9]+" $k) -}}
{{ $k }}: {{ $v.Labels }}{{ end }}
{{ end }}
```
Par exemple, une condition classique pour deux séries chronologiques dépassant une seule condition imprimerait :
```
B0: instance=server1
B1: instance=server2
```
Si la condition classique comporte deux conditions ou plus et qu'une série chronologique dépasse plusieurs conditions en même temps, ses étiquettes seront dupliquées pour chaque condition dépassée :
```
B0: instance=server1
B1: instance=server2
B2: instance=server1
B3: instance=server2
```
Si vous devez imprimer des étiquettes uniques, vous devriez plutôt envisager de modifier vos règles d'alerte en les remplaçant par des règles unidimensionnelles par des règles multidimensionnelles. Vous pouvez le faire en remplaçant votre condition classique par des expressions de réduction et mathématiques.
**Imprimer toutes les valeurs d'une condition classique**
Pour imprimer toutes les valeurs d'une condition classique, prenez l'exemple précédent et remplacez-le `$v.Labels` par `$v.Value` :
```
{{ range $k, $v := $values -}}
{{ if (match "B[0-9]+" $k) -}}
{{ $k }}: {{ $v.Value }}{{ end }}
{{ end }}
```
Par exemple, une condition classique pour deux séries chronologiques dépassant une seule condition imprimerait :
```
B0: 81.2345
B1: 84.5678
```
Si la condition classique comporte au moins deux conditions et qu'une série chronologique dépasse plusieurs conditions en même temps, elle `$values` contiendra les valeurs de toutes les conditions :
```
B0: 81.2345
B1: 92.3456
B2: 84.5678
B3: 95.6789
```
## Variables
Les variables suivantes sont à votre disposition lors de la création de modèles d'étiquettes et d'annotations :
### La variable labels
La `$labels` variable contient tous les libellés de la requête. Supposons, par exemple, que vous ayez une requête qui renvoie l'utilisation du processeur pour tous vos serveurs, et que vous disposiez d'une règle d'alerte qui se déclenche lorsque l'un de vos serveurs a dépassé 80 % d'utilisation du processeur au cours des 5 dernières minutes. Vous souhaitez ajouter une annotation récapitulative à l'alerte qui indique quel serveur utilise beaucoup le processeur. Avec la `$labels` variable, vous pouvez écrire un modèle qui imprime une phrase lisible par l'homme, telle que :
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes
```
**Note**
Si vous utilisez une condition classique, `$labels` elle ne contiendra aucune étiquette provenant de la requête. Les conditions classiques suppriment ces étiquettes afin d'imposer un comportement unidimensionnel (au maximum une alerte par règle d'alerte). Si vous souhaitez utiliser les étiquettes de la requête dans votre modèle, suivez l'exemple précédent *Imprimer toutes les étiquettes à partir d'un exemple de condition classique*.
### La variable de valeur
La `$value` variable est une chaîne contenant les libellés et les valeurs de toutes les requêtes instantanées, les expressions de seuil, de réduction et mathématiques, ainsi que les conditions classiques de la règle d'alerte. Il ne contient pas les résultats des requêtes de plage, car celles-ci peuvent renvoyer de 10 à 10 000 lignes ou métriques. Si tel était le cas, pour des requêtes particulièrement volumineuses, une seule alerte pourrait utiliser des dizaines de secondes MBs de mémoire et Grafana manquerait de mémoire très rapidement.
Pour imprimer la `$value` variable dans le résumé, vous devez écrire quelque chose comme ceci :
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ $value }}
```
Et cela ressemblerait à ceci :
```
CPU usage for instance1 has exceeded 80% for the last 5 minutes: [ var='A' labels={instance=instance1} value=81.234 ]
```
Ici, il `var='A'` fait référence à la requête instantanée avec l'ID de `labels={instance=instance1}` référence A, aux étiquettes et `value=81.234` à l'utilisation moyenne du processeur au cours des 5 dernières minutes.
Si vous souhaitez imprimer une partie de la chaîne au lieu de la chaîne complète, utilisez la `$values` variable. Il contient les mêmes informations que`$value`, mais dans un tableau structuré, et il est beaucoup plus facile à utiliser que d'écrire une expression régulière correspondant exactement au texte souhaité.
### La variable de valeurs
La `$values` variable est une table contenant les étiquettes et les valeurs à virgule flottante de toutes les requêtes et expressions instantanées, indexées par leur référence. IDs
Pour imprimer la valeur de la requête instantanée avec l'ID de référence A :
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ index $values "A" }}
```
Par exemple, à partir d'une alerte avec les libellés `instance=server1` et d'une requête instantanée avec la valeur`81.2345`, ceci imprimerait :
```
CPU usage for instance1 has exceeded 80% for the last 5 minutes: 81.2345
```
Si la requête dans l'ID de référence A est une requête de plage plutôt qu'une requête instantanée, ajoutez une expression de réduction avec l'ID de référence B et remplacez-la par `(index $values "A")` `(index $values "B")` :
```
CPU usage for {{ index $labels "instance" }} has exceeded 80% for the last 5 minutes: {{ index $values "B" }}
```
## Fonctions
Les fonctions suivantes sont à votre disposition lors de la création de modèles d'étiquettes et d'annotations :
**args**
La `args` fonction traduit une liste d'objets en une carte avec les clés arg0, arg1, etc. Cela a pour but de permettre la transmission de plusieurs arguments aux modèles.
```
{{define "x"}}{{.arg0}} {{.arg1}}{{end}}{{template "x" (args 1 "2")}}
```
```
1 2
```
**URL externe**
La `externalURL` fonction renvoie l'URL externe du serveur Grafana.
```
{{ externalURL }}
```
```
https://example.com/grafana
```
**GraphLink**
La `graphLink` fonction renvoie le chemin d'accès à la vue graphique [Explorez dans la version 10 de Grafana](v10-explore.md) pour l'expression et la source de données données.
```
{{ graphLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}
```
```
/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":false,"range":true}]
```
**humaniser**
La `humanize` fonction humanise les nombres décimaux.
```
{{ humanize 1000.0 }}
```
```
1k
```
**humaniser 1024**
Il `humanize1024` fonctionne de manière similaire `humanize` mais utilise 1024 comme base au lieu de 1000.
```
{{ humanize1024 1024.0 }}
```
```
1ki
```
**Humaniser la durée**
La `humanizeDuration` fonction humanise une durée en secondes.
```
{{ humanizeDuration 60.0 }}
```
```
1m 0s
```
**Pourcentage d'humanisation**
La `humanizePercentage` fonction humanise une valeur de ratio par rapport à un pourcentage.
```
{{ humanizePercentage 0.2 }}
```
```
20%
```
**Humaniser l'horodatage**
La `humanizeTimestamp` fonction humanise un horodatage Unix.
```
{{ humanizeTimestamp 1577836800.0 }}
```
```
2020-01-01 00:00:00 +0000 UTC
```
**match**
La `match` fonction compare le texte à un modèle d'expression régulière.
```
{{ match "a.*" "abc" }}
```
```
true
```
**Préfixe de chemin**
La `pathPrefix` fonction renvoie le chemin du serveur Grafana.
```
{{ pathPrefix }}
```
```
/grafana
```
**Tableau Link**
La `tableLink` fonction renvoie le chemin d'accès à la vue tabulaire [Explorez dans la version 10 de Grafana](v10-explore.md) pour l'expression et la source de données données.
```
{{ tableLink "{\"expr\": \"up\", \"datasource\": \"gdev-prometheus\"}" }}
```
```
/explore?left=["now-1h","now","gdev-prometheus",{"datasource":"gdev-prometheus","expr":"up","instant":true,"range":false}]
```
**title**
La `title` fonction met en majuscule le premier caractère de chaque mot.
```
{{ title "hello, world!" }}
```
```
Hello, World!
```
**ToLower**
La `toLower` fonction renvoie tout le texte en minuscules.
```
{{ toLower "Hello, world!" }}
```
```
hello, world!
```
**ToupPper**
La `toUpper` fonction renvoie tout le texte en majuscules.
```
{{ toUpper "Hello, world!" }}
```
```
HELLO, WORLD!
```
**reReplaceAll**
La `reReplaceAll` fonction remplace le texte correspondant à l'expression régulière.
```
{{ reReplaceAll "localhost:(.*)" "example.com:$1" "localhost:8080" }}
```
```
example.com:8080
```
# À propos des règles d'alerte
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Une règle d'alerte est un ensemble de critères d'évaluation qui déterminent si une instance d'alerte va se déclencher. La règle comprend une ou plusieurs requêtes et expressions, une condition, la fréquence d'évaluation et la durée pendant laquelle la condition doit être remplie pour commencer à se déclencher.
Alors que les requêtes et les expressions sélectionnent l'ensemble de données à évaluer, une *condition* définit le seuil que les données doivent atteindre ou dépasser pour créer une alerte.
Un *intervalle* indique la fréquence à laquelle une règle d'alerte est évaluée. *La durée*, lorsqu'elle est configurée, indique la durée pendant laquelle une condition doit être remplie. Les règles d'alerte peuvent également définir le comportement des alertes en l'absence de données.
**Topics**
+ [Types de règles d'alerte](v10-alerting-explore-rules-types.md)
+ [Règles d'enregistrement](v10-alerting-explore-rule-recording.md)
+ [Requêtes et conditions](v10-alerting-explore-rules-queries.md)
+ [Instances d'alerte](v10-alerting-rules-instances.md)
+ [Espaces de noms, dossiers et groupes](v10-alerting-rules-grouping.md)
+ [Évaluation des règles d'alerte](v10-alerting-rules-evaluation.md)
+ [État et état des règles d'alerte](v10-alerting-explore-state.md)
+ [Modèle de notification](v10-alerting-rules-notification-templates.md)
# Types de règles d'alerte
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Grafana prend en charge plusieurs types de règles d'alerte. Apprenez-en davantage sur chacun des types de règles d'alerte, leur fonctionnement et déterminez celle qui convient le mieux à votre cas d'utilisation.
## Règles gérées par Grafana
Les règles gérées par Grafana sont le type de règle d'alerte le plus flexible. Ils vous permettent de créer des alertes qui peuvent agir sur les données provenant de n'importe laquelle de vos sources de données existantes.
Outre la prise en charge de plusieurs sources de données, vous pouvez ajouter [des expressions](v10-panels-query-xform-expressions.md) pour transformer vos données et exprimer les conditions d'alerte.
Dans Grafana, gestion des alertes :
+ Les règles d'alerte sont créées dans Grafana, sur la base d'une ou de plusieurs sources de données.
+ Les règles d'alerte sont évaluées par le moteur d'évaluation des règles d'alerte depuis Grafana.
+ Les alertes sont diffusées à l'aide du Grafana Alertmanager interne.
**Note**
Vous pouvez également configurer les alertes à diffuser à l'aide d'un gestionnaire d'alertes externe, ou utiliser à la fois des gestionnaires d'alertes internes et externes. Pour plus d'informations, voir [Ajouter un gestionnaire d'alertes externe](v10-alerting-setup-alertmanager.md).
## Règles de gestion des sources de données
Pour créer des règles d'alerte gérées par une source de données, vous devez disposer d'une source de données Prometheus ou Loki compatible. Vous pouvez vérifier si votre source de données prend en charge la création de règles via Grafana en testant la source de données et en observant si l'API Ruler est prise en charge.
Dans les alertes gérées par les sources de données :
+ Les règles d'alerte sont créées et stockées dans la source de données elle-même.
+ Les règles d'alerte ne peuvent être créées que sur la base des données Prometheus.
+ L'évaluation et la diffusion des règles d'alerte sont réparties sur plusieurs nœuds pour garantir une haute disponibilité et une tolérance aux pannes.
## Choisissez un type de règle d'alerte
Lorsque vous choisissez le type de règle d'alerte à utiliser, considérez la comparaison suivante entre les règles d'alerte gérées par Grafana et les règles d'alerte gérées par les sources de données.
| Fonctionnalité | Règle d'alerte gérée par Grafana | Règle d'alerte gérée par Loki/Mimir |
| --- | --- | --- |
| Créez des règles d'alerte basées sur les données provenant de l'une de nos sources de données prises en charge | Oui | Non : vous pouvez uniquement créer des règles d'alerte basées sur les données Prometheus. L'API Ruler doit être activée dans la source de données. |
| Combinez et associez les sources de données | Oui | Non |
| Inclut la prise en charge des règles d'enregistrement | Non | Oui |
| Ajoutez des expressions pour transformer vos données et définir des conditions d'alerte | Oui | Non |
| Utiliser des images dans les notifications d'alerte | Oui | Non |
| Mise à l’échelle | Plus gourmands en ressources, dépendent de la base de données et sont susceptibles de présenter des erreurs transitoires. Ils ne sont redimensionnés que verticalement. | Stockez les règles d'alerte dans la source de données elle-même et permettez une mise à l'échelle « infinie ». Générez et envoyez des notifications d'alerte depuis l'emplacement de vos données. |
| Évaluation et diffusion des règles d'alerte | L'évaluation et la diffusion des règles d'alerte sont effectuées depuis Grafana, en utilisant un Alertmanager externe, ou les deux. | L'évaluation des règles d'alerte et la diffusion des alertes sont distribuées, ce qui signifie qu'il n'existe aucun point de défaillance unique. |
# Règles d'enregistrement
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
*Les règles d'enregistrement ne sont disponibles que pour les sources de données Prometheus ou Loki compatibles.*
Une règle d'enregistrement vous permet de précalculer des expressions fréquemment nécessaires ou coûteuses en termes de calcul et d'enregistrer leur résultat sous la forme d'un nouvel ensemble de séries chronologiques. Cela est utile si vous souhaitez exécuter des alertes sur des données agrégées ou si vous disposez de tableaux de bord qui interrogent à plusieurs reprises des expressions coûteuses en termes de calcul.
L'interrogation de cette nouvelle série chronologique est plus rapide, en particulier pour les tableaux de bord, car ils demandent la même expression à chaque actualisation des tableaux de bord.
En savoir plus sur les [règles d'enregistrement](https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/) dans Prometheus.
# Requêtes et conditions
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Dans Grafana, les requêtes jouent un rôle essentiel dans la récupération et la transformation des données à partir de sources de données prises en charge, notamment des bases de données telles que MySQL et PostgreSQL, des bases de données de séries chronologiques telles que Prometheus, InfluxDB et Graphite, et des services tels qu'Amazon, Azure Monitor et Google Cloud Monitoring. OpenSearch CloudWatch
Pour plus d'informations sur les sources de données prises en charge, consultez[Sources de données et alertes Grafana](v10-alerting-overview-datasources.md).
Le processus d'exécution d'une requête implique de définir la source de données, de spécifier les données à récupérer et d'appliquer des filtres ou des transformations appropriés. Des langages de requête ou des syntaxes spécifiques à la source de données choisie sont utilisés pour construire ces requêtes.
Dans Alerting, vous définissez une requête pour obtenir les données que vous souhaitez mesurer et une condition qui doit être remplie avant qu'une règle d'alerte ne soit déclenchée.
Une règle d'alerte consiste en une ou plusieurs requêtes et expressions qui sélectionnent les données que vous souhaitez mesurer.
Pour plus d'informations sur les requêtes et les expressions, consultez[Interrogez et transformez les données](v10-panels-query-xform.md).
## Requêtes sur les sources de données
Les requêtes dans Grafana peuvent être appliquées de différentes manières, en fonction de la source de données et du langage de requête utilisés. L'éditeur de requêtes de chaque source de données fournit une interface utilisateur personnalisée qui vous permet de rédiger des requêtes qui tirent parti de ses fonctionnalités uniques.
En raison des différences entre les langages de requête, chaque éditeur de requêtes de source de données présente une apparence et un fonctionnement différents. En fonction de votre source de données, l'éditeur de requêtes peut fournir des fonctionnalités de saisie automatique, des noms de métriques, des suggestions de variables ou une interface visuelle de création de requêtes.
Parmi les types courants de composants de requête, on peut citer :
**Métriques ou champs de données** : spécifiez les métriques ou les champs de données spécifiques que vous souhaitez récupérer, tels que l'utilisation du processeur, le trafic réseau ou les relevés des capteurs.
**Plage de temps** : définissez la plage de temps pour laquelle vous souhaitez récupérer des données, telle que la dernière heure, un jour spécifique ou une plage horaire personnalisée.
**Filtres** : appliquez des filtres pour affiner les données en fonction de critères spécifiques, tels que le filtrage des données en fonction d'une balise, d'un hôte ou d'une application spécifique.
**Agrégations** : effectuez des agrégations sur les données pour calculer des indicateurs tels que des moyennes, des sommes ou des dénombrements sur une période donnée.
**Regroupement : regroupez** les données selon des dimensions ou des balises spécifiques pour créer des vues agrégées ou des ventilations.
**Note**
Grafana ne prend pas en charge les requêtes d'alerte avec des variables de modèle. Plus d'informations sont disponibles [ici](https://community.grafana.com/t/template-variables-are-not-supported-in-alert-queries-while-setting-up-alert/2514) dans les forums de Grafana Labs.
## Requêtes d'expression
Dans Grafana, une expression est utilisée pour effectuer des calculs, des transformations ou des agrégations sur les données demandées par la source de données. Il vous permet de créer des métriques personnalisées ou de modifier des métriques existantes en fonction d'opérations mathématiques, de fonctions ou d'expressions logiques.
En utilisant les requêtes d'expression, les utilisateurs peuvent effectuer des tâches telles que le calcul de la variation en pourcentage entre deux valeurs, l'application de fonctions telles que les fonctions logarithmiques ou trigonométriques, l'agrégation de données sur des plages de temps ou des dimensions spécifiques et la mise en œuvre d'une logique conditionnelle pour gérer différents scénarios.
Dans Alerting, vous ne pouvez utiliser des expressions que pour les règles d'alerte gérées par Grafana. Pour chaque expression, vous pouvez choisir entre les expressions mathématiques, réduire ou rééchantillonner. Ces règles sont appelées règles multidimensionnelles, car elles génèrent une alerte distincte pour chaque série.
Vous pouvez également utiliser une condition classique, qui crée une règle d'alerte qui déclenche une seule alerte lorsque sa condition est remplie. Grafana n'envoie donc qu'une seule alerte, même lorsque les conditions d'alerte sont remplies pour plusieurs séries.
**Note**
Les conditions classiques existent principalement pour des raisons de compatibilité et doivent être évitées dans la mesure du possible.
**Réduire**
Regroupe les valeurs des séries chronologiques dans la plage de temps sélectionnée en une seule valeur.
**Math**
Effectue des calculs de forme libre functions/operations sur les séries chronologiques et les données numériques. Peut être utilisé pour prétraiter des données de séries chronologiques ou pour définir une condition d'alerte pour les données numériques.
**Rééchantillonner**
Réaligne une plage de temps sur un nouvel ensemble d'horodatages, ce qui est utile lorsque vous comparez des données de séries chronologiques provenant de différentes sources de données où les horodatages ne seraient pas alignés autrement.
**Threshold**
Vérifie si des données de séries chronologiques correspondent à la condition de seuil.
L'expression de seuil vous permet de comparer deux valeurs uniques. Il est renvoyé `0` lorsque la condition est fausse et `1` si la condition est vraie. Les fonctions de seuil suivantes sont disponibles :
+ Est supérieur à (x > y)
+ Est inférieur à (x < y)
+ Se situe dans la plage (x > y1 ET x < y2)
+ Est hors de portée (x < y1 AND x > y2)
**État classique**
Vérifie si des données de séries chronologiques correspondent à la condition d'alerte.
**Note**
Les requêtes d'expression de condition classiques ne produisent toujours qu'une seule instance d'alerte, quel que soit le nombre de séries chronologiques répondant à la condition. Les conditions classiques existent principalement pour des raisons de compatibilité et doivent être évitées dans la mesure du possible.
## Agrégations
Grafana Alerting fournit les fonctions d'agrégation suivantes pour vous permettre d'affiner davantage votre requête.
Ces fonctions sont disponibles uniquement pour **les expressions de condition Reduce** **et Classic**.
| Fonction | Expression | Ce qu'il fait |
| --- | --- | --- |
| avg | Réduire/Classique | Affiche la moyenne des valeurs |
| min | Réduire/Classique | Affiche la valeur la plus faible |
| max | Réduire/Classique | Affiche la valeur la plus élevée |
| sum | Réduire/Classique | Affiche la somme de toutes les valeurs |
| count | Réduire/Classique | Compte le nombre de valeurs dans le résultat |
| last | Réduire/Classique | Affiche la dernière valeur |
| median | Réduire/Classique | Affiche la valeur médiane |
| diff | Classique | Affiche la différence entre la valeur la plus récente et la plus ancienne |
| diff\$1abs | Classique | Affiche la valeur absolue de diff |
| percent\$1diff | Classique | Affiche la valeur en pourcentage de la différence entre la valeur la plus récente et la plus ancienne |
| pourcent\$1diff\$1abs | Classique | Affiche la valeur absolue de percent\$1diff |
| count\$1non\$1null | Classique | Affiche le nombre de valeurs du jeu de résultats qui ne sont pas null |
## État d'alerte
Une condition d'alerte est la requête ou l'expression qui détermine si l'alerte se déclenchera ou non en fonction de la valeur qu'elle produit. Il ne peut y avoir qu'une seule condition qui déterminera le déclenchement de l'alerte.
Après avoir défini les and/or expressions de vos requêtes, choisissez l'une d'entre elles comme condition de règle d'alerte.
Lorsque les données demandées répondent à la condition définie, Grafana déclenche l'alerte associée, qui peut être configurée pour envoyer des notifications via différents canaux tels que le courrier électronique, Slack ou. PagerDuty Les notifications vous informent que la condition est remplie, vous permettant de prendre les mesures appropriées ou d'étudier le problème sous-jacent.
Par défaut, la dernière expression ajoutée est utilisée comme condition d'alerte.
## Seuil de récupération
Pour réduire le bruit des alertes, vous pouvez définir un seuil de récupération différent du seuil d'alerte.
Les alertes clignotantes se produisent lorsqu'une métrique passe au-dessus de la condition de seuil d'alerte et peuvent entraîner de fréquents changements d'état, entraînant la génération d'un trop grand nombre de notifications.
Les règles d'alerte gérées par Grafana sont évaluées pour un intervalle de temps spécifique. Lors de chaque évaluation, le résultat de la requête est vérifié par rapport au seuil défini dans la règle d'alerte. Si la valeur d'une métrique est supérieure au seuil, une règle d'alerte est déclenchée et une notification est envoyée. Lorsque la valeur passe en dessous du seuil et qu'une alerte est active pour cette métrique, l'alerte est résolue et une autre notification est envoyée.
Il peut être difficile de créer une règle d'alerte pour une métrique bruyante. C'est-à-dire lorsque la valeur d'une métrique passe continuellement au-dessus et en dessous d'un seuil. Ce phénomène, appelé battement, donne lieu à une série de notifications de déclenchement résolues et à un historique de l'état des alertes bruyantes.
Par exemple, si vous recevez une alerte de latence avec un seuil de 1 000 ms et que le nombre fluctue autour de 1 000 (disons 980 -> 1010 -> 990 -> 1020, etc.), chacune de ces alertes déclenchera une notification.
Pour résoudre ce problème, vous pouvez définir un seuil de récupération (personnalisé), ce qui signifie essentiellement avoir deux seuils au lieu d'un. Une alerte est déclenchée lorsque le premier seuil est franchi et n'est résolue que lorsque le second seuil est franchi.
Par exemple, vous pouvez définir un seuil de 1 000 ms et un seuil de récupération de 900 ms. Ainsi, une règle d'alerte ne cessera de se déclencher que lorsqu'elle passe en dessous de 900 ms et que les battements seront réduits.
# Instances d'alerte
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Les alertes gérées par Grafana prennent en charge les alertes multidimensionnelles. Chaque règle d'alerte peut créer plusieurs instances d'alerte. C'est très utile si vous observez plusieurs séries dans une seule expression.
Considérez l'expression ProMQL suivante :
```
sum by(cpu) (
rate(node_cpu_seconds_total{mode!="idle"}[1m])
)
```
Une règle utilisant cette expression créera autant d'instances d'alerte que le nombre d' CPUs alertes observées après la première évaluation, permettant ainsi à une seule règle de signaler l'état de chaque processeur.
# Espaces de noms, dossiers et groupes
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Les alertes peuvent être organisées à l'aide de dossiers pour les règles gérées par Grafana et d'espaces de noms pour les règles et les noms de groupes Mimir, Loki ou Prometheus.
**Espaces de noms et dossiers**
Lors de la création de règles gérées par Grafana, le dossier peut être utilisé pour contrôler l'accès et accorder ou refuser l'accès à toutes les règles d'un dossier spécifique.
Un espace de noms contient un ou plusieurs groupes. Les règles d'un groupe sont exécutées séquentiellement à intervalles réguliers. L'intervalle par défaut est d'une minute. Vous pouvez renommer les espaces de noms et les groupes de règles Grafana Mimi ou Loki, et modifier les intervalles d'évaluation des groupes.
**Groups** (Groupes)
Les règles d'un groupe sont exécutées séquentiellement à intervalles réguliers, ce qui signifie qu'aucune règle ne sera évaluée en même temps et par ordre d'apparition. L'intervalle par défaut est d'une minute. Vous pouvez renommer les espaces de noms de règles Grafana Mimir ou Loki ou les espaces de noms et groupes de règles Loki, et modifier les intervalles d'évaluation des groupes.
**Astuce**
Si vous souhaitez que les règles soient évaluées simultanément et à des intervalles différents, pensez à les stocker dans différents groupes.
**Note**
Les règles d'alerte gérées par Grafana sont évaluées simultanément plutôt que séquentiellement.
# Évaluation des règles d'alerte
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Utilisez l'évaluation des règles d'alerte pour déterminer à quelle fréquence une règle d'alerte doit être évaluée et à quelle vitesse elle doit changer d'état.
Pour ce faire, vous devez vous assurer que votre règle d'alerte se trouve dans le bon groupe d'évaluation et définir une période d'attente adaptée à votre cas d'utilisation.
## Groupe d'évaluation
Chaque règle d'alerte fait partie d'un groupe d'évaluation. Chaque groupe d'évaluation contient un intervalle d'évaluation qui détermine la fréquence à laquelle la règle d'alerte est vérifiée.
Les règles d'alerte **gérées par les sources de données** au sein d'un même groupe sont évaluées les unes après les autres, tandis que les règles d'alerte des différents groupes peuvent être évaluées simultanément. Cette fonctionnalité est particulièrement utile lorsque vous souhaitez vous assurer que les règles d'enregistrement sont évaluées avant toute règle d'alerte.
Les règles d'alerte **gérées par Grafana** sont évaluées en même temps, quel que soit le groupe de règles d'alerte. L'intervalle d'évaluation par défaut est fixé à 10 secondes, ce qui signifie que les règles d'alerte gérées par Grafana sont évaluées toutes les 10 secondes jusqu'à la fenêtre de 10 secondes la plus proche de l'horloge, par exemple 10:00:00, 10:00:10, 10:00:20, etc. Vous pouvez également configurer votre propre intervalle d'évaluation, si nécessaire.
**Note**
Les groupes d'évaluation et le regroupement des alertes dans les politiques de notification sont deux choses distinctes. Le regroupement dans les politiques de notification permet d'envoyer plusieurs alertes partageant les mêmes étiquettes dans le même message horaire.
## Période d'attente
En définissant une période d'attente, vous pouvez éviter les alertes inutiles en cas de problèmes temporaires.
Pendant la période d'attente, vous sélectionnez la période pendant laquelle une règle d'alerte peut ne pas respecter la condition jusqu'à ce qu'elle se déclenche.
**Exemple**
Imaginez que l'intervalle d'évaluation des règles d'alerte est défini toutes les 30 secondes et que la période d'attente est fixée à 90 secondes.
L'évaluation se déroulera comme suit :
[00:30] Première évaluation - condition non remplie.
[01:00] Deuxième évaluation : violation de la condition. En attente de démarrage du compteur. **L'alerte commence à être en attente.**
[01:30] Troisième évaluation : violation de la condition. Compteur en attente = 30 s. **État en attente.**
[02:00] Quatrième évaluation : violation de la condition. Compteur en attente = 60 s **État en attente.**
[02:30] Cinquième évaluation : violation de la condition. Compteur en attente = 90 s. **L'alerte commence à se déclencher**
Si la règle d'alerte comporte une condition qui doit être enfreinte pendant un certain temps avant d'agir, son état change comme suit :
+ Lorsque la condition est violée pour la première fois, la règle passe à l'état « en attente ».
+ La règle reste dans l'état « en attente » jusqu'à ce que la condition soit rompue pendant la durée requise (période d'attente).
+ Une fois le temps requis écoulé, la règle passe en état de « déclenchement ».
+ Si la condition n'est plus rompue pendant la période d'attente, la règle revient à son état normal.
**Note**
Si vous souhaitez ignorer l'état d'attente, vous pouvez simplement définir la période d'attente sur 0. Cela permet d'ignorer la période d'attente et votre règle d'alerte commence à se déclencher dès que la condition est violée.
Lorsqu'une règle d'alerte est déclenchée, des instances d'alerte sont produites, qui sont ensuite envoyées au gestionnaire d'alertes.
# État et état des règles d'alerte
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
L'état et l'état des règles d'alerte vous aident à comprendre plusieurs indicateurs clés relatifs à l'état de vos alertes.
Il existe trois éléments clés : l'état de la *règle d'alerte, l'état* de *l'instance d'alerte et l'état* de *la règle d'alerte*. Bien que lié, chaque composant transmet des informations subtilement différentes.
**État de la règle d'alerte**
Une règle d'alerte peut avoir l'un des états suivants :
| State | Description |
| --- | --- |
| Normal | Aucune des séries chronologiques renvoyées par le moteur d'évaluation n'est à `Firing` l'état `Pending` or. |
| En attente | Au moins une série chronologique renvoyée par le moteur d'évaluation est`Pending`. |
| Mise à feu | Au moins une série chronologique renvoyée par le moteur d'évaluation est`Firing`. |
**Note**
Les alertes passeront d'abord à `pending` puis`firing`, il faudra donc au moins deux cycles d'évaluation avant qu'une alerte ne soit déclenchée.
**État de l'instance d'alerte**
Une instance d'alerte peut se trouver dans l'un des états suivants :
| State | Description |
| --- | --- |
| Normal | L'état d'une alerte qui n'est ni en cours ni en attente indique que tout fonctionne correctement. |
| En attente | État d'une alerte active pendant une durée inférieure au seuil configuré. |
| Alerte | État d'une alerte active pendant une durée supérieure au seuil configuré. |
| NoData | Aucune donnée n'a été reçue pour la fenêtre horaire configurée. |
| Erreur | Erreur survenue lors de la tentative d'évaluation d'une règle d'alerte. |
**Conserver le dernier état**
Une règle d'alerte peut être configurée pour conserver le dernier état lorsque `NoData` ou le dernier `Error` état est rencontré. Cela empêchera à la fois le déclenchement des alertes, leur résolution et leur réactivation. Tout comme dans le cas d'une évaluation normale, la règle d'alerte passera de `Pending` à une `Firing` fois la période d'attente écoulée.
**État des règles d'alerte**
Une règle d'alerte peut avoir l'un des états de santé suivants :
| State | Description |
| --- | --- |
| Ok | Aucune erreur lors de l'évaluation d'une règle d'alerte. |
| Erreur | Une erreur s'est produite lors de l'évaluation d'une règle d'alerte. |
| NoData | Absence de données dans au moins une série chronologique renvoyée lors de l'évaluation d'une règle. |
**Alertes spéciales pour `NoData` et `Error`**
Lorsque l'évaluation d'une règle d'alerte produit un état `NoData``Error`, Grafana Alerting génère des instances d'alerte portant les étiquettes supplémentaires suivantes :
| Étiquette | Description |
| --- | --- |
| nom de l'alerte | Soit, `DatasourceNoData` soit `DatasourceError` selon l'État. |
| dataource\$1uid | L'UID de la source de données à l'origine de l'état. |
Vous pouvez gérer ces alertes de la même manière que les alertes classiques en ajoutant un silence, un itinéraire vers un point de contact, etc.
# Modèle de notification
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Les notifications envoyées via les points de contact sont créées à l'aide de modèles de notification. Les modèles par défaut de Grafana sont basés sur le [système de modèles Go dans](https://golang.org/pkg/text/template) lequel certains champs sont évalués sous forme de texte, tandis que d'autres sont évalués sous forme de HTML (ce qui peut affecter l'évasion).
Le modèle par défaut [default\$1template.go](https://github.com/grafana/alerting/blob/main/templates/default_template.go) est une référence utile pour les modèles personnalisés.
Comme la plupart des champs des points de contact peuvent être modélisés, vous pouvez créer des modèles personnalisés réutilisables et les utiliser dans plusieurs points de contact. Pour en savoir plus sur les notifications personnalisées à l'aide de modèles, consultez[Personnaliser les notifications](v10-alerting-manage-notifications.md).
**Modèles imbriqués**
Vous pouvez intégrer des modèles dans d'autres modèles.
Par exemple, vous pouvez définir un fragment de modèle à l'aide du `define` mot clé.
```
{{ define "mytemplate" }}
{{ len .Alerts.Firing }} firing. {{ len .Alerts.Resolved }} resolved.
{{ end }}
```
Vous pouvez ensuite intégrer des modèles personnalisés dans ce fragment à l'aide du `template` mot clé. Par exemple :
```
Alert summary:
{{ template "mytemplate" . }}
```
Vous pouvez utiliser l'une des options de modèle intégrées suivantes pour intégrer des modèles personnalisés.
| Nom | Remarques |
| --- | --- |
| `default.title` | Affiche des informations d'état de haut niveau. |
| `default.message` | Fournit un résumé formaté des alertes déclenchées et résolues. |
| `teams.default.message` | Similaire à`default.messsage`, formaté pour Microsoft Teams. |
**HTML dans les modèles de notification**
Le code HTML des modèles de notification d'alerte est évité. Nous ne prenons pas en charge le rendu du code HTML dans la notification qui en résulte.
Certains notificateurs proposent d'autres méthodes pour modifier l'apparence de la notification qui en résulte. Par exemple, Grafana installe le modèle de base pour envoyer des alertes aux e-mails. `/public/emails/ng_alert_notification.html` Vous pouvez modifier ce fichier pour modifier l'apparence de tous les e-mails d'alerte.
# Gestionnaire d'alertes
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Alertmanager vous permet de gérer les alertes et d'y répondre rapidement et efficacement. Il reçoit les alertes, gère les mutings, l'inhibition, le regroupement et le routage en envoyant des notifications via le canal de votre choix, par exemple par e-mail ou Slack.
Dans Grafana, vous pouvez utiliser le Grafana Alertmanager ou un Alertmanager externe. Vous pouvez également exécuter plusieurs gestionnaires d'alertes ; votre décision dépend de votre configuration et de l'endroit où vos alertes sont générées.
**Responsable des alertes Grafana**
Grafana Alertmanager est un gestionnaire d'alertes interne préconfiguré et disponible à la sélection par défaut.
Le Grafana Alertmanager peut recevoir des alertes de Grafana, mais il ne peut pas recevoir d'alertes provenant de l'extérieur de Grafana, par exemple de Mimir ou de Loki.
**Note**
Les règles d'inhibition ne sont pas prises en charge dans le Grafana Alertmanager.
**Gestionnaire d'alertes externe**
Si vous souhaitez utiliser un seul gestionnaire d'alertes pour recevoir toutes vos alertes Grafana, Loki, Mimir et Prometheus, vous pouvez configurer Grafana pour qu'il utilise un Alertmanager externe. Ce gestionnaire d'alertes externe peut être configuré et administré depuis Grafana même.
Voici deux exemples de situations dans lesquelles vous pouvez configurer votre propre gestionnaire d'alertes externe et y envoyer vos alertes au lieu du gestionnaire d'alertes Grafana :
1. Vous disposez déjà de gestionnaires d'alertes sur site dans votre propre infrastructure cloud que vous avez configurée et que vous souhaitez toujours utiliser, car vous disposez d'autres générateurs d'alertes, tels que Prometheus.
1. Vous souhaitez utiliser Prometheus sur site et Grafana hébergé pour envoyer des alertes au même gestionnaire d'alertes qui s'exécute dans votre infrastructure cloud.
Les gestionnaires d'alertes sont visibles dans le menu déroulant des pages Alerte, Points de contact et Politiques de notification.
Si vous approvisionnez votre source de données, définissez l'indicateur `handleGrafanaManagedAlerts` dans le `jsonData` champ sur pour envoyer des alertes gérées par Grafana `true` à ce gestionnaire d'alertes.
# Points de contact
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Les points de contact contiennent la configuration pour envoyer des notifications. Un point de contact est une liste d'intégrations, chacune d'entre elles envoyant une notification à une adresse e-mail, un service ou une URL en particulier. Les points de contact peuvent avoir plusieurs intégrations du même type ou une combinaison d'intégrations de différents types. Par exemple, un point de contact peut contenir une intégration Pagerduty, une intégration Amazon SNS et Slack, ou une intégration Pagerduty, une intégration Slack et deux intégrations Amazon SNS. Vous pouvez également configurer un point de contact sans intégrations ; dans ce cas, aucune notification n'est envoyée.
Un point de contact ne peut pas envoyer de notifications tant qu'il n'a pas été ajouté à une politique de notification. Une politique de notification ne peut envoyer des alertes qu'à un seul point de contact, mais un point de contact peut être ajouté à plusieurs politiques de notification en même temps. Lorsqu'une alerte correspond à une politique de notification, l'alerte est envoyée au point de contact indiqué dans cette politique de notification, qui envoie ensuite une notification à chaque intégration dans sa configuration.
Les points de contact peuvent être configurés pour le Grafana Alertmanager ainsi que pour les alertmanagers externes.
Vous pouvez également utiliser des modèles de notification pour personnaliser les messages de notification en fonction des types de points de contact.
**Types de points de contact pris en charge**
Le tableau suivant répertorie les types de points de contact pris en charge par Grafana.
| Name | Type |
| --- | --- |
| Amazon SNS | `sns` |
| OpsGenie | `opsgenie` |
| Devoir de téléavertisseur | `pagerduty` |
| Slack | `slack` |
| VictorOps | `victorops` |
Pour plus d'informations sur les points de contact, reportez-vous [Configuration des points de contact](v10-alerting-configure-contactpoints.md) aux sections et[Personnaliser les notifications](v10-alerting-manage-notifications.md).
# Notifications
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Choisir comment, quand et où envoyer vos notifications d'alerte est un élément important de la configuration de votre système d'alerte. Ces décisions auront un impact direct sur votre capacité à résoudre les problèmes rapidement et à ne rien manquer d'important.
Dans un premier temps, définissez vos [points de contact](v10-alerting-explore-contacts.md), qui définissent où envoyer vos notifications d'alerte. Un point de contact est un ensemble d'une ou de plusieurs intégrations utilisées pour envoyer des notifications. Ajoutez des modèles de notification aux points de contact afin de les réutiliser et de diffuser des messages cohérents dans vos notifications.
Créez ensuite une politique de notification qui est un ensemble de règles indiquant où, quand et comment vos alertes sont acheminées vers les points de contact. Dans une politique de notification, vous définissez où envoyer vos notifications d'alerte en choisissant l'un des points de contact que vous avez créés.
## Gestionnaires d'alertes
Grafana utilise Alertmanagers pour envoyer des notifications en cas de déclenchement et de résolution d'alertes. **[Grafana possède son propre Alertmanager, appelé Grafana dans l'interface utilisateur, mais prend également en charge l'envoi de notifications depuis d'autres Alertmanagers, tels que le Prometheus Alertmanager.](https://prometheus.io/docs/alerting/latest/alertmanager/)** Le Grafana Alertmanager utilise des politiques de notification et des points de contact pour configurer comment et où une notification est envoyée, à quelle fréquence une notification doit être envoyée et si les alertes doivent toutes être envoyées dans la même notification, envoyées dans des notifications groupées basées sur un ensemble d'étiquettes ou sous forme de notifications distinctes.
## Politiques de notification
Les politiques de notification contrôlent quand et où les notifications sont envoyées. Une politique de notification peut choisir d'envoyer toutes les alertes ensemble dans la même notification, d'envoyer les alertes sous forme de notifications groupées en fonction d'un ensemble d'étiquettes ou d'envoyer des alertes sous forme de notifications distinctes. Vous pouvez configurer chaque politique de notification pour contrôler la fréquence à laquelle les notifications doivent être envoyées, ainsi que pour désactiver les notifications à certains moments de la journée et certains jours de la semaine.
Les politiques de notification sont organisées dans une arborescence où, à la racine de l'arborescence, se trouve une politique de notification appelée politique par défaut. Il ne peut y avoir qu'une seule stratégie par défaut et la stratégie par défaut ne peut pas être supprimée.
Les politiques de routage spécifiques sont dérivées de la politique racine et peuvent être utilisées pour faire correspondre toutes les alertes ou un sous-ensemble d'alertes en fonction d'un ensemble d'étiquettes correspondantes. Une politique de notification correspond à une alerte lorsque ses libellés correspondants correspondent à ceux de l'alerte.
Une politique imbriquée peut avoir ses propres politiques imbriquées, ce qui permet une correspondance supplémentaire des alertes. Par exemple, une politique imbriquée peut être l'envoi d'alertes relatives à l'infrastructure à l'équipe des opérations, tandis qu'une politique secondaire peut envoyer des alertes prioritaires à Pagerduty et des alertes de faible priorité à Slack.
Toutes les alertes, quel que soit leur libellé, sont conformes à la politique par défaut. Toutefois, lorsque la stratégie par défaut reçoit une alerte, elle examine chaque stratégie imbriquée et envoie l'alerte à la première stratégie imbriquée qui correspond à l'alerte. Si la stratégie imbriquée comporte d'autres politiques imbriquées, elle peut tenter de faire correspondre l'alerte à l'une de ses politiques imbriquées. Si aucune politique imbriquée ne correspond à l'alerte, la stratégie elle-même est la stratégie correspondante. S'il n'existe aucune politique imbriquée ou si aucune politique imbriquée ne correspond à l'alerte, la stratégie par défaut est la stratégie correspondante.
Pour des informations plus détaillées sur les politiques de notification, consultez[Politiques de notification](v10-alerting-explore-notifications-policies-details.md).
## Modèles de notification
Vous pouvez personnaliser les notifications à l'aide de modèles. Par exemple, les modèles peuvent être utilisés pour modifier le titre et le message des notifications envoyées à Slack.
Les modèles ne se limitent pas à une intégration ou à un point de contact individuel, mais peuvent être utilisés dans un certain nombre d'intégrations au sein d'un même point de contact et même dans des intégrations entre différents points de contact. Par exemple, un utilisateur de Grafana peut créer un modèle appelé `custom_subject_or_title` et l'utiliser à la fois pour modéliser les sujets dans Pager Duty et les titres des messages Slack sans avoir à créer deux modèles distincts.
Tous les modèles de notifications sont rédigés dans le [langage de modélisation de Go](https://pkg.go.dev/text/template) et se trouvent dans l'onglet Points de contact de la page Alertes.
Pour des informations plus détaillées sur la personnalisation des notifications, consultez[Personnaliser les notifications](v10-alerting-manage-notifications.md).
## Silences
Vous pouvez utiliser les silences pour désactiver les notifications relatives à une ou plusieurs règles de déclenchement. Les silences n'empêchent pas les alertes de se déclencher ou d'être résolues, ni ne masquent les alertes de déclenchement dans l'interface utilisateur. Un silence dure aussi longtemps que sa durée, qui peut être configurée en minutes, heures, jours, mois ou années.
Pour des informations plus détaillées sur l'utilisation des silences, consultez[Désactiver les notifications d'alerte](v10-alerting-silences.md).
# Politiques de notification
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Les politiques de notification vous offrent un moyen flexible d'acheminer les alertes vers différents destinataires. À l'aide des analyseurs d'étiquettes, vous pouvez modifier la diffusion des notifications d'alerte sans avoir à mettre à jour chaque règle d'alerte individuelle.
Dans cette section, vous en apprendrez davantage sur le fonctionnement et la structure des politiques de notification, afin de tirer le meilleur parti de la configuration de vos politiques de notification.
## Arborescence des politiques
Les politiques de notification *ne sont pas* une liste, mais sont structurées selon une structure arborescente. Cela signifie que chaque politique peut comporter des politiques relatives aux enfants, etc. La racine de l'arborescence des politiques de notification s'appelle la **stratégie de notification par défaut**.
Chaque politique consiste en un ensemble de correspondants d'étiquettes (0 ou plus) qui spécifient les étiquettes qu'elles souhaitent ou ne souhaitent pas gérer.
Pour plus d'informations sur la correspondance des étiquettes, consultez[Comment fonctionne la correspondance des étiquettes](v10-alerting-overview-labels-matching.md).
**Note**
Si vous n'avez configuré aucun outil de correspondance d'étiquettes pour votre politique de notification, celle-ci correspondra à *toutes les* instances d'alerte. Cela peut empêcher l'évaluation des politiques relatives aux enfants, sauf si vous avez activé l'option **Continuer à associer les frères et sœurs** dans la politique de notification.
## Routage
Pour déterminer quelle politique de notification gérera quelles instances d'alerte, vous devez commencer par examiner l'ensemble de politiques de notification existant, en commençant par la politique de notification par défaut.
Si aucune politique autre que la stratégie par défaut n'est configurée, la stratégie par défaut gérera l'instance d'alerte.
Si des politiques autres que la politique par défaut sont définies, il évaluera ces politiques de notification dans l'ordre dans lequel elles sont affichées.
Si une politique de notification comporte des indicateurs d'étiquettes qui correspondent aux libellés de l'instance d'alerte, elle passe aux politiques relatives aux enfants et, le cas échéant, continue à rechercher les politiques relatives aux enfants susceptibles d'avoir des critères de correspondance permettant de restreindre davantage le jeu d'étiquettes, et ainsi de suite jusqu'à ce qu'aucune autre politique relative aux enfants ne soit trouvée.
Si aucune politique enfant n'est définie dans une stratégie de notification ou si aucune des politiques enfant ne possède de correspondance d'étiquettes correspondant aux étiquettes de l'instance d'alerte, la stratégie de notification parent est utilisée.
Dès qu'une politique correspondante est trouvée, le système ne continue pas à rechercher d'autres politiques correspondantes. Si vous souhaitez continuer à rechercher d'autres politiques susceptibles de correspondre, activez **Continuer à associer les frères et sœurs à** cette politique en particulier.
Enfin, si aucune des politiques de notification n'est sélectionnée, la politique de notification par défaut est utilisée.
### Exemple de routage
Voici un exemple d'arborescence de politiques de notification relativement simple et de quelques instances d'alerte.
![\[Image illustrant un ensemble de politiques de notification dans une arborescence, ainsi qu'un ensemble d'instances d'alerte avec différentes étiquettes correspondant aux politiques.\]](http://docs.aws.amazon.com/fr_fr/grafana/latest/userguide/images/notification-routing.png)
Voici un aperçu de la manière dont ces politiques sont sélectionnées :
**Pod stuck in CrashLoop** ne possède pas d'`severity`étiquette, donc aucune de ses politiques relatives aux enfants ne correspond. Il possède une `team=operations` étiquette, de sorte que la première politique correspond.
La `team=security` politique n'est pas évaluée car nous avons déjà trouvé une correspondance et l'option **Continuer à faire correspondre les frères et sœurs** n'a pas été configurée pour cette politique.
**Utilisation du disque : 80 %** possèdent à la fois une `severity` étiquette `team` et et correspondent à une politique relative aux enfants définie par l'équipe des opérations.
Une **entrée de journal non autorisée** possède une `team` étiquette mais ne correspond pas à la première politique (`team=operations`) car les valeurs ne sont pas les mêmes. La recherche sera donc poursuivie et correspondra à la `team=security` politique. Il n'a aucune politique relative aux enfants, de sorte que l'`severity=high`étiquette supplémentaire est ignorée.
## Héritage
Outre le fait que les politiques enfants constituent un concept utile pour le routage des instances d'alerte, elles héritent également des propriétés de leur politique parent. Cela s'applique également à toutes les politiques qui sont des politiques secondaires de la politique de notification par défaut.
Les propriétés suivantes sont héritées par les politiques relatives aux enfants :
+ Point de contact
+ Options de regroupement
+ Options de chronométrage
+ Horaire du mode muet
Chacune de ces propriétés peut être remplacée par une politique individuelle si vous souhaitez remplacer les propriétés héritées.
Pour hériter d'un point de contact de la politique parent, laissez ce champ vide. Pour annuler les options de regroupement héritées, activez l'option **Remplacer** le regroupement. Pour annuler les options de chronométrage héritées, activez l'option Annuler **les horaires généraux**.
### Exemple d'héritage
L'exemple ci-dessous montre comment l'arborescence des politiques de notification de notre exemple précédent permet aux politiques enfants du d'`team=operations`hériter de son point de contact.
De cette façon, nous pouvons éviter d'avoir à spécifier plusieurs fois le même point de contact pour chaque politique relative aux enfants.
![\[Image illustrant un ensemble de politiques de notification dans une arborescence, avec des points de contact affectés à certaines politiques, mais certaines politiques relatives aux enfants héritant des points de contact de leurs parents au lieu de définir les leurs.\]](http://docs.aws.amazon.com/fr_fr/grafana/latest/userguide/images/notification-inheritance.png)
## Options de configuration supplémentaires
### Regroupement
Le regroupement est une fonctionnalité importante de Grafana Alerting car il vous permet de regrouper les alertes pertinentes en un plus petit nombre de notifications. Cela est particulièrement important si les notifications sont envoyées aux premiers intervenants, tels que les ingénieurs de garde, où la réception d'un grand nombre de notifications en peu de temps peut être accablante et, dans certains cas, peut avoir un impact négatif sur la capacité des premiers intervenants à répondre à un incident. Par exemple, imaginez une panne importante au cours de laquelle un grand nombre de vos systèmes sont en panne. Dans ce cas, le regroupement peut faire la différence entre la réception d'un appel téléphonique et de 100 appels téléphoniques.
Vous choisissez la manière dont les alertes sont regroupées à l'aide de l'option Regrouper par dans une politique de notification. Par défaut, les politiques de notification de Grafana regroupent les alertes par règle d'alerte en utilisant les `grafana_folder` étiquettes `alertname` et (car les noms des alertes ne sont pas uniques dans plusieurs dossiers). Si vous souhaitez regrouper les alertes selon une autre méthode que la règle d'alerte, remplacez le regroupement par une autre combinaison d'étiquettes.
#### Désactiver le regroupement
Si vous souhaitez recevoir chaque alerte sous forme de notification séparée, vous pouvez le faire en les regroupant par une étiquette spéciale appelée`...`. Cela est utile lorsque vos alertes sont transmises à un système automatisé plutôt qu'à un premier intervenant.
#### Un seul groupe pour toutes les alertes
Si vous souhaitez recevoir toutes les alertes dans une seule notification, vous pouvez le faire en laissant le champ Groupe vide.
### Options de chronométrage
Les options de synchronisation déterminent la fréquence d'envoi des notifications pour chaque groupe d'alertes. Il existe trois minuteries que vous devez connaître : l'attente de groupe, l'intervalle de groupe et l'intervalle de répétition.
#### Attente en groupe
L'attente de groupe est le temps que Grafana attend avant d'envoyer la première notification pour un nouveau groupe d'alertes. Plus l'attente du groupe est longue, plus vous avez de temps pour que les autres alertes arrivent. Plus l'attente du groupe est courte, plus la première notification sera envoyée tôt, mais au risque d'envoyer des notifications incomplètes. Vous devez toujours choisir l'attente de groupe la plus adaptée à votre cas d'utilisation.
**Par défaut** : 30 secondes
#### Intervalle de groupe
Une fois que la première notification a été envoyée pour un nouveau groupe d'alertes, Grafana lance le chronomètre de groupe. Il s'agit du temps que Grafana attend avant d'envoyer des notifications concernant les modifications apportées au groupe. Par exemple, une autre alerte de déclenchement vient peut-être d'être ajoutée au groupe alors qu'une alerte existante a peut-être été résolue. Si une alerte est arrivée trop tard pour être incluse dans la première notification en raison de l'attente du groupe, elle sera incluse dans les notifications suivantes après l'intervalle de groupe. Une fois l'intervalle de groupe écoulé, Grafana réinitialise le temporisateur d'intervalle de groupe. Cela se répète jusqu'à ce qu'il n'y ait plus d'alertes dans le groupe, après quoi le groupe est supprimé.
**Par défaut** : 5 minutes
#### Intervalle de répétition
L'intervalle de répétition détermine la fréquence à laquelle les notifications sont répétées si le groupe n'a pas changé depuis la dernière notification. Vous pouvez les considérer comme des rappels indiquant que certaines alertes sont toujours en cours de déclenchement. L'intervalle de répétition est étroitement lié à l'intervalle de groupe, ce qui signifie que votre intervalle de répétition doit non seulement être supérieur ou égal à l'intervalle de groupe, mais également être un multiple de l'intervalle de groupe. Si l'intervalle de répétition n'est pas un multiple de l'intervalle de groupe, il sera réduit à un. Par exemple, si votre intervalle de groupe est de 5 minutes et que votre intervalle de répétition est de 9 minutes, l'intervalle de répétition sera arrondi au multiple de 5 le plus proche, soit 10 minutes.
**Par défaut** : 4 heures
# Alerter la haute disponibilité
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Amazon Managed Grafana est configuré pour une haute disponibilité, notamment pour exécuter plusieurs instances dans plusieurs zones de disponibilité pour chaque espace de travail que vous créez.
Grafana Alerting utilise le modèle Prometheus qui permet de séparer l'évaluation des règles d'alerte de l'envoi des notifications. Dans ce modèle, l'évaluation des règles d'alerte est effectuée dans le générateur d'alertes et l'envoi des notifications est effectué dans le récepteur d'alertes. Dans Grafana Alerting, le générateur d'alertes est le planificateur et le récepteur est le gestionnaire d'alertes.
Avec les configurations de haute disponibilité, toutes les règles d'alerte sont évaluées sur toutes les instances. Vous pouvez considérer que l'évaluation des règles d'alerte est dupliquée. C'est ainsi que Grafana Alerting garantit que tant qu'au moins une instance Grafana fonctionne, les règles d'alerte seront toujours évaluées et les notifications d'alertes seront toujours envoyées. Vous verrez cette duplication dans l'historique des états, et c'est un bon moyen de savoir si vous utilisez la haute disponibilité.
# Configurer les alertes
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Configurez les fonctionnalités et les intégrations dont vous avez besoin pour créer et gérer vos alertes.
**Conditions préalables**
Avant de configurer les alertes, vous devez effectuer les opérations suivantes.
+ Configurez vos [sources de données](AMG-data-sources.md).
+ Assurez-vous que la source de données que vous choisissez est compatible et prise en charge par les alertes [Grafana](v10-alerting-overview-datasources.md).
**Pour configurer les alertes**
1. Configurez [les règles d'alerte](v10-alerting-configure.md).
+ Créez des règles d'alerte et d'enregistrement gérées par Grafana ou gérées par des sources de données.
1. Configurez les [points de contact](v10-alerting-configure-contactpoints.md).
+ Vérifiez le point de contact par défaut et mettez-le à jour pour votre système.
+ Ajoutez éventuellement de nouveaux points de contact et intégrations.
1. Configuration des [politiques de notification](v10-alerting-explore-notifications-policies-details.md)
+ Vérifiez la politique de notification par défaut et mettez-la à jour pour votre système.
+ Ajoutez éventuellement des politiques imbriquées supplémentaires.
+ Ajoutez éventuellement des étiquettes et des correspondants d'étiquettes pour contrôler le routage des alertes.
Les rubriques suivantes vous fournissent des informations supplémentaires sur les options de configuration supplémentaires, notamment la configuration des gestionnaires d'alertes externes et le routage des alertes gérées par Grafana en dehors de Grafana.
**Topics**
+ [Migration des alertes classiques du tableau de bord vers les alertes Grafana](v10-alerting-use-grafana-alerts.md)
+ [Ajouter un gestionnaire d'alertes externe](v10-alerting-setup-alertmanager.md)
+ [Approvisionnement des ressources d'alerte Grafana](v10-alerting-setup-provision.md)
# Migration des alertes classiques du tableau de bord vers les alertes Grafana
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Les espaces de travail qui choisissent de ne pas utiliser les alertes Grafana utilisent le. [Alertes classiques sur le tableau](old-alerts-overview.md) Pour passer à la nouvelle alerte Grafana, vous devez activer cette fonctionnalité. Pour en savoir plus sur les différences entre les alertes classiques du tableau de bord et les alertes Grafana, voir. [Alertes Grafana et alertes du tableau de bord traditionnel](#v10-alerting-diff-old-new) GrafanaLabs a annoncé que les alertes classiques du tableau de bord seront supprimées dans la version 11.
Lorsque vous utilisez les alertes de tableau de bord classiques, Amazon Managed Grafana vous montre un aperçu des alertes Grafana, dans lequel vous pouvez consulter et modifier vos alertes mises à niveau avant de finaliser la mise à niveau.
## Prévisualisation des alertes Grafana
Vous pouvez prévisualiser vos alertes dans les alertes Grafana avant de procéder à la migration. Dans l'aperçu, vous pouvez apporter des modifications aux alertes qui modifieront la migration.
**Pour prévisualiser votre migration vers les alertes Grafana**
1. Connectez-vous à votre espace de travail Grafana.
1. Dans le menu de gauche, choisissez **Alerting (legacy)** pour afficher vos alertes actuelles.
1. Dans le menu de gauche, choisissez **Mise à niveau des alertes** pour afficher vos alertes dans Grafana Alerting.
Dans cette vue, vous pouvez voir à quoi ressembleront vos alertes après la migration.
**Note**
Dans cette vue, vous pouvez également apporter des modifications qui auront une incidence sur votre migration. Pour annuler les modifications que vous apportez, choisissez **Réinitialiser la mise** à niveau en haut à droite de la page de mise à niveau.
Lorsque vous êtes prêt à mettre à jour vos alertes, consultez la section suivante.
## Migration vers le système d'alerte Grafana
Vous pouvez configurer votre instance Amazon Managed Grafana pour utiliser les alertes Grafana à l'aide de l'API Amazon Managed Grafana AWS CLI ou de l' AWS Management Console API Amazon Managed Grafana. Pour plus d'informations sur la configuration d'Amazon Managed Grafana, notamment sur l'activation ou la désactivation des alertes Grafana, consultez. [Configuration d'un espace de travail Grafana géré par Amazon](AMG-configure-workspace.md)
Lorsque les alertes Grafana sont activées, les alertes de tableau de bord classiques existantes migrent dans un format compatible avec les alertes Grafana. Sur la page d'alerte de votre instance Grafana, vous pouvez consulter les alertes migrées ainsi que les nouvelles alertes. Avec les alertes Grafana, vos règles d'alerte gérées par Grafana envoient plusieurs notifications plutôt qu'une seule alerte lorsqu'elles correspondent.
L'accès en lecture et en écriture aux alertes classiques du tableau de bord et aux alertes Grafana est régi par les autorisations des dossiers qui les stockent. Lors de la migration, les autorisations d'alerte classiques du tableau de bord sont associées aux nouvelles règles, comme suit :
+ Si le tableau de bord de l'alerte d'origine comporte des autorisations, la migration crée un dossier nommé dans ce format `Migrated {"dashboardUid": "UID", "panelId": 1, "alertId": 1}` afin de correspondre aux autorisations du tableau de bord d'origine (y compris les autorisations héritées du dossier).
+ S'il n'existe aucune autorisation de tableau de bord et que le tableau de bord se trouve sous un dossier, la règle est liée à ce dossier et hérite de ses autorisations.
+ S'il n'existe aucune autorisation de tableau de bord et que le tableau de bord se trouve dans le dossier Général, la règle est liée au dossier Alertes générales et la règle hérite des autorisations par défaut.
**Note**
Comme il n'existe aucune `Keep Last State` option d'alerte `NoData` dans Grafana, cette option est utilisée `NoData` lors de la migration classique des règles. L'option `Keep Last State` de `Error` gestion est migrée vers une nouvelle option`Error`. Pour correspondre au comportement du`Keep Last State`, dans les deux cas, pendant la migration, Amazon Managed Grafana crée automatiquement un silence d'une durée d'un an pour chaque règle d'alerte.
Les canaux de notification sont migrés vers une configuration Alertmanager avec les itinéraires et les récepteurs appropriés. Les canaux de notification par défaut sont ajoutés en tant que points de contact à l'itinéraire par défaut. Les canaux de notification qui ne sont associés à aucune alerte du tableau de bord sont affectés à l'`autogen-unlinked-channel-recv`itinéraire.
### Limitations
+ Le système d'alerte Grafana peut récupérer les règles de toutes les sources de données Prometheus, Loki et Alertmanager disponibles. Il se peut qu'il ne soit pas en mesure de récupérer les règles d'alerte à partir d'autres sources de données prises en charge.
+ La migration entre les alertes Grafana et les alertes classiques du tableau de bord peut entraîner une perte de données pour les fonctionnalités prises en charge dans un système, mais pas dans l'autre.
**Note**
Si vous revenez aux alertes classiques du tableau de bord, vous perdez toutes les modifications apportées à la configuration des alertes alors que les alertes Grafana étaient activées, y compris les nouvelles règles d'alerte créées.
## Alertes Grafana et alertes du tableau de bord traditionnel
Introduite dans Grafana 8, l'alerte Grafana présente plusieurs améliorations par rapport aux anciennes alertes du tableau de bord.
### Alertes multidimensionnelles
Vous pouvez désormais créer des alertes qui vous offrent une visibilité à l'échelle du système à l'aide d'une seule règle d'alerte. Générez plusieurs instances d'alerte à partir d'une seule règle d'alerte. Par exemple, vous pouvez créer une règle pour surveiller l'utilisation du disque de plusieurs points de montage sur un même hôte. Le moteur d'évaluation renvoie plusieurs séries chronologiques à partir d'une seule requête, chaque série chronologique étant identifiée par son jeu d'étiquettes.
### Créez des alertes en dehors des tableaux de bord
Contrairement aux anciennes alertes de tableau de bord, les alertes Grafana vous permettent de créer des requêtes et des expressions qui combinent des données provenant de plusieurs sources de manière unique. Vous pouvez toujours associer les tableaux de bord et les panneaux aux règles d'alerte à l'aide de leur identifiant et dépanner rapidement le système observé.
Comme les alertes unifiées ne sont plus directement liées aux requêtes du panel, elles n'incluent pas d'images ni de valeurs de requête dans l'e-mail de notification. Vous pouvez utiliser des modèles de notification personnalisés pour afficher les valeurs des requêtes.
### Création de règles d'alerte pour Loki et Grafana Mimir
Dans Grafana Alerting, vous pouvez gérer les règles d'alerte de Loki et de Grafana Mimir en utilisant la même interface utilisateur et la même API que vos alertes gérées par Grafana.
### Afficher et rechercher des alertes provenant de sources de données compatibles avec Prometheus
Les alertes pour les sources de données compatibles avec Prometheus sont désormais répertoriées dans la section Alertes Grafana. Vous pouvez rechercher des étiquettes dans plusieurs sources de données pour trouver rapidement les alertes pertinentes.
### Alertes spéciales concernant l'état de l'alerte NoData et l'erreur
Grafana Alerting a introduit un nouveau concept des états d'alerte. Lorsque l'évaluation d'une règle d'alerte produit un état NoData ou une erreur, Grafana Alerting génère des alertes spéciales portant les étiquettes suivantes :
+ `alertname`avec une valeur DatasourceNoData ou DatasourceError en fonction de l'état.
+ `rulename`nom de la règle d'alerte à laquelle appartient l'alerte spéciale.
+ `datasource_uid`aura l'UID de la source de données à l'origine de l'état.
+ Toutes les étiquettes et annotations de la règle d'alerte d'origine
Vous pouvez gérer ces alertes de la même manière que les alertes classiques en ajoutant un silence, un itinéraire vers un point de contact, etc.
**Note**
Si la règle utilise de nombreuses sources de données et qu'une ou plusieurs ne renvoient aucune donnée, l'alerte spéciale sera créée pour chaque source de données à l'origine de l'état d'alerte.
# Ajouter un gestionnaire d'alertes externe
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Configurez Grafana pour qu'il utilise un gestionnaire d'alertes externe en tant que gestionnaire d'alertes unique pour recevoir toutes vos alertes. Ce gestionnaire d'alertes externe peut ensuite être configuré et administré depuis Grafana même.
**Note**
Vous ne pouvez pas utiliser Amazon Managed Service for Prometheus en tant que gestionnaire d'alertes externe.
Une fois que vous avez ajouté le gestionnaire d'alertes, vous pouvez utiliser l'interface utilisateur d'alerte de Grafana pour gérer les silences, les points de contact et les politiques de notification. Une option déroulante de ces pages vous permet de passer d'un gestionnaire d'alertes à un autre.
Les gestionnaires d'alertes externes sont configurés en tant que sources de données à l'aide de la configuration de Grafana depuis le menu de navigation principal de Grafana. Cela vous permet de gérer les points de contact et les politiques de notification des gestionnaires d'alertes externes depuis Grafana et de chiffrer les informations d'authentification HTTP de base qui étaient auparavant visibles lors de la configuration des gestionnaires d'alertes externes par URL.
**Note**
À partir de Grafana 9.2, la configuration des URL des gestionnaires d'alertes externes depuis l'onglet Admin de la page d'alerte est obsolète. Il sera supprimé dans une future version.
**Pour ajouter un Alertmanager externe**
1. Choisissez **Connexions** dans le menu principal de gauche.
1. Recherchez `Alertmanager`.
1. Cliquez sur le bouton **Créer une nouvelle source de données**.
1. Remplissez les champs de la page, le cas échéant.
Si vous approvisionnez votre source de données, définissez l'indicateur `handleGrafanaManagedAlerts` dans le `jsonData` champ sur pour envoyer des alertes gérées par Grafana `true` à ce gestionnaire d'alertes.
**Note**
Les implémentations d'Alertmanager par Prometheus, Grafana Mimir et Cortex sont prises en charge. Pour Prometheus, les points de contact et les politiques de notification sont en lecture seule dans l'interface utilisateur de Grafana Alerting.
1. Choisissez **Enregistrer et tester**.
# Approvisionnement des ressources d'alerte Grafana
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
L'infrastructure d'alerte est souvent complexe, de nombreux éléments du pipeline se trouvant souvent à des endroits différents. L'étendre à plusieurs équipes et organisations est une tâche particulièrement difficile. Le provisionnement de Grafana Alerting facilite ce processus en vous permettant de créer, de gérer et de maintenir vos données d'alerte de la manière la mieux adaptée à votre organisation.
Vous avez le choix entre deux options :
1. Approvisionnez vos ressources d'alerte à l'aide de l'API HTTP Alerting Provisioning.
**Note**
En règle générale, vous ne pouvez pas modifier les règles d'alerte configurées par l'API depuis l'interface utilisateur de Grafana.
Pour activer la modification, ajoutez l' x-disable-provenanceen-tête aux demandes suivantes lors de la création ou de la modification de vos règles d'alerte dans l'API :
```
POST /api/v1/provisioning/alert-rules
PUT /api/v1/provisioning/alert-rules/{UID}
```
1. Provisionnez vos ressources d'alerte à l'aide de Terraform.
**Note**
Actuellement, le provisionnement pour Grafana Alerting prend en charge les règles d'alerte, les points de contact, les horaires de mise en sourdine et les modèles. Les ressources d'alerte provisionnées à l'aide du provisionnement de fichiers ou de Terraform ne peuvent être modifiées que dans la source qui les a créées et non à partir de Grafana ou de toute autre source. Par exemple, si vous approvisionnez vos ressources d'alerte à l'aide de fichiers sur disque, vous ne pouvez pas modifier les données dans Terraform ou depuis Grafana.
**Topics**
+ [Créez et gérez des ressources d'alerte à l'aide de Terraform](v10-alerting-setup-provision-terraform.md)
+ [Afficher les ressources d'alerte provisionnées dans Grafana](v10-alerting-setup-provision-view.md)
# Créez et gérez des ressources d'alerte à l'aide de Terraform
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Utilisez le fournisseur Grafana de Terraform pour gérer vos ressources d'alerte et les intégrer à votre système Grafana. Le support des fournisseurs Terraform pour Grafana Alerting facilite la création, la gestion et la maintenance de l'ensemble de votre pile d'alertes Grafana sous forme de code.
Pour plus d'informations sur la gestion de vos ressources d'alerte à l'aide de Terraform, consultez la documentation du [fournisseur](https://registry.terraform.io/providers/grafana/grafana/latest/docs) Grafana dans la documentation Terraform.
Effectuez les tâches suivantes pour créer et gérer vos ressources d'alerte à l'aide de Terraform.
1. Créez une clé d'API pour le provisionnement.
1. Configurez le fournisseur Terraform.
1. Définissez vos ressources d'alerte dans Terraform.
1. Exécutez `terraform apply` pour approvisionner vos ressources d'alerte.
## Conditions préalables
+ Assurez-vous d'avoir le [fournisseur grafana/grafana Terraform](https://registry.terraform.io/providers/grafana/grafana/1.28.0) 1.27.0 ou supérieur.
+ Assurez-vous d'utiliser Grafana 9.1 ou une version ultérieure. Si vous avez créé votre instance Amazon Managed Grafana avec la version 9 de Grafana, cela sera vrai.
## Création d'une clé d'API pour le provisionnement
Vous pouvez [créer une clé d'API Grafana normale](Using-Grafana-APIs.md) pour authentifier Terraform auprès de Grafana. La plupart des outils existants utilisant des clés d'API devraient fonctionner automatiquement avec le nouveau support Grafana Alerting. Pour des informations spécifiques sur la création de clés à utiliser avec Terraform, consultez [Utilisation de Terraform pour l'automatisation d'Amazon Managed](https://aws-observability.github.io/observability-best-practices/recipes/recipes/amg-automation-tf/) Grafana.
**Pour créer une clé d'API pour le provisionnement**
1. Créez un nouveau compte de service pour votre pipeline CI.
1. Attribuez le rôle « Accéder à l'API de provisionnement des règles d'alerte ».
1. Créez un nouveau jeton de compte de service.
1. Nommez et enregistrez le jeton pour l'utiliser dans Terraform.
Vous pouvez également utiliser l'authentification de base. Pour voir tous les formats d'authentification pris en charge, voir [Authentification Grafana](https://registry.terraform.io/providers/grafana/grafana/latest/docs#authentication) dans la documentation Terraform.
## Configurer le fournisseur Terraform
[Le support Grafana Alerting est inclus dans le fournisseur Grafana Terraform.](https://registry.terraform.io/providers/grafana/grafana/latest/docs)
Voici un exemple que vous pouvez utiliser pour configurer le fournisseur Terraform.
```
terraform {
required_providers {
grafana = {
source = "grafana/grafana"
version = ">= 1.28.2"
}
}
}
provider "grafana" {
url =
auth =
}
```
## Fournir des points de contact et des modèles
Les points de contact relient une pile d'alertes au monde extérieur. Ils indiquent à Grafana comment se connecter à vos systèmes externes et où envoyer les notifications. Vous avez le choix entre plus de quinze [intégrations](https://registry.terraform.io/providers/grafana/grafana/latest/docs/resources/contact_point#optional) différentes. Cet exemple utilise un point de contact Slack.
**Pour fournir des points de contact et des modèles**
1. Copiez ce bloc de code dans un fichier .tf sur votre machine locale. **Remplacez-le par l'URL de votre webhook Slack (ou d'autres informations de point de contact).
Cet exemple crée un point de contact qui envoie des notifications d'alerte à Slack.
```
resource "grafana_contact_point" "my_slack_contact_point" {
name = "Send to My Slack Channel"
slack {
url =
text = <
Les politiques de notification indiquent à Grafana comment acheminer les instances d'alerte, et non leur localisation. Ils connectent les alertes de tir à vos points de contact préalablement définis à l'aide d'un système d'étiquettes et de matchers.
**Pour configurer les politiques de notification et le routage**
1. Copiez ce bloc de code dans un fichier .tf sur votre machine locale.
Dans cet exemple, les alertes sont regroupées par`alertname`, ce qui signifie que toutes les notifications provenant d'alertes portant le même nom sont regroupées dans le même message Slack.
Si vous souhaitez acheminer des notifications spécifiques différemment, vous pouvez ajouter des sous-politiques. Les sous-politiques vous permettent d'appliquer un routage à différentes alertes en fonction de la correspondance des étiquettes. Dans cet exemple, nous appliquons une temporisation muette à toutes les alertes portant le label a=b.
```
resource "grafana_notification_policy" "my_policy" {
group_by = ["alertname"]
contact_point = grafana_contact_point.my_slack_contact_point.name
group_wait = "45s"
group_interval = "6m"
repeat_interval = "3h"
policy {
matcher {
label = "a"
match = "="
value = "b"
}
group_by = ["..."]
contact_point = grafana_contact_point.a_different_contact_point.name
mute_timings = [grafana_mute_timing.my_mute_timing.name]
policy {
matcher {
label = "sublabel"
match = "="
value = "subvalue"
}
contact_point = grafana_contact_point.a_third_contact_point.name
group_by = ["..."]
}
}
}
```
1. Dans le champ mute\$1timings, associez une temporisation muette à votre politique de notification.
1. Exécutez la commande `terraform apply`.
1. Accédez à l'interface utilisateur de Grafana et vérifiez les détails de votre politique de notification.
**Note**
Vous ne pouvez pas modifier les ressources fournies par Terraform depuis l'interface utilisateur. Cela garantit que votre pile d'alertes reste toujours synchronisée avec votre code.
1. Cliquez sur **Tester** pour vérifier que le point de notification fonctionne correctement.
## Provisionner les horaires de mise en sourdine
Les horaires de mise en sourdine permettent de désactiver les notifications d'alerte pendant des périodes définies.
**Pour configurer les horaires de mise en sourdine**
1. Copiez ce bloc de code dans un fichier .tf sur votre machine locale.
Dans cet exemple, les notifications d'alerte sont désactivées le week-end.
```
resource "grafana_mute_timing" "my_mute_timing" {
name = "My Mute Timing"
intervals {
times {
start = "04:56"
end = "14:17"
}
weekdays = ["saturday", "sunday", "tuesday:thursday"]
months = ["january:march", "12"]
years = ["2025:2027"]
}
}
```
1. Exécutez la commande `terraform apply`.
1. Accédez à l'interface utilisateur de Grafana et vérifiez les détails de votre temps de sourdine.
1. Référencez le délai de mise en sourdine que vous venez de créer dans une politique de notification à l'aide du `mute_timings` champ. Cela appliquera votre temps de sourdine à certaines ou à toutes vos notifications.
**Note**
Vous ne pouvez pas modifier les ressources fournies par Terraform depuis l'interface utilisateur. Cela garantit que votre pile d'alertes reste toujours synchronisée avec votre code.
1. Cliquez sur **Tester** pour vérifier que le temps de sourdine fonctionne correctement.
## Règles d'alerte relatives aux approvisionnements
[Les règles d'alerte](v10-alerting-configure.md) vous permettent d'émettre des alertes concernant n'importe quelle source de données Grafana. Il peut s'agir d'une source de données que vous avez déjà configurée, ou vous pouvez [définir vos sources de données dans Terraform](https://registry.terraform.io/providers/grafana/grafana/latest/docs/resources/data_source) parallèlement à vos règles d'alerte.
**Pour configurer des règles d'alerte**
1. Créez une source de données à interroger et un dossier dans lequel stocker vos règles.
Dans cet exemple, la source de [Configuration d'une source TestData de données à des fins de test](testdata-data-source.md) données est utilisée.
Les alertes peuvent être définies par rapport à n'importe quelle source de données principale dans Grafana.
```
resource "grafana_data_source" "testdata_datasource" {
name = "TestData"
type = "testdata"
}
resource "grafana_folder" "rule_folder" {
title = "My Rule Folder"
}
```
1. Définissez une règle d'alerte.
Pour plus d'informations sur les règles d'alerte, reportez-vous à la section [Comment créer des alertes gérées par Grafana.](https://grafana.com/blog/2022/08/01/grafana-alerting-video-how-to-create-alerts-in-grafana-9/)
1. Créez un groupe de règles contenant une ou plusieurs règles.
Dans cet exemple, le groupe de `grafana_rule_group` ressources est utilisé.
```
resource "grafana_rule_group" "my_rule_group" {
name = "My Alert Rules"
folder_uid = grafana_folder.rule_folder.uid
interval_seconds = 60
org_id = 1
rule {
name = "My Random Walk Alert"
condition = "C"
for = "0s"
// Query the datasource.
data {
ref_id = "A"
relative_time_range {
from = 600
to = 0
}
datasource_uid = grafana_data_source.testdata_datasource.uid
// `model` is a JSON blob that sends datasource-specific data.
// It's different for every datasource. The alert's query is defined here.
model = jsonencode({
intervalMs = 1000
maxDataPoints = 43200
refId = "A"
})
}
// The query was configured to obtain data from the last 60 seconds. Let's alert on the average value of that series using a Reduce stage.
data {
datasource_uid = "__expr__"
// You can also create a rule in the UI, then GET that rule to obtain the JSON.
// This can be helpful when using more complex reduce expressions.
model = <
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Vous pouvez vérifier que vos ressources d'alerte ont été créées dans Grafana.
**Pour consulter vos ressources approvisionnées dans Grafana**
1. Ouvrez votre instance Grafana.
1. Accédez à Alertes.
1. Cliquez sur un dossier de ressources d'alerte, par exemple, Règles d'alerte.
Les ressources provisionnées sont étiquetées **Provisioned**, de sorte qu'il est clair qu'elles n'ont pas été créées manuellement.
**Note**
Vous ne pouvez pas modifier les ressources provisionnées depuis Grafana. Vous ne pouvez modifier les propriétés des ressources qu'en modifiant le fichier de provisionnement et en redémarrant Grafana ou en effectuant un rechargement à chaud. Cela empêche les modifications apportées à la ressource qui seraient remplacées si un fichier était à nouveau provisionné ou si un rechargement à chaud était effectué.
# Configuration des alertes
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Configurez les fonctionnalités et les intégrations dont vous avez besoin pour créer et gérer vos alertes.
**Topics**
+ [Configurer les règles d'alerte gérées par Grafana](v10-alerting-configure-grafanamanaged.md)
+ [Configuration des règles d'alerte gérées par les sources de données](v10-alerting-configure-datasourcemanaged.md)
+ [Configuration des règles d'enregistrement](v10-alerting-configure-recordingrules.md)
+ [Configuration des points de contact](v10-alerting-configure-contactpoints.md)
+ [Configuration des politiques de notification](v10-alerting-configure-notification-policies.md)
# Configurer les règles d'alerte gérées par Grafana
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Les règles gérées par Grafana constituent le type de règle d'alerte le plus flexible. Ils vous permettent de créer des alertes qui peuvent agir sur les données provenant de l'une de nos sources de données prises en charge. Outre la prise en charge de plusieurs sources de données, vous pouvez également ajouter des expressions pour transformer vos données et définir des conditions d'alerte. L'utilisation d'images dans les notifications d'alerte est également prise en charge. Il s'agit du seul type de règle qui permet d'émettre des alertes à partir de plusieurs sources de données dans une seule définition de règle.
Plusieurs instances d'alerte peuvent être créées à la suite d'une seule règle d'alerte (également appelée alerte multidimensionnelle).
Les règles d'alerte gérées par Grafana ne peuvent être modifiées ou supprimées que par les utilisateurs disposant d'autorisations de modification pour le dossier contenant les règles.
Si vous supprimez une ressource d'alerte créée dans l'interface utilisateur, vous ne pouvez plus la récupérer. Pour effectuer une sauvegarde de votre configuration et pouvoir restaurer les ressources d'alerte supprimées, créez vos ressources d'alerte à l'aide de Terraform ou de l'API d'alerte.
Dans les procédures suivantes, nous allons passer en revue le processus de création de vos règles d'alerte gérées par Grafana.
Pour créer une règle d'alerte gérée par Grafana, utilisez le flux de création d'alertes intégré à l'espace de travail et suivez ces étapes pour vous aider.
**Définir le nom de la règle d'alerte**
1. Choisissez **Alerte** -> **Règles d'alerte** -> **\$1 Nouvelle règle d'alerte**.
1. Entrez un nom pour identifier votre règle d'alerte.
Ce nom est affiché dans la liste des règles d'alerte. Il s'agit également de l'`alertname`étiquette de chaque instance d'alerte créée à partir de cette règle.
Définissez ensuite une requête pour obtenir les données que vous souhaitez mesurer et une condition qui doit être remplie avant qu'une règle d'alerte ne soit déclenchée.
**Pour définir la requête et la condition**
1. Sélectionnez une source de données.
1. Dans le menu déroulant **Options**, spécifiez une [plage de temps](v10-dash-using-dashboards.md#v10-dash-setting-dashboard-time-range).
**Note**
Grafana Alerting ne prend en charge que des plages de temps relatives fixes, par exemple. `now-24hr: now`
Il ne prend pas en charge les plages de temps absolues : `2021-12-02 00:00:00 to 2021-12-05 23:59:592` ou les plages de temps semi-relatives :`now/d to: now`.
1. Ajoutez une requête.
Pour ajouter plusieurs [requêtes](v10-panels-query-xform.md#v10-panels-query-xform-add), choisissez **Ajouter une requête**.
Toutes les règles d'alerte sont gérées par Grafana par défaut. Si vous souhaitez passer à une règle d'alerte gérée par source de données, cliquez sur **Basculer vers une règle d'alerte gérée par source de données.**
1. Ajoutez une ou plusieurs [expressions](v10-panels-query-xform-expressions.md).
1. Pour chaque expression, sélectionnez soit la **condition classique** pour créer une règle d'alerte unique, soit les options **Mathématiques**, **Réduire** et **Rééchantillonner** pour générer une alerte distincte pour chaque série.
**Note**
Lorsque vous utilisez Prometheus, vous pouvez utiliser un vecteur instantané et des fonctions intégrées, vous n'avez donc pas besoin d'ajouter d'expressions supplémentaires.
1. Choisissez **Aperçu** pour vérifier que l'expression est réussie.
1. [Facultatif] Pour ajouter un seuil de récupération, activez l'option **Seuil de récupération personnalisé** et saisissez une valeur indiquant à quel moment votre règle d'alerte doit cesser de se déclencher.
Vous ne pouvez ajouter qu'un seul seuil de récupération dans une requête et il doit s'agir de la condition d'alerte.
1. Choisissez **Définir comme condition d'alerte** sur la requête ou l'expression que vous souhaitez définir comme condition d'alerte.
Utilisez l'évaluation des règles d'alerte pour déterminer à quelle fréquence une règle d'alerte doit être évaluée et à quelle vitesse elle doit changer d'état.
Pour ce faire, vous devez vous assurer que votre règle d'alerte se trouve dans le bon groupe d'évaluation et définir une période d'attente adaptée à votre cas d'utilisation.
**Pour définir le comportement d'évaluation des alertes**
1. Sélectionnez un dossier ou choisissez **\$1 Nouveau dossier**.
1. Sélectionnez un groupe d'évaluation ou cliquez sur **\$1 Nouveau groupe d'évaluation**.
Si vous créez un nouveau groupe d'évaluation, spécifiez l'intervalle pour le groupe.
Toutes les règles d'un même groupe sont évaluées simultanément sur le même intervalle de temps.
1. Entrez une période d'attente.
La période d'attente est la période pendant laquelle une règle d'alerte peut enfreindre la condition jusqu'à ce qu'elle se déclenche.
Une fois qu'une condition est remplie, l'alerte passe à l'état **En attente**. Si la condition reste active pendant la durée spécifiée, l'alerte passe à l'état de **déclenchement**, sinon elle revient à l'état **normal**.
1. Activez les notifications d'alerte de pause, si nécessaire.
**Note**
Suspendez l'évaluation des règles d'alerte pour éviter les alertes bruyantes lors du réglage de vos alertes. La pause arrête l'évaluation des règles d'alerte et ne crée aucune instance d'alerte. Cela est différent des délais de mise en sourdine, qui interrompent l'envoi des notifications, tout en permettant l'évaluation des règles d'alerte et la création d'instances d'alerte.
Vous pouvez suspendre l'évaluation des règles d'alerte pour éviter les alertes bruyantes lors du réglage de vos alertes. La pause arrête l'évaluation des règles d'alerte et ne crée aucune instance d'alerte. Cela est différent des délais de mise en sourdine, qui interrompent l'envoi des notifications, tout en permettant l'évaluation des règles d'alerte et la création d'instances d'alerte.
1. Dans **Configurer l'absence de données et la gestion des erreurs**, configurez le comportement des alertes en l'absence de données.
Utilisez les directives présentées plus loin dans cette section.
Ajoutez des libellés à vos règles d'alerte pour définir la politique de notification qui doit gérer vos instances d'alerte de déclenchement.
Toutes les règles et instances d'alerte, quel que soit leur libellé, correspondent à la politique de notification par défaut. S'il n'existe aucune politique imbriquée ou si aucune politique imbriquée ne correspond aux libellés de la règle d'alerte ou de l'instance d'alerte, la stratégie de notification par défaut est la stratégie correspondante.
**Pour configurer des notifications**
1. Ajoutez des libellés si vous souhaitez modifier le mode d'acheminement de vos notifications.
Ajoutez des étiquettes personnalisées en sélectionnant des paires clé-valeur existantes dans le menu déroulant, ou ajoutez de nouvelles étiquettes en saisissant la nouvelle clé ou valeur.
1. Prévisualisez la configuration du routage de votre instance d'alerte.
Sur la base des étiquettes ajoutées, les instances d'alerte sont acheminées vers les politiques de notification affichées.
Développez chaque politique de notification pour afficher plus de détails.
1. Choisissez **Voir les détails** pour afficher les détails du routage des alertes et un aperçu.
Ajoutez [des annotations](v10-alerting-overview-labels.md#v10-alerting-overview-labels-annotations) pour fournir plus de contexte sur l'alerte dans votre message de notification d'alerte.
Les annotations ajoutent des métadonnées pour fournir plus d'informations sur l'alerte dans votre message de notification d'alerte. Par exemple, ajoutez une annotation **récapitulative** pour vous indiquer la valeur à l'origine du déclenchement de l'alerte ou le serveur sur lequel elle s'est produite.
**Pour ajouter des annotations**
1. [Facultatif] Ajoutez un résumé.
Bref résumé de ce qui s'est passé et pourquoi.
1. [Facultatif] Ajoutez une description.
Description de l'action de la règle d'alerte.
1. [Facultatif] Ajoutez une URL Runbook.
Page Web où vous conservez votre runbook pour l'alerte
1. [Facultatif] Ajouter une annotation personnalisée
1. [Facultatif] Ajoutez un tableau de bord et un lien vers un panneau.
Lie les alertes aux panneaux d'un tableau de bord.
1. Choisissez **Enregistrer la règle**.
**Règle unique et multidimensionnelle**
Pour les alertes gérées par Grafana, vous pouvez créer une règle avec une condition classique ou vous pouvez créer une règle multidimensionnelle.
+ **Règle avec condition classique**
Utilisez l'expression de condition classique pour créer une règle qui déclenche une seule alerte lorsque sa condition est remplie. Pour une requête qui renvoie plusieurs séries, Grafana ne suit pas l'état d'alerte de chaque série. Grafana n'envoie donc qu'une seule alerte, même lorsque les conditions d'alerte sont remplies pour plusieurs séries.
+ **Règle multidimensionnelle**
Pour générer une alerte distincte pour chaque série, créez une règle multidimensionnelle. Utilisez `Math``Reduce`, ou `Resample` expressions pour créer une règle multidimensionnelle. Par exemple :
+ Ajoutez une `Reduce` expression pour chaque requête afin d'agréger les valeurs de la plage de temps sélectionnée en une seule valeur (inutile pour les [règles utilisant des données numériques](v10-alerting-overview-numeric.md)).
+ Ajoutez une `Math` expression avec la condition de la règle. Inutile dans le cas où une requête ou une expression de réduction renvoie déjà `0` si la règle ne doit pas être déclenchée, ou un nombre positif si elle doit se déclencher. Quelques exemples : `$B > 70` s'il doit se déclencher si la valeur de B query/expression est supérieure à 70. `$B < $C * 100`au cas où il devrait se déclencher si la valeur de B est inférieure à la valeur de C multipliée par 100. Si les requêtes comparées contiennent plusieurs séries dans leurs résultats, les séries issues de différentes requêtes sont mises en correspondance si elles ont les mêmes étiquettes ou si l'une est un sous-ensemble de l'autre.
**Note**
Grafana ne prend pas en charge les requêtes d'alerte avec des variables de modèle. De plus amples informations sont disponibles sur [https://comtemplate-variables-are-notmunity.grafana.com/t/](https://community.grafana.com/t/template-variables-are-not-supported-in-alert-queries-while-setting-up-alert/2514) - - /2514. supported-in-alert-queries while-setting-up-alert
**Configuration de l'absence de données et de la gestion des erreurs**
Configurez le comportement des alertes lorsque l'évaluation de vos règles d'alerte ne renvoie aucune donnée ou une erreur.
**Note**
Les règles d'alerte configurées pour se déclencher lorsqu'une évaluation ne renvoie aucune donnée ou qu'une erreur ne s'affichent que lorsque toute la durée de la période d'évaluation est terminée. Cela signifie qu'au lieu de se déclencher immédiatement lorsque la condition de la règle d'alerte est violée, la règle d'alerte attend que l'heure définie pour le champ **Pour** soit terminée, puis se déclenche, ce qui réduit le bruit des alertes et permet de résoudre des problèmes temporaires de disponibilité des données.
Si l'évaluation de votre règle d'alerte ne renvoie aucune donnée, vous pouvez définir l'état de votre règle d'alerte pour qu'il apparaisse comme suit :
| Aucune donnée | Description |
| --- | --- |
| Aucune donnée | Crée une nouvelle alerte DatasourceNoData avec le nom et l'UID de la règle d'alerte, ainsi que l'UID de la source de données qui n'a renvoyé aucune donnée sous forme d'étiquette. |
| Alerte | Définit l'état de la règle d'alerte surAlerting. La règle d'alerte attend la fin de l'heure définie dans le champ Pour avant de tirer. |
| Ok | Définit l'état de la règle d'alerte surNormal. |
Si votre évaluation renvoie une erreur, vous pouvez définir l'état de votre règle d'alerte pour qu'il apparaisse comme suit :
| Erreur | Description |
| --- | --- |
| Erreur | Crée une instance d'alerte DatasourceError avec le nom et l'UID de la règle d'alerte, ainsi que l'UID de la source de données qui n'a renvoyé aucune donnée sous forme d'étiquette. |
| Alerte | Définit l'état de la règle d'alerte surAlerting. La règle d'alerte attend la fin de l'heure définie dans le champ Pour avant de tirer. |
| Ok | Définit l'état de la règle d'alerte surNormal. |
**Résoudre les instances d'alerte obsolètes**
Une instance d'alerte est considérée comme obsolète si sa dimension ou sa série a complètement disparu des résultats de la requête pendant deux intervalles d'évaluation.
Les instances d'alerte périmées qui sont dans l'`Error`état `Alerting``NoData`//sont automatiquement marquées comme `Resolved` et l'`grafana_state_reason`annotation est ajoutée à l'instance d'alerte avec le motif`MissingSeries`.
**Créez des alertes à partir de panneaux**
Créez des alertes à partir de n'importe quel type de panneau. Cela signifie que vous pouvez réutiliser les requêtes du panneau et créer des alertes en fonction de celles-ci.
1. Accédez à un tableau de bord dans la section **Tableaux de bord**.
1. Dans le coin supérieur droit du panneau, choisissez les trois points (ellipses).
1. Dans le menu déroulant, sélectionnez **Plus...** puis choisissez **Nouvelle règle d'alerte**.
Cela ouvrira le formulaire des règles d'alerte, vous permettant de configurer et de créer votre alerte en fonction de la requête du panneau actuel.
# Configuration des règles d'alerte gérées par les sources de données
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Créez des règles d'alerte pour une instance externe de Grafana Mimir ou Loki sur laquelle l'API Ruler est activée ; ces règles sont appelées règles d'alerte gérées par source de données.
**Note**
Les règles d'alerte pour une instance externe de Grafana Mimir ou Loki peuvent être modifiées ou supprimées par les utilisateurs ayant des rôles d'éditeur ou d'administrateur.
Si vous supprimez une ressource d'alerte créée dans l'interface utilisateur, vous ne pouvez plus la récupérer. Pour effectuer une sauvegarde de votre configuration et pouvoir restaurer les ressources d'alerte supprimées, créez vos ressources d'alerte à l'aide de Terraform ou de l'API d'alerte.
**Conditions préalables**
+ Vérifiez que vous disposez d'une autorisation d'écriture sur la source de données Prometheus ou Loki. Sinon, vous ne pourrez pas créer ou mettre à jour les règles d'alerte gérées par Grafana Mimir.
+ Pour les sources de données Grafana Mimir et Loki, activez l'API Ruler en configurant leurs services respectifs.
+ **Loki** - Le type de stockage des `local` règles, par défaut pour la source de données Loki, prend uniquement en charge l'affichage des règles. Pour modifier les règles, configurez l'un des autres types de stockage de règles.
+ **Grafana Mimir** - utilise le préfixe. `/prometheus` [https://grafana.com/docs/mimir/latest/operators-guide/reference-http-api/#querier--query-frontend](https://grafana.com/docs/mimir/latest/operators-guide/reference-http-api/#querier--query-frontend) Vous ne pouvez pas fournir d'URL distincte pour l'API Ruler.
**Note**
Si vous ne souhaitez pas gérer les règles d'alerte pour une source de données Loki ou Prometheus en particulier, accédez à ses paramètres et décochez la case **Gérer les alertes via l'interface utilisateur** d'alerte.
Dans les procédures suivantes, nous vous guiderons tout au long du processus de création de vos règles d'alerte gérées par les sources de données.
Pour créer une règle d'alerte gérée par une source de données, utilisez le flux de création d'alertes intégré à l'espace de travail et suivez ces étapes pour vous aider.
**Pour définir le nom de la règle d'alerte**
1. Choisissez **Alerte** -> **Règles d'alerte** -> **\$1 Nouvelle règle d'alerte**.
1. Entrez un nom pour identifier votre règle d'alerte.
Ce nom est affiché dans la liste des règles d'alerte. Il s'agit également de l'`alertname`étiquette de chaque instance d'alerte créée à partir de cette règle.
Définissez une requête pour obtenir les données que vous souhaitez mesurer et une condition qui doit être remplie avant qu'une règle d'alerte ne soit déclenchée.
**Pour définir la requête et la condition**
1. Toutes les règles d'alerte sont gérées par Grafana par défaut. Pour passer à une règle d'alerte gérée par source de données, choisissez **Basculer vers une règle d'alerte gérée par source de données**.
1. Sélectionnez une source de données dans la liste déroulante.
Vous pouvez également choisir **Ouvrir le sélecteur de source de données avancé** pour voir d'autres options, notamment l'ajout d'une source de données (administrateurs uniquement).
1. Entrez une requête ProMQL ou LogQL.
1. Choisissez **Aperçu des alertes**.
Utilisez l'évaluation des règles d'alerte pour déterminer à quelle fréquence une règle d'alerte doit être évaluée et à quelle vitesse elle doit changer d'état.
**Pour définir le comportement d'évaluation des alertes**
1. Sélectionnez un espace de noms ou choisissez **\$1 Nouvel espace de noms**.
1. Sélectionnez un groupe d'évaluation ou choisissez **\$1 Nouveau groupe d'évaluation**.
Si vous créez un nouveau groupe d'évaluation, spécifiez l'intervalle pour le groupe.
Toutes les règles d'un même groupe sont évaluées séquentiellement sur le même intervalle de temps.
1. Entrez une période d'attente.
La période d'attente est la période pendant laquelle une règle d'alerte peut enfreindre la condition jusqu'à ce qu'elle se déclenche.
Une fois qu'une condition est remplie, l'alerte passe à l'`Pending`état. Si la condition reste active pendant la durée spécifiée, l'alerte passe à l'`Firing`état, sinon elle revient à l'`Normal`état.
Ajoutez des libellés à vos règles d'alerte pour définir la politique de notification qui doit gérer vos instances d'alerte de déclenchement.
Toutes les règles et instances d'alerte, quel que soit leur libellé, correspondent à la politique de notification par défaut. S'il n'existe aucune politique imbriquée ou si aucune politique imbriquée ne correspond aux libellés de la règle d'alerte ou de l'instance d'alerte, la stratégie de notification par défaut est la stratégie correspondante.
**Configuration des notifications**
+ Ajoutez des libellés si vous souhaitez modifier le mode d'acheminement de vos notifications.
Ajoutez des étiquettes personnalisées en sélectionnant des paires clé-valeur existantes dans le menu déroulant, ou ajoutez de nouvelles étiquettes en saisissant la nouvelle clé ou valeur.
Ajoutez [des annotations](v10-alerting-overview-labels.md#v10-alerting-overview-labels-annotations) pour fournir plus de contexte sur l'alerte dans vos notifications d'alerte.
Les annotations ajoutent des métadonnées pour fournir plus d'informations sur l'alerte dans vos notifications d'alerte. Par exemple, ajoutez une `Summary` annotation pour vous indiquer quelle valeur a provoqué le déclenchement de l'alerte ou sur quel serveur elle s'est produite.
**Pour ajouter des annotations**
1. [Facultatif] Ajoutez un résumé.
Bref résumé de ce qui s'est passé et pourquoi.
1. [Facultatif] Ajoutez une description.
Description de l'action de la règle d'alerte.
1. [Facultatif] Ajoutez une URL Runbook.
Page Web où vous conservez votre runbook pour l'alerte
1. [Facultatif] Ajouter une annotation personnalisée
1. [Facultatif] Ajoutez un tableau de bord et un lien vers un panneau.
Lie les alertes aux panneaux d'un tableau de bord.
1. Choisissez **Enregistrer la règle**.
# Configuration des règles d'enregistrement
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Vous pouvez créer et gérer des règles d'enregistrement pour une instance externe de Grafana Mimir ou Loki. Les règles d'enregistrement calculent à l'avance les expressions fréquemment nécessaires ou les expressions coûteuses en termes de calcul et enregistrent le résultat sous la forme d'un nouvel ensemble de séries chronologiques. L'interrogation de cette nouvelle série chronologique est plus rapide, en particulier pour les tableaux de bord, car ils demandent la même expression à chaque actualisation des tableaux de bord.
**Note**
Les règles d'enregistrement sont exécutées en tant que règles d'instance et exécutées toutes les 10 secondes.
**Conditions préalables**
+ Vérifiez que vous disposez des autorisations d'écriture sur la source de données Prometheus ou Loki. Vous allez créer ou mettre à jour des règles d'alerte dans votre source de données.
+ Pour les sources de données Grafana Mimir et Loki, activez l'API Ruler en configurant leurs services respectifs.
+ **Loki** — Le type de stockage des `local` règles, par défaut pour la source de données Loki, prend uniquement en charge l'affichage des règles. Pour modifier les règles, configurez l'un des autres types de stockage.
+ **Grafana Mimir** — Utilisez le préfixe. `/prometheus` La source de données Prometheus prend en charge Grafana Mimir et Prometheus, et Grafana s'attend à ce que l'API Query et l'API Ruler se trouvent sous la même URL. Vous ne pouvez pas fournir d'URL distincte pour l'API Ruler.
**Note**
Si vous ne souhaitez pas gérer les règles d'alerte pour une source de données Loki ou Prometheus en particulier, accédez à ses paramètres et décochez la case **Gérer les alertes** via l'interface utilisateur d'alerte.
**Pour créer des règles d'enregistrement**
1. **Depuis votre console Grafana, dans le menu Grafana, choisissez **Alerting, Alert** rules.**
1. Choisissez **Nouvelle règle d'enregistrement**.
1. Définissez le nom de la règle.
Le nom de la règle d'enregistrement doit être un nom de métrique Prometheus et ne contenir aucun espace.
1. Définir la requête
+ Sélectionnez votre source de données Loki ou Prometheus.
+ Saisissez une requête.
1. Ajoutez un espace de noms et un groupe.
+ Dans le menu déroulant **Namespace**, sélectionnez un espace de noms de règles existant ou ajoutez-en un nouveau. Les espaces de noms peuvent contenir un ou plusieurs groupes de règles et n'ont qu'un objectif organisationnel.
+ Dans le menu déroulant **Groupe**, sélectionnez un groupe existant dans l'espace de noms sélectionné ou ajoutez-en un nouveau. Les règles nouvellement créées sont ajoutées à la fin du groupe. Les règles d'un groupe sont exécutées séquentiellement à intervalles réguliers, avec le même temps d'évaluation.
1. Ajoutez des étiquettes.
+ Ajoutez des étiquettes personnalisées en sélectionnant les paires clé-valeur existantes dans la liste déroulante, ou ajoutez de nouvelles étiquettes en saisissant la nouvelle clé ou valeur.
1. Choisissez **Enregistrer la règle** pour enregistrer la règle, ou **Enregistrer la règle et quitter** pour enregistrer la règle et revenir à la page d'alerte.
# Configuration des points de contact
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Utilisez les points de contact pour définir la manière dont vos contacts sont avertis lorsqu'une règle d'alerte est déclenchée.
**Note**
Vous pouvez créer et modifier des points de contact pour les alertes gérées par Grafana. Les points de contact pour les alertes gérées par les sources de données sont en lecture seule.
## Travailler avec les points de contact
Les procédures suivantes indiquent comment ajouter, modifier, supprimer et tester un point de contact.
**Pour ajouter un point de contact**
1. Dans le menu de gauche, choisissez **Alerting**.
1. Choisissez **Points de contact**.
1. Dans le menu déroulant **Choisir un gestionnaire d'alertes**, sélectionnez un gestionnaire d'alertes. Le Grafana Alertmanager est sélectionné par défaut.
1. Dans l'onglet **Points de contact**, choisissez **\$1 Ajouter un point de contact**.
1. Entrez un **nom** pour le point de contact.
1. Dans **Intégration**, choisissez un type et remplissez les champs obligatoires en fonction de ce type. Par exemple, si vous choisissez Slack, entrez les chaînes Slack et les utilisateurs à contacter.
1. Si disponible pour le point de contact que vous avez sélectionné, choisissez **les paramètres facultatifs** souhaités pour définir des paramètres supplémentaires.
1. Dans **Paramètres de notification**, sélectionnez éventuellement **Désactiver le message résolu** si vous ne souhaitez pas être averti lorsqu'une alerte est résolue.
1. Pour ajouter une autre intégration de point de contact, choisissez **Ajouter une intégration de point de contact** et répétez les étapes pour chaque type de point de contact requis.
1. Enregistrez vos modifications.
**Pour modifier un point de contact**
1. Dans le menu de gauche, choisissez **Alerting**.
1. Choisissez **Points de contact** pour voir la liste des points de contact existants.
1. Sélectionnez le point de contact à modifier, puis choisissez **Modifier**.
1. Mettez à jour le point de contact, puis enregistrez vos modifications.
Vous pouvez supprimer les points de contact qui ne sont pas utilisés par une politique de notification.
**Pour supprimer un point de contact**
1. Dans le menu de gauche, choisissez **Alerting**.
1. Choisissez **Points de contact** pour ouvrir la liste des points de contact existants.
1. Dans les **points de contact**, sélectionnez le point de contact à supprimer, puis choisissez **Plus**, **Supprimer**.
1. Dans la boîte de dialogue de confirmation, choisissez **Oui, supprimer**.
**Note**
Si le point de contact est utilisé par une politique de notification, vous devez supprimer la politique de notification ou la modifier pour utiliser un autre point de contact avant de supprimer le point de contact.
Une fois votre point de contact créé, vous pouvez envoyer une notification de test pour vérifier qu'il est correctement configuré.
**Pour envoyer une notification de test**
1. Dans le menu de gauche, choisissez **Alerting**.
1. Choisissez **Points de contact** pour ouvrir la liste des points de contact existants.
1. Sur les **points de contact**, sélectionnez le point de contact à tester, puis choisissez **Modifier**. Vous pouvez également créer un nouveau point de contact si nécessaire.
1. Choisissez **Test** pour ouvrir la boîte de dialogue de test du point de contact.
1. Choisissez d'envoyer une notification de test prédéfinie ou de choisir **Personnalisé** pour ajouter vos propres annotations et étiquettes personnalisées dans la notification de test.
1. Choisissez **Envoyer une notification** de test pour tester l'alerte auprès des points de contact indiqués.
## Configurer les intégrations de points de contact
Configurez les intégrations de points de contact dans Grafana pour sélectionner votre canal de communication préféré pour recevoir des notifications lorsque vos règles d'alerte se déclenchent. Chaque intégration possède ses propres options de configuration et processus de configuration. Dans la plupart des cas, cela implique de fournir une clé d'API ou une URL de webhook.
Une fois configurée, vous pouvez utiliser les intégrations dans le cadre de vos points de contact pour recevoir des notifications chaque fois que l'état de votre alerte change. Dans cette section, nous aborderons les étapes de base pour configurer une intégration, en prenant PagerDuty comme exemple le fait que vous puissiez commencer à recevoir des alertes en temps réel et rester au courant de vos données de surveillance.
**Liste des intégrations prises en charge**
Le tableau suivant répertorie les types de points de contact pris en charge par Grafana.
| Nom | Type |
| --- | --- |
| Amazon SNS | `sns` |
| OpsGenie | `opsgenie` |
| Devoir de téléavertisseur | `pagerduty` |
| Slack | `slack` |
| VictorOps | `victorops` |
**Configuration PagerDuty des alertes**
Pour le configurer PagerDuty, vous devez fournir une clé d'intégration. Fournissez les informations suivantes.
| Paramètre | Description |
| --- | --- |
| Clé d'intégration | Clé d'intégration pour PagerDuty |
| Sévérité | Niveau pour les notifications dynamiques. La valeur par défaut est critical. |
| Détails personnalisés | Informations supplémentaires sur l'événement |
Le `CustomDetails` champ est un objet contenant des paires clé-valeur arbitraires. Les détails définis par l'utilisateur sont fusionnés avec ceux utilisés par défaut.
Les valeurs par défaut pour `CustomDetails` sont les suivantes :
```
{
"firing": `{{ template "__text_alert_list" .Alerts.Firing }}`,
"resolved": `{{ template "__text_alert_list" .Alerts.Resolved }}`,
"num_firing": `{{ .Alerts.Firing | len }}`,
"num_resolved": `{{ .Alerts.Resolved | len }}`,
}
```
En cas de double clé, les informations définies par l'utilisateur remplacent celles définies par défaut.
# Configuration des politiques de notification
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Les politiques de notification déterminent la manière dont les alertes sont acheminées vers les points de contact.
Les politiques ont une structure arborescente, dans laquelle chaque politique peut avoir une ou plusieurs politiques imbriquées. Chaque politique, à l'exception de la stratégie par défaut, peut également correspondre à des étiquettes d'alerte spécifiques.
Chaque alerte est évaluée par la stratégie par défaut, puis par chaque stratégie imbriquée.
Si vous activez l'`Continue matching subsequent sibling nodes`option pour une politique imbriquée, l'évaluation se poursuit même après une ou plusieurs correspondances. Les paramètres de configuration et les informations du point de contact d'une politique parent régissent le comportement d'une alerte qui ne correspond à aucune des politiques enfant. Une politique par défaut régit toute alerte qui ne correspond pas à une politique imbriquée.
Pour plus d'informations sur les politiques de notification, consultez[Notifications](v10-alerting-explore-notifications.md).
Les procédures suivantes vous montrent comment créer et gérer des politiques de notification.
**Pour modifier la politique de notification par défaut**
1. Dans le menu de gauche, choisissez **Alerting**.
1. Choisissez **Politiques de notification**.
1. Dans le menu déroulant **Choisir le gestionnaire d'alertes**, sélectionnez le gestionnaire d'alertes que vous souhaitez modifier.
1. Dans la section **Politique par défaut**, choisissez**...** , **Modifier**.
1. Dans **Point de contact par défaut**, mettez à jour le point de contact auquel les notifications doivent être envoyées pour les règles lorsque les règles d'alerte ne correspondent à aucune politique spécifique.
1. Dans **Regrouper par**, choisissez les libellés selon lesquels regrouper les alertes. Si plusieurs alertes correspondent à cette politique, elles sont regroupées selon ces étiquettes. Une notification est envoyée par groupe. Si le champ est vide (valeur par défaut), toutes les notifications sont envoyées dans un seul groupe. Utilisez une étiquette spéciale `...` pour regrouper les alertes en fonction de toutes les étiquettes (ce qui désactive efficacement le regroupement).
1. Dans **Options de chronométrage**, sélectionnez l'une des options suivantes.
+ **Patience de groupe** : temps d'attente nécessaire pour mettre en mémoire tampon les alertes d'un même groupe avant d'envoyer une notification initiale. Le durée par défaut est 30 secondes.
+ **Intervalle de groupe** : intervalle de temps minimum entre deux notifications pour un groupe. La valeur par défaut est de 5 minutes.
+ **Intervalle de répétition** : intervalle de temps minimal avant le renvoi d'une notification si aucune nouvelle alerte n'a été ajoutée au groupe. La valeur par défaut est de 4 heures.
1. Choisissez **Save** pour enregistrer les changements.
Pour créer une nouvelle politique de notification, vous devez suivre son arborescence. Les nouvelles politiques créées sur le tronc de l'arbre (la politique par défaut) sont les branches de l'arbre. Chaque branche peut avoir ses propres politiques imbriquées. C'est pourquoi vous ajouterez toujours une nouvelle politique **imbriquée**, soit dans le cadre de la stratégie par défaut, soit dans le cadre d'une politique déjà imbriquée.
**Pour ajouter une nouvelle politique imbriquée**
1. Dans le menu de gauche, choisissez **Alerting**.
1. Choisissez **Politiques de notification**.
1. Dans le menu déroulant **Choisir le gestionnaire d'alertes**, sélectionnez le gestionnaire d'alertes que vous souhaitez modifier.
1. Pour ajouter une politique spécifique de haut niveau, rendez-vous dans la section Routage spécifique (soit vers la politique par défaut, soit vers une autre politique existante dans laquelle vous souhaitez ajouter une nouvelle politique imbriquée) et choisissez **\$1** Nouvelle politique imbriquée.
1. Dans la section des étiquettes correspondantes, ajoutez une ou plusieurs règles pour faire correspondre les étiquettes d'alerte.
1. Dans la liste déroulante **Point de contact**, sélectionnez le point de contact auquel envoyer des notifications si une alerte correspond uniquement à cette politique spécifique et à aucune des politiques imbriquées.
1. Activez éventuellement l'option **Continuer à faire correspondre les nœuds frères suivants** pour continuer à faire correspondre les politiques sœurs même après que l'alerte corresponde à la politique actuelle. Lorsque cette option est activée, vous pouvez recevoir plusieurs notifications pour une alerte.
1. Activez éventuellement le **regroupement Override** pour spécifier le même regroupement que la politique par défaut. Si l'option n'est pas activée, le regroupement de politiques par défaut est utilisé.
1. Activez éventuellement l'option **Ignorer les horaires généraux** pour annuler les options de chronométrage configurées dans la politique de notification de groupe.
1. Choisissez **Enregistrer la politique** pour enregistrer les changements.
**Pour modifier une politique imbriquée**
1. Dans le menu de gauche, choisissez **Alerting**.
1. Choisissez **Politiques de notification**.
1. Sélectionnez la politique que vous souhaitez modifier, puis choisissez**...** , **Modifier**.
1. Apportez des modifications (comme lors de l'ajout d'une politique imbriquée).
1. Enregistrez vos modifications.
**Recherche de politiques**
Vous pouvez effectuer une recherche dans l'arborescence des politiques par *Label Matchers* ou *points de contact*.
+ Pour effectuer une recherche par point de contact, entrez le nom partiel ou complet d'un point de contact dans le champ **Rechercher par point de contact**. Les politiques qui utilisent ce point de contact seront mises en évidence dans l'interface utilisateur.
+ Pour effectuer une recherche par étiquette, entrez une étiquette valide dans le champ **de saisie Recherche par étiquette**. Plusieurs correspondances peuvent être saisies, séparées par une virgule. Par exemple, une entrée de correspondance valide pourrait être. `severity=high, region=~EMEA|NA`
**Note**
Lorsque vous effectuez une recherche par étiquette, toutes les politiques correspondantes correspondront exactement. Les correspondances partielles et les correspondances de style regex ne sont pas prises en charge.
# Gérez vos alertes
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Une fois que vous avez défini vos règles d'alerte, vos points de contact et vos politiques de notification, vous pouvez utiliser les alertes Grafana pour gérer vos alertes dans la pratique.
**Topics**
+ [Personnaliser les notifications](v10-alerting-manage-notifications.md)
+ [Gérer les points de contact](v10-alerting-manage-contactpoints.md)
+ [Désactiver les notifications d'alerte](v10-alerting-silences.md)
+ [Afficher et filtrer les règles d'alerte](v10-alerting-manage-rules-viewfilter.md)
+ [Horaire du mode muet](v10-alerting-manage-muting.md)
+ [Afficher l'état et l'état des règles d'alerte](v10-alerting-manage-rulestate.md)
+ [Afficher et filtrer par groupes d'alertes](v10-alerting-manage-viewfiltergroups.md)
+ [Afficher les erreurs de notification](v10-alerting-manage-viewnotificationerrors.md)
# Personnaliser les notifications
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Personnalisez vos notifications à l'aide de modèles de notifications.
Vous pouvez utiliser des modèles de notification pour modifier le titre, le message et le format du message dans vos notifications.
Les modèles de notification ne sont pas liés à des intégrations de points de contact spécifiques, telles qu'Amazon SNS ou Slack. Vous pouvez toutefois choisir de créer des modèles de notification distincts pour les différentes intégrations de points de contact.
Vous pouvez utiliser des modèles de notification pour :
+ Ajoutez, supprimez ou réorganisez les informations dans la notification, notamment le résumé, la description, les étiquettes et les annotations, les valeurs et les liens
+ Mettre en forme le texte en gras et en italique, et ajouter ou supprimer des sauts de ligne
Vous ne pouvez pas utiliser de modèles de notification pour :
+ Modifier le design des notifications dans les services de messagerie instantanée tels que Slack et Microsoft Teams
**Topics**
+ [Utilisation du langage de création de modèles de Go](v10-alerting-notifications-go-templating.md)
+ [Création de modèles de notification](v10-alerting-create-templates.md)
+ [Utilisation de modèles de notification](#v10-alerting-use-notification-templates)
+ [Référence de modèles](v10-alerting-template-reference.md)
# Utilisation du langage de création de modèles de Go
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Vous rédigez des modèles de notification dans le langage de modélisation de Go, [texte/modèle](https://pkg.go.dev/text/template).
Cette section fournit un aperçu du langage de création de modèles de Go et des modèles d'écriture sous forme de texte/modèle.
## Point
text/template Il y a un curseur spécial appelé point, écrit sous la forme`.`. Vous pouvez considérer ce curseur comme une variable dont la valeur change en fonction de l'endroit où il est utilisé dans le modèle. Par exemple, au début d'un modèle de notification, il `.` fait référence à l'`ExtendedData`objet, qui contient un certain nombre de champs`Alerts`, notamment`Status`,`GroupLabels`,`CommonLabels`, `CommonAnnotations` et`ExternalURL`. Cependant, le point peut faire référence à autre chose lorsqu'il est utilisé dans `range` une liste, lorsqu'il est utilisé dans un `with` ou lors de la rédaction de modèles de fonctionnalités à utiliser dans d'autres modèles. Vous pouvez en voir des exemples dans[Création de modèles de notification](v10-alerting-create-templates.md), ainsi que toutes les données et fonctions du[Référence de modèles](v10-alerting-template-reference.md).
## Étiquettes d'ouverture et de fermeture
Dans le texte/le modèle, les modèles commencent par `{{` et se terminent par`}}`, qu'ils impriment une variable ou exécutent des structures de contrôle telles que des instructions if. Ceci est différent des autres langages de modélisation tels que Jinja où l'impression d'une variable utilise `{{` et et où les structures de contrôle utilisent `}}` `{%` et. `%}`
## Print
Pour imprimer la valeur d'un élément, utilisez `{{` et`}}`. Vous pouvez imprimer la valeur d'un point, un champ de points, le résultat d'une fonction et la valeur d'une [variable](#v10-go-variables). Par exemple, pour imprimer le `Alerts` champ où le point fait référence, `ExtendedData` vous devez écrire ce qui suit :
```
{{ .Alerts }}
```
## Répéter les alertes
Pour imprimer uniquement les étiquettes de chaque alerte, plutôt que toutes les informations relatives à l'alerte, vous pouvez utiliser a `range` pour itérer les alertes dans `ExtendedData` :
```
{{ range .Alerts }}
{{ .Labels }}
{{ end }}
```
À l'intérieur de la plage, le point ne fait plus référence à`ExtendedData`, mais à un`Alert`. Vous pouvez l'utiliser `{{ .Labels }}` pour imprimer les étiquettes de chaque alerte. Cela fonctionne car le point `{{ range .Alerts }}` change pour faire référence à l'alerte en cours dans la liste des alertes. Lorsque la plage est terminée, le point est remis à la valeur qu'il avait avant le début de la plage, qui dans cet exemple est `ExtendedData` :
```
{{ range .Alerts }}
{{ .Labels }}
{{ end }}
{{/* does not work, .Labels does not exist here */}}
{{ .Labels }}
{{/* works, cursor was reset */}}
{{ .Status }}
```
## Répéter sur les annotations et les étiquettes
Rédigons un modèle pour imprimer les étiquettes de chaque alerte au format`The name of the label is $name, and the value is $value`, où `$name` et `$value` contenant le nom et la valeur de chaque étiquette.
Comme dans l'exemple précédent, utilisez une plage pour parcourir les alertes de `.Alerts` manière à ce que le point fasse référence à l'alerte en cours dans la liste des alertes, puis utilisez une deuxième plage sur les étiquettes triées afin que le point soit mis à jour une deuxième fois pour faire référence à l'étiquette actuelle. Dans la deuxième plage, utilisez `.Name` et `.Value` pour imprimer le nom et la valeur de chaque étiquette :
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
The name of the label is {{ .Name }}, and the value is {{ .Value }}
{{ end }}
{{ range .Annotations.SortedPairs }}
The name of the annotation is {{ .Name }}, and the value is {{ .Value }}
{{ end }}
{{ end }}
```
## Les fonctions d'index
Pour imprimer une annotation ou une étiquette spécifique, utilisez la `index` fonction.
```
{{ range .Alerts }}
The name of the alert is {{ index .Labels "alertname" }}
{{ end }}
```
## Si des déclarations
Vous pouvez utiliser des instructions if dans les modèles. Par exemple, pour imprimer `There are no alerts` s'il n'y a aucune alerte, `.Alerts` vous devez écrire ce qui suit :
```
{{ if .Alerts }}
There are alerts
{{ else }}
There are no alerts
{{ end }}
```
## Avec
with est similaire aux instructions if, mais contrairement aux instructions if, `with` met à jour le point pour faire référence à la valeur du with :
```
{{ with .Alerts }}
There are {{ len . }} alert(s)
{{ else }}
There are no alerts
{{ end }}
```
## Variables
Les variables text/template doivent être créées dans le modèle. Par exemple, pour créer une variable appelée `$variable` avec la valeur actuelle de point, vous devez écrire ce qui suit :
```
{{ $variable := . }}
```
Vous pouvez `$variable` l'utiliser à l'intérieur d'une plage ou `with` cela fera référence à la valeur du point au moment où la variable a été définie, et non à la valeur actuelle du point.
Par exemple, vous ne pouvez pas écrire un modèle `{{ .Labels }}` à utiliser dans la deuxième plage car ici, le point fait référence à l'étiquette actuelle, et non à l'alerte en cours :
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{/* does not work because in the second range . is a label not an alert */}}
There are {{ len .Labels }}
{{ end }}
{{ end }}
```
Vous pouvez résoudre ce problème en définissant une variable appelée `$alert` dans la première plage et avant la deuxième plage :
```
{{ range .Alerts }}
{{ $alert := . }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{/* works because $alert refers to the value of dot inside the first range */}}
There are {{ len $alert.Labels }}
{{ end }}
{{ end }}
```
## Gamme avec index
Vous pouvez obtenir l'indice de chaque alerte au sein d'une plage en définissant des variables d'indice et de valeur au début de la plage :
```
{{ $num_alerts := len .Alerts }}
{{ range $index, $alert := .Alerts }}
This is alert {{ $index }} out of {{ $num_alerts }}
{{ end }}
```
## Définir des modèles
Vous pouvez définir des modèles qui peuvent être utilisés dans d'autres modèles, `define` en utilisant le nom du modèle entre guillemets. Vous ne devez pas définir de modèles portant le même nom que les autres modèles, y compris les modèles par défaut tels que `__subject``__text_values_list`,`__text_alert_list`, `default.title` et`default.message`. Lorsqu'un modèle a été créé avec le même nom qu'un modèle par défaut, ou un modèle dans un autre modèle de notification, Grafana peut utiliser l'un ou l'autre modèle. Grafana n'empêche pas ou n'affiche pas de message d'erreur lorsqu'il existe deux modèles ou plus portant le même nom.
```
{{ define "print_labels" }}
{{ end }}
```
## Exécuter des modèles
Vous pouvez exécuter un modèle défini dans votre modèle en utilisant `template` le nom du modèle entre guillemets et le curseur qui doit être passé au modèle :
```
{{ template "print_labels" . }}
```
## Transmettre les données aux modèles
Dans un modèle, le point fait référence à la valeur transmise au modèle.
Par exemple, si une liste d'alertes de déclenchement est transmise à un modèle, le point fait référence à cette liste d'alertes de déclenchement :
```
{{ template "print_alerts" .Alerts }}
```
Si le modèle reçoit les libellés triés d'une alerte, le point fait référence à la liste des libellés triés :
```
{{ template "print_labels" .SortedLabels }}
```
Cela est utile lors de la rédaction de modèles réutilisables. Par exemple, pour imprimer toutes les alertes, vous pouvez écrire ce qui suit :
```
{{ template "print_alerts" .Alerts }}
```
Ensuite, pour imprimer uniquement les alertes de déclenchement, vous pouvez écrire ceci :
```
{{ template "print_alerts" .Alerts.Firing }}
```
Cela fonctionne car `.Alerts` les deux `.Alerts.Firing` sont des listes d'alertes.
```
{{ define "print_alerts" }}
{{ range . }}
{{ template "print_labels" .SortedLabels }}
{{ end }}
{{ end }}
```
## Commentaires
Vous pouvez ajouter des commentaires avec `{{/*` et `*/}}` :
```
{{/* This is a comment */}}
```
Pour empêcher les commentaires d'ajouter des sauts de ligne, utilisez :
```
{{- /* This is a comment with no leading or trailing line breaks */ -}}
```
## Indentation
Vous pouvez utiliser l'indentation, à la fois des tabulations et des espaces, ainsi que des sauts de ligne, pour rendre les modèles plus lisibles :
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{ end }}
{{ end }}
```
Cependant, l'indentation du modèle sera également présente dans le texte. Ensuite, nous verrons comment le supprimer.
## Supprimer les espaces et les sauts de ligne
En cours text/template d'utilisation `{{-` et `-}}` pour supprimer les espaces de début et de fin et les sauts de ligne.
Par exemple, lorsque vous utilisez l'indentation et les sauts de ligne pour rendre un modèle plus lisible :
```
{{ range .Alerts }}
{{ range .Labels.SortedPairs }}
{{ .Name }} = {{ .Value }}
{{ end }}
{{ end }}
```
L'indentation et les sauts de ligne seront également présents dans le texte :
```
alertname = "Test"
grafana_folder = "Test alerts"
```
Vous pouvez supprimer l'indentation et les sauts de ligne du texte en le `}}` remplaçant par le `-}}` début de chaque plage :
```
{{ range .Alerts -}}
{{ range .Labels.SortedPairs -}}
{{ .Name }} = {{ .Value }}
{{ end }}
{{ end }}
```
L'indentation et les sauts de ligne du modèle sont désormais absents du texte :
```
alertname = "Test"
grafana_folder = "Test alerts"
```
# Création de modèles de notification
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Créez des modèles de notification réutilisables à envoyer à vos points de contact.
Vous pouvez ajouter un ou plusieurs modèles à votre modèle de notification.
Le nom de votre modèle de notification doit être unique. Vous ne pouvez pas avoir deux modèles portant le même nom dans le même modèle de notification ou dans des modèles de notification différents. Évitez de définir des modèles portant le même nom que les modèles par défaut, tels que : `__subject``__text_values_list`,`__text_alert_list`, `default.title` et`default.message`.
Dans l'onglet Points de contact, vous pouvez voir la liste de vos modèles de notification.
## Création de modèles de notification
**Pour créer un modèle de notification**
1. Choisissez **Alerte**, **Points de contact.**
1. Cliquez sur l'onglet **Modèles de notification**, puis sur **\$1 Ajouter un modèle de notification**.
1. Choisissez un nom pour le modèle de notification, par exemple`email.subject`.
1. Écrivez le contenu du modèle dans le champ de contenu.
Par exemple :
```
{{ if .Alerts.Firing -}}
{{ len .Alerts.Firing }} firing alerts
{{ end }}
{{ if .Alerts.Resolved -}}
{{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Enregistrez vos modifications.
`{{ define "email.subject" }}`(où `email.subject` est le nom de votre modèle) et `{{ end }}` est automatiquement ajouté au début et à la fin du contenu.
**Pour créer un modèle de notification contenant plusieurs modèles**
1. Choisissez **Alerte**, **Points de contact.**
1. Cliquez sur l'onglet **Modèles de notification**, puis sur **\$1 Ajouter un modèle de notification**.
1. Entrez un nom pour le modèle de notification global. Par exemple, `email`.
1. Écrivez chaque modèle dans le champ Contenu, y compris `{{ define "name-of-template" }}` `{{ end }}` au début et à la fin de chaque modèle. Vous pouvez utiliser des noms descriptifs pour chacun des modèles du modèle de notification, par exemple, `email.subject` ou`email.message`. Dans ce cas, ne réutilisez pas le nom du modèle de notification que vous avez saisi ci-dessus.
Les sections suivantes présentent des exemples détaillés de modèles que vous pourriez créer.
1. Cliquez sur Sauvegarder
## Afficher un aperçu des modèles de notification
Prévisualisez l'apparence de vos modèles de notification avant de les utiliser dans vos points de contact, afin de comprendre le résultat du modèle que vous créez et de corriger les erreurs éventuelles avant de l'enregistrer.
**Note**
Les aperçus des notifications ne sont disponibles que pour Grafana Alertmanager.
**Pour prévisualiser vos modèles de notification**
1. Choisissez **Alerte**, **Points de contact.**
1. Choisissez l'onglet **Modèles de notification**, puis **\$1 Ajouter un modèle de notification** ou modifiez un modèle existant.
1. Ajoutez ou mettez à jour le contenu de votre modèle.
Les données par défaut sont fournies et vous pouvez y ajouter ou modifier des données d'alerte ainsi que des instances d'alerte. Vous pouvez ajouter des données d'alerte directement dans la fenêtre de données de charge utile elle-même, ou cliquer sur **Sélectionner des instances d'alerte** ou sur **Ajouter des alertes personnalisées**.
1. [Facultatif] Pour ajouter des données d'alerte provenant d'instances d'alerte existantes :
1. Choisissez **Sélectionner les instances d'alerte**.
1. Passez le curseur sur les instances d'alerte pour afficher plus d'informations sur chaque instance d'alerte/
1. Choisissez **Confirm** pour ajouter l'instance d'alerte à la charge utile.
1. [Facultatif] Pour ajouter des données d'alerte à l'aide de l'éditeur de données d'alerte, choisissez **Ajouter des données personnalisées** :
1. Ajoutez des annotations, des étiquettes personnalisées ou définissez un tableau de bord ou un panneau.
1. Activez le mode Déclenchement ou Résolu, selon que vous souhaitez ajouter des alertes déclenchées ou résolues à votre notification.
1. Choisissez **Ajouter des données d'alerte**.
1. Choisissez **Actualiser l'aperçu** pour voir à quoi ressemblera le contenu de votre modèle et les données de charge utile correspondantes.
Si votre modèle contient des erreurs, elles sont affichées dans l'aperçu et vous pouvez les corriger avant de les enregistrer.
1. Enregistrez vos modifications.
## Création d'un modèle pour l'objet du message
Créez un modèle pour l'objet d'un e-mail contenant le nombre d'alertes déclenchées et résolues, comme dans cet exemple :
```
1 firing alerts, 0 resolved alerts
```
**Pour créer un modèle pour l'objet d'un e-mail**
1. Créez un modèle appelé `email.subject` avec le contenu suivant :
```
{{ define "email.subject" }}
{{ len .Alerts.Firing }} firing alerts, {{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Utilisez le modèle lors de la création de votre intégration de points de contact en le plaçant dans le champ **Objet** avec le `template` mot clé.
```
{{ template "email.subject" . }}
```
## Création d'un modèle pour le message d'un e-mail
Créez un modèle pour le message d'un e-mail contenant un résumé de toutes les alertes déclenchées et résolues, comme dans cet exemple :
```
There are 2 firing alerts, and 1 resolved alerts
Firing alerts:
- alertname=Test 1 grafana_folder=GrafanaCloud has value(s) B=1
- alertname=Test 2 grafana_folder=GrafanaCloud has value(s) B=2
Resolved alerts:
- alertname=Test 3 grafana_folder=GrafanaCloud has value(s) B=0
```
**Pour créer un modèle pour le message d'un e-mail**
1. Créez un modèle de notification appelé `email` avec deux modèles dans le contenu : `email.message_alert` et`email.message`.
Le `email.message_alert` modèle est utilisé pour imprimer les étiquettes et les valeurs de chaque alerte déclenchée et résolue, tandis que le `email.message` modèle contient la structure de l'e-mail.
```
{{- define "email.message_alert" -}}
{{- range .Labels.SortedPairs }}{{ .Name }}={{ .Value }} {{ end }} has value(s)
{{- range $k, $v := .Values }} {{ $k }}={{ $v }}{{ end }}
{{- end -}}
{{ define "email.message" }}
There are {{ len .Alerts.Firing }} firing alerts, and {{ len .Alerts.Resolved }} resolved alerts
{{ if .Alerts.Firing -}}
Firing alerts:
{{- range .Alerts.Firing }}
- {{ template "email.message_alert" . }}
{{- end }}
{{- end }}
{{ if .Alerts.Resolved -}}
Resolved alerts:
{{- range .Alerts.Resolved }}
- {{ template "email.message_alert" . }}
{{- end }}
{{- end }}
{{ end }}
```
1. Utilisez le modèle lors de la création de votre intégration de points de contact en le plaçant dans le champ **du corps du texte** avec le `template` mot clé.
```
{{ template "email.message" . }}
```
## Création d'un modèle pour le titre d'un message Slack
Créez un modèle pour le titre d'un message Slack contenant le nombre d'alertes déclenchées et résolues, comme dans l'exemple suivant :
```
1 firing alerts, 0 resolved alerts
```
**Pour créer un modèle pour le titre d'un message Slack**
1. Créez un modèle appelé `slack.title` avec le contenu suivant :
```
{{ define "slack.title" }}
{{ len .Alerts.Firing }} firing alerts, {{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Exécutez le modèle à partir du champ de titre dans l'intégration de votre point de contact.
```
{{ template "slack.title" . }}
```
## Création d'un modèle pour le contenu d'un message Slack
Créez un modèle pour le contenu d'un message Slack contenant une description de toutes les alertes déclenchées et résolues, y compris leurs étiquettes, leurs annotations et l'URL du tableau de bord.
**Note**
Ce modèle est réservé aux alertes gérées par Grafana. Pour utiliser le modèle pour les alertes gérées par des sources de données, supprimez les références à DashboardUrl et SilenceURL. Pour plus d'informations sur la configuration des notifications Prometheus, consultez la documentation de [Prometheus](https://prometheus.io/docs/alerting/latest/notifications/) sur les notifications.
```
1 firing alerts:
[firing] Test1
Labels:
- alertname: Test1
- grafana_folder: GrafanaCloud
Annotations:
- description: This is a test alert
Go to dashboard: https://example.com/d/dlhdLqF4z?orgId=1
1 resolved alerts:
[firing] Test2
Labels:
- alertname: Test2
- grafana_folder: GrafanaCloud
Annotations:
- description: This is another test alert
Go to dashboard: https://example.com/d/dlhdLqF4z?orgId=1
```
**Pour créer un modèle pour le contenu d'un message Slack**
1. Créez un modèle appelé `slack` avec deux modèles dans le contenu : `slack.print_alert` et`slack.message`.
Le `slack.print_alert` modèle est utilisé pour imprimer les étiquettes, les annotations et l'URL du tableau de bord tandis que le `slack.message` modèle contient la structure de la notification.
```
{{ define "slack.print_alert" -}}
[{{.Status}}] {{ .Labels.alertname }}
Labels:
{{ range .Labels.SortedPairs -}}
- {{ .Name }}: {{ .Value }}
{{ end -}}
{{ if .Annotations -}}
Annotations:
{{ range .Annotations.SortedPairs -}}
- {{ .Name }}: {{ .Value }}
{{ end -}}
{{ end -}}
{{ if .DashboardURL -}}
Go to dashboard: {{ .DashboardURL }}
{{- end }}
{{- end }}
{{ define "slack.message" -}}
{{ if .Alerts.Firing -}}
{{ len .Alerts.Firing }} firing alerts:
{{ range .Alerts.Firing }}
{{ template "slack.print_alert" . }}
{{ end -}}
{{ end }}
{{ if .Alerts.Resolved -}}
{{ len .Alerts.Resolved }} resolved alerts:
{{ range .Alerts.Resolved }}
{{ template "slack.print_alert" .}}
{{ end -}}
{{ end }}
{{- end }}
```
1. Exécutez le modèle à partir du champ du corps du texte lors de l'intégration de votre point de contact :
```
{{ template "slack.message" . }}
```
## Modélisez à la fois vos e-mails et Slack avec des modèles partagés
Au lieu de créer des modèles de notification distincts pour chaque point de contact, tels que les e-mails et Slack, vous pouvez partager le même modèle.
Par exemple, si vous souhaitez envoyer un e-mail avec cet objet et un message Slack avec ce titre`1 firing alerts, 0 resolved alerts`, vous pouvez créer un modèle partagé.
**Pour créer un modèle partagé**
1. Créez un modèle appelé `common.subject_title` avec le contenu suivant :
```
{{ define "common.subject_title" }}
{{ len .Alerts.Firing }} firing alerts, {{ len .Alerts.Resolved }} resolved alerts
{{ end }}
```
1. Pour les e-mails, exécutez le modèle à partir du champ d'objet de l'intégration de votre point de contact e-mail :
```
{{ template "common.subject_title" . }}
```
1. Pour Slack, exécutez le modèle à partir du champ de titre dans l'intégration de votre point de contact Slack :
```
{{ template "common.subject_title" . }}
```
## Utilisation de modèles de notification
Utilisez des modèles dans les points de contact pour personnaliser vos notifications.
**Pour utiliser un modèle lors de la création d'un point de contact**
1. Dans le menu **Alertes**, choisissez l'onglet **Points de contact** pour afficher la liste des points de contact existants.
1. Choisissez **Nouveau**. Vous pouvez également modifier un point de contact existant en cliquant sur l'icône **Modifier**.
1. Entrez les modèles que vous souhaitez utiliser dans un champ, tel que **Message** ou **Objet**. Pour saisir un modèle, utilisez le formulaire `{{ template "template_name" . }}` en le *template\$1name* remplaçant par le nom du modèle que vous souhaitez utiliser.
1. Choisissez **Enregistrer le point de contact**.
# Référence de modèles
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Cette section fournit des informations de référence pour créer vos modèles.
**Alerte (type)**
Le type d'alerte contient les données suivantes.
| Name | Kind | Description | Exemple |
| --- | --- | --- | --- |
| Statut | chaîne | `firing` ou `resolved`. | \$1\$1 .Status \$1\$1 |
| Étiquettes | KeyValue | Ensemble d'étiquettes associées à l'alerte. | \$1\$1 .Labels \$1\$1 |
| Annotations | KeyValue | Ensemble d'annotations associées à l'alerte. | \$1\$1 .Annotations \$1\$1 |
| Valeurs | KeyValue | Les valeurs de toutes les expressions, y compris les conditions classiques | \$1\$1 .Values \$1\$1 |
| StartsAt | Heure. Heure | Heure à laquelle l'alerte a commencé à se déclencher. | \$1\$1 .StartsAt \$1\$1 |
| EndsAt | Heure. Heure | Paramétré uniquement si l'heure de fin d'une alerte est connue. Sinon, définissez un délai d'expiration configurable à compter de la date de réception de la dernière alerte. | \$1\$1 .EndsAt \$1\$1 |
| URL du générateur | chaîne | Un lien de retour vers Grafana ou un Alertmanager externe. | \$1\$1 .GeneratorURL \$1\$1 |
| URL de silence | chaîne | Un lien pour désactiver l'alerte (avec des étiquettes préremplies pour cette alerte). Uniquement pour les alertes gérées par Grafana. | \$1\$1 .SilenceURL\$1\$1 |
| URL du tableau de bord | chaîne | Lien vers le tableau de bord de Grafana, si la règle d'alerte appartient à l'une d'entre elles. Uniquement pour les alertes gérées par Grafana. | \$1\$1 .DashboardURL \$1\$1 |
| URL du panneau | chaîne | Lien vers le panneau du tableau de bord de Grafana, si la règle d'alerte appartient à l'une d'entre elles. Uniquement pour les alertes gérées par Grafana. | \$1\$1 .PanelURL \$1\$1 |
| Empreinte | chaîne | Empreinte digitale qui peut être utilisée pour identifier l'alerte. | \$1\$1 .Fingerprint \$1\$1 |
| ValueString | chaîne | Chaîne contenant les libellés et la valeur de chaque expression réduite de l'alerte. | \$1\$1 .ValueString \$1\$1 |
**ExtendedData**
L' ExtendedData objet contient les propriétés suivantes.
| Name | Kind | Description | Exemple |
| --- | --- | --- | --- |
| Récepteur | `string` | Nom du point de contact qui envoie la notification. | `{{ .Receiver }}` |
| Statut | `string` | L'état indique `firing` si au moins une alerte est déclenchée, sinon`resolved`. | `{{ .Status }}` |
| Alerts (Alertes) | `[]Alert` | Liste de toutes les alertes déclenchées et résolues dans cette notification. | `There are {{ len .Alerts }} alerts` |
| Alertes de tir | `[]Alert` | Liste de toutes les alertes de tir contenues dans cette notification. | `There are {{ len .Alerts.Firing }} firing alerts` |
| Alertes résolues | `[]Alert` | Liste de toutes les alertes résolues dans cette notification. | `There are {{ len .Alerts.Resolved }} resolved alerts` |
| GroupLabels | `KeyValue` | Les étiquettes qui regroupent ces alertes dans cette notification. | `{{ .GroupLabels }}` |
| CommonLabels | `KeyValue` | Les libellés communs à toutes les alertes de cette notification. | `{{ .CommonLabels }}` |
| CommonAnnotations | `KeyValue` | Les annotations communes à toutes les alertes de cette notification. | `{{ .CommonAnnotations }}` |
| URL externe | `string` | Un lien vers l'espace de travail Grafana ou Alertmanager qui a envoyé cette notification. | `{{ .ExternalURL }}` |
**KeyValue type**
Le `KeyValue` type est un ensemble de paires de key/value chaînes qui représentent des étiquettes et des annotations.
Outre l'accès direct aux données stockées sous forme de fichier`KeyValue`, il existe également des méthodes de tri, de suppression et de transformation des données.
| Name | Arguments | Renvoie | Remarques | Exemple |
| --- | --- | --- | --- | --- |
| SortedPairs | | Liste triée des paires de chaînes de clés et de valeurs | | `{{ .Annotations.SortedPairs }}` |
| Supprimer | [] chaîne | KeyValue | Renvoie une copie de la Key/Value carte sans les clés données. | `{{ .Annotations.Remove "summary" }}` |
| Noms | | [] chaîne | Liste des noms | `{{ .Names }}` |
| Valeurs | | [] chaîne | Liste de valeurs | `{{ .Values }}` |
**Time (Période)**
L'heure est comptée dans le [https://pkg.go.dev/time#Time](https://pkg.go.dev/time#Time)package Go. Vous pouvez imprimer une heure dans différents formats. Par exemple, pour imprimer l'heure à laquelle une alerte s'est déclenchée dans ce format`Monday, 1st January 2022 at 10:00AM`, vous devez écrire le modèle suivant :
```
{{ .StartsAt.Format "Monday, 2 January 2006 at 3:04PM" }}
```
Vous pouvez trouver une référence pour le format horaire de Go [ici](https://pkg.go.dev/time#pkg-constants).
# Gérer les points de contact
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
La vue de la liste des **points de contact** répertorie tous les points de contact et modèles de notification existants.
Dans l'onglet **Points de contact**, vous pouvez :
+ Recherchez les noms et les types de points de contact et d'intégrations.
+ Consultez tous les points de contact et intégrations existants.
+ Consultez le nombre de politiques de notification pour lesquelles chaque point de contact est utilisé et accédez directement aux politiques de notification associées.
+ Consultez l'état des envois de notifications.
+ Exportez des points de contact individuels ou tous les points de contact au format JSON, YAML ou Terraform.
+ Supprimez les points de contact qui ne sont pas utilisés par une politique de notification.
Dans l'onglet **Modèles de notification**, vous pouvez :
+ Affichez, modifiez, copiez ou supprimez les modèles de notification existants.
# Désactiver les notifications d'alerte
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Vous pouvez supprimer les notifications d'alerte par un *silence*. Un silence empêche uniquement la création de notifications : les silences n'empêchent pas l'évaluation des règles d'alerte et n'empêchent pas l'affichage des instances d'alerte dans l'interface utilisateur. Lorsque vous désactivez une alerte, vous spécifiez une période pendant laquelle elle doit être supprimée.
**Note**
Pour supprimer les notifications d'alerte à intervalles réguliers, par exemple pendant les périodes de maintenance régulières, utilisez-les [Horaire du mode muet](v10-alerting-manage-muting.md) plutôt que des silences.
**Pour ajouter un silence**
1. **Depuis votre console Grafana, dans le menu Grafana, choisissez Alerting.**
1. Choisissez **Silences.**
1. Choisissez un gestionnaire d'alertes dans la liste déroulante du gestionnaire d'**alertes**.
1. Choisissez **Create Silence**.
1. Sélectionnez les dates de début et de fin dans **Début et fin du silence** pour indiquer quand le silence doit entrer en vigueur et quand il doit prendre fin.
1. Au lieu de définir une heure de fin, dans **Durée**, spécifiez la durée pendant laquelle le silence est appliqué. Cela met automatiquement à jour l'heure de fin dans les champs de **début et de fin du silence**.
1. Dans les champs **Étiquette** et **Valeur**, entrez une ou plusieurs *étiquettes correspondantes*. Les matchers déterminent les règles auxquelles le silence s'applique. Toutes les alertes correspondantes (en état de déclenchement) apparaîtront dans le champ **Instances d'alertes concernées**.
1. Ajoutez éventuellement un **commentaire** décrivant le silence.
1. Sélectionnez **Soumettre**.
**Pour modifier un silence**
1. **Depuis votre console Grafana, dans le menu Grafana, choisissez Alerting.**
1. Choisissez **Silences** pour afficher la liste des silences existants.
1. Recherchez le silence que vous souhaitez modifier, puis choisissez **Modifier** (icône en forme de stylo).
1. Apportez les modifications souhaitées, puis choisissez **Soumettre** pour enregistrer vos modifications.
Vous pouvez modifier un silence existant en cliquant sur l'icône **Modifier** (stylo).
**Pour créer un lien URL vers un formulaire de silence**
Lorsque vous créez un lien vers un formulaire de silence, fournissez les libellés correspondants par défaut, ainsi que les paramètres de commentaire `matcher` et de `comment` requête. Le `matcher` paramètre doit être au format suivant, dans `[label][operator][value]` lequel le `operator` paramètre peut être l'un des suivants : `=` (égal, pas regex), `!=` (pas égal, pas regex), `=~` (égal, regex), `!~` (non égal, regex). L'URL peut contenir de nombreux paramètres de requête avec la clé`matcher`. Par exemple, pour créer un lien vers un formulaire de silence avec les libellés `severity=critical` `cluster!~europe-.*` et les commentaires correspondants`Silence critical EU alerts`, créez une URL`https://mygrafana/alerting/silence/new?matcher=severity%3Dcritical&matcher=cluster!~europe-*&comment=Silence%20critical%20EU%20alert`.
Pour créer un lien vers une nouvelle page de silence pour un Alertmanager externe, ajoutez un `alertmanager` paramètre de requête
**Pour supprimer un silence**
1. **Depuis votre console Grafana, dans le menu Grafana, choisissez Alerting.**
1. Choisissez **Silences** pour afficher la liste des silences existants.
1. Sélectionnez le silence auquel vous souhaitez mettre fin, puis choisissez Annuler **le silence**. Cela met fin à la suppression de l'alerte.
**Note**
La désactivation met fin à la suppression de l'alerte, comme si l'heure de fin était définie pour l'heure actuelle. Les silences qui ont pris fin (automatiquement ou manuellement) sont conservés et répertoriés pendant cinq jours. Vous ne pouvez pas supprimer un silence de la liste manuellement.
# Afficher et filtrer les règles d'alerte
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
La page **Alertes** répertorie les règles d'alerte. Par défaut, les règles sont regroupées par type de source de données. La section **Grafana** répertorie les règles gérées par Grafana. Les règles d'alerte pour les sources de données compatibles avec Prometheus sont également répertoriées ici. Vous pouvez consulter les règles d'alerte pour les sources de données compatibles avec Prometheus, mais vous ne pouvez pas les modifier.
La section Mimir/Cortex/Loki des règles répertorie toutes les règles relatives aux sources de données Mimir, Cortex ou Loki. Les règles d'alerte cloud sont également répertoriées dans cette section.
Lorsque vous gérez de gros volumes d'alertes, vous pouvez utiliser des fonctionnalités de recherche de règles d'alerte étendues pour filtrer les dossiers, les groupes d'évaluation et les règles. En outre, vous pouvez filtrer les règles d'alerte en fonction de leurs propriétés telles que les étiquettes, l'état, le type et l'état de santé.
## Afficher les règles d'alerte
Grâce aux alertes Grafana, vous pouvez consulter toutes vos alertes sur une seule page.
**Pour afficher les détails des alertes**
1. **Depuis votre console Grafana, dans le menu Grafana, choisissez **Alerting, Alert** rules.** Par défaut, la vue en liste est affichée.
1. Dans **Afficher sous**, vous pouvez basculer entre les affichages groupé, liste et état en choisissant l'option que vous préférez.
1. Développez la ligne des règles pour afficher les étiquettes des règles, les annotations, les sources de données, les requêtes relatives aux règles et la liste des instances d'alerte résultant de la règle.
À partir de cette page, vous pouvez également créer des copies d'une règle d'alerte pour vous aider à réutiliser les règles existantes.
## Exporter les règles d'alerte
Vous pouvez exporter les règles au format YAML ou JSON dans l'espace de travail Grafana.
+ Choisissez l'icône **Exporter le groupe de règles** à côté de chaque groupe de règles d'alerte à exporter vers YAML, JSON ou Terraform.
+ Choisissez **Exporter les règles** pour exporter toutes les règles d'alerte gérées par Grafana vers YAML, JSON ou Terraform.
+ Choisissez **Plus**, **Modifier et exporter** à côté de chaque règle d'alerte individuelle au sein d'un groupe pour modifier les règles d'alerte configurées et exporter une version modifiée.
## Afficher les définitions de requêtes pour les alertes provisionnées
Affichez les définitions de requêtes en lecture seule pour les alertes provisionnées. Vérifiez rapidement si vos requêtes relatives aux règles d'alerte sont correctes, sans avoir à consulter votre référentiel « en tant que code » pour les définitions de règles.
**Vue groupée**
La vue groupée montre les règles d'alerte Grafana regroupées par dossier et les règles d'alerte Loki ou Prometheus groupées par \$1. `namespace` `group` Il s'agit de la vue de liste de règles par défaut, destinée à la gestion des règles. Vous pouvez développer chaque groupe pour afficher la liste des règles de ce groupe. Développez davantage une règle pour en afficher les détails. Vous pouvez également développer les boutons d'action et les alertes résultant de la règle pour en afficher les détails.
**Vue de l'État**
La vue État affiche les règles d'alerte regroupées par état. Utilisez cette vue pour avoir une vue d'ensemble des règles dans quel état. Chaque règle peut être étendue pour afficher ses détails. Boutons d'action et toutes les alertes générées par cette règle, et chaque alerte peut être étendue pour afficher ses détails.
## Règles de filtrage des alertes
Vous pouvez filtrer les règles d'alerte qui apparaissent sur la page **Alertes de** plusieurs manières.
**Pour filtrer les règles d'alerte**
1. **Dans Sélectionner les sources de données**, sélectionnez une source de données. Vous pouvez voir les règles d'alerte qui interrogent la source de données sélectionnée.
1. Dans **Rechercher par étiquette**, entrez les critères de recherche à l'aide de sélecteurs d'étiquettes. Par exemple, `environment=production;region=~US|EU,severity!=warning`.
1. Dans **Filtrer les alertes par état**, sélectionnez l'état d'alerte que vous souhaitez consulter. Vous pouvez voir les règles d'alerte correspondant à cet état. Les règles correspondant aux autres états sont masquées.
# Horaire du mode muet
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Un temps de sourdine est un intervalle de temps récurrent pendant lequel aucune nouvelle notification relative à une politique n'est générée ou envoyée. Utilisez-les pour empêcher les alertes de se déclencher pendant une période spécifique et récurrente, par exemple une période de maintenance régulière.
À l'instar des silences, le temps de mise en sourdine n'empêche pas l'évaluation des règles d'alerte, ni l'affichage des instances d'alerte dans l'interface utilisateur. Ils empêchent uniquement la création de notifications.
Vous pouvez configurer les durées de sourdine gérées par Grafana ainsi que les durées de sourdine pour une source de données Alertmanager externe.
## Timings muets ou silences
Le tableau suivant met en évidence les différences entre les temps de mise en sourdine et les silences.
| Synchronisation en mode muet | Silence |
| --- | --- |
| Utilise des définitions d'intervalles de temps qui peuvent se reproduire. | A une heure de début et de fin fixes. |
| Est créé puis ajouté aux politiques de notification. | Utilise des étiquettes pour établir une correspondance avec une alerte afin de déterminer s'il convient de désactiver ou non. |
## Ajouter une temporisation muette
Vous pouvez créer des horaires muets dans votre espace de travail Grafana.
**Pour ajouter une temporisation muette**
1. **Depuis votre console Grafana, dans le menu Grafana, choisissez Alerting.**
1. Choisissez **Politiques de notification**, puis sélectionnez l'onglet Durée de **mise en sourdine.**
1. Dans le menu déroulant **Alertmanager**, sélectionnez le Alertmanager que vous souhaitez modifier.
1. Cliquez sur le bouton **\$1 Ajouter une temporisation muette**.
1. Remplissez le formulaire pour créer un [intervalle de temps à comparer](#v10-alerting-manage-muting-interval) à votre temps de mise en sourdine.
1. Enregistrez votre temps de mise en sourdine.
## Ajouter une temporisation muette à une politique de notification
Une fois que vous avez défini le temps de mise en sourdine, vous pouvez l'utiliser en l'ajoutant à la politique de notification que vous souhaitez désactiver à intervalles réguliers.
**Pour ajouter une temporisation muette à une politique de notification**
1. **Depuis votre console Grafana, dans le menu Grafana, choisissez Alerting.**
1. Choisissez **Politiques de notification**, puis sélectionnez l'onglet **Politiques de notification**.
1. **Sélectionnez la politique de notification à laquelle vous souhaitez ajouter le temps de sourdine, puis choisissez...** , **Modifier**.
1. Dans le menu déroulant Durée de **mise en sourdine**, sélectionnez la durée de mise en sourdine que vous souhaitez ajouter à la politique.
1. Enregistrez vos modifications.
## Intervalles de temps
Un intervalle de temps est une durée spécifique pendant laquelle les alertes sont supprimées. La durée comprend généralement une plage de temps spécifique et les jours de la semaine, du mois ou de l'année.
Support : les options d'intervalle de temps sont les suivantes :
+ **Plage horaire** : heure comprise entre l'heure de début et l'heure de fin (en UTC, si aucun lieu n'a été sélectionné, sinon heure locale).
+ **Emplacement** — Définit le lieu pour le chronométrage : la plage horaire est affichée en heure locale pour le lieu.
+ **Jours de la semaine** : jour ou plage de jours de la semaine. Par exemple, `monday:thursday`.
+ **Jours du mois** : dates comprises dans un mois. Les valeurs peuvent être comprises entre `1` -`31`. Les valeurs négatives indiquent les jours du mois dans l'ordre inverse, ce `-1` qui représente le dernier jour du mois.
+ **Mois** — Les mois de l'année sont exprimés sous forme numérique ou sous le nom complet du mois calendaire. Par exemple, `1, may:august`.
+ **Années** : année ou années de l'intervalle. Par exemple, `2023:2024`.
Chacun de ces éléments peut être une liste, et au moins un élément de l'élément doit être satisfait pour correspondre. Les champs prennent également en charge les plages, en utilisant`:`. Par exemple, `monday:thursday`.
Si un champ est laissé vide, le champ correspondra à tout moment. Pour qu'un instant corresponde à un intervalle de temps complet, tous les champs doivent correspondre. Une temporisation muette peut contenir plusieurs intervalles de temps.
Si vous souhaitez spécifier une durée exacte, spécifiez toutes les options nécessaires pour cette durée. Par exemple, si vous souhaitez créer un intervalle de temps pour le premier lundi du mois, pour mars, juin, septembre et décembre, entre 12 h 00 et 24 h 00 UTC, votre spécification d'intervalle de temps peut être la suivante :
+ Plage de temps :
+ Heure de début : `12:00`
+ Heure de fin : `24:00`
+ Jours de la semaine : `monday`
+ Mois : `3, 6, 9, 12`
+ Jours du mois : `1:7`
# Afficher l'état et l'état des règles d'alerte
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Les règles relatives à l'état et à l'état des alertes vous fournissent plusieurs indicateurs de statut clés concernant vos alertes.
Il y a trois composantes :
+ [État de la règle d'alerte](#v10-alerting-manage-rulestate-state)
+ [État de l'instance d'alerte](#v10-alerting-manage-rulestate-instance)
+ [État des règles d'alerte](#v10-alerting-manage-rulestate-health)
Bien que lié, chaque composant transmet des informations subtilement différentes.
**Pour consulter l'état et l'état de vos règles d'alerte**
1. **Depuis votre console Grafana, dans le menu Grafana, choisissez Alerting.**
1. Choisissez **Règles d'alerte** pour afficher la liste des alertes existantes.
1. Choisissez une règle d'alerte pour voir son état et son état de santé.
## État de la règle d'alerte
Une règle d'alerte peut avoir l'un des états suivants :
| State | Description |
| --- | --- |
| Normal | Aucune des séries chronologiques renvoyées par le moteur d'évaluation n'est à firing l'état pending or. |
| En suspens | Au moins une série chronologique renvoyée par le moteur d'évaluation estpending. |
| Mise à feu | Au moins une série chronologique renvoyée par le moteur d'évaluation estfiring. |
**Note**
Les alertes passent d'abord à `pending` puis`firing`, il faut donc au moins deux cycles d'évaluation avant qu'une alerte ne soit déclenchée.
## État de l'instance d'alerte
Une instance d'alerte peut se trouver dans l'un des états suivants :
| State | Description |
| --- | --- |
| Normal | État d'une alerte qui n'est ni « pending ni firing ». Tout fonctionne comme prévu. |
| En suspens | État d'une alerte active pendant une durée inférieure au seuil configuré. |
| Alerte | État d'une alerte active pendant une durée supérieure au seuil configuré. |
| Aucune donnée | Aucune donnée n'a été reçue pour la fenêtre horaire configurée. |
| Alerte | Une erreur s'est produite lors de la tentative d'évaluation d'une règle d'alerte. |
## Conserver le dernier état
Une règle d'alerte peut être configurée pour conserver le dernier état lorsqu'un `Error` état `NoData` ou est détecté. Cela empêchera à la fois le déclenchement des alertes, leur résolution et leur réactivation. Tout comme dans le cas d'une évaluation normale, la règle d'alerte passera de `pending` à une `firing` fois la période d'attente écoulée.
## État des règles d'alerte
Une règle d'alerte peut avoir l'un des états de santé suivants.
| State | Description |
| --- | --- |
| D'accord | Aucune erreur lors de l'évaluation de la règle d'alerte. |
| Error (Erreur) | Une erreur s'est produite lors de l'évaluation de la règle d'alerte. |
| NoData | Absence de données dans au moins une série chronologique renvoyée lors de l'évaluation d'une règle. |
| \$1statut\$1, KeepLast | La règle aurait reçu un autre statut, mais elle a été configurée pour conserver le dernier état de la règle d'alerte. |
## Alertes spéciales en cas NoData d'erreur
Lorsque l'évaluation d'une règle d'alerte produit l'état `NoData` ou`Error`, l'alerte Grafana génère des instances d'alerte portant les étiquettes supplémentaires suivantes.
| Étiquette | Description |
| --- | --- |
| nom de l'alerte | SoitDatasourceError, DatasourceNoData soit, selon l'état. |
| dataource\$1uid | L'UID de la source de données à l'origine de l'état. |
**Note**
Vous devez définir la règle d'absence de données ou de gestion des erreurs sur `NoData` ou `Error` dans la règle d'alerte, comme décrit dans la [Configurer les règles d'alerte gérées par Grafana](v10-alerting-configure-grafanamanaged.md) rubrique, pour générer les étiquettes supplémentaires.
Vous pouvez gérer ces alertes de la même manière que les alertes classiques, notamment en ajoutant des silences, en les acheminant vers un point de contact, etc.
# Afficher et filtrer par groupes d'alertes
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana compatibles avec la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Les groupes d'alertes affichent les alertes groupées provenant d'une instance d'Alertmanager. Par défaut, les règles d'alerte sont regroupées en fonction des clés d'étiquette correspondant à la politique par défaut dans les politiques de notification. Le regroupement des règles d'alerte communes dans un seul groupe d'alertes empêche le déclenchement de règles d'alerte dupliquées.
Vous pouvez afficher les groupes d'alertes et également filtrer les règles d'alerte correspondant à des critères spécifiques.
**Pour afficher les groupes d'alertes**
1. **Depuis votre console Grafana, dans le menu Grafana, choisissez Alerting.**
1. Choisissez **Groupes** pour afficher les groupes existants.
1. Dans le menu déroulant **Alertmanager**, sélectionnez un Alertmanager externe comme source de données.
1. Dans le menu déroulant **Grouper par personnalisé**, sélectionnez une combinaison d'étiquettes pour afficher un regroupement autre que celui par défaut. Cela est utile pour déboguer et vérifier votre regroupement de politiques de notification.
Si une alerte ne contient aucune étiquette spécifiée dans le regroupement de la politique racine ou dans le regroupement personnalisé, l'alerte est ajoutée à un groupe catch all avec un en-tête de`No grouping`.
Vous pouvez filtrer les alertes par étiquette ou par état des alertes.
**Pour filtrer par étiquette**
+ Dans **Rechercher**, entrez une étiquette existante pour afficher les alertes correspondant à cette étiquette.
Par exemple, `environment=production,region=~US|EU,severity!=warning`.
**Pour filtrer par état**
+ Dans **États**, sélectionnez l'état actif, supprimé ou non traité pour afficher les alertes correspondant à l'état sélectionné. Toutes les autres alertes sont masquées.
# Afficher les erreurs de notification
****
**Cette rubrique de documentation est conçue pour les espaces de travail Grafana qui prennent en charge la version 10.x de Grafana.**
Pour les espaces de travail Grafana compatibles avec la version 9.x de Grafana, voir. [Travailler dans la version 9 de Grafana](using-grafana-v9.md)
Pour les espaces de travail Grafana compatibles avec la version 8.x de Grafana, voir. [Travailler dans la version 8 de Grafana](using-grafana-v8.md)
Consultez les erreurs de notification et comprenez pourquoi elles n'ont pas été envoyées ou n'ont pas été reçues.
**Note**
Cette fonctionnalité n'est prise en charge que pour Grafana Alertmanager.
**Pour afficher les erreurs de notification**
1. Dans le menu de gauche, choisissez **Alerte** puis **Points de contact**.
Si l'un des points de contact est défaillant, un message dans le coin droit de l'espace de travail vous indique qu'il y a des erreurs et leur nombre.
1. Sélectionnez un point de contact pour afficher le détail des erreurs associées à ce point de contact.
Les détails de l'erreur s'affichent si vous passez le curseur sur l'icône d'erreur.
Si un point de contact possède plusieurs intégrations, toutes les erreurs s'affichent pour chacune des intégrations répertoriées.
1. Dans la colonne Health, vérifiez l'état de la notification.
Cela peut être OK, Aucune tentative ou Erreur.