Créez et gérez des ressources d'alerte à l'aide de Terraform

Créez un nouveau compte de service pour votre pipeline CI.

Attribuez le rôle « Accéder à l'API de provisionnement des règles d'alerte ».

Créez un nouveau jeton de compte de service.

Nommez et enregistrez le jeton pour l'utiliser dans Terraform.

Copiez ce bloc de code dans un fichier .tf sur votre machine locale. Remplacez < slack-webhook-url > 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 = <slack-webhook-url>
        text = <<EOT
{{ len .Alerts.Firing }} alerts are firing!

Alert summaries:
{{ range .Alerts.Firing }}
{{ template "Alert Instance Template" . }}
{{ end }}
EOT
    }
}

Entrez le texte de votre notification dans le champ de texte.

Le text champ prend en charge les modèles de style GO. Cela vous permet de gérer vos modèles de notification Grafana Alerting directement dans Terraform.

Exécutez la commande terraform apply.

Accédez à l'interface utilisateur de Grafana et vérifiez les coordonnées de votre point de contact.

Vous ne pouvez pas modifier les ressources fournies via Terraform depuis l'interface utilisateur. Cela garantit que votre pile d'alertes reste toujours synchronisée avec votre code.

Cliquez sur Tester pour vérifier que le point de contact fonctionne correctement.

Copiez ce bloc de code dans un fichier .tf sur votre machine locale.

Dans cet exemple, les alertes sont regroupées paralertname, 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 = ["..."]
        }
    }
}

Dans le champ mute_timings, associez une temporisation muette à votre politique de notification.

Exécutez la commande terraform apply.

Accédez à l'interface utilisateur de Grafana et vérifiez les détails de votre politique de notification.

Cliquez sur Tester pour vérifier que le point de notification fonctionne correctement.

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"]
    }
}

Exécutez la commande terraform apply.

Accédez à l'interface utilisateur de Grafana et vérifiez les détails de votre temps de sourdine.

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.

Cliquez sur Tester pour vérifier que le temps de sourdine fonctionne correctement.

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 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"
}

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.

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 = <<EOT
{"conditions":[{"evaluator":{"params":[0,0],"type":"gt"},"operator":{"type":"and"},"query":{"params":["A"]},"reducer":{"params":[],"type":"last"},"type":"avg"}],"datasource":{"name":"Expression","type":"__expr__","uid":"__expr__"},"expression":"A","hide":false,"intervalMs":1000,"maxDataPoints":43200,"reducer":"last","refId":"B","type":"reduce"}
EOT
            ref_id = "B"
            relative_time_range {
                from = 0
                to = 0
            }
        }

        // Now, let's use a math expression as our threshold.
        // We want to alert when the value of stage "B" above exceeds 70.
        data {
            datasource_uid = "__expr__"
            ref_id = "C"
            relative_time_range {
                from = 0
                to = 0
            }
            model = jsonencode({
                expression = "$B > 70"
                type = "math"
                refId = "C"
            })
        }
    }
}

Accédez à l'interface utilisateur de Grafana et vérifiez votre règle d'alerte.

Vous pouvez voir si la règle d'alerte se déclenche. Vous pouvez également voir une visualisation de chacune des étapes de requête de la règle d'alerte.

Lorsque l'alerte se déclenche, Grafana achemine une notification via la politique que vous avez définie.

Par exemple, si vous avez choisi Slack comme point de contact, le gestionnaire d'alertes intégré de Grafana publie automatiquement un message sur Slack.