Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Wettkampf

Ziel: Fünf Störungen, wie sie im Betrieb vorkommen. Du kennst die Ursache – sie steht im Befehl, der sie auslöst. Die Aufgabe ist, sie mit Metriken, Logs, Traces und Alarmen zu belegen, so wie du es ohne Vorwissen tun müsstest. · Dauer: ca. 90 min · Voraussetzung: Tag 0–14

Spielregeln

  • Jede Runde beginnt mit einem Befehl, der die Störung auslöst. Danach beantwortest du die Fragen der Runde – nur mit promtool, logcli, amtool und curl gegen Tempo und Grafana. kubectl get und kubectl describe sind tabu, bis die Runde gelöst ist.
  • Jede Runde hat ein Zeitlimit. Wer es reißt, liest erst den Hinweis, dann die Lösung.
  • Am Ende jeder Runde steht Aufräumen. Die nächste Runde beginnt erst, wenn die Alarme der Runde in amtool alert query namespace=app erloschen sind.

Runde 1: Die Datenbank ist weg

Zeitlimit: 10 Minuten

kubectl -n app scale statefulset postgres --replicas 0

Erwartet:

statefulset.apps/postgres scaled

Beantworte:

  1. Welche Alarme feuern – und welcher feuert nicht, obwohl du ihn erwarten würdest?
  2. Welchen Wert hat notes_db_up?
  3. Welche Fehlermeldung schreibt notes-api ins Log?

Hinweis: Die Readiness-Probe von notes-api fragt /healthz, und /healthz fragt die Datenbank. Ein Pod, der nicht bereit ist, bekommt über den Service keine Anfragen mehr – wird er dann noch gescrapt?

Lösung

Nach fünf Minuten:

amtool alert query namespace=app

Erwartet (gekürzt, Prozent ungefähr; die zweite Zeile nur nach der Challenge von Tag 8):

Alertname             Starts At                Summary                               ...
NotesApiErrors        2026-11-05 10:37:53 UTC  notes-api: 62.5% Fehler               ...
NotesApiServerErrors  2026-11-05 10:37:23 UTC  notes-api: 38 Fehlerzeilen in 5 Minut...

NotesApiDown bleibt stumm – und NotesApiErrors feuert aus dem falschen Grund:

  • /healthz antwortet 503, die Pods werden nicht bereit, der Service schickt ihnen keine Anfragen mehr. Die Anfragen des Lastgenerators scheitern schon am Service. notes-api sieht sie nie.
  • Prometheus scrapt die Pods trotzdem weiter. Die Endpunkte eines Service enthalten auch Pods, die nicht bereit sind – mit ready=false. Darum bleibt up bei 1, und absent() schlägt nicht an.
  • Die einzigen Anfragen, die notes-api noch bekommt, sind die Readiness-Probe und /metrics. Die Probe scheitert mit 503 – und genau diese 503 zählt NotesApiErrors. Der Alarm stimmt, aber nur zufällig. Das SLI aus Tag 12 mit path="/notes" zeigt dagegen 0 Prozent Fehler: Es kommen schlicht keine Anfragen an.

Prüfe es:

promtool query instant http://localhost:30090 \
  'sum by (path, code) (rate(notes_http_requests_total[1m]))'

Erwartet (ungefähr):

{code="200", path="/metrics"} => 0.1333333333333333 @[...]
{code="503", path="/healthz"} => 0.2222222222222222 @[...]
promtool query instant http://localhost:30090 'notes_db_up'

Erwartet (gekürzt):

notes_db_up{..., pod="notes-api-76d9df4449-8rszn", ...} => 0 @[...]
notes_db_up{..., pod="notes-api-76d9df4449-zgs5d", ...} => 0 @[...]

Die Wahrheit steht in der Metrik – aber keine Regel schaut direkt hin. Ein Alarm max(notes_db_up) == 0 hätte diesen Ausfall sofort und aus dem richtigen Grund gemeldet. Genau solche Lücken findet man in Übungen wie dieser, nicht im Ernstfall.

logcli query --quiet -o raw --limit 2 --since 5m \
  '{app="notes-api"} | json | level="ERROR"'

Erwartet (gekürzt):

{"time":"...","level":"ERROR","msg":"request","method":"GET","path":"/notes","status"...
{"time":"...","level":"ERROR","msg":"list notes","err":"failed to connect to `user=no...

Die letzten Anfragen, die noch durchkamen, warteten fünf Sekunden auf Postgres (duration_ms steht bei rund 5000) und scheiterten dann.

Aufräumen:

kubectl -n app scale statefulset postgres --replicas 1

Fortschritt speichern? Kostenlos registrieren

Runde 2: Ein Pod ist langsam

Zeitlimit: 15 Minuten

Ein dritter Pod gesellt sich zu notes-api – mit 500 ms Verzögerung:

cd ~/obs-lab
cat > langsam.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: notes-api-langsam
  namespace: app
  labels:
    app.kubernetes.io/name: notes-api
spec:
  containers:
    - name: notes-api
      image: notes-api:0.9.0
      env:
        - name: NOTES_API_KEY
          valueFrom:
            secretKeyRef: {name: notes, key: api-key}
        - name: NOTES_DB_URL
          valueFrom:
            secretKeyRef: {name: notes, key: db-url}
        - {name: NOTES_LOG_FORMAT, value: json}
        - {name: NOTES_DELAY, value: 500ms}
        - {name: OTEL_SERVICE_NAME, value: notes-api}
        - name: OTEL_EXPORTER_OTLP_ENDPOINT
          value: http://otel-collector.monitoring:4318
      ports:
        - {name: http, containerPort: 8080}
EOF
kubectl apply -f langsam.yaml

Erwartet:

pod/notes-api-langsam created

Der Pod trägt das Label des Service und bekommt darum ein Drittel der Anfragen. Das Deployment übernimmt ihn nicht – ihm fehlt das Label pod-template-hash seines ReplicaSets.

Beantworte:

  1. Wie hoch ist das 95. Perzentil der Antwortzeit insgesamt – und pro Pod?
  2. Welcher Pod ist der Übeltäter? Belege es mit einer Metrik und einem Trace.

Hinweis: histogram_quantile mit by (le, pod). In Tempo trägt jeder Span das Resource Attribute k8s.pod.name – der Collector hat es angehängt.

Lösung

Nach drei Minuten:

promtool query instant http://localhost:30090 \
  'job:notes_http_request_duration_seconds:p95_5m'
promtool query instant http://localhost:30090 '
  histogram_quantile(0.95, sum by (le, pod) (rate(
    notes_http_request_duration_seconds_bucket{path="/notes"}[2m])))'

Erwartet (ungefähr):

job:notes_http_request_duration_seconds:p95_5m{job="notes-api"} => 0.855... @[...]
{pod="notes-api-76d9df4449-8rszn"} => 0.023760416666666666 @[...]
{pod="notes-api-76d9df4449-zgs5d"} => 0.024884615384615387 @[...]
{pod="notes-api-langsam"} => 0.975 @[...]

Insgesamt über 800 ms – weit über der Schwelle von NotesApiSlow. Pro Pod zeigt sich: Zwei sind schnell, einer ist es nicht. Der Gesamtwert allein hätte in die Irre geführt.

curl -s -G localhost:30320/api/search --data-urlencode limit=3 \
  --data-urlencode 'q={ duration > 400ms } | select(resource.k8s.pod.name)' \
  | jq -r '.traces[].spanSet.spans[0].attributes[]
           | select(.key == "k8s.pod.name") | .value.stringValue'

Erwartet:

notes-api-langsam
notes-api-langsam
notes-api-langsam

select(…) holt zusätzliche Attribute in das Suchergebnis. Alle langsamen Traces stammen aus demselben Pod.

Aufräumen:

kubectl -n app delete pod notes-api-langsam

Fortschritt speichern? Kostenlos registrieren

Runde 3: Funkstille im Log

Zeitlimit: 10 Minuten

kubectl -n monitoring scale deploy/alloy --replicas 0

Erwartet:

deployment.apps/alloy scaled

Beantworte:

  1. Schreibe eine LogQL-Abfrage, die 1 liefert, wenn notes-api seit zwei Minuten keine Zeile mehr nach Loki gebracht hat.
  2. Belege mit PromQL, warum.

Hinweis: LogQL kennt absent_over_time wie PromQL. kube-state-metrics kennt die bereiten Replikas jedes Deployments.

Lösung

Nach drei Minuten:

logcli instant-query --quiet -o raw 'absent_over_time({app="notes-api"}[2m])'

Erwartet:

[{"metric":{"app":"notes-api"},"value":[1793878211.1,"1"]}]
promtool query instant http://localhost:30090 \
  'kube_deployment_status_replicas_available{deployment="alloy"}'

Erwartet (gekürzt):

kube_deployment_status_replicas_available{..., deployment="alloy", ...} => 0 @[...]

notes-api läuft und loggt – nur holt niemand die Zeilen ab. Als Log-Regel im Ruler (Tag 8) wäre die erste Abfrage ein Alarm, der genau das meldet.

Aufräumen:

kubectl -n monitoring scale deploy/alloy --replicas 1

Alloy holt die Lücke nach: Beim Start fragt es die Kubernetes-API nach den Logs der laufenden Pods – auch nach den Minuten, in denen es fehlte. Prüfe es mit logcli query --since 10m '{app="notes-api"}'.

Fortschritt speichern? Kostenlos registrieren

Runde 4: Alarme kommen nicht an

Zeitlimit: 10 Minuten

kubectl -n monitoring scale deploy/alarm-echo --replicas 0
kubectl -n app set env deploy/notes-api NOTES_ERROR_RATE=0.2

Erwartet:

deployment.apps/alarm-echo scaled
deployment.apps/notes-api env updated

Beantworte:

  1. Feuert NotesApiErrors? Woran siehst du es, ohne dass eine Benachrichtigung ankommt?
  2. Beweise mit einer Metrik des Alertmanagers, dass er versucht zu benachrichtigen und scheitert.

Hinweis: Der Alertmanager wird über den ServiceMonitor kps-alertmanager gescrapt. Seine Metriken beginnen mit alertmanager_notifications.

Lösung

Nach vier Minuten:

amtool alert query alertname=NotesApiErrors

Erwartet:

Alertname       Starts At                Summary                   State
NotesApiErrors  2026-11-05 10:52:53 UTC  notes-api: 20.86% Fehler  active
promtool query instant http://localhost:30090 \
  'sum by (integration) (increase(alertmanager_notifications_failed_total[5m])) > 0'

Erwartet (ungefähr):

{integration="webhook"} => 1.0153518518518518 @[...]

Der Alertmanager versucht es immer wieder und scheitert. Im Betrieb gehört diese Abfrage in einen eigenen Alarm – an einen anderen Empfänger als den, der kaputt ist. Das Chart bringt ihn mit: AlertmanagerFailedToSendAlerts.

Aufräumen:

kubectl -n app set env deploy/notes-api NOTES_ERROR_RATE-
kubectl -n monitoring scale deploy/alarm-echo --replicas 1

Fortschritt speichern? Kostenlos registrieren

Runde 5: Die Abhängigkeit draußen

Zeitlimit: 15 Minuten

notes-api ruft für /upstream einen Dienst außerhalb auf. Jemand hat die Adresse verstellt, und ein zweiter Lastgenerator ruft /upstream auf:

kubectl -n app set env deploy/notes-api NOTES_UPSTREAM=https://notes.invalid
kubectl -n app rollout status deploy/notes-api
kubectl -n app run upstream-last --image curlimages/curl:8.23.0 -- \
  -sS -m 5 -o /dev/null --rate 1/s "http://notes-api:8080/upstream?n=[1-1000000]"

Erwartet (letzte Zeilen):

deployment "notes-api" successfully rolled out
pod/upstream-last created

Beantworte:

  1. Mit welchem Status antwortet /upstream? Zeige es mit PromQL.
  2. Was genau scheitert? Finde im Trace den Span, der den Fehler trägt, und seine Fehlermeldung.

Hinweis: TraceQL kennt das intrinsische Feld status. Fehlermeldungen stehen in statusMessage des Spans.

Lösung

promtool query instant http://localhost:30090 \
  'sum by (code) (rate(notes_http_requests_total{path="/upstream"}[2m]))'

Erwartet (ungefähr):

{code="502"} => 0.9954723228372703 @[...]
curl -s -G localhost:30320/api/search --data-urlencode limit=1 \
  --data-urlencode 'q={ status = error && kind = client }' \
  | jq -r '.traces[0].traceID'

Erwartet (die ID weicht ab):

5eb089f653c12dc4e47c49afe5371b37

Setze die ID ein:

curl -s localhost:30320/api/v2/traces/5eb089f653c12dc4e47c49afe5371b37 \
  | jq -r '.trace.resourceSpans[].scopeSpans[].spans[]
           | select(.kind == "SPAN_KIND_CLIENT") | [.name, .status.message] | @tsv'

Erwartet (gekürzt):

HTTP GET    dial tcp: lookup notes.invalid on 10.43.0.10:53: no such host

Nicht notes-api ist kaputt, sondern die Namensauflösung für das Ziel. Der Client-Span von otelhttp.NewTransport trägt den Fehler, der Server-Span darüber nur die Folge: 502.

Aufräumen:

kubectl -n app delete pod upstream-last
kubectl -n app set env deploy/notes-api NOTES_UPSTREAM-

Fortschritt speichern? Kostenlos registrieren

Auswertung

Runde Signal, das es gezeigt hat Lehre
1 notes_db_up, Probe-Fehler Ein Alarm kann aus dem falschen Grund feuern
2 Perzentil pro Pod, Trace-Attribut Gesamtwerte verstecken Ausreißer
3 absent_over_time, kube-state-metrics Auch die Sammler fallen aus
4 Metriken des Alertmanagers Die Alarmkette braucht eigene Alarme
5 Fehlerstatus im Client-Span Traces zeigen, wo es bricht

Vier oder fünf Runden in der Zeit gelöst, ohne in die Lösung zu schauen? Bereit für Anhang B.