# Kubernetes-Alarme auf deinem Handy.

> Kubernetes-Alerts als Push-Benachrichtigung aufs Smartphone. Richte eine Alertmanager webhook_config auf Pocket Alert aus, und CrashLoopBackOff oder OOMKilled landet in unter einer Sekunde als Push-Nachricht bei dir.

<!-- source: https://pocketalert.app/de/use-cases/kubernetes-alerts -->

Zuletzt aktualisiert: 2026-08-11

Ein CrashLoopBackOff-Pod, ein OOMKilled-Container, ein fehlgeschlagener Rollout oder ein NotReady-Node wird zu einer Push-Benachrichtigung auf deinem Handy, mit Namespace und Pod-Name direkt auf dem Bildschirm. Erkenne Cluster-Probleme, ohne ständig in kubectl zu arbeiten.

## Drei Schritte von Alertmanager zum Handy

1. **Empfangs-URL holen** — Erstelle einen Pocket-Alert-Webhook mit einer GJSON-Nachrichtenvorlage und kopiere seine Empfangs-URL.
2. **Alertmanager verbinden** — Füge in Alertmanager einen webhook_configs-Receiver hinzu und leite deine kritischen Alarme dorthin.
3. **Loslegen** — Der nächste ausgelöste Alarm wird in unter einer Sekunde auf dein Handy gepusht. Passe die GJSON-Vorlage an, während du die Routen verfeinerst.

## Vom ausgelösten Alarm aufs Handy

Behalte den Alertmanager, den du schon betreibst. Pocket Alert macht aus seiner Webhook-Ausgabe eine Push-Benachrichtigung auf deinem Handy.

- **Natives webhook_config** — Alertmanager hat einen nativen webhook_config-Receiver. Trage deine Anwendungs-URL ein, und du bist fertig.
- **GJSON-Feld-Mapping** — GJSON zieht alertname, namespace, pod und severity aus dem JSON in einen lesbaren Titel und eine lesbare Nachricht.
- **Status und Schweregrad inline** — Zeige Status und Schweregrad direkt an, damit sich ein ausgelöster kritischer Alarm von einer Entwarnung unterscheidet.
- **Pod- und Node-Ereignisse** — Erkenne CrashLoopBackOff, OOMKilled, fehlgeschlagene Rollouts, NotReady-Nodes und volle PVCs.
- **Kanäle pro Cluster** — Getrennte Anwendungen geben prod und staging jeweils eigene Kanäle mit eigener Webhook-URL.
- **Zustellung in unter einer Sekunde** — Push-Benachrichtigungen kommen unter einer Sekunde an, sobald Alertmanager auslöst. Kein zusätzlicher Agent im Cluster.

## Kubernetes-Alarme auf dein Handy schicken

### 1. Pocket-Alert-Webhook anlegen

Erstelle auf der Seite [Webhooks](https://pocketalert.app/de/webhooks) einen Webhook, dessen GJSON-`message`-Vorlage das Alertmanager-Payload ausliest (oberstes `status` und `commonLabels` sowie ein `alerts`-Array):

```
curl -X POST "https://api.pocketalert.app/v1/webhooks" \
  -H "Token: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"K8s Alertmanager","message":"[%status%] %commonLabels.alertname% (%commonLabels.severity%)\n%alerts.0.labels.namespace%/%alerts.0.labels.pod%\n%alerts.0.annotations.summary%","application_id":"qm47b9pzxzxg"}'
```

Du erhältst eine eingehende URL wie `https://p4a.me/wh/1234abcd`. Verwende pro Cluster einen eigenen Webhook, um prod und staging getrennt zu halten.

### 2. Alertmanager darauf ausrichten

Füge einen `webhook_configs`-Receiver hinzu und leite deine kritischen Alarme dorthin ([Alertmanager-Dokumentation](https://prometheus.io/docs/alerting/latest/configuration/#webhook_config)):

```
receivers:
  - name: 'pocketalert'
    webhook_configs:
      - url: 'https://p4a.me/wh/1234abcd'

route:
  receiver: 'pocketalert'
  group_by: ['alertname', 'namespace']
```

Alertmanager sendet sein Standard-JSON per POST; die GJSON-Pfade oben übernehmen status, alertname, severity, namespace und pod in die Push-Benachrichtigung. Wenn der Alarm endet, wechselt `status` auf `resolved`.

### 3. Oder per POST aus einem Controller / kubectl

Ein Controller oder ein einmaliges Skript kann die Messages-API direkt mit einem Token-Header aufrufen:

```
curl -X POST "https://api.pocketalert.app/v1/messages" \
  -H "Token: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title":"CrashLoopBackOff","level":"critical","message":"api-7c9 in prod, 12 restarts","application_id":"qm47b9pzxzxg"}'
```

Die [Dokumentation zu den Webhook-Einstellungen](https://info.pocketalert.app/api/webhooks/settings.html) beschreibt alle GJSON-Pfade und Webhook-Optionen.

## FAQ

### Wie schicke ich Kubernetes-Alarme an Pocket Alert?

Füge in Alertmanager einen webhook_configs-Receiver hinzu, der auf deine Pocket-Alert-Empfangs-URL zeigt, https://p4a.me/wh/1234abcd. Ein ausgelöster CrashLoopBackOff- oder OOMKilled-Alarm wird zu einer Push-Benachrichtigung.

### Wie liest Pocket Alert das Alertmanager-Payload?

Das GJSON-Feld-Mapping liest das Alertmanager-JSON aus. Übernimm commonLabels.alertname in den Titel und alerts.0.labels.namespace / alerts.0.labels.pod in den Text, damit Namespace und Pod auf dem Bildschirm erscheinen statt des rohen Payloads.

### Kann ich ausgelöste Alarme von behobenen unterscheiden?

Das Payload enthält status (firing oder resolved) und commonLabels.severity. Verwende beide in deiner GJSON-Nachrichtenvorlage, damit sich ein ausgelöster kritischer Alarm von einer Entwarnung unterscheidet.

### Wie trenne ich Prod- und Staging-Cluster?

Gib prod und staging jeweils eigene Pocket-Alert-Anwendungen mit eigener Webhook-URL. Leite eine Alertmanager-Route pro Anwendung, damit ein NotReady-Node in staging nie mit prod verwechselt wird.

### Brauche ich einen Agenten im Cluster?

Nein. Du betreibst Alertmanager bereits. Pocket Alert braucht im Cluster nichts Zusätzliches. Ein Controller oder Skript kann auch direkt per POST an https://api.pocketalert.app/v1/messages mit einem Token-Header senden.

### Kann ich die Alarmschwere auf die Priorität der Push-Benachrichtigung abbilden?

Ja. Jede Nachricht akzeptiert eine Priorität: silent, low, default, high oder critical. Nimm ein "level"-Feld in das Webhook-Payload auf oder setze default_level am Webhook selbst; eine explizite Priorität im Payload hat immer Vorrang. Eine übliche Aufteilung ist firing=critical und resolved=silent: Der ausgelöste Alarm durchbricht auf Android „Nicht stören“ und landet auf dem iPhone als zeitkritisch, während die Entwarnung still im Verlauf liegt. Ein ungültiger Wert fällt auf default zurück und wird nie abgelehnt.
