Du betreibst Prometheus auf deinem Homeserver oder im Rechenzentrum und willst nicht ständig das Grafana-Dashboard offen halten? Dann ist es Zeit, Prometheus Alerts an Telegram und Discord einzurichten. In dieser Anleitung konfigurierst du den Alertmanager so, dass kritische Ereignisse wie hohe CPU-Last oder eine volllaufende Festplatte direkt als Push-Nachricht auf deinem Smartphone und in deinem Discord-Server landen. Wir gehen Schritt für Schritt durch die komplette Alertmanager Konfiguration: Telegram-Bot anlegen, Discord-Webhook erstellen, Alert-Rules mit PromQL schreiben sowie Routing und Inhibitions sauber aufbauen. Am Ende erhältst du zuverlässige Benachrichtigungen, ohne dafür einen externen Dienst bezahlen zu müssen.

Kurz gesagt: Du legst einen Telegram-Bot (Token + Chat-ID) und einen Discord-Webhook an, definierst Alert-Rules in Prometheus, trägst beide Receiver in die alertmanager.yml ein und steuerst über Routes, welcher Alert wohin geht. Alertmanager läuft auf Port 9093.

Was ist der Alertmanager und warum brauchst du 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. Genau das nutzen wir: Telegram für schnelle mobile Push-Nachrichten, Discord als zentralen Team-Kanal. So bekommst du eine zuverlässige Prometheus Benachrichtigung, egal ob du am Schreibtisch sitzt oder unterwegs bist.

Der große Vorteil dieser Lösung: Sie läuft komplett selbst gehostet, du bist von keinem kostenpflichtigen Drittanbieter abhängig, und du behältst die volle Kontrolle über Schwellenwerte und Empfängerlisten.

Voraussetzungen

Ein laufender Prometheus-Server (Version 2.x oder neuer), der bereits Metriken scrapt (z. B. von einem Node Exporter).
Eine Docker-Umgebung oder ein Linux-Host für den Alertmanager. Falls Docker noch fehlt, hilft dir unsere Anleitung zur Docker-Installation.
Ein Telegram-Konto und die installierte Telegram-App auf dem Smartphone.
Ein Discord-Server, auf dem du Webhooks anlegen darfst (Server-Verwalten-Recht).
Grundkenntnisse in YAML und Zugriff auf die Kommandozeile deines Servers.
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 erstellst du beim offiziellen BotFather.

Öffne in Telegram die Suche, gib @BotFather ein und starte den Chat.
Sende /newbot, vergib einen Anzeigenamen und einen Benutzernamen (muss auf bot enden).
Der BotFather antwortet mit einem Bot-Token in der Form 123456789:ABCdefGhIJKlmNoPQRstuVWxyz. Notiere ihn sicher.
Schreibe deinem neuen Bot eine beliebige Nachricht (sonst kann er dir später nicht antworten).

Nun brauchst du die Chat-ID, also die ID des Chats, in den die Alerts gesendet werden. Rufe dazu die Telegram-API mit deinem Token auf:

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

In der JSON-Antwort findest du unter message.chat.id deine Chat-ID (eine ganze Zahl, bei Gruppen mit führendem Minus). Für eine Gruppe fügst du den Bot zunächst der Gruppe hinzu und schreibst dort eine Nachricht, bevor du getUpdates aufrufst.

Schritt 2: Discord-Webhook erstellen

Discord-Alerts laufen über eine Webhook-URL. Du brauchst keinen Bot.

Öffne in Discord die Servereinstellungen des Zielservers.
Gehe zu Integrationen → Webhooks und klicke auf Neuer Webhook.
Vergib einen Namen (z. B. Prometheus Alerts) und wähle den Zielkanal aus.
Klicke auf Webhook-URL kopieren. Die URL hat das Format https://discord.com/api/webhooks/<id>/<token>.

Teste die URL kurz mit einer manuellen Nachricht, damit du sicher bist, dass der Webhook funktioniert:

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

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

Schritt 3: Alert-Rules in Prometheus definieren

Damit überhaupt etwas ausgelöst wird, brauchst du Alert-Rules. Lege 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."

Binde die Rules-Datei und den Alertmanager in deiner prometheus.yml ein:

rule_files:
  - "alert.rules.yml"

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

Schritt 4: Die alertmanager.yml mit beiden Receivern schreiben

Jetzt kommt das Herzstück: die zentrale alertmanager.yml. Hier definierst du Receiver für Telegram und Discord sowie das Routing und die Inhibitions. Trage deinen Bot-Token, deine Chat-ID und die 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/dein-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. Wichtig zu wissen: Der Root-Receiver feuert nur, wenn gar keine Child-Route passt - deshalb ist die explizite Discord-Route mit continue: true nötig, damit beide Wege parallel funktionieren. Die Inhibition-Regel unterdrückt Warnungen, wenn für dieselbe Instanz bereits ein kritischer Alert aktiv ist, damit du keine doppelten Meldungen bekommst.

Schritt 5: Alertmanager mit Docker Compose starten

Am einfachsten startest du Alertmanager und Prometheus per Docker Compose. Lege folgende docker-compose.yml an und passe die Pfade an.

services:
  prometheus:
    image: prom/prometheus:v3.4.1
    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.28.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:

Starte den Stack:

docker compose up -d

Prüfe, ob beide Container laufen:

docker compose ps

Schritt 6: Konfiguration verifizieren und ersten Test auslösen

Bevor du auf einen echten Alert wartest, prüfe die Syntax und feuere einen Testalert ab.

Config validieren

Der Alertmanager bringt das Tool amtool mit. Prüfe deine 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

Schicke 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 kannst du 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).

Updates und Wartung

Halte die Images aktuell, um Bugfixes und Sicherheitsupdates zu erhalten. Mit Docker Compose ist das schnell erledigt:

docker compose pull
docker compose up -d

Verwende möglichst feste Versions-Tags (wie oben v0.28.1) statt eines beweglichen latest-Tags, damit ein Pull nicht unbemerkt eine inkompatible Version zieht. Prüfe nach jedem Update erneut mit amtool check-config, ob deine Konfiguration weiterhin gültig ist.

Backup

Sichere regelmäßig deine Konfigurationsdateien: alertmanager.yml, alert.rules.yml, prometheus.yml und die docker-compose.yml. Diese Dateien gehören idealerweise in ein Git-Repository oder in dein normales Server-Backup. Da Token und Webhook-URL Geheimnisse sind, gehören sie nicht in ein öffentliches Repo. Lege sie stattdessen über Umgebungsvariablen oder eine separate, nicht versionierte Datei ab.

Troubleshooting

Keine Telegram-Nachricht: Prüfe, ob du dem Bot bereits eine Nachricht geschrieben hast. Bots können keine Konversation initiieren. Kontrolliere Token und Chat-ID (Gruppen-IDs sind negativ).
Discord schweigt: Teste die Webhook-URL erneut per curl. Eine gelöschte oder neu generierte Webhook-URL ist die häufigste Ursache.
Alert feuert nicht: Schau 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: Logs ansehen mit docker logs alertmanager. YAML reagiert empfindlich auf Einrückungen und Tabs - verwende ausschließlich Leerzeichen.
Doppelte Meldungen: Prüfe deine 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. Prometheus liefert seine Alerts an genau diesen Port. Achte darauf, dass deine Firewall den Port intern erreichbar hält, ihn aber nicht ungeschützt ins Internet exponiert.

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 du ohne Zusatzdienst auskommst.

Wie verhindere ich, dass ich von Alerts zugespammt werde?

Nutze 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 legst du 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. Du fügst sie einfach als weiteren Receiver hinzu und leitest passende Routes dorthin.

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

Sende einen manuellen Alert per curl an die API http://localhost:9093/api/v2/alerts (siehe Schritt 6). So prüfst du die komplette Kette von Routing bis zur Zustellung, ohne Last zu erzeugen oder eine Disk volllaufen zu lassen.

Fazit

Mit dieser Alertmanager Konfiguration hast du Prometheus Alerts an Telegram und Discord eingerichtet und bekommst kritische Ereignisse zuverlässig aufs Smartphone und in deinen Team-Kanal. Du hast einen Telegram-Bot angelegt, einen Discord-Webhook erstellt, Alert-Rules mit PromQL geschrieben und über Routes sowie Inhibitions sauber gesteuert, welcher Alert wohin geht. Damit ist dein Monitoring nicht nur passiv, sondern meldet sich aktiv, bevor aus einer hohen CPU-Last oder einer fast vollen Disk ein echter Ausfall wird.

Weiterführende Artikel

Bevor du den Alertmanager aufsetzt, lohnt sich ein Blick in unsere Schritt-für-Schritt-Anleitung zur Docker-Installation, damit die Container sauber laufen. Wenn du dich generell für Monitoring-Sicherheit interessierst, zeigt der Beitrag zum Grafana-Labs-Supply-Chain-Vorfall rund um einen GitHub-Token, warum du Secrets wie Bot-Token und Webhook-URLs konsequent schützen solltest. Weitere Anleitungen findest du in unserer Kategorie Monitoring.

Quellen

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