Prometheus Alarme

Einführung

Effektives Monitoring bedeutet nicht nur das Sammeln von Metriken, sondern auch das Benachrichtigtwerden, wenn Probleme auftreten. Prometheus verfügt über ein leistungsstarkes, integriertes Alarmierungssystem, mit dem Sie Alarmbedingungen mithilfe derselben PromQL-Abfragesprache definieren können, die Sie auch für die grafische Darstellung verwenden. Wenn die Bedingung eines Alarms erfüllt ist, wechselt dieser in einen „Feuernden“ (firing) Zustand.

In diesem Lab lernen Sie die Grundlagen der Prometheus-Alarmierung kennen. Sie beginnen mit einer vorkonfigurierten Umgebung, in der Prometheus und ein Node Exporter laufen. Ihre Aufgabe wird es sein, eine separate Alarmregeldatei zu erstellen, eine Regel zur Erkennung hoher CPU-Auslastung zu definieren, Prometheus so zu konfigurieren, dass diese Datei geladen wird, und schließlich eine hohe CPU-Last zu simulieren, um zu beobachten, wie Ihr Alarm in der Prometheus-Benutzeroberfläche ausgelöst wird.

Die Alarmierungsumgebung verstehen

In diesem Schritt machen Sie sich mit der Lab-Umgebung vertraut. Das Setup-Skript hat bereits zwei Docker-Container für Sie gestartet: einen für Prometheus und einen für den Node Exporter.

Überprüfen wir zunächst, ob beide Container laufen. Öffnen Sie ein Terminal und führen Sie den Befehl docker ps aus:

docker ps

Sie sollten eine Ausgabe sehen, die der folgenden ähnelt und die Container prometheus und node-exporter im Status „Up“ anzeigt.

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

Der Container node-exporter stellt Metriken über das Hostsystem (unsere Lab-VM) bereit, und der Container prometheus ist so konfiguriert, dass er diese Metriken „scrapt“ (erfasst).

Überprüfen wir nun die Prometheus-Benutzeroberfläche (UI). Um darauf zuzugreifen:

1. Klicken Sie in der LabEx-Oberfläche auf die Schaltfläche + (Neuer Tab) in der oberen Navigationsleiste.
2. Wählen Sie im Dropdown-Menü Web Service.
3. Geben Sie für die Portnummer 9090 ein.
4. Klicken Sie auf Open, um die Prometheus-Weboberfläche zu starten.

Wenn sich der neue Tab öffnet, sollten Sie die Landingpage des Prometheus Expression Browsers sehen. Navigieren Sie im oberen Menü zu Status -> Targets. Sie sollten sehen, dass der Job node_exporter den grünen Status „UP“ hat, was bestätigt, dass Prometheus erfolgreich Daten von ihm sammelt. Diese Verbindung ist die Grundlage für unsere Alarmregel.

Erstellen von alert-rules.yml für den High CPU Alert

In diesem Schritt erstellen Sie eine dedizierte Datei für Ihre Alarmregeln. Es ist eine bewährte Methode, Regeln zur besseren Organisation von der Hauptkonfiguration von Prometheus getrennt zu halten.

Wir erstellen eine Datei namens alert-rules.yml in Ihrem Projektverzeichnis. Verwenden Sie den nano-Editor, um die Datei zu erstellen und zu bearbeiten:

nano ~/project/alert-rules.yml

Kopieren Sie nun den folgenden YAML-Inhalt und fügen Sie ihn in den nano-Editor ein. Dies definiert eine Regelgruppe, die eine einzelne Alarmierung enthält, die ausgelöst wird, wenn die CPU-Auslastung hoch ist.

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

Schlüsseln wir diese Regel auf:

• groups: Regeln werden in Gruppen organisiert. Alle Regeln in einer Gruppe werden sequenziell ausgewertet.
• alert: Der Name unseres Alarms, HighCpuLoad.
• expr: Der PromQL-Ausdruck, der ausgewertet wird. Wenn er einen Wert zurückgibt, wird der Alarm ausgelöst. Hier berechnen wir den Prozentsatz der Nicht-Leerlauf-CPU-Zeit der letzten Minute. Wenn dieser Wert größer als 10 % ist, ist die Bedingung erfüllt.
• for: Diese Klausel legt fest, dass die Bedingung für eine kontinuierliche Dauer (1 Minute) wahr sein muss, bevor der Alarm in den Zustand „Firing“ (Feuernd) wechselt. Dies verhindert, dass Alarme bei kurzen Spitzen ausgelöst werden.
• annotations: Diese fügen dem Alarm menschenlesbare Informationen hinzu. summary und description sind Standard-Annotationen. Sie können Variablen wie {{ $labels.instance }} und {{ $value }} verwenden, um dynamische Daten in Ihre Alarmmeldungen einzufügen.

Nachdem Sie den Inhalt eingefügt haben, speichern Sie die Datei und beenden Sie nano, indem Sie Ctrl+X, dann Y und dann Enter drücken.

Prometheus Container mit eingebundener Regelsdatei ausführen

In diesem Schritt weisen Sie Prometheus an, Ihre neue Regelsdatei zu laden, und starten den Container mit der aktualisierten Konfiguration neu.

Zuerst müssen Sie die Hauptkonfigurationsdatei, prometheus.yml, bearbeiten, um einen Verweis auf Ihre Regelsdatei aufzunehmen. Öffnen Sie sie mit nano:

nano ~/project/prometheus.yml

Fügen Sie die Direktive rule_files unter der Sektion global hinzu. Die Datei sollte nach Ihren Änderungen wie folgt aussehen:

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

Speichern Sie die Datei und beenden Sie nano (Ctrl+X, Y, Enter).

Nachdem die Konfiguration aktualisiert wurde, müssen Sie den Prometheus-Container neu starten, um die Änderungen zu übernehmen. Stoppen und entfernen Sie zuerst den alten Container:

docker stop prometheus

docker rm prometheus

Führen Sie schließlich einen neuen Prometheus-Container aus. Dieser Befehl ähnelt dem aus dem Setup-Skript, enthält jedoch ein zweites -v-Flag, um Ihre Datei alert-rules.yml in den Container einzubinden (mounten).

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

Dieser Befehl stellt sicher, dass sowohl die Hauptkonfiguration als auch die Alarmregeln im Prometheus-Container verfügbar sind.

Alarmregeln in der Prometheus UI überprüfen

In diesem Schritt überprüfen Sie, ob Prometheus Ihre neue Alarmregel erfolgreich geladen hat.

Gehen Sie zurück zum Tab der Prometheus UI in Ihrem Browser (oder öffnen Sie bei Bedarf einen neuen Web Service Tab auf Port 9090). Falls die Seite nicht lädt, warten Sie einige Sekunden, bis der neue Container gestartet ist, und aktualisieren Sie dann die Seite.

Klicken Sie in der oberen Navigationsleiste auf den Menüpunkt Alerts.

Sie sollten nun Ihren Alarm HighCpuLoad in der Liste sehen. Der Alarm befindet sich im Abschnitt Inactive (Inaktiv), gekennzeichnet durch einen grünen Hintergrund. Dies ist der erwartete Zustand, da die CPU-Auslastung auf dem System derzeit niedrig ist und der Ausdruck (expr) des Alarms somit zu „false“ ausgewertet wird.

Es ist wichtig, die drei Zustände eines Alarms zu verstehen:

• Inactive (Grün): Die Alarmbedingung ist falsch.
• Pending (Gelb): Die Alarmbedingung ist wahr geworden, aber die for-Dauer ist noch nicht abgelaufen. Prometheus wartet darauf, ob die Bedingung bestehen bleibt.
• Firing (Rot): Die Alarmbedingung war für die gesamte for-Dauer wahr. In einer Produktionsumgebung würde Prometheus den Alarm dann an einen Alertmanager senden.

Ihr Alarm ist derzeit inaktiv, was korrekt ist. Im nächsten Schritt werden wir bewirken, dass er ausgelöst wird (Firing).

Last simulieren, um das Auslösen des Alarms zu testen

In diesem letzten Schritt erhöhen Sie absichtlich die CPU-Last auf dem System, um zu testen, ob Ihr Alarm korrekt ausgelöst wird.

Wir können die CPU-Last mithilfe einer einfachen, unendlichen Shell-Schleife erzeugen. Führen Sie in Ihrem Terminal den folgenden Befehl aus. Das & am Ende führt den Prozess im Hintergrund aus, sodass Sie Ihr Terminal weiter verwenden können.

while true; do true; done &

Dieser Befehl startet einen Prozess, der 100% eines einzelnen CPU-Kerns verbraucht. Wechseln Sie nun schnell zurück zur Seite Alerts in der Prometheus UI (zugänglich über den Web Service Tab auf Port 9090).

Sie werden beobachten, wie sich der Zustand des Alarms HighCpuLoad ändert:

1. Innerhalb von etwa 15–30 Sekunden wird der Ausdruck des Alarms wahr. Der Alarm wechselt in den Abschnitt Pending (Ausstehend) und wird gelb. Das bedeutet, Prometheus hat die hohe CPU-Last erkannt, wartet aber noch auf die in der for-Klausel angegebene Dauer von 1m.
2. Nachdem der Alarm eine Minute lang im Pending-Zustand war, wechselt er in den Abschnitt Firing (Auslösend) und wird rot. Dies bestätigt, dass Ihre Alarmregel wie erwartet funktioniert! Sie können den Alarm erweitern, um die von Ihnen definierten Annotationen inklusive des aktuellen Wertes zu sehen.

Sobald Sie gesehen haben, dass der Alarm ausgelöst wurde, können Sie die Lastgenerierung stoppen. Gehen Sie zurück zu Ihrem Terminal und führen Sie den folgenden Befehl aus, um den Hintergrundprozess der Schleife zu beenden:

Wichtig: Um Ressourcen auf dem LabEx VM Server zu schonen, stellen Sie bitte sicher, dass Sie den folgenden Befehl ausführen, um die Lastgenerierung zu stoppen.

kill $!

Nach dem Stoppen der Last beobachten Sie erneut die Prometheus UI. Der Alarm wird bald wieder in den Zustand Inactive (Grün) zurückkehren und damit den Testzyklus abschließen.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben erfolgreich einen Prometheus-Alarm konfiguriert und getestet.

In diesem Lab haben Sie gelernt, wie man:

• Alarmregeln in einer separaten YAML-Datei strukturiert.
• Einen PromQL-Ausdruck schreibt, um eine Alarmbedingung für hohe CPU-Auslastung zu definieren.
• Annotationen verwendet, um aussagekräftige, menschenlesbare Alarmmeldungen zu erstellen.
• Prometheus so konfiguriert, dass es Ihre Regeldateien lädt, und es neu startet, um Änderungen zu übernehmen.
• Den Lebenszyklus eines Alarms in der Prometheus UI beobachtet, von Inactive über Pending bis hin zu Firing.
• Eine Bedingung simuliert, um Ihren Alarm auszulösen und zu testen.

Dies ist die erste Hälfte des Alerting-Bildes. Der nächste logische Schritt, der außerhalb des Rahmens dieses Labs liegt, wäre die Einrichtung einer Alertmanager-Instanz. Prometheus würde seine auslösenden Alarme an den Alertmanager senden, der dann für die Deduplizierung, Gruppierung und Weiterleitung an tatsächliche Benachrichtigungskanäle wie E-Mail, Slack oder PagerDuty verantwortlich wäre.