Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Wettkampf – Desaster-Drills

Ziel: Zehn Störungen finden und beheben, wie sie im Betrieb eines Gateways vorkommen, jede mit Zeitlimit. · Dauer: ca. 120 min · Voraussetzung: Tag 14

Briefing

  • Jede Runde hat eine Spielleitung: einen Block, der den Fehler einbaut. Lies ihn erst nach der Runde, sonst ist es keine Übung. Am besten tippt ihn jemand anderes.
  • Lage beschreibt, was gemeldet wird, Zeitlimit die Zeit bis zur Lösung.
  • Werkzeuge: curl mit -i, Logs von CP und DP, deck gateway diff, git diff, die Admin API und localhost:8100/metrics der DP.
  • Alle Runden laufen auf der VM kong im Hybrid-Modus aus Tag 13.
 Symptom ──► Wer antwortet? (Kong oder Backend, X-Kong-*-Latency)
         ──► Was sagt Kong? (message, request_id, Log)
         ──► Was hat sich geändert? (git diff, deck gateway diff)

Tagesstart:

source ~/kong-lab/setup/env.sh
mkdir -p ~/kong-lab/tag15 && cd ~/kong-lab/kong
git status --short | wc -l

Erwartet: ein sauberer Stand.

0

Runde 1: Die fehlende Liste

Spielleitung:

deck file patch -s kong.yaml --selector '$..routes[?(@.name=="notes-lesen")]' \
  --value 'paths:["/api/v1/note"]' -o kong.yaml
ksync > /dev/null 2>&1

Lage: „Die Liste der Notizen ist weg, seit dem letzten Deploy.” Zeitlimit: 10 min

curl -si $PROXY/api/v1/notes | sed -n '1p;$p'

Erwartet:

HTTP/1.1 404 Not Found
404 page not found

Lösung

404 page not found kommt von Go, nicht von Kong: Eine Route hat gepasst. Was hat sich geändert?

git diff | grep -E '^[-+] '
git checkout kong.yaml && ksync 2>/dev/null | tail -1
curl -s -o /dev/null -w '%{http_code}\n' $PROXY/api/v1/notes

Erwartet:

-    - /api/v1/notes
+    - /api/v1/note
Updated 1 path from the index
  Deleted: 0
200

/api/v1/note passt als Präfix auch auf /api/v1/notes. Kong schneidet das Präfix ab, hängt den Rest (s) an den Service-Pfad und fragt notes-api nach /notess.

Fortschritt speichern? Kostenlos registrieren

Runde 2: Niemand zu Hause

Spielleitung:

docker compose -f ~/kong-lab/code/backend/compose.yaml stop notes-api notes-api-2
sleep 7

Lage: „Die API antwortet mit 503.” Zeitlimit: 10 min

curl -s $PROXY/api/v1/version | jq -r .message
curl -s $ADMIN/upstreams/notes-up/health | jq -r '.data[] | [.target, .health] | @tsv'

Erwartet:

failure to get a peer from the ring-balancer
notes-api-2:8080
notes-api:8080

Lösung

Kein gesundes Target. Die Admin API der CP zeigt keinen Zustand: Im Hybrid-Modus prüft die DP die Targets, und ihre Metriken sagen es:

curl -s localhost:8100/metrics | grep '^kong_upstream_target_health' \
  | grep -c 'state="healthy".* 1$'
docker compose -f ~/kong-lab/code/backend/compose.yaml --profile lb \
  start notes-api notes-api-2
sleep 7
curl -s $PROXY/api/v1/version

Erwartet (gekürzt):

0
 Container backend-notes-api-2-1 Started
0.2.0

Fortschritt speichern? Kostenlos registrieren

Runde 3: Gesund und doch krank

Spielleitung:

docker compose -f ~/kong-lab/code/backend/compose.yaml stop db
sleep 8

Lage: „Wieder 503, aber die Container von notes-api laufen alle.” Zeitlimit: 10 min

docker compose -f ~/kong-lab/code/backend/compose.yaml ps --format '{{.Service}}'
curl -s $PROXY/api/v1/version | jq -r .message

Erwartet:

echo
notes-api
notes-api-2
failure to get a peer from the ring-balancer

Lösung

Die Container laufen, aber Kong hält sie für krank. Was sagt der Health Check selbst?

docker run --rm --network lab curlimages/curl:8.17.0 -s -w ' %{http_code}\n' \
  notes-api:8080/healthz
docker compose -f ~/kong-lab/code/backend/compose.yaml start db
sleep 10
curl -s $PROXY/api/v1/version

Erwartet (gekürzt):

db unreachable
 503
 Container backend-db-1 Started
0.2.0

/healthz prüft auch Postgres (Tag 9). Ohne Datenbank sind beide Instanzen krank, und Kong schickt niemanden mehr hin. Richtig so, aber die eigentliche Ursache liegt eine Ebene tiefer.

Fortschritt speichern? Kostenlos registrieren

Runde 4: Die Änderung, die nicht ankommt

Spielleitung:

P='$..routes[?(@.name=="notes-schreiben")].plugins[?(@.name=="rate-limiting")].config'
deck file patch -s kong.yaml --selector "$P" --value 'policy:"cluster"' \
  --value 'minute:100' -o kong.yaml
ksync > /dev/null 2>&1

Lage: „Wir haben das Limit fürs Schreiben auf 100 erhöht, ksync lief ohne Fehler, aber Clients bekommen weiter 429 nach drei Versuchen.” Zeitlimit: 15 min

deck gateway diff kong.yaml 2>/dev/null | tail -3
curl -si --cacert ~/kong-lab/tag10/tls/ca.crt -X POST -H 'apikey: lab-key-anna-456' \
  -H 'Content-Type: application/json' -d '{"text":"r4"}' \
  https://localhost:8443/api/v1/notes | grep -i '^ratelimit-limit'

Erwartet:

  Created: 0
  Updated: 0
  Deleted: 0
RateLimit-Limit: 3

Lösung

Die CP hat die Änderung (kein Diff), die DP zeigt den alten Wert: Sie hat die neue Konfiguration nicht übernommen. Der Diff im Git verrät warum:

git diff | grep -E '^[-+] '
git checkout kong.yaml
deck file patch -s kong.yaml --selector "$P" --value 'minute:100' -o kong.yaml
ksync 2>/dev/null | tail -1
curl -si --cacert ~/kong-lab/tag10/tls/ca.crt -X POST -H 'apikey: lab-key-anna-456' \
  -H 'Content-Type: application/json' -d '{"text":"r4"}' \
  https://localhost:8443/api/v1/notes | grep -i '^ratelimit-limit'
git checkout kong.yaml && ksync > /dev/null 2>&1

Erwartet:

-        minute: 3
-        policy: local
+        minute: 100
+        policy: cluster
Updated 1 path from the index
  Deleted: 0
RateLimit-Limit: 100
Updated 1 path from the index

policy: cluster braucht eine Datenbank, die DP hat keine (Tag 13). Die DP verwirft die ganze Konfiguration und arbeitet mit der alten weiter. Manchmal steht das im Log der DP („unable to update running config”), verlässlich ist der Blick auf ihr Verhalten.

Fortschritt speichern? Kostenlos registrieren

Runde 5: Nach dem Sicherheitsupdate

Spielleitung:

sudo chown 1000:1000 cluster/cluster.key
docker compose restart kong
sleep 8

Lage: „Nach einem Neustart erreicht niemand mehr die Admin API. Der Proxy läuft.” Zeitlimit: 10 min

curl -s -o /dev/null -w 'Admin: %{http_code}\n' $ADMIN
curl -s -o /dev/null -w 'Proxy: %{http_code}\n' $PROXY/api/v1/version

Erwartet:

Admin: 000
Proxy: 200

Lösung

docker compose logs --since 30s kong 2>&1 \
  | grep -o 'cannot load certificate key.*denied' \
  | head -1
sudo chown 1001:1001 cluster/cluster.key
docker compose up -d --wait kong
curl -s -o /dev/null -w 'Admin: %{http_code}\n' $ADMIN

Erwartet (gekürzt):

cannot load certificate key "/kong/cluster/cluster.key": BIO_new_file() failed (SSL:
error:8000000D:system library::Permission denied
 Container kong-kong-1 Healthy
Admin: 200

Die CP startet nicht, weil sie den Cluster-Schlüssel nicht lesen darf (Tag 13). Die DP arbeitet mit der letzten Konfiguration weiter: Für Clients war nichts zu merken.

Fortschritt speichern? Kostenlos registrieren

Runde 6: Die neue Data Plane schweigt

Spielleitung:

sed -i '/kong-dp:/,/volumes:/ s/<<: \*kong-common/&\n      KONG_PLUGINS: bundled/' \
  compose.yaml
docker compose up -d --wait kong-dp
sleep 8

Lage: „Nach einem Update der lokalen DP antwortet alles mit 404.” Zeitlimit: 15 min

curl -s -o /dev/null -w '%{http_code}\n' $PROXY/api/v1/version
curl -s -o /dev/null -w 'bereit: %{http_code}\n' localhost:8100/status/ready

Erwartet:

404
bereit: 503

Lösung

curl -s $ADMIN/clustering/data-planes | jq -r '.data[] | .sync_status' | sort | uniq -c
git diff compose.yaml | grep -E '^[-+] '
git checkout compose.yaml && docker compose up -d --wait kong-dp
sleep 8
curl -s -o /dev/null -w '%{http_code}\n' $PROXY/api/v1/version

Erwartet (gekürzt):

      1 normal
      1 plugin_set_incompatible
+      KONG_PLUGINS: bundled
 Container kong-kong-dp-1 Healthy
200

Die DP kennt jwt-identity nicht mehr, die CP schickt ihr deshalb keine Konfiguration. Nach einem Neustart hat sie gar keine: 404 für alles (Tag 13, Drill 5).

Fortschritt speichern? Kostenlos registrieren

Runde 7: Montagmorgen, alle Tokens ungültig

Spielleitung (Keycloak bekommt einen neuen Signaturschlüssel mit höherer Priorität):

KCB=http://localhost:8180
AT=$(curl -s -d grant_type=password -d client_id=admin-cli -d username=admin \
  -d password=lab-admin-pw-123 $KCB/realms/master/protocol/openid-connect/token \
  | jq -r .access_token)
RID=$(curl -s -H "Authorization: Bearer $AT" $KCB/admin/realms/lab | jq -r .id)
curl -s -o /dev/null -w '%{http_code}\n' -X POST -H "Authorization: Bearer $AT" \
  -H 'Content-Type: application/json' $KCB/admin/realms/lab/components \
  -d "{\"name\":\"rsa-neu\",\"providerId\":\"rsa-generated\",
       \"providerType\":\"org.keycloak.keys.KeyProvider\",\"parentId\":\"$RID\",
       \"config\":{\"priority\":[\"200\"],\"keySize\":[\"2048\"]}}"
unset AT

Lage: „Seit heute früh scheitert jeder Aufruf mit Token. Mit API-Key geht alles.” Zeitlimit: 20 min

T=$(token)
curl -s -w ' %{http_code}\n' -H "Authorization: Bearer $T" $PROXY/whoami \
  | tr -d '\n'; echo
curl -s -o /dev/null -w '%{http_code}\n' -H 'apikey: lab-key-anna-456' $PROXY/whoami

Erwartet (gekürzt):

{  "message":"You cannot consume this service",  "request_id":"d3746c00…"} 403
200

Lösung

403 statt 401: Das Token scheitert und der anonyme Consumer gast an der ACL (Tag 6). Woran scheitert es? Die Kid im Token ist neu, Kong kennt nur den alten Schlüssel. Hol den aktuellen öffentlichen Schlüssel und trag ihn ein:

echo "$T" | jq -R 'split(".")[0] | @base64d | fromjson | .kid'
PUB=$(curl -s $KC | jq -r .public_key)
{ echo "-----BEGIN PUBLIC KEY-----"; echo "$PUB" | fold -w 64
  echo "-----END PUBLIC KEY-----"; } > ~/kong-lab/tag15/neu.pem
deck file patch -s kong.yaml \
  --selector '$.consumers[?(@.username=="keycloak")].jwt_secrets[0]' \
  --value "rsa_public_key:$(jq -Rs . ~/kong-lab/tag15/neu.pem)" -o kong.yaml
ksync 2>/dev/null | tail -2
curl -s -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer $T" $PROXY/whoami
git commit -qam "Keycloak: neuer Signaturschlüssel"

Erwartet (gekürzt):

"SGnM-TojSrTCdWmd518TpkXmTIz_QQTvcJdh9bAmT2g"
  Updated: 1
  Deleted: 0
200

jq -Rs . macht aus der PEM-Datei einen JSON-String mit \n, den decK als Wert nimmt. Die Enterprise-Notiz aus Tag 6 hatte gewarnt: Ein Schlüsselwechsel braucht einen Plan.

Fortschritt speichern? Kostenlos registrieren

Runde 8: Das Zertifikat ist weg

Spielleitung:

curl -s -o /dev/null -X DELETE $ADMIN/snis/localhost
sleep 6

Lage: „HTTPS meldet plötzlich ein unbekanntes Zertifikat.” Zeitlimit: 10 min

curl -s -o /dev/null --cacert ~/kong-lab/tag10/tls/ca.crt \
  https://localhost:8443/api/v1/version; echo "rc=$?"

Erwartet:

rc=60

Lösung

echo | openssl s_client -connect localhost:8443 -servername localhost 2>/dev/null \
  | openssl x509 -noout -subject | cut -c1-60
deck gateway diff kong.yaml 2>/dev/null | grep -E '^(creating|updating|deleting)'
ksync 2>/dev/null | tail -1
curl -s --cacert ~/kong-lab/tag10/tls/ca.crt https://localhost:8443/api/v1/version

Erwartet:

subject=C = US, ST = California, L = San Francisco, O = Kong
creating sni localhost
  Deleted: 0
0.2.0

Jemand hat über die Admin API am Git vorbei gelöscht: Drift (Tag 7). Kong zeigt für localhost wieder sein Standard-Zertifikat. deck gateway diff findet es, ksync stellt es wieder her.

Fortschritt speichern? Kostenlos registrieren

Runde 9: Die offene Tür

Spielleitung:

sed -i 's/"127.0.0.1:8001:8001"/"8001:8001"/' compose.yaml
docker compose up -d --wait kong

Lage: Ein Penetrationstest meldet: „Kong Admin API ohne Anmeldung aus dem Netz erreichbar.” Zeitlimit: 10 min

Auf dem Laptop:

curl -s http://$KONG_IP:8001 | jq -r .version

Erwartet:

3.9.4

Lösung

Auf der VM kong:

ss -ltn | grep ':8001 '
git diff compose.yaml | grep -E '^[-+] '
git checkout compose.yaml && docker compose up -d --wait kong
ss -ltn | grep ':8001 '

Erwartet (gekürzt):

LISTEN 0      4096         0.0.0.0:8001       0.0.0.0:*
LISTEN 0      4096            [::]:8001          [::]:*
-      - "127.0.0.1:8001:8001"
+      - "8001:8001"
 Container kong-kong-1 Healthy
LISTEN 0      4096       127.0.0.1:8001       0.0.0.0:*

Vom Laptop kommt danach keine Antwort mehr. Wer die Admin API erreicht, kann jede Route umleiten und jeden Schlüssel lesen; sie gehört nie ins Netz (Tag 1, Tag 5).

Fortschritt speichern? Kostenlos registrieren

Runde 10: Name unbekannt

Spielleitung:

deck file patch -s kong.yaml --selector '$.services[?(@.name=="notes-version")]' \
  --value 'host:"notes-upp"' -o kong.yaml
ksync > /dev/null 2>&1

Lage: „/api/v1/version liefert 503, die Liste der Notizen geht.” Zeitlimit: 10 min

curl -s $PROXY/api/v1/version | jq -r .message
curl -s -o /dev/null -w '%{http_code}\n' $PROXY/api/v1/notes

Erwartet:

name resolution failed
200

Lösung

git diff | grep -E '^[-+] '
git checkout kong.yaml && ksync 2>/dev/null | tail -1
curl -s $PROXY/api/v1/version

Erwartet:

-  host: notes-up
+  host: notes-upp
  Deleted: 0
0.3.0

notes-upp ist kein Upstream, also fragt Kong das DNS, und dort gibt es den Namen nicht: 503 mit name resolution failed (Tag 2).

Fortschritt speichern? Kostenlos registrieren

Auswertung

Runden in der Zeit gelöst Einschätzung
9–10 Du betreibst Kong.
6–8 Solide; wiederhole die Tage der verpassten Runden.
unter 6 Tag 7, 9 und 13 noch einmal, dann zurück in den Wettkampf.

Kontrollpunkt

git -C ~/kong-lab/kong status --short | wc -l

Erwartet: Alle Spielleitungen sind zurückgenommen.

0
deck gateway diff ~/kong-lab/kong/kong.yaml 2>/dev/null | tail -3

Erwartet: Datei, CP und Git stimmen überein.

  Created: 0
  Updated: 0
  Deleted: 0
curl -s $ADMIN/clustering/data-planes | jq -r '.data[] | .sync_status' | sort -u

Erwartet: Alle Data Planes sind im Takt.

normal

Enterprise-Notiz

  • Runbooks: Jede dieser Runden ist ein Kandidat für ein Runbook: Symptom, Diagnosebefehle, Behebung, Ursache.
  • Alarme statt Meldungen: 503-Quote, kranke Targets, plugin_set_incompatible, Drift aus deck gateway diff und offene Ports gehören ins Monitoring, nicht erst in den Penetrationstest.
  • Gamedays: Solche Drills regelmäßig mit dem ganzen Team, in einer Umgebung wie dieser; Chaos-Werkzeuge bauen Fehler automatisiert ein.
  • Änderungen nur über Git: Fast jede Runde war eine Änderung am Git vorbei oder ein ungeprüfter Commit. Pull Request plus deck gateway diff in der CI verhindert beides.