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,
forlä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 alertErwartet:
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.urlbei 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.yamlErwartet:
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,humanizePercentagemacht aus0.2den Text20%.- NotesApiDown nutzt
absent(). Sind alle Pods weg, gibt es auch keine Zeitreiheup{job="notes-api"}mehr – eine Regelup == 0bliebe dann stumm.absent()liefert genau dann etwas, wenn die Abfrage darin leer ist. severityentscheidet später über den Weg der Benachrichtigung.namespace: appsteht bei NotesApiDown von Hand, weilabsent()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-apiErwartet (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=NotesApiErrorsErwartet:
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.yamlErwartet:
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 --waitErwartet (gekürzt):
Release "kps" has been upgraded. Happy Helming!
NAME: kps
...
REVISION: 2
routeist ein Baum. Jeder Alarm beginnt an der Wurzel und wandert in die erste passende Unterroute. Watchdog landet weiter beinull, alles andere beiecho.group_by: [alertname, namespace]: Alarme mit gleichem Namen im selben Namespace kommen in eine Benachrichtigung – auch wenn zehn Pods betroffen sind.group_wait: 30swartet nach dem ersten Alarm einer Gruppe, ob weitere folgen.group_intervalregelt Nachzügler,repeat_intervaldie 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 routesErwartet:
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ürdejqscheitern..jsonist 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 queryErwartet (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=NotesApiErrorsErwartet: 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=NotesApiErrorsErwartet:
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 0Erwartet:
deployment.apps/notes-api scaled
Nach gut zwei Minuten – eine für den Scrape, eine für
for: 1m:
amtool alert query severity=criticalErwartet:
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 2Erwartet:
deployment.apps/notes-api scaled
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Nach weiteren zwei Minuten:
amtool alert query namespace=appErwartet: nur die Kopfzeile. Beide Alarme sind aufgelöst.
kubectl -n monitoring logs deploy/alarm-echo | grep '^{' | jq -r .json.status \
| sort | uniq -cErwartet:
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=300msNach etwa vier Minuten – das Fenster der Recording Rule muss sich erst füllen:
amtool alert query alertname=NotesApiSlowErwartet:
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_urlverweist 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,warningin einen Chat-Kanal. Die Route dafür ist einmatchers: [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.