# Erfahre die Sekunde, wenn ein Server ausfällt.

> Erhalte sofort Push-Benachrichtigungen, wenn deine Server ausfallen. Verbinde Grafana, Prometheus oder UptimeRobot per Webhook und bekomme Alerts in unter einer Sekunde auf dein Smartphone.

<!-- source: https://pocketalert.app/de/use-cases/server-monitoring -->

Zuletzt aktualisiert: 2026-08-11

Pocket Alert verwandelt Server-Monitoring-Alarme in Push-Benachrichtigungen auf dein iPhone oder Android. Verbinde Grafana, Prometheus, UptimeRobot oder einen einfachen Cronjob-Health-Check mit einer Webhook-URL. Alarme erreichen dein Handy in unter einer Sekunde, ohne Agent auf dem Server und ohne E-Mail-Sammelbericht, den du durchsuchen musst.

## Drei Schritte zu deinem ersten Server-Alarm

1. **Pocket Alert einrichten** — Installiere die pocketalert-CLI und führe pocketalert auth YOUR_API_KEY aus, oder erstelle einen Webhook zur Weiterleitung.
2. **Monitoring anbinden** — Füge einen Cronjob-Health-Check, einen Netdata custom_sender oder einen Alertmanager webhook_config hinzu, der auf die Empfangs-URL zeigt.
3. **Benachrichtigung erhalten** — Löse einen Test-Alarm aus, und dein Handy vibriert kurz darauf. Ordne Felder zu, um den Inhalt feinabzustimmen.

## Vom Metrik-Ausreißer direkt aufs Handy

Richte dein Monitoring auf eine Webhook-URL aus, und jeder Alarm erreicht dein Handy in unter einer Sekunde.

- **Funktioniert mit deinem Stack** — Grafana, Prometheus, UptimeRobot, Datadog und Zabbix erreichen dein Handy, sobald sie einen Webhook auslösen.
- **Zustellung in unter einer Sekunde** — Die Push-Benachrichtigung kommt in unter einer Sekunde, noch bevor die erste Beschwerde eines Nutzers eingeht.
- **Feldzuordnung (GJSON)** — Ordne JSON-Payload-Felder dem Titel und der Nachricht zu. Alarmname und Schweregrad bleiben in der Benachrichtigung erhalten.
- **Skript oder Webhook** — Ein Cronjob-Health-Check oder ein weitergeleiteter Alertmanager-Alarm erreichen dein Handy auf die gleiche Weise.
- **Kanäle pro Anwendung** — Gib Produktiv, Staging und Homelab jeweils eigene Kanäle.
- **Kein Agent nötig** — Pocket Alert verarbeitet die Webhooks, die dein Monitoring ohnehin erzeugt, daher läuft auf dem überwachten Rechner nichts zusätzlich.

## Dein Monitoring anbinden

### 1. Ein Bash-Health-Check per Cronjob

Installiere die CLI, melde dich einmal an und prüfe dann den Dienst. Antwortet er nicht, sendest du eine Push-Benachrichtigung.

```
sudo mv pocketalert /usr/local/bin/ && chmod +x /usr/local/bin/pocketalert
pocketalert auth YOUR_API_KEY
```

```
#!/usr/bin/env bash
URL=https://api.example.com/health
if ! curl -fsS --max-time 10 "$URL" >/dev/null; then
  pocketalert send -t "API DOWN on $(hostname)" -m "$URL did not respond"
fi
```

Führe es jede Minute per Cron aus.

```
* * * * * /usr/local/bin/check-health.sh
```

### 2. Oder ein Netdata-Alarm-Hook

Füge einen `custom_sender()` in `health_alarm_notify.conf` hinzu (bearbeiten über `sudo ./edit-config health_alarm_notify.conf`), damit jeder Netdata-Alarm an die Messages-API gesendet wird.

```
custom_sender() {
  curl -X POST 'https://api.pocketalert.app/v1/messages' \
    -H 'Token: YOUR_API_KEY' \
    -H 'Content-Type: application/json' \
    -d "{\"title\":\"${name} is ${status} on ${host}\",\"message\":\"${chart}.${family}: ${value_string}\",\"level\":\"critical\"}"
}
```

### 3. Oder Alertmanager per Webhook weiterleiten

Erstelle auf der Seite [Webhooks](https://pocketalert.app/de/webhooks) einen Webhook mit einer GJSON-Vorlage und trage dann die Empfangs-URL in einer Prometheus-Alertmanager-`webhook_config` ein.

```
curl -X POST 'https://api.pocketalert.app/v1/webhooks' \
  -H 'Token: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"name":"Alertmanager","application_id":"qm47b9pzxzxg","message":"%status%: %alerts.0.labels.alertname% — %alerts.0.annotations.summary%"}'
```

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

In der [Dokumentation](https://info.pocketalert.app/api/webhooks/settings.html) findest du die GJSON-Pfade.

## FAQ

### Wie funktionieren Server-Monitoring-Alerts?

Pocket Alert gibt jeder Anwendung eine eingehende Webhook-URL. Richte ein Monitoring-Tool wie Grafana, Prometheus Alertmanager, UptimeRobot, Datadog oder Zabbix auf diese URL, und die Alarme, die es auslöst, werden innerhalb einer Sekunde zu Push-Benachrichtigungen auf deinem Handy.

### Kann ich den Inhalt der Alarme anpassen?

Ja. Ordne Felder aus dem eingehenden JSON mit GJSON-Pfaden dem Titel und der Nachricht der Benachrichtigung zu. Ein Alertmanager-Alarm behält dabei durchgehend seinen Namen, Status und Schweregrad.

### Welche Monitoring-Tools werden unterstützt?

Jedes Tool, das bei einem Alarm eine HTTP-Anfrage sendet, funktioniert: Grafana, Prometheus Alertmanager, UptimeRobot, Datadog, Zabbix, Netdata, Uptime Kuma und eigene Health-Check-Skripte.

### Wie vermeide ich Alarmmüdigkeit?

Sende eine Push-Benachrichtigung, wenn ein Server ausfällt, und eine weitere, wenn er wieder läuft. Kanäle pro Anwendung trennen Produktiv-, Staging- und private Infrastruktur, sodass dringende Alarme nicht in einem lauten Feed untergehen.

### Muss ich auf meinen Servern einen Agenten installieren?

Du musst keinen Agenten installieren. Pocket Alert empfängt die Webhooks, die dein Monitoring ohnehin sendet, daher läuft auf dem überwachten Server nichts zusätzlich.

### Kann ein Alarm bei Serverausfall nachts den Modus Nicht stören durchbrechen?

Ja. Sende den Alarm mit level: critical, und er umgeht auf Android den Modus Nicht stören und setzt sich auf dem iPhone als zeitkritische Benachrichtigung über den Fokus-Modus hinweg durch. Lass Wiederherstellungsmeldungen auf dem Standardwert oder stumm, damit nur der Ausfall selbst Lärm macht. Die Stufen reichen von silent (-2) bis critical (2) und funktionieren in der API, in Webhook-Payloads und als Standard pro Webhook.
