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

> Sende Prometheus-Alertmanager-Alerts als Push-Benachrichtigungen auf iPhone und Android. Eine Push-Benachrichtigung pro Alert-Gruppe, kritische Alerts laut, Warnungen normal, Auflösungen leise. Eine getestete alertmanager.yml, Beispielregeln und wann die Payload-Option von Alertmanager 0.32 die bessere Wahl ist.

*29.10.2026*

<!-- source: https://pocketalert.app/de/blog/prometheus-alertmanager-notifications -->

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](/get-app)-Handy und einen API-Schlüssel aus [API Keys](/account/apikeys).
- 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:

```json
{
  "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.
- **`commonAnnotations` ist 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.
- **`status` gehört zur Gruppe.** Er ist nur dann `resolved`, wenn jeder Alert der Gruppe aufgelöst ist. Erholt sich ein Host, während ein anderer noch down ist, bleibt der Status `firing`, 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

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Webhook</th><th><code>default_level</code></th><th>Empfängt</th></tr></thead>
<tbody>
<tr><th>Prometheus critical</th><td><code>2</code> (critical)</td><td>Feuernde Gruppen mit <code>severity="critical"</code></td></tr>
<tr><th>Prometheus warning</th><td><code>0</code> (default)</td><td>Alle anderen feuernden Gruppen</td></tr>
<tr><th>Prometheus resolved</th><td><code>-1</code> (low)</td><td>Gruppen, in denen alle Alerts aufgelöst sind</td></tr>
</tbody>
</table>
</div>

Buttons lassen sich nur über die API setzen, also legst du alle drei mit einem Skript an:

```bash
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](https://info.pocketalert.app/api/webhooks/settings), und GJSON kann Arrays abfragen:

- `alerts.#(status=="firing")#|#` zählt die Alerts der Gruppe, die noch feuern.
- `alerts.#(status=="firing").annotations.summary` ist die Zusammenfassung des ersten feuernden Alerts.
- `alerts.#(status=="firing")#.labels.instance` listet 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:

```yaml
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, `info` wird verworfen, und alles andere, auch Alerts ohne Label `severity`, fällt auf den Warnungs-Receiver.
- **Die URL wählt den Webhook.** Seit 0.31.0 ist die Webhook-`url` ein Template. Eine Gruppe mit dem Status `resolved` geht an den leisen Webhook, alles andere an den eigenen Webhook des Receivers. `send_resolved` ist für Webhooks standardmäßig bereits `true`; es steht trotzdem explizit da, damit niemand es unbemerkt abschaltet.
- **`max_alerts: 20`** begrenzt, wie viele Alerts in eine Anfrage passen. Im Test fielen 25 Hosts gleichzeitig aus. Das ergab eine Push-Benachrichtigung mit „20 firing“ und `truncatedAlerts: 5` in der Payload.
- **Inhibition.** Feuert der kritische `DiskSpaceLow` für ein Dateisystem, wird die Warnung für dieselben `alertname`, `instance` und `mountpoint` unterdrückt. `amtool alert query --inhibited` zeigt sie als `suppressed`.

Prüfe Konfiguration und Routing, bevor du neu lädst:

```bash
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](/use-cases/server-monitoring)). `DiskSpaceLow` gibt es mit zwei Schwellenwerten, damit die Inhibition-Regel etwas zu tun hat:

```yaml
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:

```yaml
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:

```bash
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:

```text
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:

```text
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:

```text
Webhook Prometheus resolved
Resolved: InstanceDown (critical)
["web-1:9100","web-2:9100"]
```

## Timer: Push-Stürme vermeiden

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Einstellung</th><th>Was sie tut</th><th>Hier</th></tr></thead>
<tbody>
<tr><th><code>group_wait</code></th><td>Wie lange eine neue Gruppe auf weitere Alerts wartet, bevor die erste Push-Benachrichtigung rausgeht</td><td>30s, 10s für critical</td></tr>
<tr><th><code>group_interval</code></th><td>Mindestabstand zwischen Push-Benachrichtigungen für eine Gruppe, deren Alerts sich geändert haben</td><td>5m</td></tr>
<tr><th><code>repeat_interval</code></th><td>Erinnerung für eine Gruppe, die noch feuert und sich nicht geändert hat</td><td>4h, 1h für critical</td></tr>
</tbody>
</table>
</div>

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](https://info.pocketalert.app/features/daily-limits) (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](/features/action-buttons) ergänzen. Dieser hier öffnet für die erste feuernde Instanz ein Grafana-Dashboard:

```bash
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:

```yaml
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:

```json
{"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](/features/webhook-history). 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 failed` mit dem Statuscode protokolliert. Ein `404` bedeutet 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 funktioniert `CPU over 90% on %groupLabels.alertname%`. Schreibe `%%`, wenn das `%` an anderen Text grenzt, wie in `%commonLabels.usage%%%`.
- **Nutze den [Webhook-Tester](/tools/webhook)**, 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](/use-cases/kubernetes-alerts).

### Ich nutze Grafana-Alerting, nicht Alertmanager. Was ändert sich?

Grafana sendet sein eigenes Webhook-Format. Siehe [die Grafana-Anleitung](/blog/how-to-integrate-grafana-into-pocketalert).

[Erstelle ein kostenloses Konto](/signup), führe das Skript aus, füge die drei Slugs in `alertmanager.yml` ein, und der nächste `InstanceDown` erreicht dein Handy.
