Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 4: Alarme mit Alertmanager

Ziel: Zwei Alarmregeln für notes-api, ein Empfänger für Benachrichtigungen und der Umgang mit amtool: Alarme ansehen, stummschalten, auflösen. · Dauer: ca. 75 min · Voraussetzung: Tag 3

Briefing

  • Eine Alarmregel ist eine PromQL-Abfrage. Liefert sie eine Zeitreihe, ist der Alarm aktiv. Mit for: muss der Zustand eine Weile anhalten, bevor er zählt.
  • Ein Alarm durchläuft drei Zustände: inactive (Abfrage leer), pending (Abfrage liefert etwas, for läuft noch) und firing.
  • Prometheus schickt Alarme im Zustand firing an den Alertmanager. Der fasst sie zu Gruppen zusammen, unterdrückt Doppeltes und benachrichtigt einen Empfänger – Mail, Chat, Pager oder einen Webhook.
  • Auch Stummschalten (Silences) erledigt der Alertmanager. Prometheus rechnet die Alarme unverändert weiter.
 Prometheus ── Regel alle 30 s ──► firing ──► Alertmanager ── Route ──► Empfänger
                                                  │                    alarm-echo
                                                Silences

Drill 1: amtool

amtool ist für den Alertmanager, was promtool für Prometheus ist:

cd ~/obs-lab
curl -fsSLO https://github.com/prometheus/alertmanager/releases/download/\
v0.34.2/alertmanager-0.34.2.linux-amd64.tar.gz
tar xzf alertmanager-0.34.2.linux-amd64.tar.gz
mv alertmanager-0.34.2.linux-amd64/amtool ~/.local/bin/
rm -r alertmanager-0.34.2.linux-amd64*
mkdir -p ~/.config/amtool
cat > ~/.config/amtool/config.yml <<'EOF'
alertmanager.url: http://localhost:30093
EOF
amtool alert

Erwartet:

Alertname  Starts At                Summary                                    State
Watchdog   2026-11-05 08:15:54 UTC  An alert that should always be firing ...  active
  • Die Konfigurationsdatei erspart dir --alertmanager.url bei jedem Aufruf.
  • Watchdog feuert immer. Er kommt aus den Regeln des Charts und beweist, dass die Kette Prometheus → Alertmanager funktioniert. Bleibt er aus, ist die Überwachung selbst kaputt.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Die Alarmregeln

cat > notes-alerts.yaml <<'EOF'
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: notes-api-alerts
  namespace: app
spec:
  groups:
    - name: notes-api.alerts
      rules:
        - alert: NotesApiErrors
          expr: |
            sum by (namespace) (rate(notes_http_requests_total{code=~"5.."}[2m]))
              / sum by (namespace) (rate(notes_http_requests_total[2m])) > 0.05
          for: 2m
          labels:
            severity: warning
          annotations:
            summary: "notes-api: {{ $value | humanizePercentage }} Fehler"
            description: Mehr als 5 % der Anfragen enden mit einem 5xx-Status.
        - alert: NotesApiDown
          expr: absent(up{job="notes-api"} == 1)
          for: 1m
          labels:
            severity: critical
            namespace: app
          annotations:
            summary: notes-api ist nicht erreichbar
            description: Prometheus erreicht keinen einzigen Pod von notes-api.
EOF
kubectl apply -f notes-alerts.yaml

Erwartet:

prometheusrule.monitoring.coreos.com/notes-api-alerts created
  • NotesApiErrors teilt die Rate der Fehler durch die Rate aller Anfragen. Über 5 Prozent, zwei Minuten lang: Alarm. [2m] statt [5m], damit du im Lab nicht ewig wartest.
  • {{ $value }} ist das Ergebnis der Abfrage, humanizePercentage macht aus 0.2 den Text 20%.
  • NotesApiDown nutzt absent(). Sind alle Pods weg, gibt es auch keine Zeitreihe up{job="notes-api"} mehr – eine Regel up == 0 bliebe dann stumm. absent() liefert genau dann etwas, wenn die Abfrage darin leer ist.
  • severity entscheidet später über den Weg der Benachrichtigung. namespace: app steht bei NotesApiDown von Hand, weil absent() keine Labels hat, die es erben könnte.

Prüfe, ob Prometheus die Regeln geladen hat:

promtool query instant http://localhost:30090 'ALERTS{namespace="app"}'

Erwartet: keine Ausgabe. ALERTS enthält nur Alarme, die pending oder firing sind, und notes-api läuft fehlerfrei. In der Weboberfläche unter Alerts stehen beide Regeln als Inactive.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Einen Alarm auslösen

Jede fünfte Anfrage soll scheitern:

kubectl -n app set env deploy/notes-api NOTES_ERROR_RATE=0.2
kubectl -n app rollout status deploy/notes-api

Erwartet (letzte Zeile):

deployment "notes-api" successfully rolled out

Nach etwa einer Minute:

promtool query instant http://localhost:30090 'ALERTS{namespace="app"}'

Erwartet:

ALERTS{alertname="NotesApiErrors", alertstate="pending", namespace="app",
severity="warning"} => 1 @[...]

Die Bedingung ist erfüllt, aber for: 2m läuft noch. Zwei Minuten später:

promtool query instant http://localhost:30090 'ALERTS{namespace="app"}'

Erwartet:

ALERTS{alertname="NotesApiErrors", alertstate="firing", namespace="app",
severity="warning"} => 1 @[...]

Jetzt erfährt es auch der Alertmanager:

amtool alert query alertname=NotesApiErrors

Erwartet:

Alertname       Starts At                Summary                   State
NotesApiErrors  2026-11-05 08:39:53 UTC  notes-api: 20.54% Fehler  active

Der Alertmanager kennt den Alarm, schickt ihn aber nirgendwohin: Das Chart leitet alles an einen Empfänger namens null. Das änderst du jetzt.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Ein Empfänger

Als Empfänger dient ein kleiner Webserver, der jede Anfrage ins Log schreibt:

cat > alarm-echo.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: alarm-echo
  namespace: monitoring
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: alarm-echo
  template:
    metadata:
      labels:
        app.kubernetes.io/name: alarm-echo
    spec:
      containers:
        - name: echo
          image: mendhak/http-https-echo:43
          env:
            - {name: LOG_WITHOUT_NEWLINE, value: "true"}
            - {name: DISABLE_REQUEST_LOGS, value: "true"}
          ports:
            - containerPort: 8080
          resources:
            requests: {cpu: 10m, memory: 32Mi}
            limits: {memory: 96Mi}
---
apiVersion: v1
kind: Service
metadata:
  name: alarm-echo
  namespace: monitoring
spec:
  selector:
    app.kubernetes.io/name: alarm-echo
  ports:
    - port: 8080
EOF
kubectl apply -f alarm-echo.yaml

Erwartet:

deployment.apps/alarm-echo created
service/alarm-echo created

LOG_WITHOUT_NEWLINE schreibt jede Anfrage als eine JSON-Zeile, DISABLE_REQUEST_LOGS lässt die zusätzliche Zugriffszeile weg.

Die Konfiguration des Alertmanagers steht in den Werten des Charts. Ergänze kps.yaml um den Block alertmanager.config – hier die ganze Datei:

cat > kps.yaml <<'EOF'
fullnameOverride: kps

prometheus:
  service:
    type: NodePort
    nodePort: 30090
  prometheusSpec:
    serviceMonitorSelectorNilUsesHelmValues: false
    ruleSelectorNilUsesHelmValues: false
    retention: 3d
    resources:
      requests: {cpu: 100m, memory: 300Mi}
      limits: {memory: 800Mi}

alertmanager:
  service:
    type: NodePort
    nodePort: 30093
  config:
    route:
      receiver: echo
      group_by: [alertname, namespace]
      group_wait: 30s
      group_interval: 2m
      repeat_interval: 4h
      routes:
        - receiver: "null"
          matchers: [alertname = "Watchdog"]
    receivers:
      - name: "null"
      - name: echo
        webhook_configs:
          - url: http://alarm-echo.monitoring:8080/

grafana:
  adminPassword: lab-grafana-pw-123
  service:
    type: NodePort
    nodePort: 30300

kubeControllerManager: {enabled: false}
kubeScheduler: {enabled: false}
kubeProxy: {enabled: false}
kubeEtcd: {enabled: false}
EOF
helm upgrade kps prometheus-community/kube-prometheus-stack --version 92.18.0 \
  -n monitoring -f kps.yaml --wait

Erwartet (gekürzt):

Release "kps" has been upgraded. Happy Helming!
NAME: kps
...
REVISION: 2
  • route ist ein Baum. Jeder Alarm beginnt an der Wurzel und wandert in die erste passende Unterroute. Watchdog landet weiter bei null, alles andere bei echo.
  • group_by: [alertname, namespace]: Alarme mit gleichem Namen im selben Namespace kommen in eine Benachrichtigung – auch wenn zehn Pods betroffen sind.
  • group_wait: 30s wartet nach dem ersten Alarm einer Gruppe, ob weitere folgen. group_interval regelt Nachzügler, repeat_interval die Erinnerung an einen Alarm, der weiter feuert.

Der Operator schreibt die Konfiguration in ein Secret, und ein Hilfscontainer im Alertmanager-Pod lädt sie neu. Das dauert bis zu zwei Minuten. Dann:

amtool config routes

Erwartet:

Routing tree:
.
└── default-route  receiver: echo
    └── {alertname="Watchdog"}  receiver: null

Steht dort noch zweimal receiver: null, warte noch etwas. Kurz danach kommt die Benachrichtigung an:

kubectl -n monitoring logs deploy/alarm-echo | grep '^{' \
  | jq -c '.json | [.status, .groupKey]'

Erwartet:

["firing","{}:{alertname=\"NotesApiErrors\", namespace=\"app\"}"]
  • grep '^{' behält nur die JSON-Zeilen. Die erste Zeile im Log ist die Startmeldung des Webservers, an ihr würde jq scheitern.
  • .json ist der Körper der Anfrage, den der Webserver schon zerlegt hat.

Was genau ankommt, zeigt der ganze Text:

kubectl -n monitoring logs deploy/alarm-echo | grep -m1 '^{' | jq '.json.alerts[0]'

Erwartet (gekürzt):

{
  "status": "firing",
  "labels": {
    "alertname": "NotesApiErrors",
    "namespace": "app",
    "prometheus": "monitoring/kps-prometheus",
    "severity": "warning"
  },
  "annotations": {
    "description": "Mehr als 5 % der Anfragen enden mit einem 5xx-Status.",
    "summary": "notes-api: 18.93% Fehler"
  },
  "startsAt": "2026-11-05T08:39:53.516Z",
  "endsAt": "0001-01-01T00:00:00Z",
  "generatorURL": "http://kps-prometheus.monitoring:9090/graph?g0.expr=sum+by...",
  "fingerprint": "3b322bed87653e29"
}

Genau dieses JSON bekommt jeder Webhook-Empfänger: ein Chat-Bot, ein Ticketsystem, ein Pager-Dienst.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Stummschalten

Du weißt Bescheid und arbeitest am Problem. Weitere Erinnerungen sollen für 30 Minuten ausbleiben:

amtool silence add alertname=NotesApiErrors --duration 30m \
  --comment "Fehlerquote wird untersucht"
amtool silence query

Erwartet (die ID weicht ab, rechts gekürzt):

07d562d9-c902-44c3-a141-018117eb4c95
ID                                    Matchers                    Ends At          ...
07d562d9-c902-44c3-a141-018117eb4c95  alertname="NotesApiErrors"  2026-11-05 09...  ...
amtool alert query alertname=NotesApiErrors

Erwartet: nur die Kopfzeile. amtool alert zeigt standardmäßig nur aktive Alarme, ein stummgeschalteter gilt als suppressed. Mit --silenced siehst du ihn:

amtool alert query --silenced alertname=NotesApiErrors

Erwartet:

Alertname       Starts At                Summary                   State
NotesApiErrors  2026-11-05 08:39:53 UTC  notes-api: 18.93% Fehler  suppressed

Prometheus feuert unverändert weiter – die Silence lebt nur im Alertmanager.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Auflösen

Beende die Störung und nimm die Silence zurück:

kubectl -n app set env deploy/notes-api NOTES_ERROR_RATE-
kubectl -n app rollout status deploy/notes-api
amtool silence expire $(amtool silence query -q)

Erwartet (letzte Zeile des Rollouts, expire schreibt nichts):

deployment "notes-api" successfully rolled out

-q gibt nur die IDs aus. So passt die Ausgabe direkt in expire.

Nach zwei bis drei Minuten fällt die Fehlerquote unter 5 Prozent, der Alarm erlischt, und der Empfänger bekommt eine Entwarnung:

kubectl -n monitoring logs deploy/alarm-echo | grep '^{' \
  | jq -c '.json | [.status, .groupKey]'

Erwartet:

["firing","{}:{alertname=\"NotesApiErrors\", namespace=\"app\"}"]
["resolved","{}:{alertname=\"NotesApiErrors\", namespace=\"app\"}"]

Webhooks bekommen die Entwarnung von selbst (send_resolved: true ist dort die Voreinstellung).

Fortschritt speichern? Kostenlos registrieren

Drill 7: absent()

Was passiert, wenn notes-api ganz verschwindet?

kubectl -n app scale deploy/notes-api --replicas 0

Erwartet:

deployment.apps/notes-api scaled

Nach gut zwei Minuten – eine für den Scrape, eine für for: 1m:

amtool alert query severity=critical

Erwartet:

Alertname     Starts At                Summary                         State
NotesApiDown  2026-11-05 08:48:53 UTC  notes-api ist nicht erreichbar  active

Wieder hochfahren:

kubectl -n app scale deploy/notes-api --replicas 2

Erwartet:

deployment.apps/notes-api scaled

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Nach weiteren zwei Minuten:

amtool alert query namespace=app

Erwartet: nur die Kopfzeile. Beide Alarme sind aufgelöst.

kubectl -n monitoring logs deploy/alarm-echo | grep '^{' | jq -r .json.status \
  | sort | uniq -c

Erwartet:

      2 firing
      2 resolved

Zwei Alarme, jeweils ausgelöst und aufgelöst.

Challenge

Schreibe einen dritten Alarm NotesApiSlow: Er soll feuern, wenn das 95. Perzentil der Antwortzeit von /notes länger als zwei Minuten über 250 ms liegt. Löse ihn mit NOTES_DELAY=300ms aus.

Hinweis: Die Recording Rule aus Tag 3 hat die Rechnung schon erledigt. Ein PrometheusRule-Objekt darf mehrere Regeln enthalten – oder du legst ein zweites an.

Lösung

cat > notes-slow.yaml <<'EOF'
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: notes-api-slow
  namespace: app
spec:
  groups:
    - name: notes-api.slow
      rules:
        - alert: NotesApiSlow
          expr: job:notes_http_request_duration_seconds:p95_5m > 0.25
          for: 2m
          labels:
            severity: warning
            namespace: app
          annotations:
            summary: "notes-api: p95 bei {{ $value | humanizeDuration }}"
EOF
kubectl apply -f notes-slow.yaml
kubectl -n app set env deploy/notes-api NOTES_DELAY=300ms

Nach etwa vier Minuten – das Fenster der Recording Rule muss sich erst füllen:

amtool alert query alertname=NotesApiSlow

Erwartet:

Alertname     Starts At                Summary                     State
NotesApiSlow  2026-11-05 08:55:35 UTC  notes-api: p95 bei 477.8ms  active

Aufräumen:

kubectl -n app set env deploy/notes-api NOTES_DELAY-

Die Regel darf bleiben. Sie wird an Tag 15 noch gebraucht.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Auf Symptome alarmieren: Gute Alarme beschreiben, was Nutzer spüren – Fehler, Langsamkeit, Ausfall. Ein voller Speicher oder ein neu gestarteter Pod ist erst dann ein Alarm, wenn er Folgen hat. Mehr dazu an Tag 12.
  • Jeder Alarm braucht eine Anleitung: Die Annotation runbook_url verweist auf eine Seite mit den ersten Schritten. Die fertigen Regeln des Charts haben das schon.
  • Wer bekommt was: Im Betrieb gehen critical-Alarme an einen Pager-Dienst, der nachts weckt, warning in einen Chat-Kanal. Die Route dafür ist ein matchers: [severity = "critical"] mehr im Baum.
  • Watchdog nach außen: Leite Watchdog an einen externen Dienst, der Alarm schlägt, wenn er ausbleibt (Dead Man’s Switch). Sonst merkt niemand, wenn Prometheus selbst ausfällt.