Alertes Prometheus : Créer et Déclencher des Alertes de CPU Élevé

Introduction

Une surveillance efficace ne consiste pas seulement à collecter des métriques ; il s'agit d'être notifié lorsque quelque chose ne va pas. Prometheus dispose d'un système d'alerte intégré et puissant qui vous permet de définir des conditions d'alerte en utilisant le même langage de requête PromQL que vous utilisez pour le traçage graphique. Lorsqu'une condition d'alerte est remplie, elle passe à l'état "en cours de déclenchement" (firing).

Dans ce laboratoire, vous apprendrez les fondamentaux de l'alerte Prometheus. Vous commencerez avec un environnement préconfiguré exécutant Prometheus et un Node Exporter. Votre tâche consistera à créer un fichier de règles d'alerte séparé, à définir une règle pour détecter une utilisation élevée du CPU, à configurer Prometheus pour charger ce fichier, et enfin, à simuler une charge CPU élevée pour observer le déclenchement de votre alerte dans l'interface utilisateur de Prometheus.

Comprendre l'Environnement d'Alerte

Dans cette étape, vous vous familiariserez avec l'environnement du laboratoire. Le script de configuration a déjà démarré deux conteneurs Docker pour vous : un pour Prometheus et un pour Node Exporter.

Tout d'abord, vérifions que les deux conteneurs sont en cours d'exécution. Ouvrez un terminal et exécutez la commande docker ps :

docker ps

Vous devriez voir une sortie similaire à ce qui suit, montrant les conteneurs prometheus et node-exporter dans un état "Up" (Actif).

CONTAINER ID   IMAGE                           COMMAND                  CREATED          STATUS          PORTS                                       NAMES
...            prom/prometheus                 "/bin/prometheus --c…"   15 seconds ago   Up 14 seconds   0.0.0.0:9090->9090/tcp, :::9090->9090/tcp   prometheus
...            prom/node-exporter               "/bin/node_exporter …"   16 seconds ago   Up 15 seconds   0.0.0.0:9100->9100/tcp, :::9100->9100/tcp   node-exporter

Le conteneur node-exporter expose des métriques concernant le système hôte (notre VM de laboratoire), et le conteneur prometheus est configuré pour scraper (collecter) ces métriques.

Maintenant, vérifions l'interface utilisateur (UI) de Prometheus. Pour y accéder :

Dans l'interface LabEx, cliquez sur le bouton + (Nouvel Onglet) dans la barre de navigation supérieure.
Choisissez Web Service dans le menu déroulant.
Entrez 9090 pour le numéro de port.
Cliquez sur Open pour lancer l'interface web de Prometheus.

Lors de l'ouverture du nouvel onglet, vous devriez voir la page d'accueil du Navigateur d'Expressions (Expression Browser) de Prometheus. Naviguez vers Status -> Targets depuis le menu de navigation supérieur. Vous devriez voir que le job node_exporter affiche un état vert "UP", confirmant que Prometheus collecte les données avec succès depuis celui-ci. Cette connexion est le fondement de notre règle d'alerte.

Créer alert-rules.yml pour l'Alerte de CPU Élevé

Dans cette étape, vous allez créer un fichier dédié à vos règles d'alerte. Il est recommandé de séparer les règles de la configuration principale de Prometheus pour une meilleure organisation.

Nous allons créer un fichier nommé alert-rules.yml dans votre répertoire de projet. Utilisez l'éditeur nano pour créer et éditer le fichier :

nano ~/project/alert-rules.yml

Maintenant, copiez et collez le contenu YAML suivant dans l'éditeur nano. Ceci définit un groupe de règles contenant une alerte unique qui se déclenche lorsque l'utilisation du CPU est élevée.

groups:
  - name: node_alerts
    rules:
      - alert: HighCpuLoad
        expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[1m])) * 100) > 10
        for: 1m
        labels:
          severity: warning
        annotations:
          summary: "High CPU load on {{ $labels.instance }}"
          description: "CPU load is > 10% (current value: {{ $value }}%)"

Décortiquons cette règle :

groups: Les règles sont organisées en groupes. Toutes les règles d'un groupe sont évaluées séquentiellement.
alert: Le nom de notre alerte, HighCpuLoad.
expr: L'expression PromQL qui est évaluée. Si elle retourne une valeur, l'alerte est déclenchée. Ici, nous calculons le pourcentage de temps CPU non inactif (non-idle) au cours de la dernière minute. Si ce pourcentage est supérieur à 10 %, la condition est remplie.
for: Cette clause spécifie que la condition doit être vraie pendant une durée continue (1 minute) avant que l'alerte ne passe à l'état "Firing" (En cours de déclenchement). Ceci empêche les alertes de se déclencher sur de brèves pointes.
annotations: Celles-ci ajoutent des informations lisibles par l'homme à l'alerte. summary (résumé) et description sont des annotations standards. Vous pouvez utiliser des variables de modèle (template variables) comme {{ $labels.instance }} et {{ $value }} pour inclure des données dynamiques dans vos messages d'alerte.

Après avoir collé le contenu, enregistrez le fichier et quittez nano en appuyant sur Ctrl+X, puis Y, et enfin Enter.

Exécuter le Conteneur Prometheus avec le Fichier de Règles Monté

Dans cette étape, vous allez indiquer à Prometheus de charger votre nouveau fichier de règles et redémarrer le conteneur avec la configuration mise à jour.

Tout d'abord, vous devez modifier le fichier de configuration principal, prometheus.yml, pour y inclure une référence à votre fichier de règles. Ouvrez-le avec nano :

nano ~/project/prometheus.yml

Ajoutez la directive rule_files sous la section global. Le fichier devrait ressembler à ceci après vos modifications :

global:
  scrape_interval: 15s
  rule_files:
    - "alert-rules.yml"

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["prometheus:9090"]
  - job_name: "node_exporter"
    static_configs:
      - targets: ["node-exporter:9100"]

Enregistrez le fichier et quittez nano (Ctrl+X, Y, Enter).

Maintenant que la configuration est mise à jour, vous devez redémarrer le conteneur Prometheus pour appliquer les changements. Arrêtez et supprimez d'abord l'ancien conteneur :

docker stop prometheus

docker rm prometheus

Enfin, exécutez un nouveau conteneur Prometheus. Cette commande est similaire à celle du script de configuration, mais elle inclut un deuxième flag -v pour monter votre fichier alert-rules.yml dans le conteneur.

docker run -d --name prometheus -p 9090:9090 \
  --network monitoring \
  -v /home/labex/project/prometheus.yml:/etc/prometheus/prometheus.yml \
  -v /home/labex/project/alert-rules.yml:/etc/prometheus/alert-rules.yml \
  prom/prometheus

Cette commande garantit que la configuration principale ainsi que les règles d'alerte sont disponibles à l'intérieur du conteneur Prometheus.

Vérifier le Chargement des Règles d'Alerte dans l'Interface Utilisateur de Prometheus

Dans cette étape, vous allez confirmer que Prometheus a chargé avec succès votre nouvelle règle d'alerte.

Retournez à l'onglet de l'interface utilisateur (UI) de Prometheus dans votre navigateur (ou ouvrez un nouvel onglet de Service Web sur le port 9090 si nécessaire). Si la page ne se charge pas, attendez quelques secondes que le nouveau conteneur démarre, puis actualisez la page.

Dans la barre de navigation supérieure, cliquez sur l'élément de menu Alerts (Alertes).

Vous devriez maintenant voir votre alerte HighCpuLoad listée. L'alerte se trouvera dans la section Inactive, indiquée par un fond vert. C'est l'état attendu car la charge CPU sur le système est actuellement faible, donc l'expression de l'alerte (expr) s'évalue à faux.

Il est important de comprendre les trois états d'une alerte :

Inactive (Vert) : La condition de l'alerte est fausse.
Pending (Jaune) : La condition de l'alerte est devenue vraie, mais la durée spécifiée par for n'est pas encore écoulée. Prometheus attend de voir si la condition persiste.
Firing (Rouge) : La condition de l'alerte est restée vraie pendant toute la durée spécifiée par for. Dans une configuration de production, c'est à ce moment que Prometheus enverrait l'alerte à un Alertmanager.

Votre alerte est actuellement inactive, ce qui est correct. Dans l'étape suivante, nous allons la faire passer à l'état "Firing".

Simuler une Charge pour Tester le Déclenchement de l'Alerte

Dans cette dernière étape, vous allez intentionnellement augmenter la charge CPU sur le système pour tester si votre alerte se déclenche correctement.

Nous pouvons générer une charge CPU en utilisant une boucle shell simple et infinie. Dans votre terminal, exécutez la commande suivante. Le & à la fin exécutera le processus en arrière-plan, vous permettant de continuer à utiliser votre terminal.

while true; do true; done &

Cette commande démarre un processus qui consomme 100 % d'un seul cœur CPU. Maintenant, basculez rapidement vers la page Alerts dans l'interface utilisateur de Prometheus (accessible via l'onglet Service Web sur le port 9090).

Vous observerez le changement d'état de l'alerte HighCpuLoad :

En environ 15 à 30 secondes, l'expression de l'alerte deviendra vraie. L'alerte passera à la section Pending (En attente) et deviendra jaune. Cela signifie que Prometheus a détecté la charge CPU élevée mais attend la durée de 1m spécifiée dans la clause for.
Après être restée dans l'état Pending pendant une minute, l'alerte passera à la section Firing (En cours de déclenchement) et deviendra rouge. Cela confirme que votre règle d'alerte fonctionne comme prévu ! Vous pouvez développer l'alerte pour voir les annotations que vous avez définies, complétées par la valeur actuelle.

Une fois que vous avez vu l'alerte se déclencher, vous pouvez arrêter la génération de charge. Retournez à votre terminal et exécutez la commande suivante pour arrêter le processus de boucle en arrière-plan :

Important : Pour économiser les ressources du serveur VM LabEx, veuillez vous assurer d'exécuter la commande suivante pour arrêter la génération de charge.

kill $!

Après avoir arrêté la charge, observez à nouveau l'interface utilisateur de Prometheus. L'alerte reviendra bientôt à l'état Inactive (vert), complétant ainsi le cycle de test.

Résumé

Félicitations ! Vous avez réussi à configurer et à tester une alerte Prometheus.

Dans ce laboratoire, vous avez appris à :

Structurer les règles d'alerte dans un fichier YAML séparé.
Écrire une expression PromQL pour définir une condition d'alerte pour une utilisation CPU élevée.
Utiliser des annotations pour créer des messages d'alerte significatifs et lisibles par l'homme.
Configurer Prometheus pour charger vos fichiers de règles et le redémarrer pour appliquer les changements.
Observer le cycle de vie d'une alerte dans l'interface utilisateur de Prometheus, de Inactive à Pending puis à Firing.
Simuler une condition pour déclencher et tester votre alerte.

Ceci représente la première moitié du tableau général de l'alerte. L'étape logique suivante, qui est hors du cadre de ce laboratoire, serait de configurer une instance Alertmanager. Prometheus enverrait ses alertes en cours de déclenchement à l'Alertmanager, qui serait alors responsable de la déduplication, du regroupement et du routage de celles-ci vers des canaux de notification réels comme l'e-mail, Slack ou PagerDuty.