Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 18: Wettkampf – das kaputte Mesh

Ziel: Du findest und behebst in acht Runden eingebaute Mesh-Fehler quer durch das Buch – gegen die Uhr, mit Nachweis vorher und nachher. · Dauer: ca. 90 min · Voraussetzung: Tag 0–17

Briefing

  • Du baust dir in tag18 eine vollständige Kopie von notes: im Mesh, mit Default-Deny, den Regeln aus Tag 6 und den Retries aus Tag 7.
  • Acht Runden, alle Themen: Injection, Opaque Ports, Autorisierung, Timeouts, Rate Limits, Traffic Shifting, Egress und Zertifikate. Die Runden bauen aufeinander auf: der Reihe nach spielen.
  • Werkzeuge: Lastgenerator, linkerd viz stat/authz/stat-outbound, linkerd diagnostics policy/proxy-metrics, linkerd identity, Proxy-Logs, Events.
  • Jede Runde endet mit einem Beweis-Befehl: kaputt vorher, heil nachher.
Runde  Symptom                                   Zeitziel
1      Alles 403, nur /flaky 500                 3 min
2      /flaky nur noch 502                       5 min
3      Erst 403, dann 503 auf /api/notes         7 min
4      /api/notes komplett 504                   4 min
5      Jeder zweite Aufruf 429                   4 min
6      Ein paar Prozent 500 nach einem Release   5 min
7      /api/upstream bricht ab                   5 min
8      Fragen der Revision (nur lesen)           4 min

Spielregeln

  • Pro Runde führt der Schiedsrichter die Schiedsrichter-Befehle aus – ein Kollege oder du selbst, ohne hinzusehen: Block kopieren, in ein zweites Terminal einfügen, Fenster schließen. Dann die Uhr starten.
  • Ursache finden, beheben, mit einem Befehl beweisen. Erst dann Uhr stoppen.
  • Repariere die Ursache, nicht das Symptom: Wer Default-Deny abschaltet, eine Regel löscht statt sie zu korrigieren, Policies mit all-unauthenticated öffnet oder Pods löscht, die nicht kaputt sind, bekommt null Punkte.
  • Den Hinweis erst lesen, wenn das Zeitziel abgelaufen ist.
  • Messgerät ist wie immer der Lastgenerator. Das Ziel jeder Runde: wieder 100 Prozent 200 auf /api/notes, /flaky fast nur 200 (Retries), sofern die Runde nichts anderes sagt. Der Befehl dafür heißt im Folgenden kurz Messung:
kubectl -n tag18 logs deploy/last -c last --since=40s | awk '{print $2, $3}' \
  | sort | uniq -c

Spielfeld

Die Manifeste von Tag 0 und die Regeln von Tag 6 und 7 liegen schon auf cp1. sed schreibt sie auf den neuen Namespace um und halbiert die Replikas – ein Pod je Dienst reicht für den Wettkampf.

mkdir -p ~/linkerd/tag18 && cd ~/linkerd/tag18
kubectl create namespace tag18
kubectl annotate namespace tag18 linkerd.io/inject=enabled \
  config.linkerd.io/default-inbound-policy=deny
kubectl -n tag18 create secret generic notes-db \
  --from-literal=password=lab-db-123 \
  --from-literal=url='postgres://notes:lab-db-123@postgres:5432/notes?sslmode=disable'
kubectl -n tag18 create secret generic notes-api-key --from-literal=key=lab-key-123
for a in web notes-api helper last postgres; do
  kubectl -n tag18 create serviceaccount $a
done
for f in tag06/servers tag06/authz tag06/admin tag07/route-retry tag07/route-rest; do
  sed 's/namespace: notes/namespace: tag18/; s/namespace: tag07/namespace: tag18/' \
    ~/linkerd/$f.yaml; echo ---
done > policy.yaml
for f in postgres notes-api helper web last; do
  sed 's/namespace: notes/namespace: tag18/; s/\.notes\.svc/.tag18.svc/
    s/replicas: 2/replicas: 1/' ~/linkerd/tag00/$f.yaml; echo ---
done > app.yaml
grep -c '^kind:' policy.yaml app.yaml
kubectl apply -f policy.yaml -f app.yaml | wc -l

Erwartet (gekürzt):

namespace/tag18 created
...
policy.yaml:16
app.yaml:10
26

Jetzt wie an Tag 2 die eigenen ServiceAccounts und der Opaque Port, dazu ein Ziel im Internet für notes-api (Tag 11):

kubectl -n tag18 annotate service postgres config.linkerd.io/opaque-ports=5432
kubectl -n tag18 set serviceaccount statefulset/postgres postgres
for d in web notes-api helper last; do
  kubectl -n tag18 set serviceaccount deploy/$d $d
done
kubectl -n tag18 set env deploy/notes-api NOTES_UPSTREAM=https://example.com
kubectl -n tag18 rollout status statefulset/postgres --timeout=180s
kubectl -n tag18 rollout status deploy --timeout=240s
sleep 60
kubectl -n tag18 get pods

Erwartet (gekürzt):

NAME                         READY   STATUS    RESTARTS   AGE
helper-79d57fbbbb-kn8rl      2/2     Running   0          100s
last-78895758f9-br8k7        2/2     Running   0          99s
notes-api-6ff48b7779-mmss9   2/2     Running   0          99s
postgres-0                   2/2     Running   0          84s
web-7d94ccc84d-9k2bv         2/2     Running   0          102s

Die ersten Pods starten noch mit dem ServiceAccount default und scheitern kurz an Default-Deny – nach set serviceaccount sind sie ersetzt. Die Baseline:

kubectl -n tag18 logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c
linkerd viz stat -n tag18 deploy
kubectl -n tag18 exec deploy/last -c last -- curl -s http://web/api/upstream; echo

Erwartet (gekürzt, Zahlen schwanken):

     80 /api/notes 200
     38 /flaky 200
      1 /flaky 500
NAME        MESHED   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99 ...
helper         1/1    78.57%   1.4rps           3ms          12ms          18ms ...
last           1/1   100.00%   0.3rps           1ms          19ms          20ms ...
notes-api      1/1   100.00%   1.8rps           4ms          20ms          90ms ...
web            1/1   100.00%   2.4rps          15ms          86ms          97ms ...
{"status":200,"url":"https://example.com"}

Das ist das gesunde Spielfeld. Merk dir die Zahlen.

Runde 1: Alles gesperrt

Lage: Nach einem „kleinen Update“ von web meldet der Lastgenerator nur noch Fehler. Die Policies hat angeblich niemand angefasst. Bring web zurück.

Schiedsrichter-Befehle:

kubectl -n tag18 patch deploy web -p '{"spec":{"template":{"metadata":
  {"annotations":{"linkerd.io/inject":"disabled"}}}}}'
kubectl -n tag18 rollout status deploy/web --timeout=120s

Zeitziel: 3 min

Hinweis: Zähl die Container im Pod von web.

Lösung Runde 1

sleep 50
kubectl -n tag18 logs deploy/last -c last --since=40s | awk '{print $2, $3}' \
  | sort | uniq -c
kubectl -n tag18 get pods

Erwartet (gekürzt):

     58 /api/notes 403
     28 /flaky 500
NAME                         READY   STATUS    RESTARTS   AGE
helper-79d57fbbbb-kn8rl      2/2     Running   0          2m44s
...
web-5f7fb96f68-4nq9w         1/1     Running   0          53s

web hat nur einen Container – kein Proxy. Der Beweis von der anderen Seite:

kubectl -n tag18 logs deploy/notes-api -c linkerd-proxy --since=1m \
  | grep 'Request denied' | tail -1 \
  | grep -oE 'server.name=[^ ]*|client.tls=[^ ]*|client.ip=[^ ]*'
kubectl -n tag18 get pod -l app=web -o wide
kubectl -n tag18 get deploy web \
  -o jsonpath='{.spec.template.metadata.annotations}{"\n"}'

Erwartet (gekürzt):

server.name=notes-api-http
client.tls=None(NoClientHello)
client.ip=10.0.1.179
NAME                   READY   STATUS    RESTARTS   AGE   IP           NODE      ...
web-5f7fb96f68-4nq9w   1/1     Running   0          77s   10.0.1.179   worker1   ...
{"linkerd.io/inject":"disabled"}

Ohne Proxy kein mTLS, ohne mTLS keine Identität – Default-Deny und die Regel notes-api-von-web lehnen ab (Tag 6). Und warum 500 statt 403 auf /flaky?

kubectl -n tag18 exec deploy/web -c web -- curl -si \
  'http://helper.tag18.svc.cluster.local/unstable?failure_rate=0.3' \
  | grep -iE '^HTTP|^server'

Erwartet:

HTTP/1.1 500 Internal Server Error
server: envoy

server: envoy: An helper hängen HTTPRoutes (Retries aus Tag 7). Unmeshed Clients landen damit bei Cilium, nicht bei Linkerd (Tag 9). Aber warum 500? Ein Blick in Ciliums Envoy-Konfiguration und auf die andere Seite:

kubectl -n tag18 get ciliumenvoyconfig helper \
  -o jsonpath='{..directResponse.status}{"\n"}'
kubectl -n tag18 logs deploy/helper -c linkerd-proxy --since=1m \
  | grep -c 'Request denied'

Erwartet:

500 500
0

Envoy antwortet für beide Routen selbst mit 500 (directResponse, leerer Body), und der Proxy von helper hat keinen einzigen Aufruf abgelehnt – die Anfrage verlässt Envoy nie. Der Grund steht in den Routen aus Tag 7: Keine Regel hat backendRefs. Linkerd schickt so eine Regel an den Service selbst, Cilium hält sich wörtlich an die Gateway-API und beantwortet eine Regel ohne Backend mit 500. Mit backendRefs würde Envoy weiterleiten, und dann lehnt der Proxy von helper ab: 403, weiter mit server: envoy (gegengeprüft). Zwei Statuscodes, eine Ursache – web hat keinen Proxy. Die Annotation muss weg:

kubectl -n tag18 patch deploy web --type=json -p '[{"op":"remove",
  "path":"/spec/template/metadata/annotations/linkerd.io~1inject"}]'
kubectl -n tag18 rollout status deploy/web --timeout=120s
sleep 50
kubectl -n tag18 get pods -l app=web
kubectl -n tag18 logs deploy/last -c last --since=40s | awk '{print $2, $3}' \
  | sort | uniq -c

Erwartet (Zahlen schwanken):

NAME                   READY   STATUS    RESTARTS   AGE
web-7d94ccc84d-5rwlr   2/2     Running   0          57s
     58 /api/notes 200
     28 /flaky 200
      1 /flaky 500

Fortschritt speichern? Kostenlos registrieren

Runde 2: Schneller, aber kaputt

Lage: Ein Kollege hat gelesen, dass opake Verbindungen „weniger Overhead“ haben, und helper damit beschleunigt. Seitdem ist /flaky komplett tot. Mach /flaky wieder so zuverlässig wie vorher.

Schiedsrichter-Befehle:

kubectl -n tag18 annotate service helper config.linkerd.io/opaque-ports=80

Zeitziel: 5 min

Hinweis: Der Proxy von helper lehnt web ab, obwohl web erlaubt ist. Frag den Proxy von web, welches Protokoll er für den Service annimmt.

Lösung Runde 2

sleep 60
kubectl -n tag18 logs deploy/last -c last --since=60s | awk '{print $2, $3}' \
  | sort | uniq -c
linkerd viz stat -n tag18 deploy
kubectl -n tag18 logs deploy/web -c web --since=30s | grep error | tail -1 \
  | grep -oE 'upstream prematurely[^,]*'

Erwartet (gekürzt, Zahlen schwanken):

     86 /api/notes 200
     43 /flaky 502
NAME        MESHED   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99 ...
helper         1/1   100.00%   0.4rps           1ms          10ms          10ms ...
last           1/1   100.00%   0.3rps           1ms          19ms          20ms ...
notes-api      1/1   100.00%   1.8rps           3ms         110ms         182ms ...
web            1/1    70.67%   2.5rps          18ms          96ms         175ms ...
upstream prematurely closed connection while reading response header from upstream

helper sieht nur noch die Probes (0,4 rps), die HTTP-Requests von web kommen gar nicht mehr als HTTP an. nginx meldet eine Verbindung, die ohne Antwort zugeht. Wer schließt sie?

kubectl -n tag18 logs deploy/helper -c linkerd-proxy --since=1m \
  | grep 'Connection denied' | tail -1 \
  | grep -oE 'policy::[a-z]+|server.name=[^ ]*|Name\("[^"]*'
linkerd diagnostics policy -n tag18 svc/helper 80 -o json \
  | jq -c '.protocol.Kind | keys'
kubectl -n tag18 get service helper -o jsonpath='{.metadata.annotations}{"\n"}' \
  | cut -c1-80
kubectl -n tag18 get server helper-http -o jsonpath='{.spec.proxyProtocol}{"\n"}'

Erwartet:

policy::tcp
server.name=helper-http
Name("web.tag18.serviceaccount.identity.linkerd.cluster.local
["Opaque"]
{"config.linkerd.io/opaque-ports":"80","kubectl.kubernetes.io/last-applied-confi
HTTP/1

Der Client-Proxy schickt den Verkehr jetzt als opaken TCP-Strom. Der Server helper-http ist aber als HTTP/1 deklariert – die TCP-Prüfung (policy::tcp) schließt die Verbindung, obwohl die Identität web stimmt. Selbst wenn es durchkäme: Opak heißt auch keine Routen, keine Retries, keine HTTP-Metriken. HTTP gehört nie auf einen Opaque Port:

kubectl -n tag18 annotate service helper config.linkerd.io/opaque-ports-
sleep 5
linkerd diagnostics policy -n tag18 svc/helper 80 -o json \
  | jq -c '.protocol.Kind | keys'
sleep 55
kubectl -n tag18 logs deploy/last -c last --since=50s | awk '{print $2, $3}' \
  | sort | uniq -c

Erwartet (Zahlen schwanken):

service/helper annotated
["Detect"]
     62 /api/notes 200
     31 /flaky 200
      1 /flaky 500

Fortschritt speichern? Kostenlos registrieren

Runde 3: Die Härtung

Lage: Die Sicherheitsabteilung will, dass notes-api nur noch lesende Zugriffe bekommt. Ein Kollege hat dazu eine Route gebaut und die bestehende Regel darauf umgehängt. Seitdem geht /api/notes nicht mehr. Repariere es so, dass die Härtung bleibt: POST muss abgelehnt werden.

Schiedsrichter-Befehle:

kubectl apply -f - <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: {name: notes-api-lesen, namespace: tag18}
spec:
  parentRefs:
  - {group: policy.linkerd.io, kind: Server, name: notes-api-http}
  rules:
  - matches:
    - method: GET
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata: {name: notes-api-von-web, namespace: tag18}
spec:
  targetRef: {group: gateway.networking.k8s.io, kind: HTTPRoute, name: notes-api-lesen}
  requiredAuthenticationRefs:
  - {group: policy.linkerd.io, kind: MeshTLSAuthentication, name: notes-api}
EOF

Zeitziel: 7 min

Hinweis: Zwei Fehler. Miss nach der ersten Reparatur sofort noch einmal – und erinnere dich, was Tag 6 über Routen an Servern sagt.

Lösung Runde 3

sleep 20
kubectl -n tag18 logs deploy/last -c last --since=15s | awk '{print $2, $3}' \
  | sort | uniq -c
sleep 50
kubectl -n tag18 logs deploy/last -c last --since=20s | awk '{print $2, $3}' \
  | sort | uniq -c
kubectl -n tag18 get pods -l app=notes-api

Erwartet (gekürzt):

     24 /api/notes 403
     12 /flaky 200
     30 /api/notes 503
     15 /flaky 200
      1 /flaky 500
NAME                         READY   STATUS    RESTARTS   AGE
notes-api-6ff48b7779-mmss9   1/2     Running   0          31m

Erst 403, eine halbe Minute später 503 und ein Pod, der nicht mehr Ready ist. Wer wird abgelehnt?

kubectl -n tag18 get events --field-selector reason=Unhealthy \
  --sort-by=.lastTimestamp | tail -1
kubectl -n tag18 logs deploy/notes-api -c linkerd-proxy --since=1m \
  | grep 'Request denied' \
  | grep -oE 'route.name=[^ ]*|client.ip=[^ ]*|Name\("[^"]*|client.tls=None' \
  | paste - - - | sort | uniq -c
linkerd viz authz -n tag18 deploy/notes-api | grep notes-api-lesen
kubectl -n tag18 get authorizationpolicy notes-api-von-web \
  -o jsonpath='{.spec.requiredAuthenticationRefs}{"\n"}'

Erwartet (gekürzt):

49s  Warning  Unhealthy  pod/notes-api-6ff48b7779-mmss9  Readiness probe failed: HTTP
probe failed with statuscode: 403
     17 route.name=notes-api-lesen  Name("web.tag18.serviceaccount.identity.lin...
      7 route.name=notes-api-lesen  client.tls=None  client.ip=10.0.2.241
notes-api-lesen  notes-api-http                                    0.3rps    0.00% ...
notes-api-lesen  notes-api-http  authorizationpolicy/notes-api-von-web     -       - ...
[{"group":"policy.linkerd.io","kind":"MeshTLSAuthentication","name":"notes-api"}]

Fehler 1: Die Regel verlangt die Identität notes-api – kopiert aus postgres-von-notes-api. Fehler 2: Seit eine Route am Server hängt, erlaubt Linkerd die Probes nicht mehr automatisch. Der Kubelet (10.0.2.241, ohne TLS) bekommt 403, der Pod fliegt aus dem Service, web bekommt 503 (Tag 6, Challenge). Erst die Identität:

kubectl -n tag18 patch authorizationpolicy notes-api-von-web --type=json \
  -p '[{"op":"replace","path":"/spec/requiredAuthenticationRefs/0/name","value":"web"}]'
sleep 15
kubectl -n tag18 logs deploy/last -c last --since=10s | awk '{print $2, $3}' \
  | sort | uniq -c

Erwartet:

     14 /api/notes 503
      6 /flaky 200
      1 /flaky 500

Weiter 503 – der Pod ist ja nicht Ready. Dann die Probe, mit eigener Route und den Kubelet-Adressen der Nodes (Tag 6):

cat > probe.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: {name: notes-api-probe, namespace: tag18}
spec:
  parentRefs:
  - {group: policy.linkerd.io, kind: Server, name: notes-api-http}
  rules:
  - matches:
    - path: {type: Exact, value: /healthz}
      method: GET
---
apiVersion: policy.linkerd.io/v1alpha1
kind: NetworkAuthentication
metadata: {name: kubelet, namespace: tag18}
spec:
  networks:
  - cidr: 10.0.0.88/32
  - cidr: 10.0.1.116/32
  - cidr: 10.0.2.241/32
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata: {name: notes-api-probe-von-kubelet, namespace: tag18}
spec:
  targetRef: {group: gateway.networking.k8s.io, kind: HTTPRoute, name: notes-api-probe}
  requiredAuthenticationRefs:
  - {group: policy.linkerd.io, kind: NetworkAuthentication, name: kubelet}
EOF
kubectl apply -f probe.yaml
sleep 40
kubectl -n tag18 get pods -l app=notes-api
kubectl -n tag18 logs deploy/last -c last --since=20s | awk '{print $2, $3}' \
  | sort | uniq -c
kubectl -n tag18 exec deploy/web -c web -- curl -s -o /dev/null -w '%{http_code}\n' \
  -X POST -H 'X-API-Key: lab-key-123' -d '{"text":"x"}' http://notes-api/notes

Erwartet:

httproute.gateway.networking.k8s.io/notes-api-probe created
networkauthentication.policy.linkerd.io/kubelet created
authorizationpolicy.policy.linkerd.io/notes-api-probe-von-kubelet created
NAME                         READY   STATUS    RESTARTS   AGE
notes-api-6ff48b7779-mmss9   2/2     Running   0          32m
     30 /api/notes 200
     15 /flaky 200
404

GET läuft, POST trifft keine Route und bekommt 404 – die Härtung steht. Die exakte Route /healthz schlägt die allgemeine GET-Route, deshalb gilt für die Probe ihre eigene Regel.

Fortschritt speichern? Kostenlos registrieren

Runde 4: Robust gemacht

Lage: Damit notes-api „robuster“ wird, hat das Team Retries und einen großzügigen Timeout von fünf Sekunden eingebaut. Seitdem scheitert jeder Aufruf. Behalte Retries und fünf Sekunden Timeout.

Schiedsrichter-Befehle:

kubectl apply -f - <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: notes-api-robust
  namespace: tag18
  annotations:
    retry.linkerd.io/http: 5xx
    retry.linkerd.io/limit: "2"
    timeout.linkerd.io/request: 5ms
spec:
  parentRefs:
  - {group: core, kind: Service, name: notes-api, port: 80}
  rules:
  - matches:
    - path: {type: PathPrefix, value: /}
    timeouts: {request: 5s}
EOF

Zeitziel: 4 min

Hinweis: Der Proxy schreibt bei eigenen Fehlern einen Header mit dem Grund.

Lösung Runde 4

sleep 60
kubectl -n tag18 logs deploy/last -c last --since=50s | awk '{print $2, $3}' \
  | sort | uniq -c
kubectl -n tag18 exec deploy/web -c web -- curl -si -H 'X-API-Key: lab-key-123' \
  http://notes-api/notes | grep -E '^HTTP|^l5d'

Erwartet:

     64 /api/notes 504
     30 /flaky 200
      2 /flaky 500
HTTP/1.1 504 Gateway Timeout
l5d-proxy-error: logical service 10.109.85.58:80: route HTTPRoute.tag18.notes-api-robus
t: backend Service.tag18.notes-api:80: Service.tag18.notes-api:80: timed out waiting f
or response headers: request timeout: 5ms

l5d-proxy-error nennt Route und Grund: fünf Millisekunden. Welche Einstellung gewinnt, zeigt die Sicht des Proxys, die Quote je Route stat-outbound (Tag 7):

linkerd diagnostics policy -n tag18 svc/notes-api 80 -o json \
  | jq -c '.protocol.Kind.Detect.http1.routes[]
  | {name: .metadata.Kind.Resource.name, timeouts: .rules[0].timeouts}'
kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-prometheus 9090 \
  >/dev/null 2>&1 &
sleep 4
PROM=--prometheusURL=http://localhost:9090
linkerd viz stat-outbound -n tag18 deploy/web $PROM | grep -A1 notes-api
kill %1

Erwartet (gekürzt):

{"name":"notes-api-robust","timeouts":{"request":{"nanos":5000000}}}
web   notes-api:80  notes-api-robust  HTTPRoute    ...  0.00%  ...  100.00%    0.00%
                    └──────────────►  notes-api:80 ...  0.00%  ...  100.00%

Die Annotation schlägt rules[].timeouts.request (Tag 7). Die Spalte TIMEOUTS steht auf 100 Prozent, RETRIES auf 0: Ein abgelaufener Timeout wird ohne retry.linkerd.io/timeout nicht wiederholt. Annotation entfernen, die Regel mit 5 s bleibt:

kubectl -n tag18 annotate httproute notes-api-robust timeout.linkerd.io/request-
sleep 5
linkerd diagnostics policy -n tag18 svc/notes-api 80 -o json \
  | jq -c '.protocol.Kind.Detect.http1.routes[]
  | {name: .metadata.Kind.Resource.name, timeouts: .rules[0].timeouts}'
sleep 50
kubectl -n tag18 logs deploy/last -c last --since=45s | awk '{print $2, $3}' \
  | sort | uniq -c

Erwartet (Zahlen schwanken):

httproute.gateway.networking.k8s.io/notes-api-robust annotated
{"name":"notes-api-robust","timeouts":{"request":{"seconds":5}}}
     69 /api/notes 200
     33 /flaky 200
      1 /flaky 500

Fortschritt speichern? Kostenlos registrieren

Runde 5: Die Bremse

Lage: Gegen laute Clients bekommt notes-api ein Rate Limit: höchstens eine Anfrage pro Sekunde je Identität, web als wichtigster Kunde zehn. Die Vorlage stammt aus notes. Seitdem bekommt der Lastgenerator jede zweite Anfrage abgelehnt. Das Limit soll bleiben.

Schiedsrichter-Befehle:

kubectl apply -f - <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: HTTPLocalRateLimitPolicy
metadata: {name: notes-api-rl, namespace: tag18}
spec:
  targetRef: {group: policy.linkerd.io, kind: Server, name: notes-api-http}
  total:
    requestsPerSecond: 50
  identity:
    requestsPerSecond: 1
  overrides:
  - requestsPerSecond: 10
    clientRefs:
    - {kind: ServiceAccount, name: web, namespace: notes}
EOF

Zeitziel: 4 min

Hinweis: Welcher Topf ist leer – total oder identity?

Lösung Runde 5

sleep 60
kubectl -n tag18 logs deploy/last -c last --since=50s | awk '{print $2, $3}' \
  | sort | uniq -c
kubectl -n tag18 logs deploy/notes-api -c linkerd-proxy --since=1m \
  | grep -oE '[a-z]+ rate limit exceeded: [0-9]+rps' | sort | uniq -c
linkerd diagnostics proxy-metrics -n tag18 deploy/notes-api \
  | grep '^inbound_http_local_ratelimit' \
  | grep -oE 'ratelimit_scope="[^"]*"|client_id="[a-z.0-9-]+|\} [0-9]+' | paste - - -
kubectl -n tag18 get httplocalratelimitpolicy notes-api-rl \
  -o jsonpath='{.spec.overrides}{"\n"}'

Erwartet (gekürzt, Zahlen schwanken):

     39 /api/notes 200
     39 /api/notes 429
     37 /flaky 200
      1 /flaky 500
     96 identity rate limit exceeded: 1rps
ratelimit_scope="identity"  client_id="web.tag18.serviceaccount.identity.linker... } 58
[{"clientRefs":[{"kind":"ServiceAccount","name":"web","namespace":"notes"}],"reque...

Abgelehnt im Scope identity, und zwar web.tag18 – die Ausnahme gilt aber dem ServiceAccount web in notes. Für web aus tag18 greift deshalb die Grenze für alle: eine Anfrage pro Sekunde, last schickt rund 1,5. Ohne namespace gilt der Namespace der Policy; hier ausdrücklich gesetzt:

kubectl -n tag18 patch httplocalratelimitpolicy notes-api-rl --type=json \
  -p '[{"op":"replace","path":"/spec/overrides/0/clientRefs/0/namespace",
  "value":"tag18"}]'
sleep 60
kubectl -n tag18 logs deploy/last -c last --since=50s | awk '{print $2, $3}' \
  | sort | uniq -c
kubectl -n tag18 logs deploy/notes-api -c linkerd-proxy --since=40s \
  | grep -c 'rate limit exceeded'

Erwartet (Zahlen schwanken):

httplocalratelimitpolicy.policy.linkerd.io/notes-api-rl patched
     75 /api/notes 200
     36 /flaky 200
      1 /flaky 500
0

Fortschritt speichern? Kostenlos registrieren

Runde 6: Das Release

Lage: Version 2 von notes-api geht als Canary live, die Hälfte des Verkehrs. Das Team meldet: „Läuft, nur ein paar Prozent Fehler, das sind sicher die Retries.“ Bring /api/notes auf 100 Prozent, ohne Version 2 zu löschen – das Team will sie debuggen.

Schiedsrichter-Befehle:

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: ConfigMap
metadata: {name: v2-conf, namespace: tag18}
data:
  default.conf: |
    server {
      listen 8080;
      location = /healthz { return 200 "ok\n"; }
      location / { return 500 "v2 kaputt\n"; }
    }
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: notes-api-v2, namespace: tag18}
spec:
  replicas: 1
  selector: {matchLabels: {app: notes-api-v2}}
  template:
    metadata: {labels: {app: notes-api-v2}}
    spec:
      serviceAccountName: notes-api
      containers:
      - name: notes-api
        image: docker.io/nginxinc/nginx-unprivileged:1.31.7-alpine
        ports: [{containerPort: 8080, name: http}]
        readinessProbe:
          httpGet: {path: /healthz, port: http}
        volumeMounts: [{name: conf, mountPath: /etc/nginx/conf.d}]
      volumes: [{name: conf, configMap: {name: v2-conf}}]
---
apiVersion: v1
kind: Service
metadata: {name: notes-api-v2, namespace: tag18}
spec:
  selector: {app: notes-api-v2}
  ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: policy.linkerd.io/v1beta3
kind: Server
metadata: {name: notes-api-v2-http, namespace: tag18}
spec:
  podSelector: {matchLabels: {app: notes-api-v2}}
  port: http
  proxyProtocol: HTTP/1
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata: {name: notes-api-v2-von-web, namespace: tag18}
spec:
  targetRef: {group: policy.linkerd.io, kind: Server, name: notes-api-v2-http}
  requiredAuthenticationRefs:
  - {group: policy.linkerd.io, kind: MeshTLSAuthentication, name: web}
EOF
kubectl -n tag18 rollout status deploy/notes-api-v2 --timeout=120s
kubectl -n tag18 patch httproute notes-api-robust --type=json -p '[{"op":"add",
  "path":"/spec/rules/0/backendRefs","value":[{"name":"notes-api","port":80,
  "weight":50},{"name":"notes-api-v2","port":80,"weight":50}]}]'

Zeitziel: 5 min

Hinweis: stat-outbound zeigt jedes Backend einer Route einzeln.

Lösung Runde 6

sleep 90
kubectl -n tag18 logs deploy/last -c last --since=80s | awk '{print $2, $3}' \
  | sort | uniq -c
linkerd viz stat -n tag18 deploy | grep -E 'NAME|notes-api'

Erwartet (gekürzt, Zahlen schwanken):

    101 /api/notes 200
     11 /api/notes 500
     55 /flaky 200
      1 /flaky 500
NAME           MESHED   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99 ...
notes-api         1/1   100.00%   1.7rps           5ms          32ms          38ms ...
notes-api-v2      1/1    28.57%   1.4rps           1ms           6ms           9ms ...

Rund zehn Prozent Fehler – und notes-api-v2 mit 28 Prozent Erfolg, und das nur dank der Probes. Pro Backend der Route:

kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-prometheus 9090 \
  >/dev/null 2>&1 &
sleep 4
PROM=--prometheusURL=http://localhost:9090
linkerd viz stat-outbound -n tag18 deploy/web $PROM | grep -A2 notes-api
kill %1
kubectl -n tag18 get httproute notes-api-robust \
  -o jsonpath='{range .spec.rules[0].backendRefs[*]}{.name} {.weight}{"\n"}{end}'

Erwartet (gekürzt):

web   notes-api:80  notes-api-robust  HTTPRoute       90.70%  1.43  ...  0.00%   37.23%
                    ├──────────────►  notes-api:80   100.00%  1.30  ...  0.00%
                    └──────────────►  notes-api-v2:80  0.00%  0.98  ...  0.00%
notes-api 50
notes-api-v2 50

Version 2 scheitert zu 100 Prozent. Dass die Route trotzdem auf 90 Prozent kommt, liegt an den Retries aus Runde 4: Ein Fehlschlag auf v2 wird wiederholt und landet mit 50 Prozent bei v1. Erst wenn alle drei Versuche v2 treffen (0,5³ = 12,5 Prozent), sieht der Nutzer den Fehler. Retries verstecken einen kaputten Canary. Rollback per Gewicht (Tag 9):

kubectl -n tag18 patch httproute notes-api-robust --type=json -p '[{"op":"replace",
  "path":"/spec/rules/0/backendRefs/1/weight","value":0}]'
sleep 75
kubectl -n tag18 logs deploy/last -c last --since=65s | awk '{print $2, $3}' \
  | sort | uniq -c
kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-prometheus 9090 \
  >/dev/null 2>&1 &
sleep 4
linkerd viz stat-outbound -n tag18 deploy/web $PROM -t 30s | grep -A2 notes-api
kill %1

Erwartet (gekürzt, Zahlen schwanken):

    102 /api/notes 200
     50 /flaky 200
      1 /flaky 500
web   notes-api:80  notes-api-robust  HTTPRoute      100.00%  1.50  ...  0.00%    0.00%
                    ├──────────────►  notes-api:80   100.00%  1.50  ...  0.00%
                    └──────────────►  notes-api-v2:80   NaN%  0.00  ...   NaN%

v2 läuft weiter und bekommt nichts mehr. Wer stattdessen das Deployment von v2 gelöscht hätte, hätte ebenfalls 100 Prozent gesehen (Backend ohne Endpunkte fällt aus der Verteilung) – aber genau das wollte das Team nicht.

Fortschritt speichern? Kostenlos registrieren

Runde 7: Die Firewall im Mesh

Lage: Die Sicherheitsabteilung sperrt allen ausgehenden Verkehr aus tag18. Einzig example.com per HTTPS soll erlaubt sein, das braucht notes-api für /api/upstream. Das liefert jetzt aber 502. Gib genau example.com frei – sonst nichts.

Schiedsrichter-Befehle:

kubectl apply -f - <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: EgressNetwork
metadata: {name: internet, namespace: tag18}
spec:
  trafficPolicy: Deny
---
apiVersion: gateway.networking.k8s.io/v1
kind: TLSRoute
metadata: {name: example-com, namespace: tag18}
spec:
  parentRefs:
  - {group: policy.linkerd.io, kind: EgressNetwork, name: internet, port: 443}
  hostnames: [www.example.com]
  rules:
  - backendRefs:
    - {group: policy.linkerd.io, kind: EgressNetwork, name: internet}
EOF

Zeitziel: 5 min

Hinweis: Vergleiche, welchen Namen notes-api aufruft, mit dem Namen, den die Route freigibt.

Lösung Runde 7

kubectl -n tag18 exec deploy/last -c last -- curl -s -w ' %{http_code}\n' \
  http://web/api/upstream
linkerd diagnostics proxy-metrics -n tag18 deploy/notes-api \
  | grep -E '^outbound_t(cp|ls)_route_open_total' \
  | grep -oE 'parent_name="[^"]*"|route_name="[^"]*"|\} [0-9]+' | paste - - -

Erwartet (gekürzt):

{"error":"Get \"https://example.com\": EOF"} 502
parent_name="postgres"         route_name="opaq"             } 70
parent_name="egress-fallback"  route_name="egress-fallback"  } 1
parent_name="internet"         route_name="tls-egress-deny"  } 3

Die erste Verbindung (Baseline) lief noch über egress-fallback, jetzt landet alles auf der Standardroute tls-egress-deny. Die eigene TLSRoute zählt nicht mit. Warum?

kubectl -n tag18 get tlsroute example-com \
  -o jsonpath='{.spec.hostnames} {.status.parents[0].conditions[0].reason}{"\n"}'
kubectl -n tag18 set env deploy/notes-api -c notes-api --list | grep UPSTREAM

Erwartet:

["www.example.com"] Accepted
NOTES_UPSTREAM=https://example.com

Die Route ist Accepted, passt aber nicht: Der SNI-Name muss exakt stimmen (Tag 11). www.example.com ist ein anderer Host als example.com.

kubectl -n tag18 patch tlsroute example-com --type=merge \
  -p '{"spec":{"hostnames":["example.com"]}}'
sleep 5
kubectl -n tag18 exec deploy/last -c last -- curl -s -w ' %{http_code}\n' \
  http://web/api/upstream
for u in https://example.com https://linkerd.io; do
  kubectl -n tag18 exec deploy/last -c last -- curl -s -o /dev/null \
    -w "$u %{http_code}\n" $u
done
linkerd diagnostics proxy-metrics -n tag18 deploy/notes-api \
  | grep -E '^outbound_tls_route_open_total' \
  | grep -oE 'route_name="[^"]*"|\} [0-9]+' | paste - -

Erwartet:

tlsroute.gateway.networking.k8s.io/example-com patched
{"status":200,"url":"https://example.com"}
 200
https://example.com 200
https://linkerd.io 000
command terminated with exit code 35
route_name="example-com"      } 1
route_name="tls-egress-deny"  } 3

example.com geht, linkerd.io bleibt gesperrt – auch für last, denn das EgressNetwork gilt für alle Clients im Namespace.

Fortschritt speichern? Kostenlos registrieren

Runde 8: Die Revision fragt

Lage: Zertifikate baut man im Wettkampf nicht kaputt – das träfe das ganze Mesh (Tag 16). Stattdessen will die Revision drei Antworten, belegt mit je einem Befehl. Nur lesen, nichts ändern.

  1. Welche Identität hat web in tag18, wer hat sie ausgestellt, und bis wann gilt das Zertifikat?
  2. Wann läuft der Issuer ab, und wann wird er erneuert? Müssen dafür Pods neu starten?
  3. Ist im Cluster genau der Trust Anchor aus ~/linkerd/tag05/ca.crt verteilt? Was sagt linkerd check dazu?

Zeitziel: 4 min

Hinweis: Tag 3 und Tag 5, Speed-Drills.

Lösung Runde 8

linkerd identity -n tag18 -l app=web | grep -E 'Subject:|Issuer:|Not After'
kubectl -n linkerd get certificate linkerd-identity-issuer \
  -o jsonpath='{.status.notAfter} {.status.renewalTime}{"\n"}'
kubectl -n linkerd get configmap linkerd-identity-trust-roots \
  -o jsonpath='{.data.ca-bundle\.crt}' | step certificate fingerprint -
step certificate fingerprint ~/linkerd/tag05/ca.crt
linkerd check 2>&1 | grep -A2 '‼ issuer'

Erwartet (Daten hängen von deinem Lauf ab):

        Issuer: CN=identity.linkerd.cluster.local
            Not After : Nov 20 20:40:11 2026 UTC
        Subject: CN=web.tag18.serviceaccount.identity.linkerd.cluster.local
2026-11-21T16:02:00Z 2026-11-20T15:02:00Z
8b44a80f0940a58823716aecd2aeac2895e43d94bd968826ec821389f65bab81
8b44a80f0940a58823716aecd2aeac2895e43d94bd968826ec821389f65bab81
‼ issuer cert is valid for at least 60 days
    issuer certificate will expire on 2026-11-21T16:02:00Z
    see https://linkerd.io/2/checks/#l5d-identity-issuer-cert-not-expiring-soon ...
  1. web.tag18.serviceaccount.identity.linkerd.cluster.local, ausgestellt vom Issuer identity.linkerd.cluster.local, gültig 24 Stunden ab Pod-Start – der Proxy erneuert es selbst.
  2. Der Issuer gilt 48 Stunden, cert-manager erneuert ihn 25 Stunden vor Ablauf. identity lädt ihn ohne Neustart nach (IssuerUpdated), die Proxys bekommen ihre nächsten Zertifikate vom neuen Issuer – kein Pod muss neu starten.
  3. Ja, beide Fingerprints sind gleich. Die Warnung von check ist bei einem 48-Stunden-Issuer erwartet (Tag 5) und kein Befund.

Fortschritt speichern? Kostenlos registrieren

Wertung

Runde Fehler Zeitziel Punkte
1 linkerd.io/inject: disabled am Pod-Template von web 3 min 2
2 Opaque Port auf HTTP-Service helper 5 min 2
3 falsche Identität in der Regel + Probes ohne Route 7 min 3
4 Timeout-Annotation 5ms schlägt timeouts.request 4 min 2
5 Rate-Limit-Ausnahme für SA aus falschem Namespace 4 min 2
6 Canary 50 Prozent auf kaputte Version, Retries verstecken es 5 min 2
7 TLSRoute für www.example.com statt example.com 5 min 2
8 drei Fragen zu Identität, Issuer, Trust Anchor 4 min 3

Volle Punkte nur innerhalb des Zeitziels, ohne Hinweis und mit Beweis-Befehl; sonst die Hälfte (abrunden). In Runde 8 gibt es einen Punkt je belegter Antwort. Wer statt der Ursache das Symptom beseitigt (Default-Deny aus, accessPolicy: all-unauthenticated, Härtung oder Rate Limit löschen, Route löschen statt Retries behalten, v2 löschen, trafficPolicy: Allow), bekommt für die Runde 0. Gesamtzeitziel: 37 min, Maximum: 18 Punkte.

Punkte Einschätzung
15–18 bereit für die Abschlussprüfung (Anhang B)
10–14 gut; die Tage der verpassten Runden wiederholen
0–9 Tag 2, 6, 7, 8, 9 und 11 noch einmal durcharbeiten

Challenge

Nach einer Änderung an notes-api hängt der Rollout. Die Nutzer merken nichts, der Lastgenerator zeigt 100 Prozent. Bring den Rollout zu Ende, ohne die Regeln für postgres zu lockern. Schiedsrichter-Befehle:

kubectl -n tag18 patch deploy notes-api -p '{"spec":{"template":{"metadata":
  {"annotations":{"config.beta.linkerd.io/proxy-enable-native-sidecar":"false"}}}}}'

Hinweis: Schau dir die Reihenfolge der Init-Container im neuen Pod an.

Lösung

sleep 60
kubectl -n tag18 get pods -l app=notes-api
P=$(kubectl -n tag18 get pod -l app=notes-api \
  --sort-by=.metadata.creationTimestamp -o name | tail -1)
kubectl -n tag18 get $P \
  -o jsonpath='{range .spec.initContainers[*]}{.name} {.restartPolicy}{"\n"}{end}'
kubectl -n tag18 logs $P -c migrate --tail=1 | cut -c1-80
linkerd diagnostics proxy-metrics -n tag18 po/postgres-0 \
  | grep '^inbound_tcp_authz_deny_total' \
  | grep -oE '(srv_name|no_tls_reason)="[^"]*"|\} [0-9]+' | paste - - -
kubectl -n tag18 get deploy notes-api \
  -o jsonpath='{.spec.template.metadata.annotations}{"\n"}'

Erwartet (gekürzt):

NAME                         READY   STATUS       RESTARTS      AGE
notes-api-54c8fb75bf-xdxbt   0/2     Init:Error   3 (43s ago)   60s
notes-api-6ff48b7779-mmss9   2/2     Running      0             33m
migrate
linkerd-init
time=2026-11-19T21:10:10.890Z level=ERROR msg="database unreachable" source=env
srv_name="postgres"  no_tls_reason="port_skipped"  } 7
{"config.beta.linkerd.io/proxy-enable-native-sidecar":"false"}

migrate läuft vor linkerd-init, und einen Proxy als nativen Sidecar (restartPolicy: Always) gibt es nicht mehr. Die Migration spricht Klartext mit Postgres, Default-Deny schließt die Verbindung (port_skipped, Tag 2 und 6). Die Annotation muss weg:

A='config.beta.linkerd.io~1proxy-enable-native-sidecar'
kubectl -n tag18 patch deploy notes-api --type=json -p '[{"op":"remove",
  "path":"/spec/template/metadata/annotations/'$A'"}]'
kubectl -n tag18 rollout status deploy/notes-api --timeout=180s
kubectl -n tag18 get pods -l app=notes-api

Erwartet:

deployment "notes-api" successfully rolled out
NAME                         READY   STATUS    RESTARTS   AGE
notes-api-6ff48b7779-mmss9   2/2     Running   0          34m

Das Template ist wieder identisch mit dem alten, Kubernetes skaliert einfach das alte ReplicaSet zurück – derselbe Pod läuft weiter.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

kubectl delete namespace tag18 --timeout=180s
kubectl get endpointslices -A | grep cilium-gateway | grep tag18

Erwartet: namespace "tag18" deleted, danach keine Ausgabe. Mit dem Namespace verschwinden PVC, EgressNetwork und die EndpointSlices cilium-gateway-helper und cilium-gateway-notes-api, die Cilium zu den HTTPRoutes an den Services angelegt hat. Die Dateien in ~/linkerd/tag18 bleiben als Vorlage für die Abschlussprüfung.

Kontrollpunkt

kubectl get ns | grep -c tag18
kubectl get pv | grep -c tag18

Erwartet: zweimal 0.

kubectl -n notes get pods

Erwartet: alle acht Pods 2/2 Running – notes hast du heute nicht angefasst.

kubectl -n notes logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c
linkerd check 2>&1 | tail -1

Erwartet (Zahlen schwanken):

     86 /api/notes 200
     29 /flaky 200
     14 /flaky 500
Status check results are √

Interview-Notiz

  • Ein Dienst liefert plötzlich 403 – wo fängst du an? Beim Server-Proxy: Proxy-Log Request denied zeigt Server, Route und Client-Identität. client.tls=None heißt: Client ohne Proxy. Falsche Identität heißt: ServiceAccount oder Regel prüfen.
  • Warum sieht ein kaputter Canary im Dashboard harmlos aus? Retries des Client-Proxys wiederholen Fehler auf das andere Backend. Die Route ist fast grün, das Backend steht auf 0 Prozent – stat-outbound pro Backend lesen, nicht nur die Route.
  • Was prüfst du nach jeder Policy- oder Routenänderung? Readiness der Ziel-Pods (Probes an Servern mit Routen), die Sicht des Proxys mit linkerd diagnostics policy, und eine Messung mit frischen Verbindungen.

Enterprise-Notiz

  • Game Days wie diesen regelmäßig mit der Bereitschaft spielen – aus den Lösungen werden Runbooks.
  • Annotationen mit Wirkung aufs Mesh (inject, opaque-ports, proxy-enable-native-sidecar, Timeouts) per Admission-Policy erlauben oder verbieten, nicht per Review.
  • Policies, Routen und Rate Limits aus Git mit Review und einem Test-Namespace, der Default-Deny wie Produktion hat. Kopierte Vorlagen auf Namespace und Identitäten prüfen.
  • Canary-Releases automatisch auswerten (Flagger, Argo Rollouts) – mit Fehlerquote pro Backend und Retry-Quote als Abbruchkriterium.
  • Egress-Freigaben als Liste von Hostnamen pflegen und mit Metriken (tls-egress-deny) gegenprüfen, welche Ziele gesperrt angefragt werden.