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
tag18eine vollständige Kopie vonnotes: 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
200auf/api/notes,/flakyfast nur200(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 -cSpielfeld
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 -lErwartet (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 podsErwartet (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; echoErwartet (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=120sZeitziel: 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 podsErwartet (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 -cErwartet (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=80Zeitziel: 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 -cErwartet (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}
EOFZeitziel: 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-apiErwartet (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 -cErwartet:
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/notesErwartet:
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}
EOFZeitziel: 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 %1Erwartet (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 -cErwartet (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}
EOFZeitziel: 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 %1Erwartet (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}
EOFZeitziel: 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 UPSTREAMErwartet:
["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.
- Welche Identität hat
webintag18, wer hat sie ausgestellt, und bis wann gilt das Zertifikat? - Wann läuft der Issuer ab, und wann wird er erneuert? Müssen dafür Pods neu starten?
- Ist im Cluster genau der Trust Anchor aus
~/linkerd/tag05/ca.crtverteilt? Was sagtlinkerd checkdazu?
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 ...
web.tag18.serviceaccount.identity.linkerd.cluster.local, ausgestellt vom Issueridentity.linkerd.cluster.local, gültig 24 Stunden ab Pod-Start – der Proxy erneuert es selbst.- Der Issuer gilt 48 Stunden, cert-manager erneuert ihn 25 Stunden vor
Ablauf.
identitylädt ihn ohne Neustart nach (IssuerUpdated), die Proxys bekommen ihre nächsten Zertifikate vom neuen Issuer – kein Pod muss neu starten. - Ja, beide Fingerprints sind gleich. Die Warnung von
checkist 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-apiErwartet:
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 tag18Erwartet: 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 tag18Erwartet: zweimal 0.
kubectl -n notes get podsErwartet: 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 -1Erwartet (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 deniedzeigt Server, Route und Client-Identität.client.tls=Noneheiß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-outboundpro 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.