Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 3: Der Routing-Baum

Ziel: Alarme gehen je nach Team und Schwere an verschiedene Receiver, alles landet zusätzlich im Archiv, und du prüfst jede Route mit amtool, bevor ein echter Alarm sie braucht. · Dauer: ca. 60 min · Voraussetzung: Tag 2

Briefing

  • Die Konfiguration ist ein Baum aus Routen. Ein Alarm startet an der Wurzel und wandert in das erste Kind, dessen matchers passen. Dort geht es weiter nach unten. Die tiefste passende Route bestimmt den Receiver.
  • Passt kein Kind, bleibt der Alarm bei der Eltern-Route und deren Receiver.
  • continue: true heißt: Nach dieser Route weitersuchen. So bekommt ein Alarm mehrere Receiver.
  • Kinder erben group_by und die drei Timer, solange sie nichts Eigenes setzen.
 group_wait      erste Nachricht einer neuen Gruppe wartet so lange auf weitere Alarme
 group_interval  Änderungen an einer Gruppe (neu, resolved) frühestens so oft
 repeat_interval unveränderte Gruppe wird nach dieser Zeit erneut gemeldet

Drill 1: Mehr Alarme

Ein zweites Team, plattform, kümmert sich um die VM. Dazu kommt der Watchdog: ein Alarm, der immer feuert. Er beweist, dass Prometheus, Alertmanager und Empfänger zusammenarbeiten.

cd ~/am-lab
cat > prometheus/rules/plattform.yml <<'EOF'
groups:
  - name: plattform
    rules:
      - alert: Watchdog
        expr: vector(1)
        labels:
          severity: none
        annotations:
          summary: "Feuert immer. Fehlt er, ist die Alarmkette kaputt."
      - alert: NodeExporterDown
        expr: up{job="node"} == 0
        for: 1m
        labels:
          severity: warning
          team: plattform
        annotations:
          summary: "Keine Metriken von {{ $labels.instance }}"
      - alert: HostHighLoad
        expr: node_load1 > on() count(node_cpu_seconds_total{mode="idle"}) * 2
        for: 2m
        labels:
          severity: warning
          team: plattform
        annotations:
          summary: "Load {{ $value }} auf {{ $labels.instance }}"
EOF
promtool check rules prometheus/rules/plattform.yml
curl -s -X POST localhost:9090/-/reload

Erwartet:

Checking prometheus/rules/plattform.yml
  SUCCESS: 3 rules found
  • vector(1) liefert immer eine Zeitreihe, also feuert der Watchdog immer.
  • HostHighLoad vergleicht die Load mit der doppelten Zahl der CPUs. on() erlaubt den Vergleich zweier Ausdrücke ohne gemeinsame Labels.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der Baum

Sechs Receiver, alle zeigen auf alarm-log, jeder mit eigenem Pfad. So siehst du im Log, welcher Receiver eine Nachricht bekam.

cat > alertmanager/alertmanager.yml <<'EOF'
route:
  receiver: standard
  group_by: [alertname, env]
  group_wait: 30s
  group_interval: 2m
  repeat_interval: 4h
  routes:
    - receiver: archiv
      continue: true
    - matchers: [alertname="Watchdog"]
      receiver: watchdog
      repeat_interval: 1m
    - matchers: [team="notes"]
      receiver: team-notes
      routes:
        - matchers: [severity="critical"]
          receiver: notes-bereitschaft
          group_wait: 10s
    - matchers: [team="plattform"]
      receiver: team-plattform

receivers:
  - name: standard
    webhook_configs:
      - url: http://alarm-log:5001/standard
  - name: archiv
    webhook_configs:
      - url: http://alarm-log:5001/archiv
  - name: watchdog
    webhook_configs:
      - url: http://alarm-log:5001/watchdog
  - name: team-notes
    webhook_configs:
      - url: http://alarm-log:5001/team-notes
  - name: notes-bereitschaft
    webhook_configs:
      - url: http://alarm-log:5001/notes-bereitschaft
  - name: team-plattform
    webhook_configs:
      - url: http://alarm-log:5001/team-plattform
EOF
amtool check-config alertmanager/alertmanager.yml | head -1
curl -s -X POST localhost:9093/-/reload
amtool config routes

Erwartet:

Checking 'alertmanager/alertmanager.yml'  SUCCESS
Routing tree:
.
└── default-route  receiver: standard
    ├── default-route  continue: true  receiver: archiv
    ├── {alertname="Watchdog"}  receiver: watchdog
    ├── {team="notes"}  receiver: team-notes
    │   └── {severity="critical"}  receiver: notes-bereitschaft
    └── {team="plattform"}  receiver: team-plattform
  • matchers ist eine Liste. Alle Einträge müssen passen. Erlaubt sind =, !=, =~ und !~, also gleich, ungleich, Regex und negierte Regex.
  • Die erste Route hat keine Matcher und continue: true. Sie passt auf jeden Alarm, danach geht die Suche weiter.
  • group_by: [alertname, env]: Gleicher Alarm aus verschiedenen Umgebungen ergibt getrennte Nachrichten.
  • Ältere Anleitungen schreiben match: und match_re:. Das funktioniert noch, gilt aber als veraltet.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Routen testen, ohne zu warten

amtool config routes test nimmt Labels und sagt, welche Receiver ein solcher Alarm bekäme. Ohne --config.file fragt es den laufenden Alertmanager.

amtool config routes test team=notes severity=critical

Erwartet:

archiv,notes-bereitschaft
amtool config routes test team=notes severity=warning

Erwartet:

archiv,team-notes
amtool config routes test alertname=Watchdog

Erwartet:

archiv,watchdog

Und ein Team, das der Baum nicht kennt:

amtool config routes test team=marketing

Erwartet:

archiv

Nur archiv, nicht standard. Die Archiv-Route hat gepasst. Damit gilt der Alarm als geroutet, und der Receiver der Wurzel greift nie mehr.

Ausprobiert: Eine continue-Route ohne Matcher ganz oben schaltet den Default-Receiver stillschweigend ab. Alarme ohne passendes Team landen dann nur im Archiv, und niemand wird benachrichtigt. amtool check-config meldet nichts, der Fehler fällt erst beim Testen auf.

Die Abhilfe ist eine letzte Route ohne Matcher, die alles auffängt:

cat > fallback.txt <<'EOF'
    - receiver: standard
EOF
sed -i '/receiver: team-plattform$/r fallback.txt' alertmanager/alertmanager.yml
rm fallback.txt
curl -s -X POST localhost:9093/-/reload
amtool config routes test team=marketing

Erwartet:

archiv,standard

sed '/muster/r datei' fügt den Inhalt der Datei hinter der passenden Zeile ein. Hier landet die neue Route hinter receiver: team-plattform. Wer lieber den Editor nimmt: Die neue Zeile gehört eingerückt wie die anderen Routen ganz ans Ende von routes.

Für die CI gibt es --verify.receivers. Der Befehl endet mit Fehlercode 1, wenn das Ergebnis nicht stimmt:

amtool config routes test --verify.receivers=team-notes team=plattform
echo $?

Erwartet:

archiv,team-plattform
WARNING: Expected receivers did not match resolved receivers.
1

Fortschritt speichern? Kostenlos registrieren

Drill 4: Der Baum im Betrieb

Zwei echte Ausfälle auf einmal, notes-api und node-exporter, dazu ein Testalarm eines fremden Teams.

T=$(date -u +%Y-%m-%dT%H:%M:%SZ)
docker compose stop notes-api node-exporter
amtool alert add alertname=Werbeaktion team=marketing severity=warning

T merkt sich die Startzeit, damit du gleich nur die neuen Log-Zeilen siehst. Nach etwa zwei Minuten:

docker compose logs --no-log-prefix --since $T alarm-log

Erwartet:

19:29:48 /watchdog watchdog firing [alertname=Watchdog env=prod] Watchdog (1 firing, 0 resolved)
19:29:48 /archiv archiv firing [alertname=Watchdog env=prod] Watchdog (1 firing, 0 resolved)
19:30:09 /standard standard firing [alertname=Werbeaktion] Werbeaktion (1 firing, 0 resolved)
19:30:09 /archiv archiv firing [alertname=Werbeaktion] Werbeaktion (1 firing, 0 resolved)
19:31:08 /notes-bereitschaft notes-bereitschaft firing [alertname=NotesApiDown env=prod] …
19:31:18 /team-plattform team-plattform firing [alertname=NodeExporterDown env=prod] …
19:31:18 /archiv archiv firing [alertname=NodeExporterDown env=prod] …
19:31:28 /archiv archiv firing [alertname=NotesApiDown env=prod] …
19:31:48 /watchdog watchdog firing [alertname=Watchdog env=prod] Watchdog (1 firing, 0 resolved)
  • NotesApiDown feuerte um 19:30:58. Die Bereitschaft hatte die Nachricht nach zehn Sekunden, das Archiv erst nach 30. Jede Route hat ihre eigene Gruppe mit eigenen Timern.
  • Werbeaktion hat kein Label env. Die Gruppe heißt deshalb nur [alertname=Werbeaktion].
  • Der Watchdog kam um 19:29:48 und 19:31:48, also alle zwei Minuten, obwohl repeat_interval: 1m dasteht.

Der Alertmanager prüft Wiederholungen nur im Takt von group_interval, hier zwei Minuten. Ein kürzeres repeat_interval bringt nichts. Gib der Watchdog-Route einen eigenen, kürzeren Takt:

sed -i 's/      repeat_interval: 1m/      group_interval: 30s\n      repeat_interval: 1m/' \
  alertmanager/alertmanager.yml
grep -B2 'repeat_interval: 1m' alertmanager/alertmanager.yml
curl -s -X POST localhost:9093/-/reload

Erwartet:

      receiver: watchdog
      group_interval: 30s
      repeat_interval: 1m

Nach drei Minuten:

docker compose logs --no-log-prefix --since 3m alarm-log | grep watchdog

Erwartet:

19:37:58 /watchdog watchdog firing [alertname=Watchdog env=prod] Watchdog (1 firing, 0 resolved)
19:39:28 /watchdog watchdog firing [alertname=Watchdog env=prod] Watchdog (1 firing, 0 resolved)

90 Sekunden. Nach 60 Sekunden prüft der Alertmanager, findet „genau eine Minute her“ und das ist noch nicht mehr als repeat_interval. Beim nächsten Takt 30 Sekunden später schickt er. Wer auf den Watchdog einen externen Totmannschalter setzt, rechnet mit repeat_interval plus group_interval.

Starte die Container wieder:

docker compose start notes-api node-exporter

Fortschritt speichern? Kostenlos registrieren

Drill 5: Gruppieren

Drei Alarme mit gleichem Namen, aber verschiedener instance:

T=$(date -u +%Y-%m-%dT%H:%M:%SZ)
amtool alert add alertname=PlatteVoll team=notes severity=warning instance=a
amtool alert add alertname=PlatteVoll team=notes severity=warning instance=b
amtool alert add alertname=PlatteVoll team=notes severity=warning instance=c

Nach 30 Sekunden:

docker compose logs --no-log-prefix --since $T alarm-log

Erwartet:

19:34:27 /archiv archiv firing [alertname=PlatteVoll] PlatteVoll (3 firing, 0 resolved)
19:34:27 /team-notes team-notes firing [alertname=PlatteVoll] PlatteVoll (3 firing, 0 resolved)

Eine Nachricht pro Receiver mit drei Alarmen darin. instance steht nicht in group_by, also gehören alle drei in dieselbe Gruppe. Der Sonderwert group_by: ['...'] gruppiert nach allen Labels, dann wird jeder Alarm einzeln gemeldet.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

amtool config routes

Erwartet: fünf Routen unter der Wurzel, die letzte default-route receiver: standard.

amtool config routes test team=notes severity=critical

Erwartet: archiv,notes-bereitschaft.

amtool config routes test team=marketing

Erwartet: archiv,standard.

Challenge

Alarme mit severity="info" sollen nur ins Archiv, sonst nirgendwohin, egal welches Team. Baue dafür einen Receiver nirgendwo und prüfe mit amtool.

Hinweis: Ein Receiver ohne webhook_configs und ohne andere Integration verwirft alles. Die Reihenfolge der Routen entscheidet: Die Info-Route muss vor den Team-Routen stehen.

Lösung

Ändere alertmanager/alertmanager.yml im Editor an zwei Stellen. Hinter der Archiv-Route kommt eine neue Route:

    - receiver: archiv
      continue: true
    - matchers: [severity="info"]
      receiver: nirgendwo

Und oben in der Liste der Receiver ein neuer Eintrag:

receivers:
  - name: nirgendwo
  - name: standard
amtool check-config alertmanager/alertmanager.yml | head -1
curl -s -X POST localhost:9093/-/reload
amtool config routes test severity=info team=notes

Erwartet:

Checking 'alertmanager/alertmanager.yml'  SUCCESS
archiv,nirgendwo

Ein echter Test:

T=$(date -u +%Y-%m-%dT%H:%M:%SZ)
amtool alert add alertname=Info severity=info team=notes

Nach 30 Sekunden zeigt docker compose logs --no-log-prefix --since $T alarm-log nur die Zeile /archiv archiv firing [alertname=Info]. team-notes bekommt nichts.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Routing-Bäume wachsen. Halte sie flach: oben Sonderfälle (Watchdog, Info), dann eine Route pro Team, darunter höchstens die Schwere.
  • amtool config routes test --verify.receivers gehört mit einer Liste typischer Label-Kombinationen in die CI, damit niemand die Bereitschaft abklemmt.
  • Jede Route braucht ein Ziel, das am Ende ein Mensch liest. Eine Fallback-Route ganz unten fängt Alarme neuer Teams auf.
  • group_wait kurz für die Bereitschaft (10–30 s), repeat_interval lang (4–12 h). Wer alle 5 Minuten erinnert wird, stellt die Benachrichtigungen ab.