Prometheus-Alerts: Alarme bei hoher CPU-Auslastung erstellen und auslösen

Einführung

Effektives Monitoring bedeutet nicht nur, Metriken zu sammeln, sondern auch benachrichtigt zu werden, wenn etwas schiefgeht. Prometheus verfügt über ein leistungsstarkes, integriertes Alerting-System, mit dem Sie Alarmbedingungen mithilfe derselben PromQL-Abfragesprache definieren können, die Sie auch für die Visualisierung verwenden. Wenn die Bedingung eines Alarms erfüllt ist, wechselt dieser in den Status „Firing“ (aktiv).

In diesem Lab lernen Sie die Grundlagen des Prometheus-Alertings kennen. Sie beginnen mit einer vorkonfigurierten Umgebung, in der Prometheus und ein Node Exporter laufen. Ihre Aufgabe ist es, eine separate Datei für Alerting-Regeln zu erstellen, eine Regel zur Erkennung hoher CPU-Auslastung zu definieren, Prometheus für das Laden dieser Datei zu konfigurieren und schließlich eine hohe CPU-Last zu simulieren, um das Auslösen des Alarms in der Prometheus-Benutzeroberfläche zu beobachten.

Die Alerting-Umgebung 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 ähnlich der folgenden sehen, die zeigt, dass sich die Container prometheus und node-exporter im Status „Up“ befinden.

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 node-exporter-Container stellt Metriken über das Host-System (unsere Lab-VM) bereit, und der prometheus-Container ist so konfiguriert, dass er diese Metriken abruft (collect).

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

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

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

Prometheus Targets UI

alert-rules.yml für CPU-Alarme erstellen

In diesem Schritt erstellen Sie eine dedizierte Datei für Ihre Alerting-Regeln. Es ist eine bewährte Methode, Regeln getrennt von der Hauptkonfiguration von Prometheus zu halten, um eine bessere Übersichtlichkeit zu gewährleisten.

Wir erstellen eine Datei namens alert-rules.yml in Ihrem Projektverzeichnis. Verwenden Sie den Editor nano, 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 einen einzelnen Alarm enthält, der bei hoher CPU-Auslastung ausgelöst wird.

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 innerhalb einer Gruppe werden nacheinander 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 CPU-Zeit, die nicht im Leerlauf (idle) verbracht wurde, über die letzte 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 den Status „Firing“ annimmt. Dies verhindert, dass Alarme bei kurzen Lastspitzen ausgelöst werden.
annotations: Diese fügen dem Alarm menschenlesbare Informationen hinzu. summary und description sind Standard-Annotationen. Sie können Template-Variablen wie {{ $labels.instance }} und {{ $value }} verwenden, um dynamische Daten in Ihre Alarmmeldungen einzubinden.

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

Prometheus-Container mit eingebundener Regeldatei ausführen

In diesem Schritt weisen Sie Prometheus an, Ihre neue Regeldatei 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 Regeldatei hinzuzufügen. Öffnen Sie sie mit nano:

nano ~/project/prometheus.yml

Fügen Sie die rule_files-Direktive auf der obersten Ebene der Datei hinzu, nicht innerhalb des global-Blocks. 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).

Da die Konfiguration nun aktualisiert ist, 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

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

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 Alerting-Regeln innerhalb des Prometheus-Containers verfügbar sind.

Überprüfung der geladenen Alert-Regeln in der Prometheus-UI

In diesem Schritt bestätigen Sie, dass Prometheus Ihre neue Alerting-Regel 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). Wenn 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 HighCpuLoad-Alarm aufgelistet sehen. Der Alarm befindet sich im Bereich Inactive, was durch einen grünen Hintergrund angezeigt wird. Dies ist der erwartete Zustand, da die CPU-Auslastung des Systems derzeit niedrig ist und der Ausdruck (expr) des Alarms daher als „falsch“ ausgewertet wird.

Prometheus Inactive Alert

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 ab, 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 nun an einen Alertmanager senden.

Ihr Alarm ist derzeit inaktiv, was korrekt ist. Im nächsten Schritt werden wir ihn auslösen.

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

In diesem letzten Schritt erhöhen Sie absichtlich die CPU-Auslastung des Systems, um zu testen, ob Ihr Alarm korrekt ausgelöst wird.

Wir können CPU-Last mit einer einfachen, unendlichen Shell-Schleife erzeugen. Führen Sie den folgenden Befehl in Ihrem Terminal aus. Das & am Ende führt den Prozess im Hintergrund aus, sodass Sie Ihr Terminal weiterhin 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 Alerts-Seite in der Prometheus-UI (erreichbar über den Web-Service-Tab auf Port 9090).

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

Innerhalb von etwa 15-30 Sekunden wird der Ausdruck des Alarms wahr. Der Alarm wechselt in den Bereich Pending und wird gelb. Das bedeutet, Prometheus hat die hohe CPU-Last erkannt, wartet aber die in der for-Klausel angegebene Dauer von 1m ab.
Nachdem der Alarm eine Minute lang im Status „Pending“ war, wechselt er in den Bereich Firing und wird rot. Dies bestätigt, dass Ihre Alerting-Regel wie erwartet funktioniert! Sie können den Alarm aufklappen, um die von Ihnen definierten Annotationen zusammen mit dem aktuellen Wert zu sehen.

Prometheus Firing Alert

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

Wichtig: Um Ressourcen der LabEx-VM zu sparen, stellen Sie bitte sicher, dass Sie den folgenden Befehl ausführen, um die Lasterzeugung zu stoppen.

kill $!

Beobachten Sie nach dem Stoppen der Last erneut die Prometheus-UI. Der Alarm wird bald wieder in den Status 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:

Alerting-Regeln in einer separaten YAML-Datei zu strukturieren.
Einen PromQL-Ausdruck zu schreiben, um eine Alarmbedingung für hohe CPU-Auslastung zu definieren.
Annotationen zu verwenden, um aussagekräftige, menschenlesbare Alarmmeldungen zu erstellen.
Prometheus so zu konfigurieren, dass es Ihre Regeldateien lädt, und es neu zu starten, um Änderungen anzuwenden.
Den Lebenszyklus eines Alarms in der Prometheus-UI zu beobachten, von Inactive über Pending bis hin zu Firing.
Eine Bedingung zu simulieren, um Ihren Alarm auszulösen und zu testen.

Dies ist die erste Hälfte des Alerting-Konzepts. Der nächste logische Schritt, der außerhalb des Rahmens dieses Labs liegt, wäre die Einrichtung einer Alertmanager-Instanz. Prometheus würde seine aktiven 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.