Prometheus Alertmanager Alerts aufs Handy: Schweregrad-Routing, Gruppierung und stille Auflösungen

Prometheus erkennt gut, dass etwas nicht stimmt. Die Nachricht an einen Menschen weiterzugeben, ist Aufgabe von Alertmanager, und in vielen Setups landet sie in einem E-Mail-Ordner oder einem Slack-Channel, den um 3 Uhr nachts niemand liest.
Alertmanager hat keine eigene Push-App, aber einen generischen Webhook-Receiver, und damit lassen sich Alerts aufs Handy bringen. Diese Anleitung richtet das mit Schweregrad-Routing ein: critical-Alerts kommen laut, Warnungen als normale Push-Benachrichtigungen, und „resolved“ kommt leise. Alles hier wurde mit Alertmanager 0.34.2 und Prometheus 3.15.1 in Docker getestet. Die Payloads wurden mitgeschnitten und durch den Template-Code von Pocket Alert geschickt.
Was du brauchst
- Alertmanager 0.31 oder neuer für das vollständige Setup. Ältere Versionen werden weiter unten behandelt.
- Die Pocket-Alert-App auf deinem iPhone oder Android-Handy und einen API-Schlüssel aus API Keys.
- Einen kostenpflichtigen Tarif für das Drei-Webhook-Setup, denn der kostenlose Tarif enthält einen Webhook. Eine Ein-Webhook-Variante findest du weiter unten.
Was Alertmanager sendet
Alertmanager schickt nicht pro Alert eine Anfrage. Es sammelt Alerts nach den Labels in group_by zu Gruppen und sendet eine Benachrichtigung pro Gruppe: ein POST mit festem JSON-Body, "version": "4". Fallen unter group_by: ['alertname'] zwei Hosts aus, geht eine einzige Anfrage raus. Hier ist sie, leicht gekürzt:
{
"receiver": "pocketalert-critical",
"status": "firing",
"alerts": [
{
"status": "firing",
"labels": {"alertname": "InstanceDown", "instance": "web-1:9100", "job": "node", "severity": "critical"},
"annotations": {"summary": "web-1:9100 is down"},
"startsAt": "2026-10-31T16:17:04.374Z",
"generatorURL": "http://prometheus.example.com:9090/graph?g0.expr=up%7Bjob%3D%22node%22%7D+%3D%3D+0&g0.tab=1"
},
{
"status": "firing",
"labels": {"alertname": "InstanceDown", "instance": "web-2:9100", "job": "node", "severity": "critical"},
"annotations": {"summary": "web-2:9100 is down"}
}
],
"notification_reason": "first notification",
"groupLabels": {"alertname": "InstanceDown"},
"commonLabels": {"alertname": "InstanceDown", "job": "node", "severity": "critical"},
"commonAnnotations": {},
"routeLabels": {},
"externalURL": "http://alertmanager.example.com:9093",
"version": "4",
"groupKey": "{}/{severity=\"critical\"}:{alertname=\"InstanceDown\"}",
"truncatedAlerts": 0
}
Vier Dinge an dieser Payload prägen das Setup:
- Eine Push-Benachrichtigung pro Gruppe. Die einzelnen Alerts stehen im Array
alerts, das Nachrichten-Template muss also mit einem Array umgehen können. commonAnnotationsist oft leer. Es enthält nur Annotationen, die bei jedem Alert der Gruppe identisch sind. Eine Zusammenfassung, die die Instanz nennt, ist bei jedem Alert anders und taucht dort daher nie auf.statusgehört zur Gruppe. Er ist nur dannresolved, wenn jeder Alert der Gruppe aufgelöst ist. Erholt sich ein Host, während ein anderer noch down ist, bleibt der Statusfiring, und der aufgelöste Alert steht darin mit seinem eigenen"status": "resolved".- Es gibt kein Top-Level-Feld
level, dort sucht ein Pocket-Alert-Webhook aber nach der Priorität. Die Priorität kommt deshalb aus dem Standard-Level des Webhooks, und deshalb nutzt diese Anleitung pro Lautstärke einen eigenen Webhook.
Schritt 1: Pocket-Alert-Webhooks anlegen
| Webhook | default_level | Empfängt |
|---|---|---|
| Prometheus critical | 2 (critical) | Feuernde Gruppen mit severity="critical" |
| Prometheus warning | 0 (default) | Alle anderen feuernden Gruppen |
| Prometheus resolved | -1 (low) | Gruppen, in denen alle Alerts aufgelöst sind |
Buttons lassen sich nur über die API setzen, also legst du alle drei mit einem Skript an:
PA_KEY='your-api-key'
FIRING='%groupLabels.alertname%: %alerts.#(status=="firing")#|#% firing
%alerts.#(status=="firing").annotations.summary%
Firing: %alerts.#(status=="firing")#.labels.instance%'
RESOLVED='Resolved: %groupLabels.alertname% (%commonLabels.severity%)
%alerts.#.labels.instance%'
BUTTONS='[{"type":"view","label":"Alertmanager","value":"%externalURL%"}]'
create_webhook() {
jq -n --arg name "$1" --argjson level "$2" --arg message "$3" --arg actions "$4" \
'{name: $name, default_level: $level, message: $message, actions: $actions}' |
curl -sS https://api.pocketalert.app/v1/webhooks \
-H "Token: $PA_KEY" \
-H 'Content-Type: application/json' \
--data-binary @- |
jq -r '"\(.name): https://p4a.me/wh/\(.url)"'
}
create_webhook 'Prometheus critical' 2 "$FIRING" "$BUTTONS"
create_webhook 'Prometheus warning' 0 "$FIRING" "$BUTTONS"
create_webhook 'Prometheus resolved' -1 "$RESOLVED" ''
Es werden drei Empfangs-URLs ausgegeben. Behalte den Slug am Ende jeder URL; du fügst die Slugs in alertmanager.yml ein.
Die %...%-Platzhalter sind GJSON-Pfade, und GJSON kann Arrays abfragen:
alerts.#(status=="firing")#|#zählt die Alerts der Gruppe, die noch feuern.alerts.#(status=="firing").annotations.summaryist die Zusammenfassung des ersten feuernden Alerts.alerts.#(status=="firing")#.labels.instancelistet die Instanzen aller feuernden Alerts. Das wird als JSON-Array ausgegeben, etwa["web-1:9100","web-2:9100"], weil es keine Funktion zum Verbinden von Strings gibt.
Ein nicht existierender Pfad wird als leerer String ausgegeben, ein fehlerhafter Pfad erzeugt also eine leere Zeile statt eines verlorenen Alerts. Pocket Alert setzt als Titel jeder Webhook-Push Webhook <name>, der Titel lautet also „Webhook Prometheus critical“, und der Alert-Name steht in der ersten Zeile der Nachricht. critical braucht einen kostenpflichtigen Tarif, den dieses Setup für die drei Webhooks ohnehin braucht. Es spielt über den Stummschalter und „Nicht stören“ auf dem iPhone und übernimmt auf Android den Bildschirm. Nimm stattdessen 1 (high), wenn Alerts „Nicht stören“ nicht überstimmen sollen.
Schritt 2: alertmanager.yml
Ersetze die drei *_SLUG-Platzhalter durch deine Slugs:
route:
receiver: pocketalert-warning
group_by: ['alertname']
group_wait: 30s
group_interval: 5m
repeat_interval: 4h
routes:
- matchers: ['severity="critical"']
receiver: pocketalert-critical
group_wait: 10s
repeat_interval: 1h
- matchers: ['severity="info"']
receiver: blackhole
receivers:
- name: pocketalert-critical
webhook_configs:
- url: 'https://p4a.me/wh/{{ if eq .Status "resolved" }}RESOLVED_SLUG{{ else }}CRITICAL_SLUG{{ end }}'
send_resolved: true
max_alerts: 20
- name: pocketalert-warning
webhook_configs:
- url: 'https://p4a.me/wh/{{ if eq .Status "resolved" }}RESOLVED_SLUG{{ else }}WARNING_SLUG{{ end }}'
send_resolved: true
max_alerts: 20
- name: blackhole
inhibit_rules:
- source_matchers: ['severity="critical"']
target_matchers: ['severity="warning"']
equal: ['alertname', 'instance', 'mountpoint']
So funktionieren die Teile:
- Routing nach Schweregrad.
severity="critical"geht an den lauten Receiver,infowird verworfen, und alles andere, auch Alerts ohne Labelseverity, fällt auf den Warnungs-Receiver. - Die URL wählt den Webhook. Seit 0.31.0 ist die Webhook-
urlein Template. Eine Gruppe mit dem Statusresolvedgeht an den leisen Webhook, alles andere an den eigenen Webhook des Receivers.send_resolvedist für Webhooks standardmäßig bereitstrue; es steht trotzdem explizit da, damit niemand es unbemerkt abschaltet. max_alerts: 20begrenzt, wie viele Alerts in eine Anfrage passen. Im Test fielen 25 Hosts gleichzeitig aus. Das ergab eine Push-Benachrichtigung mit „20 firing“ undtruncatedAlerts: 5in der Payload.- Inhibition. Feuert der kritische
DiskSpaceLowfür ein Dateisystem, wird die Warnung für dieselbenalertname,instanceundmountpointunterdrückt.amtool alert query --inhibitedzeigt sie alssuppressed.
Prüfe Konfiguration und Routing, bevor du neu lädst:
amtool check-config alertmanager.yml
amtool config routes test --config.file=alertmanager.yml severity=critical alertname=Test
Der zweite Befehl gibt pocketalert-critical aus.
Starte Alertmanager mit --web.external-url auf die Adresse, die du von deinem Handy aus öffnen kannst. Ohne diese Option ist externalURL nur der nackte Hostname. In Docker war das http://de48ea5ffc29:9093, und damit wäre der Button nutzlos.
Prüfe zuerst deine Version
alertmanager --version muss 0.31 oder neuer anzeigen, damit die templatebasierte URL funktioniert. Version 0.30.1 akzeptiert genau diese Konfiguration, und amtool check-config meldet SUCCESS, aber sie rendert das Template nicht. Die Anfrage ging an /wh/%7B%7B%20if%20eq%20.Status..., und dazu passt kein Webhook. Auf älteren Versionen gibst du jedem Receiver die einfache URL seines eigenen Webhooks. Auflösungen kommen dann auf dem Level dieses Webhooks an.
Schritt 3: Regeln mit einem Schweregrad-Label
Das Routing oben funktioniert nur, wenn deine Regeln severity setzen. Hier sind zwei Beispiele (weitere Ideen, was du überwachen solltest, findest du auf der Seite Server-Monitoring). DiskSpaceLow gibt es mit zwei Schwellenwerten, damit die Inhibition-Regel etwas zu tun hat:
groups:
- name: node
rules:
- alert: InstanceDown
expr: up{job="node"} == 0
for: 2m
labels:
severity: critical
annotations:
summary: '{{ $labels.instance }} is down'
- alert: DiskSpaceLow
expr: node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"} / node_filesystem_size_bytes * 100 < 15
for: 10m
labels:
severity: warning
annotations:
summary: '{{ $labels.instance }} {{ $labels.mountpoint }} has {{ printf "%.0f" $value }}% free'
- alert: DiskSpaceLow
expr: node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"} / node_filesystem_size_bytes * 100 < 5
for: 5m
labels:
severity: critical
annotations:
summary: '{{ $labels.instance }} {{ $labels.mountpoint }} has {{ printf "%.0f" $value }}% free'
promtool check rules rules.yml validiert die Datei. Verbinde Prometheus in prometheus.yml mit der Datei und mit Alertmanager:
rule_files: [rules.yml]
alerting:
alertmanagers:
- static_configs:
- targets: ['alertmanager:9093']
Mit amtool testen
Löse einen Test-Alert aus, warte auf group_wait (10 Sekunden auf der kritischen Route) und löse ihn dann auf:
amtool --alertmanager.url=http://localhost:9093 alert add alertname=PocketAlertTest severity=critical instance=test:9100 \
--annotation='summary="Test alert from amtool"'
amtool --alertmanager.url=http://localhost:9093 alert add alertname=PocketAlertTest severity=critical instance=test:9100 \
--annotation='summary="Test alert from amtool"' --end="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
Behalte die inneren doppelten Anführungszeichen in der Annotation bei, sonst warnt amtool, dass auf seinen alten Parser zurückgegriffen wurde. Die Auflösungs-Push kommt beim nächsten group_interval-Takt, bei dieser Konfiguration kann das bis zu 5 Minuten dauern.
Was auf deinem Handy ankommt
Das sind die Nachrichten, die Pocket Alert aus den echten Payloads des Tests rendert, in dem Prometheus sah, wie web-1 und web-2 ausfielen und zurückkamen:
Webhook Prometheus critical
InstanceDown: 2 firing
web-1:9100 is down
Firing: ["web-1:9100","web-2:9100"]
Wenn web-1 sich erholt, sendet Alertmanager beim nächsten group_interval ein Update. Die Gruppe feuert noch, also geht es an den kritischen Webhook:
Webhook Prometheus critical
InstanceDown: 1 firing
web-2:9100 is down
Firing: ["web-2:9100"]
Wenn beide wieder oben sind, kommt eine Push-Benachrichtigung mit niedriger Priorität:
Webhook Prometheus resolved
Resolved: InstanceDown (critical)
["web-1:9100","web-2:9100"]
Timer: Push-Stürme vermeiden
| Einstellung | Was sie tut | Hier |
|---|---|---|
group_wait | Wie lange eine neue Gruppe auf weitere Alerts wartet, bevor die erste Push-Benachrichtigung rausgeht | 30s, 10s für critical |
group_interval | Mindestabstand zwischen Push-Benachrichtigungen für eine Gruppe, deren Alerts sich geändert haben | 5m |
repeat_interval | Erinnerung für eine Gruppe, die noch feuert und sich nicht geändert hat | 4h, 1h für critical |
Eine Gruppe kann höchstens einmal pro group_interval pushen, ein flackernder Alert kostet also bei 5m bis zu 12 Push-Benachrichtigungen pro Stunde. Ein Ausfall, der einen Tag dauert, kostet bei einem repeat_interval von 1h 24 Erinnerungen. Die Gruppierung leistet den Großteil der Arbeit: Ein Switch-Ausfall, der 40 Hosts lahmlegt, ist eine Push-Benachrichtigung, nicht 40. Verwende kein group_by: ['...'], denn das gruppiert nach jedem Label und macht daraus wieder eine Push-Benachrichtigung pro Alert. Tarife haben Tageslimits für Nachrichten (Starter sind 1.000 pro Tag), und jede Anfrage an einen Webhook, der eine Nachricht erzeugt, zählt dagegen.
Buttons: Alertmanager und Grafana
Das BUTTONS-Template oben fügt einen Button „Alertmanager“ hinzu. Du kannst bis zu drei Aktionsbuttons ergänzen. Dieser hier öffnet für die erste feuernde Instanz ein Grafana-Dashboard:
BUTTONS='[{"type":"view","label":"Alertmanager","value":"%externalURL%"},{"type":"view","label":"Grafana","value":"https://grafana.example.com/d/YOUR_DASHBOARD?var-instance=%alerts.#(status=="firing").labels.instance%"}]'
Die nicht maskierten Anführungszeichen im Platzhalter sehen falsch aus, funktionieren aber: Pocket Alert ersetzt die Platzhalter zuerst und parst das JSON danach.
Achte auf leere Werte. Ein Button, dessen value leer ist, wird aus dieser Push-Benachrichtigung entfernt; die übrigen Buttons und die Nachricht kommen trotzdem an. %alerts.0.generatorURL% (der Link zum Prometheus-Graph) ist ein guter Wert für Alerts von Prometheus, Alerts aus amtool haben aber keine Generator-URL und kommen daher ohne diesen Button an. Aktionsbuttons sind ein kostenpflichtiges Feature.
Alertmanager 0.32+: die API direkt aufrufen
Ältere Anleitungen sagen, Alertmanager könne den Webhook-Body nicht ändern. Das hat sich mit 0.32.0 geändert, das eine Option payload für webhook_configs einführte. Zusammen mit http_config.http_headers, womit sich ein Token-Header senden lässt, kann Alertmanager direkt per POST an https://api.pocketalert.app/v1/messages senden, mit eigenem Titel und Level.
Es gibt eine Falle. Alertmanager parst jeden gerenderten Wert als YAML. Im Test verwandelte ein feldweises Payload mit message: '{{ range .Alerts }}{{ .Annotations.summary }}...' die Zusammenfassung web-1:9100: / has 12% free in das Objekt {"web-1:9100": "/ has 12% free"}. Die API lehnt das mit 400 ab. Alertmanager wiederholt eine 4xx-Antwort nicht sofort, sondern sendet denselben kaputten Body bei jedem group_interval erneut, sodass der Alert nie ankommt.
Den ganzen Body mit dict und toJson zu bauen, vermeidet das:
receivers:
- name: pocketalert-api
webhook_configs:
- url: https://api.pocketalert.app/v1/messages
http_config:
http_headers:
Token:
files: [/etc/alertmanager/pocketalert.key]
payload: >-
{{ $msg := "" }}{{ range .Alerts }}{{ $msg = printf "%s%s: %s\n" $msg .Status .Annotations.summary }}{{ end }}
{{ $level := "default" }}{{ if eq .Status "resolved" }}{{ $level = "low" }}{{ else if eq .CommonLabels.severity "critical" }}{{ $level = "critical" }}{{ end }}
{{ dict "title" (printf "[%s] %s" (toUpper .Status) .GroupLabels.alertname) "message" $msg "level" $level | toJson }}
Mit einer Zusammenfassung, die einen Doppelpunkt und Anführungszeichen enthält, wurde gesendet:
{"level":"critical","message":"firing: web-1:9100: / has 4% free, \"quoted\"\nfiring: web-2:9100 / has 3% free\n","title":"[FIRING] DiskSpaceLow"}
Die aufgelöste Version kam mit "level":"low" an.
Welche solltest du also nehmen? Die direkte API liefert dir für jede Benachrichtigung einen echten Titel und ein Level, alles aus einem Receiver und ohne Webhooks. Der Webhook braucht in Alertmanager überhaupt keinen API-Schlüssel und funktioniert auf jeder Version (die Variante mit einfacher URL). Ein fehlerhafter Pfad wird als leere Zeile ausgegeben statt als abgelehnte Anfrage, und jede Anfrage erscheint im Webhook-Verlauf. Die eigene Dokumentation von Alertmanager nennt payload „use at your own risk“, also teste es mit amtool, bevor du dich darauf verlässt.
Im kostenlosen Tarif
Der kostenlose Tarif hat einen Webhook, 50 Nachrichten pro Tag, keine Buttons, und critical wird als high zugestellt. Lege einen Webhook mit default_level: 1 an, trage seine einfache URL in einen einzigen Receiver ein und entferne die Schweregrad-Routen. Auflösungen kommen dann ebenfalls mit high an, es sei denn, du setzt send_resolved: false. Auf Alertmanager 0.32+ passt die direkte API-Konfiguration oben besser zum kostenlosen Tarif, weil sie keinen Webhook braucht und das Level für jede Benachrichtigung setzt.
Wenn nichts ankommt
- Lies das Alertmanager-Log. Eine fehlgeschlagene Zustellung wird als
Notify for alerts failedmit dem Statuscode protokolliert. Ein404bedeutet einen falschen Slug oder eine templatebasierte URL auf einer Version älter als 0.31. - Öffne den Webhook-Verlauf in Pocket Alert. Ist die Anfrage dort, liegt das Problem im Template. Ist sie nicht da, hat Alertmanager sie nie gesendet.
- Leere Zeilen bedeuten, dass ein Pfad nicht zur Payload passt. Feldnamen sind case-sensitiv.
- Ein
%direkt vor einem Platzhalter muss verdoppelt werden. Ein%gefolgt von einem Leerzeichen ist normaler Text, daher funktioniertCPU over 90% on %groupLabels.alertname%. Schreibe%%, wenn das%an anderen Text grenzt, wie in%commonLabels.usage%%%. - Nutze den Webhook-Tester, um zu erfassen, was dein Alertmanager tatsächlich sendet, bevor du Templates schreibst.
FAQ
Funktioniert das mit kube-prometheus-stack?
Ja. Der Receiver ist gewöhnliche Alertmanager-Konfiguration und kommt wie jeder andere Receiver in die Alertmanager-Config des Charts. Prüfe, welche Alertmanager-Version das Chart ausrollt, bevor du die templatebasierte URL oder payload verwendest. Die Cluster-Seite beschreibt Kubernetes-Alerts.
Ich nutze Grafana-Alerting, nicht Alertmanager. Was ändert sich?
Grafana sendet sein eigenes Webhook-Format. Siehe die Grafana-Anleitung.
Erstelle ein kostenloses Konto, führe das Skript aus, füge die drei Slugs in alertmanager.yml ein, und der nächste InstanceDown erreicht dein Handy.