Sie müssen nicht ständig das Grafana-Dashboard offen halten: In dieser Anleitung konfigurieren Sie den Alertmanager so, dass Prometheus Alerts an Telegram und Discord gehen. Hohe CPU-Last oder eine volllaufende Festplatte erreichen Sie dann als Push-Nachricht auf dem Smartphone und im Discord-Server. Sie legen Telegram-Bot und Discord-Webhook an, schreiben Alert-Rules mit PromQL und bauen Routing und Inhibitions auf. Stand Oktober 2026 verwendet die Anleitung Prometheus v3.15.0 und Alertmanager v0.34.1.

Was ist der Alertmanager und warum brauchen Sie ihn?

Prometheus selbst sammelt Metriken und wertet sogenannte Alert-Rules aus. Feuert eine Regel, schickt Prometheus den Alert aber nicht direkt an Telegram oder Discord, sondern an eine eigene Komponente: den Alertmanager. Dieser übernimmt das Gruppieren, Entstören (Silencing), das Unterdrücken abhängiger Alerts (Inhibition) und vor allem das Routing an verschiedene Empfänger (Receiver).

Der Alertmanager kennt von Haus aus mehrere Receiver-Typen, darunter telegram_configs, discord_configs, slack_configs und email_configs. Hier nutzen Sie Telegram für mobile Push-Nachrichten und Discord als zentralen Team-Kanal. Der Alertmanager läuft selbst gehostet; Schwellenwerte und Empfänger bestimmen Sie.

Voraussetzungen

Ein laufender Prometheus-Server (getestet mit v3.15.0, die Konfiguration funktioniert auch mit älteren 3.x-Versionen), der bereits Metriken abruft, zum Beispiel von einem Node Exporter. Den kompletten Stack beschreibt Prometheus mit Docker installieren.
Eine Docker-Umgebung oder ein Linux-Host für den Alertmanager. Falls Docker noch fehlt, hilft unsere Anleitung zur Docker-Installation.
Ein Telegram-Konto und die installierte Telegram-App auf dem Smartphone.
Ein Discord-Server, auf dem Sie Webhooks anlegen dürfen (Recht „Webhooks verwalten“).
Grundkenntnisse in YAML und Zugriff auf die Kommandozeile des Servers. Der Alertmanager läuft auf x86-64 und ARM64 und braucht neben Prometheus keine nennenswerten Zusatzressourcen (im Test 1 Container ohne Last).
Offene Ports: Alertmanager horcht standardmäßig auf 9093, Prometheus auf 9090.

Schritt 1: Telegram-Bot anlegen und Chat-ID ermitteln

Telegram-Benachrichtigungen laufen über einen Bot. Diesen erstellen Sie beim offiziellen BotFather.

Öffnen Sie in Telegram die Suche, geben Sie @BotFather ein und starten Sie den Chat.
Senden Sie /newbot und vergeben Sie einen Anzeigenamen und einen Benutzernamen (muss auf bot enden).
Der BotFather antwortet mit einem Bot-Token in der Form 123456789:ABCdefGhIJKlmNoPQRstuVWxyz. Notieren Sie ihn sicher.
Schreiben Sie dem neuen Bot eine beliebige Nachricht (sonst kann er Ihnen später nicht antworten).

Nun brauchen Sie die Chat-ID, also die ID des Chats, in den die Alerts gesendet werden. Rufen Sie dazu die Telegram-API mit Ihrem Token auf:

curl -s "https://api.telegram.org/bot123456789:ABCdefGhIJKlmNoPQRstuVWxyz/getUpdates" | jq

In der JSON-Antwort finden Sie unter message.chat.id die Chat-ID (eine ganze Zahl, bei Gruppen mit führendem Minus). Für eine Gruppe fügen Sie den Bot zunächst der Gruppe hinzu und schreiben dort eine Nachricht, bevor Sie getUpdates aufrufen.

Verifizieren: Die Antwort enthält "ok":true und einen Eintrag mit chat.id. Ist result leer, schreiben Sie dem Bot erneut eine Nachricht.

Schritt 2: Discord-Webhook erstellen

Discord-Alerts laufen über eine Webhook-URL, ein Bot ist nicht nötig.

Öffnen Sie in Discord die Servereinstellungen des Zielservers.
Gehen Sie zu Integrationen → Webhooks und klicken Sie auf Neuer Webhook.
Vergeben Sie einen Namen (z. B. Prometheus Alerts) und wählen Sie den Zielkanal aus.
Klicken Sie auf Webhook-URL kopieren. Die URL hat das Format https://discord.com/api/webhooks/<id>/<token>.

Testen Sie die URL kurz mit einer manuellen Nachricht, damit Sie sicher sind, dass der Webhook funktioniert:

curl -H "Content-Type: application/json" \
  -d '{"content": "Testnachricht vom Alertmanager"}' \
  "https://discord.com/api/webhooks/123456789/ihr-webhook-token"

Erscheint die Testnachricht im gewählten Kanal, ist der Discord-Webhook für die Alerts einsatzbereit.

Verifizieren: Der curl-Aufruf liefert HTTP 204 ohne Inhalt, und die Nachricht erscheint im Kanal. Meldet Discord Unknown Webhook, stimmt die URL nicht.

Schritt 3: Alert-Rules in Prometheus definieren

Damit überhaupt etwas ausgelöst wird, brauchen Sie Alert-Rules. Legen Sie eine Datei alert.rules.yml an. Jede Regel hat einen expr (PromQL-Ausdruck), ein for (Mindestdauer), labels (z. B. Schweregrad) und annotations (Beschreibungstexte).

groups:
  - name: host-alerts
    rules:
      - alert: HoheCpuLast
        expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Hohe CPU-Last auf {{ $labels.instance }}"
          description: "Die CPU-Auslastung liegt seit 5 Minuten ueber 85 Prozent."

      - alert: DiskFastVoll
        expr: (node_filesystem_avail_bytes{fstype!~"tmpfs|fuse.lxcfs"} / node_filesystem_size_bytes) * 100 < 10
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Wenig Speicherplatz auf {{ $labels.instance }}"
          description: "Auf {{ $labels.mountpoint }} sind weniger als 10 Prozent frei."

      - alert: InstanceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Target {{ $labels.instance }} ist nicht erreichbar"
          description: "Prometheus kann das Ziel seit 2 Minuten nicht mehr scrapen."

Binden Sie die Rules-Datei und den Alertmanager in der prometheus.yml ein. Steht dort noch kein Abschnitt scrape_configs, ergänzen Sie mindestens den Job für Prometheus selbst; ohne ihn gibt es keine Zeitreihe up, und die Regel InstanceDown bleibt wirkungslos:

rule_files:
  - "alert.rules.yml"

alerting:
  alertmanagers:
    - static_configs:
        - targets:
            - "alertmanager:9093"

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

Verifizieren: Die Prüfung mit promtool check rules in Schritt 6 meldet SUCCESS: 3 rules found.

Schritt 4: Die alertmanager.yml mit beiden Receivern schreiben

Die zentrale alertmanager.yml. Hier definieren Sie Receiver für Telegram und Discord sowie das Routing und die Inhibitions. Tragen Sie Bot-Token, Chat-ID und Webhook-URL ein.

global:
  resolve_timeout: 5m

route:
  receiver: 'discord-default'
  group_by: ['alertname', 'instance']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  routes:
    - receiver: 'discord-default'
      continue: true
    - matchers:
        - severity = "critical"
      receiver: 'telegram-critical'
      continue: true

receivers:
  - name: 'discord-default'
    discord_configs:
      - webhook_url: 'https://discord.com/api/webhooks/123456789/ihr-webhook-token'
        send_resolved: true

  - name: 'telegram-critical'
    telegram_configs:
      - bot_token: '123456789:ABCdefGhIJKlmNoPQRstuVWxyz'
        chat_id: 987654321
        parse_mode: 'HTML'
        send_resolved: true

inhibit_rules:
  - source_matchers:
      - severity = "critical"
    target_matchers:
      - severity = "warning"
    equal: ['alertname', 'instance']

Was passiert hier? Die erste Child-Route fängt jeden Alert ab und schickt ihn an Discord; dank continue: true stoppt die Auswertung dort nicht. Die zweite Route greift nur bei kritischen Alerts (severity = "critical") und leitet sie zusätzlich an Telegram. So landet jeder Alert im Discord-Kanal und kritische Meldungen zusätzlich als Push auf dem Smartphone. Der Root-Receiver feuert nur, wenn keine Child-Route passt; deshalb ist die explizite Discord-Route mit continue: true nötig. Die Inhibition-Regel unterdrückt Warnungen, wenn für dieselbe Instanz bereits ein kritischer Alert aktiv ist, damit Sie keine doppelten Meldungen bekommen.

Verifizieren: amtool check-config (Schritt 6) meldet SUCCESS, 2 receivers und 1 inhibit rules.

Schritt 5: Alertmanager mit Docker Compose starten

Starten Sie Alertmanager und Prometheus per Docker Compose. Legen Sie folgende compose.yaml an und passen Sie die Pfade an.

services:
  prometheus:
    image: prom/prometheus:v3.15.0
    container_name: prometheus
    restart: unless-stopped
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - ./alert.rules.yml:/etc/prometheus/alert.rules.yml:ro
      - prometheus_data:/prometheus

  alertmanager:
    image: prom/alertmanager:v0.34.1
    container_name: alertmanager
    restart: unless-stopped
    ports:
      - "9093:9093"
    volumes:
      - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml:ro
    command:
      - '--config.file=/etc/alertmanager/alertmanager.yml'

volumes:
  prometheus_data:

Starten Sie den Stack:

docker compose up -d

Prüfen Sie den Status:

docker compose ps

Verifizieren: Beide Container zeigen den Status Up. curl -s localhost:9090/api/v1/alertmanagers listet unter activeAlertmanagers die URL http://alertmanager:9093/api/v2/alerts.

Schritt 6: Konfiguration verifizieren und ersten Test auslösen

Prüfen Sie die Syntax und lösen Sie einen Testalert aus.

Config validieren

Der Alertmanager bringt das Tool amtool mit. Prüfen Sie die Datei direkt im Container:

docker exec alertmanager amtool check-config /etc/alertmanager/alertmanager.yml

Auch die Prometheus-Rules lassen sich validieren:

docker exec prometheus promtool check rules /etc/prometheus/alert.rules.yml

Testalert senden

Schicken Sie einen künstlichen Alert direkt an die Alertmanager-API. Er erscheint dann in Discord und (weil kritisch) auch in Telegram:

curl -H "Content-Type: application/json" -d '[{
  "labels": {"alertname": "TestAlert", "severity": "critical", "instance": "test:9100"},
  "annotations": {"summary": "Das ist ein manueller Testalert"}
}]' http://localhost:9093/api/v2/alerts

Im Browser können Sie unter http://SERVER-IP:9093 die Alertmanager-Oberfläche öffnen und aktive Alerts, Gruppen und Silences einsehen. Unter http://SERVER-IP:9090/alerts zeigt Prometheus den Status jeder Regel (inactive, pending, firing).

Verifizieren: curl -s localhost:9093/api/v2/alerts listet TestAlert mit den Receivern discord-default und telegram-critical. Mit echten Zugangsdaten treffen die Nachrichten nach etwa 30 Sekunden (group_wait) in Discord und Telegram ein.

Updates und Wartung

Aktualisieren Sie die Images regelmäßig:

docker compose pull
docker compose up -d

Verwenden Sie möglichst feste Versions-Tags (wie oben v0.34.1) statt eines beweglichen latest-Tags. Prüfen Sie nach jedem Update erneut mit amtool check-config, ob die Konfiguration weiterhin gültig ist.

Umstieg von Prometheus 3.4 und Alertmanager 0.28

Frühere Fassungen dieser Anleitung nutzten prom/prometheus:v3.4.1 und prom/alertmanager:v0.28.1. Für die hier gezeigte Konfiguration sind beim Umstieg keine Änderungen an den Konfigurationsdateien nötig: Tauschen Sie die Image-Tags, führen Sie docker compose pull und docker compose up -d aus und prüfen Sie anschließend mit amtool check-config und promtool check rules. Zwei Punkte aus den Release-Notes betreffen nur erweiterte Setups: Seit Alertmanager v0.33 ist das wirkungslose Flag --enable-feature=auto-gomaxprocs entfernt und führt beim Start zu einem Fehler, falls es noch in Ihrem command steht. Seit v0.34 unterscheidet die Metrik alertmanager_notifications_failed_total beim Label reason zusätzlich authError (etwa ein ungültiger Bot-Token) und rateLimited; eigene Alarme auf reason="clientError" sollten Sie entsprechend erweitern. Neu und nützlich für Telegram: Der Bot-Token lässt sich seit v0.31 global unter global.telegram_bot_token setzen, die Chat-ID per chat_id_file aus einer Datei lesen.

Im Test auf einem Debian-12-Host mit Docker CE (Testhost, ohne echte Zugangsdaten) liefen Prometheus v3.15.0 und Alertmanager v0.34.1 mit exakt den Dateien dieser Anleitung: amtool check-config und promtool check rules meldeten SUCCESS, Prometheus meldete den Alertmanager als aktiv, der Testalert aus Schritt 6 wurde angenommen und beiden Receivern zugeordnet. Beim Zustellversuch an Telegram und Discord mit Platzhalter-Zugangsdaten protokollierte der Alertmanager erwartungsgemäß Unauthorized (401) beziehungsweise Unknown Webhook.

Backup

Sichern Sie regelmäßig die Konfigurationsdateien: alertmanager.yml, alert.rules.yml, prometheus.yml und die compose.yaml. Legen Sie sie in ein Git-Repository oder das Server-Backup. Da Token und Webhook-URL Geheimnisse sind, gehören sie nicht in ein öffentliches Repo. Legen Sie sie stattdessen in separaten, nicht versionierten Dateien ab; der Alertmanager liest sie über bot_token_file, chat_id_file (seit v0.31) und webhook_url_file ein.

Troubleshooting

Keine Telegram-Nachricht: Prüfen Sie, ob Sie dem Bot bereits eine Nachricht geschrieben haben. Bots können keine Konversation initiieren. Kontrollieren Sie Token und Chat-ID (Gruppen-IDs sind negativ).
Discord schweigt: Testen Sie die Webhook-URL erneut per curl. Eine gelöschte oder neu generierte Webhook-URL ist die häufigste Ursache.
Alert feuert nicht: Sehen Sie unter http://SERVER-IP:9090/alerts nach. Steht die Regel auf pending, ist die for-Dauer noch nicht erreicht. Bei inactive trifft der expr nicht zu.
Config wird nicht geladen: Sehen Sie sich die Logs mit docker logs alertmanager an. YAML reagiert empfindlich auf Einrückungen und Tabs; verwenden Sie ausschließlich Leerzeichen.
Doppelte Meldungen: Prüfen Sie die inhibit_rules und das group_by, damit zusammengehörige Alerts gebündelt statt einzeln gesendet werden.

Häufige Fragen

Auf welchem Port läuft der Alertmanager?

Der Alertmanager horcht standardmäßig auf Port 9093 für die Weboberfläche und die API. Halten Sie den Port in der Firewall nur intern erreichbar.

Brauche ich für Discord einen Bot wie bei Telegram?

Nein. Telegram benötigt einen Bot mit Token und Chat-ID, Discord dagegen nur eine Webhook-URL. Der Alertmanager unterstützt seit Version 0.25 native discord_configs, sodass Sie ohne Zusatzdienst auskommen.

Wie verhindere ich, dass ich von Alerts zugespammt werde?

Nutzen Sie group_by, um gleichartige Alerts zu bündeln, repeat_interval, um Wiederholungen zu drosseln, und inhibit_rules, um abhängige Warnungen zu unterdrücken. Für geplante Wartungen legen Sie in der Alertmanager-Oberfläche ein temporäres Silence an.

Kann ich zusätzlich E-Mail oder Slack als Empfänger nutzen?

Ja. Der Alertmanager unterstützt mehrere Receiver-Typen parallel, darunter email_configs und slack_configs. Fügen Sie einen weiteren Receiver hinzu und leiten Sie passende Routes dorthin.

Wie teste ich Alerts, ohne ein echtes Problem zu provozieren?

Senden Sie einen manuellen Alert per curl an die API http://localhost:9093/api/v2/alerts (siehe Schritt 6).

Fazit

Mit dieser Alertmanager-Konfiguration haben Sie Prometheus Alerts an Telegram und Discord eingerichtet und bekommen kritische Ereignisse zuverlässig aufs Smartphone und in den Team-Kanal. Ihr Monitoring meldet sich damit aktiv, bevor aus hoher CPU-Last oder einer fast vollen Disk ein Ausfall wird.

Weiterführende Artikel

Falls Docker fehlt, hilft unsere Schritt-für-Schritt-Anleitung zur Docker-Installation Warum Sie Secrets wie Bot-Token und Webhook-URLs konsequent schützen, zeigt der Beitrag zum Grafana-Labs-Supply-Chain-Vorfall rund um einen GitHub-Token. Weitere Anleitungen finden Sie in unserer Kategorie Monitoring.

Quellen

Offizielle Dokumentation: Prometheus Alertmanager Configuration, Prometheus Alerting Rules und die Telegram Bot API.