Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang B: Abschlussprüfung

Ziel: Du löst 16 praktische Aufgaben quer durch das Buch in 120 Minuten und bewertest dich selbst. · Dauer: 120 min · Voraussetzung: Tag 0–18

Spielregeln

  • Zeit: 120 Minuten, Uhr stellen. Jede Aufgabe hat ein Gewicht in Prozent, zusammen 100 %.
  • Ein Zertifikat gibt es nicht. Die eigene Messlatte: ab 70 % sitzt das Handwerk.
  • Erlaubt: linkerd.io/2-edge, gateway-api.sigs.k8s.io, --help, kubectl explain und deine eigenen Dateien unter ~/linkerd/tagNN als Vorlage. Nicht erlaubt: dieses Buch während der Zeit.
  • Alles läuft auf cp1 im Namespace pruefung, Dateien in ~/linkerd/pruefung. Aufgabe 13 und 15 sprechen zusätzlich west an (--context west).
  • notes fasst du nicht an. Keine clusterweiten Änderungen: kein linkerd upgrade, kein helm upgrade, keine Extension neu installieren oder entfernen. Einzige Ausnahme ist der Link in Aufgabe 13 – er verschwindet beim Aufräumen wieder.
  • Reihenfolge: Aufgabe 1 bis 6 der Reihe nach, Aufgabe 4 vor Aufgabe 7, Aufgabe 7 vor Aufgabe 10. Ab Aufgabe 8 gilt Default-Deny aus Aufgabe 6. Sonst ist die Reihenfolge frei.
  • Die Lösungen stehen am Ende. Erst nach Ablauf der Zeit lesen.

Vorbereitung

Eine Kopie der App aus den Tag-0-Manifesten, ein Replikat je Dienst, noch ohne Mesh. Dazu notes-api mit einem Ziel im Internet (Tag 11) und ein Dienst statistik, den ein Kollege gebaut hat. Er zählt alle zehn Sekunden die Notizen direkt in Postgres:

mkdir -p ~/linkerd/pruefung && cd ~/linkerd/pruefung
kubectl create namespace pruefung
kubectl -n pruefung 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 pruefung create secret generic notes-api-key --from-literal=key=lab-key-123
for f in postgres notes-api helper web last; do
  sed 's/namespace: notes/namespace: pruefung/; s/\.notes\.svc/.pruefung.svc/
    s/replicas: 2/replicas: 1/' ~/linkerd/tag00/$f.yaml; echo ---
done > app.yaml
kubectl -n pruefung create serviceaccount statistik
cat > statistik.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: statistik, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: statistik}}
  template:
    metadata:
      labels: {app: statistik}
      annotations: {config.linkerd.io/skip-outbound-ports: "5432"}
    spec:
      serviceAccountName: statistik
      containers:
      - name: statistik
        image: docker.io/library/postgres:18.7-alpine
        env:
        - {name: PGCONNECT_TIMEOUT, value: "3"}
        - name: PGPASSWORD
          valueFrom: {secretKeyRef: {name: notes-db, key: password}}
        command: [sh, -c]
        args:
        - |
          while true; do
            n=$(psql -h postgres -U notes -tAc 'select count(*) from notes' 2>&1)
            echo "$(date +%T) $n"
            sleep 10
          done
EOF
kubectl apply -f app.yaml -f statistik.yaml
kubectl -n pruefung set env deploy/notes-api NOTES_UPSTREAM=https://example.com
kubectl -n pruefung rollout status statefulset/postgres --timeout=180s
kubectl -n pruefung rollout status deploy --timeout=240s

Für Aufgabe 8 liegt ein kaputter notes-api bereit – nur als Datei, noch nicht angewendet. Er beantwortet die Readiness-Probe und sonst alles mit 500:

cat > kaputt.yaml <<'EOF'
apiVersion: v1
kind: ConfigMap
metadata: {name: kaputt-conf, namespace: pruefung}
data:
  default.conf: |
    server {
      listen 8080;
      location = /healthz { return 200 "ok\n"; }
      location / { return 500 "kaputt\n"; }
    }
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: notes-api-kaputt, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: notes-api, variante: kaputt}}
  template:
    metadata: {labels: {app: notes-api, variante: kaputt}}
    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: kaputt-conf}}]
EOF

Nach einer Minute die Baseline:

kubectl -n pruefung logs deploy/last --since=35s | awk '{print $2, $3}' | sort | uniq -c
kubectl -n pruefung logs deploy/statistik --tail=2

Erwartet (Zahlen schwanken):

     58 /api/notes 200
     20 /flaky 200
      9 /flaky 500
21:23:34 0
21:23:44 0

Die 0 ist die Zahl der Notizen in der neuen Datenbank. Uhr starten.

Aufgabe 1: Bestandsaufnahme (5 %)

Schreibe nach ~/linkerd/pruefung/01.txt vier Zeilen: die Version der Control Plane, die Zahl der Linkerd-CRDs im Cluster, die letzte Zeile von linkerd check und die Namen der installierten Extensions (eine Zeile, durch Leerzeichen getrennt).

Aufgabe 2: Ins Mesh (7 %)

Hol pruefung ins Mesh. Jeder der fünf App-Dienste bekommt einen eigenen ServiceAccount mit seinem Namen; statistik hat schon einen. Danach laufen alle Pods mit Proxy (2/2), und linkerd check --proxy -n pruefung meldet keinen Fehler und keine Warnung zu Opaque Ports.

Aufgabe 3: Wer spricht mit Postgres? (6 %)

Ohne tcpdump: Schreibe nach 03.txt die Identität, mit der notes-api bei postgres-0 ankommt (Zeile 1), und die Zahl der Klartext-Verbindungen, die postgres-0 auf Port 5432 bisher angenommen hat (Zeile 2). Zeig außerdem mit einem Befehl, dass alle HTTP-Kanten in pruefung per mTLS laufen.

Aufgabe 4: Golden Metrics (6 %)

Vor Aufgabe 7 lösen. Schreibe nach 04.txt die Erfolgsquote von helper aus Sicht von web als Dezimalzahl – einmal laut linkerd viz (Zeile 1), einmal per PromQL über fünf Minuten direkt aus Prometheus (Zeile 2).

Aufgabe 5: Die Revision fragt nach Zertifikaten (5 %)

Nur lesen. Schreibe nach 05.txt: wann der Trust Anchor im Cluster abläuft, wann der Issuer abläuft und wann er erneuert wird, und zwei Fingerprints, die belegen, dass im Cluster genau der Anchor aus ~/linkerd/tag05/ca.crt verteilt ist.

Aufgabe 6: Default-Deny (8 %)

In pruefung darf nur noch sprechen, wer muss: last → web → notes-api → postgres und web → helper. Neue Ports ohne Regel sind gesperrt. Probes und die Prometheus-Scrapes (up = 1 für jeden Proxy in pruefung) laufen weiter, der Lastgenerator zeigt dieselben Quoten wie vorher. Weise mit einem Pod fremd (mit Proxy, ServiceAccount default) nach, dass er von helper 403 bekommt.

Aufgabe 7: Retries und Timeouts (7 %)

/flaky gelingt zu mindestens 95 Prozent: Der Client-Proxy von web wiederholt GET-Requests auf /unstable bei 5xx höchstens zweimal, andere Methoden nie. Alle übrigen Pfade von helper bleiben erreichbar. /slow bricht nach einer Sekunde mit 504 ab.

Aufgabe 8: Ein Pod, der lügt (6 %)

Starte den kaputten Pod mit kubectl apply -f kaputt.yaml. Er ist bereit, liefert aber nur 500. Ohne ihn zu löschen, zu skalieren oder seine Labels zu ändern: Jeder Client soll ihn nach drei Fehlern in Folge mindestens 30 Sekunden meiden, höchstens zwei Minuten. /api/notes liegt danach wieder über 99 Prozent. Weise pro Pod nach, wer noch Verkehr von web bekommt.

Aufgabe 9: Eine Bremse für den Bericht (7 %)

Lege ein Deployment bericht an (curlimages/curl:8.23.0, sleep infinity, eigener ServiceAccount bericht). bericht darf helper direkt aufrufen, aber höchstens 2 Requests pro Sekunde und Pod. web darf bis zu 20, jeder helper-Pod nimmt insgesamt höchstens 50 an. Nachweis: 40 schnelle Aufrufe aus bericht enden überwiegend mit 429, der Lastgenerator sieht keinen einzigen.

Aufgabe 10: Canary (6 %)

Eine neue Version helper-v2 (go-httpbin 2.26.0, Label app: helper-v2, ServiceAccount helper, Service helper-v2 auf Port 80) bekommt 20 Prozent der Aufrufe von web an helper – außer /delay, das bleibt bei der alten Version. Die Retries aus Aufgabe 7 bleiben wirksam, Default-Deny bleibt. Weise die Verteilung nach.

Aufgabe 11: Der Eingang (7 %)

Ein Cilium-Gateway pruefung nimmt HTTP auf Port 80 für den Host pruefung.lab.internal an und leitet an web. Von cp1 aus liefert /api/notes über den NodePort des Gateways auf jedem Node 200. Ein Pod ohne Proxy, der web direkt aufruft, bekommt weiter 403 – das Pod-Netz freizugeben gilt nicht.

Aufgabe 12: Nur example.com (6 %)

Pods in pruefung erreichen außerhalb des Clusters nur noch https://example.com. /api/upstream über web liefert weiter 200, https://linkerd.io und http://example.com scheitern aus last. Das muss auch für frische Verbindungen von notes-api gelten.

Aufgabe 13: Ein helper aus west (8 %)

Auf west läuft im Namespace pruefung ein helper im Mesh (go-httpbin 2.26.0 mit USE_REAL_HOSTNAME=true, Service Port 80). In ost erscheint er als helper-west, und last bekommt unter http://helper-west/hostname einen Pod-Namen aus west. Weise am Gateway in west nach, mit welcher Identität last ankommt. Zu Beginn ist kein Link aktiv (Tag 13, Aufräumen).

Aufgabe 14: Die Statistik zählt nicht mehr (7 %)

Seit Aufgabe 6 meldet statistik nur noch Fehler. Repariere den Dienst, sodass er mit seiner eigenen Identität zählen darf. Default-Deny bleibt, und postgres nimmt weiter weder Klartext noch fremde Identitäten an.

Aufgabe 15: west im Blick (4 %)

Nur lesen. Schreibe nach 15.txt Chart und Revision des Release linkerd-control-plane auf west (Zeile 1), die wirksamen Werte controllerReplicas und webhookFailurePolicy (Zeile 2 und 3) und die Zahl der bereiten Replikas von linkerd-destination (Zeile 4).

Aufgabe 16: Ein Proxy mit Budget (5 %)

Der Proxy von web bekommt 50m CPU und 32 MiB Speicher als Request und 128 MiB als Limit – nur per Annotation, die App selbst bleibt ohne Ressourcen. Zeig die Ressourcen des Proxy-Containers und die QoS-Klasse des Pods vorher und nachher.

Uhr stoppen.

Lösungen

Alle Befehle auf cp1 im Ordner ~/linkerd/pruefung.

Lösung 1

linkerd version --short | tail -1 > 01.txt
kubectl get crd -o name | grep -c linkerd >> 01.txt
linkerd check 2>&1 | tail -1 >> 01.txt
kubectl get ns -l linkerd.io/extension \
  -o jsonpath='{.items[*].metadata.labels.linkerd\.io/extension}{"\n"}' >> 01.txt
cat 01.txt

Erwartet:

edge-26.11.2
11
Status check results are √
multicluster viz

--short zeigt erst die CLI, dann die Control Plane – tail -1 nimmt die zweite. Elf CRDs: die zehn aus Tag 1 plus links.multicluster.linkerd.io. Extensions erkennt linkerd check am Label linkerd.io/extension ihres Namespace (Tag 15).

Lösung 2

kubectl annotate namespace pruefung linkerd.io/inject=enabled
for a in web notes-api helper last postgres; do
  kubectl -n pruefung create serviceaccount $a
done
for d in web notes-api helper last; do
  kubectl -n pruefung set serviceaccount deploy/$d $d
done
kubectl -n pruefung set serviceaccount statefulset/postgres postgres
kubectl -n pruefung annotate service postgres config.linkerd.io/opaque-ports=5432
kubectl -n pruefung rollout restart deploy/statistik
kubectl -n pruefung rollout status statefulset/postgres --timeout=180s
kubectl -n pruefung rollout status deploy --timeout=240s
kubectl -n pruefung get pods
linkerd check --proxy -n pruefung 2>&1 | grep -E '‼|×|opaque|Status'

Erwartet (gekürzt):

NAME                         READY   STATUS    RESTARTS   AGE
helper-79d57fbbbb-bg874      2/2     Running   0          24s
last-78895758f9-wvbz6        2/2     Running   0          24s
notes-api-6ff48b7779-86v22   2/2     Running   0          24s
postgres-0                   2/2     Running   0          21s
statistik-64cf4b6f5b-fvwxw   2/2     Running   0          22s
web-7d94ccc84d-tp7wk         2/2     Running   0          25s
‼ issuer cert is valid for at least 60 days
√ opaque ports are properly annotated
Status check results are √

set serviceaccount ändert das Pod-Template und startet die vier Deployments und Postgres ohnehin neu – mit Proxy, weil der Namespace schon annotiert ist. Nur statistik braucht einen eigenen Neustart (Tag 2). Die Issuer-Warnung kennst du aus Tag 5, sie ist kein Befund.

Lösung 3

linkerd diagnostics proxy-metrics -n pruefung po/postgres-0 \
  | grep '^tcp_open_total{direction="inbound",peer="src"' \
  | grep 'target_port="5432"' > pg-tcp.txt
grep -o 'client_id="[^"]*' pg-tcp.txt | cut -d'"' -f2 > 03.txt
grep port_skipped pg-tcp.txt | grep -oE '[0-9]+$' >> 03.txt
cat 03.txt
linkerd viz edges -n pruefung deploy

Erwartet (Zahl schwankt):

notes-api.pruefung.serviceaccount.identity.linkerd.cluster.local
11
SRC    DST         SRC_NS     DST_NS     SECURED
last   web         pruefung   pruefung   √
web    helper      pruefung   pruefung   √
web    notes-api   pruefung   pruefung   √

Die Klartext-Verbindungen tragen no_tls_reason="port_skipped" – jemand spricht am Proxy vorbei mit Postgres (Tag 3, Drill 7). Wer das ist, klärt Aufgabe 14. edges zeigt jede HTTP-Kante mit √; Postgres fehlt, weil es ein StatefulSet ist.

Lösung 4

linkerd viz stat -n pruefung deploy/helper --from deploy/web
linkerd viz stat -n pruefung deploy/helper --from deploy/web -o json \
  | jq -r '.[0].success' > 04.txt
kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-prometheus 9090 \
  >/dev/null 2>&1 &
sleep 4
Q='sum(rate(response_total{namespace="pruefung", deployment="web",
 direction="outbound", dst_deployment="helper", classification="success"}[5m]))
 / sum(rate(response_total{namespace="pruefung", deployment="web",
 direction="outbound", dst_deployment="helper"}[5m]))'
curl -s localhost:9090/api/v1/query --data-urlencode "query=$Q" \
  | jq -r '.data.result[0].value[1]' >> 04.txt
kill %1
cat 04.txt

Erwartet (Zahlen schwanken):

NAME     MESHED   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99   TCP_CONN
helper      1/1    71.43%   0.7rps           8ms          36ms          39ms          1
0.7142857142857143
0.6820478364789672

Beide um 0,7 – die Baseline von /flaky. --from deploy/web lässt die Readiness-Probes weg, die die Inbound-Quote von helper schönen (Tag 4, Drill 4). viz rechnet über eine Minute, die PromQL-Abfrage über fünf.

Lösung 5

kubectl -n linkerd get configmap linkerd-identity-trust-roots \
  -o jsonpath='{.data.ca-bundle\.crt}' | openssl x509 -noout -enddate > 05.txt
kubectl -n linkerd get certificate linkerd-identity-issuer \
  -o jsonpath='{.status.notAfter} {.status.renewalTime}{"\n"}' >> 05.txt
kubectl -n linkerd get configmap linkerd-identity-trust-roots \
  -o jsonpath='{.data.ca-bundle\.crt}' | step certificate fingerprint - >> 05.txt
step certificate fingerprint ~/linkerd/tag05/ca.crt >> 05.txt
cat 05.txt

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

notAfter=Nov 16 15:51:50 2036 GMT
2026-11-21T16:02:00Z 2026-11-20T15:02:00Z
8b44a80f0940a58823716aecd2aeac2895e43d94bd968826ec821389f65bab81
8b44a80f0940a58823716aecd2aeac2895e43d94bd968826ec821389f65bab81

Zehn Jahre für den Anchor, 48 Stunden für den Issuer, Erneuerung 25 Stunden vor Ablauf (Tag 5). Gleiche Fingerprints: Der Cluster vertraut genau deinem ca.crt.

Lösung 6

Die Regeln aus Tag 6 passen eins zu eins. proxy-admin kommt mit, bevor die Default-Policy umgestellt wird – sonst fehlen Minuten an Metriken:

for f in servers authz admin; do
  sed 's/namespace: notes/namespace: pruefung/' ~/linkerd/tag06/$f.yaml; echo ---
done > policy.yaml
grep -c '^kind:' policy.yaml
kubectl apply -f policy.yaml
kubectl annotate namespace pruefung config.linkerd.io/default-inbound-policy=deny
kubectl -n pruefung rollout restart deploy
kubectl -n pruefung rollout restart statefulset/postgres
kubectl -n pruefung rollout status statefulset/postgres --timeout=180s
kubectl -n pruefung rollout status deploy --timeout=240s
kubectl -n pruefung run fremd --image=docker.io/curlimages/curl:8.23.0 \
  --command -- sleep 3600
kubectl -n pruefung wait --for=condition=Ready pod/fremd --timeout=90s
kubectl -n pruefung exec fremd -c fremd -- curl -s -o /dev/null -w '%{http_code}\n' \
  http://helper/get

Erwartet (gekürzt):

14
server.policy.linkerd.io/web-http created
...
authorizationpolicy.policy.linkerd.io/admin-von-prometheus created
namespace/pruefung annotated
...
pod/fremd condition met
403

Eine Minute später die Gegenprobe:

kubectl -n pruefung logs deploy/last -c last --since=40s | awk '{print $2, $3}' \
  | sort | uniq -c
kubectl -n pruefung get server -o custom-columns=NAME:.metadata.name,\
POLICY:.spec.accessPolicy
kubectl -n monitoring port-forward svc/kps-kube-prometheus-stack-prometheus 9090 \
  >/dev/null 2>&1 &
sleep 4
curl -s localhost:9090/api/v1/query \
  --data-urlencode 'query=up{job="monitoring/linkerd-proxy", namespace="pruefung"}' \
  | jq -r '.data.result[] | .metric.pod + " " + .value[1]'
kill %1

Erwartet (gekürzt, Zahlen schwanken):

     53 /api/notes 200
     20 /flaky 200
      7 /flaky 500
NAME             POLICY
helper-http      deny
notes-api-http   deny
postgres         deny
proxy-admin      deny
web-http         deny
statistik-597fcff454-2qpqf 1
helper-5798bffc7f-7bt64 1
...
postgres-0 1
fremd 1

Die Annotation am Namespace wirkt nur in neuen Pods, deshalb der Neustart (Tag 6, Drill 6). fremd hat einen Proxy und die Identität default.pruefung – keine Regel, also 403. Ein Blick in kubectl -n pruefung logs deploy/statistik zeigt schon jetzt den nächsten Fehler; das ist Aufgabe 14.

Lösung 7

Die drei Routen aus Tag 7, umgeschrieben auf pruefung. Ohne die Catch-all-Route helper-rest liefen alle anderen Pfade in ein 404 (Tag 7, Drill 3):

for f in route-retry route-rest route-delay; do
  sed 's/namespace: tag07/namespace: pruefung/' ~/linkerd/tag07/$f.yaml; echo ---
done > routes.yaml
grep -A1 'value: /unstable' routes.yaml
kubectl apply -f routes.yaml
sleep 5
kubectl -n pruefung get httproute \
  -o custom-columns=NAME:.metadata.name,STATUS:.status.parents[0].conditions[0].reason
kubectl -n pruefung exec deploy/last -c last -- \
  curl -s -o /dev/null -w '%{http_code} %{time_total}s\n' http://web/slow
kubectl -n pruefung exec deploy/last -c last -- \
  curl -s -o /dev/null -w '%{http_code}\n' http://web/

Erwartet:

    - path: {type: PathPrefix, value: /unstable}
      method: GET
httproute.gateway.networking.k8s.io/helper-unstable created
httproute.gateway.networking.k8s.io/helper-rest created
httproute.gateway.networking.k8s.io/helper-delay created
NAME              STATUS
helper-delay      Accepted
helper-rest       Accepted
helper-unstable   Accepted
504 1.044076s
200

Nach einer Minute:

kubectl -n pruefung logs deploy/last -c last --since=55s | 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 pruefung deploy/web \
  --prometheusURL=http://localhost:9090 | grep -A1 helper-unstable
kill %1

Erwartet (gekürzt, Zahlen schwanken):

     70 /api/notes 200
     36 /flaky 200
ROUTE            TYPE       BACKEND    SUCCESS   RPS  ...  TIMEOUTS  RETRIES
helper-unstable  HTTPRoute             100.00%  0.63  ...     0.00%   28.30%
└────────────────────────►  helper:80   71.70%  0.88  ...     0.00%

method: GET in der Regel schließt POST aus, der dann über helper-rest ohne Retry läuft (Tag 7, Drill 6). Cilium legt zu den Routen die EndpointSlice cilium-gateway-helper an; sie verschwindet beim Aufräumen mit dem Namespace.

Lösung 8

kubectl apply -f kaputt.yaml
kubectl -n pruefung rollout status deploy/notes-api-kaputt --timeout=120s
sleep 60
kubectl -n pruefung logs deploy/last -c last --since=50s | awk '{print $2, $3}' \
  | sort | uniq -c
linkerd viz stat -n pruefung po -l app=notes-api --from deploy/web

Erwartet (gekürzt, Zahlen schwanken):

     22 /api/notes 200
     50 /api/notes 500
     34 /flaky 200
      2 /flaky 500
NAME                                 STATUS   MESHED   SUCCESS      RPS  ...
notes-api-795f4f4468-pdvd6          Running      1/1   100.00%   0.5rps  ...
notes-api-kaputt-6d4cf657d6-h22mh   Running      1/1     0.00%   1.0rps  ...

Der kaputte Pod bekommt sogar mehr Verkehr: Er antwortet schneller, und der Load Balancer wählt nach Latenz. Er trägt die Labels und den ServiceAccount von notes-api, darum lassen ihn Server und Regel aus Aufgabe 6 herein. Failure Accrual am Service:

kubectl -n pruefung annotate service notes-api \
  balancer.linkerd.io/failure-accrual=consecutive \
  balancer.linkerd.io/failure-accrual-consecutive-max-failures=3 \
  balancer.linkerd.io/failure-accrual-consecutive-min-penalty=30s \
  balancer.linkerd.io/failure-accrual-consecutive-max-penalty=2m
sleep 75
kubectl -n pruefung logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c
linkerd viz stat -n pruefung po -l app=notes-api --from deploy/web

Erwartet (gekürzt, Zahlen schwanken):

service/notes-api annotated
     77 /api/notes 200
      1 /api/notes 500
     37 /flaky 200
      2 /flaky 500
NAME                                 STATUS   MESHED   SUCCESS      RPS  ...
notes-api-795f4f4468-pdvd6          Running      1/1   100.00%   1.4rps  ...
notes-api-kaputt-6d4cf657d6-h22mh   Running      1/1     0.00%   0.0rps  ...

Die eine 500 ist ein Probe-Request nach Ablauf der Pause (Tag 8, Drill 4). Kein Neustart, keine Änderung an web: Jeder Client-Proxy liest die Annotation am Service.

Lösung 9

kubectl -n pruefung create serviceaccount bericht
kubectl -n pruefung create deployment bericht \
  --image=docker.io/curlimages/curl:8.23.0 -- sleep infinity
kubectl -n pruefung set serviceaccount deploy/bericht bericht
kubectl -n pruefung rollout status deploy/bericht --timeout=120s
kubectl -n pruefung exec deploy/bericht -c curl -- sh -c 'for i in $(seq 20); do
  curl -s -o /dev/null -w "%{http_code}\n" http://helper/get; done' | sort | uniq -c

Erwartet (gekürzt):

deployment "bericht" successfully rolled out
     20 403

Erst die Erlaubnis (Default-Deny), dann die Bremse. Ein Rate Limit hängt an einem Server – hier am vorhandenen helper-http:

cat > bericht.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: MeshTLSAuthentication
metadata: {name: bericht, namespace: pruefung}
spec:
  identityRefs: [{kind: ServiceAccount, name: bericht}]
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata: {name: helper-von-bericht, namespace: pruefung}
spec:
  targetRef: {group: policy.linkerd.io, kind: Server, name: helper-http}
  requiredAuthenticationRefs:
  - {group: policy.linkerd.io, kind: MeshTLSAuthentication, name: bericht}
---
apiVersion: policy.linkerd.io/v1alpha1
kind: HTTPLocalRateLimitPolicy
metadata: {name: helper-rl, namespace: pruefung}
spec:
  targetRef: {group: policy.linkerd.io, kind: Server, name: helper-http}
  total:
    requestsPerSecond: 50
  identity:
    requestsPerSecond: 2
  overrides:
  - requestsPerSecond: 20
    clientRefs:
    - {kind: ServiceAccount, name: web}
EOF
kubectl apply -f bericht.yaml
sleep 10
kubectl -n pruefung exec deploy/bericht -c curl -- sh -c 'for i in $(seq 40); do
  curl -s -o /dev/null -w "%{http_code}\n" http://helper/get; done' | sort | uniq -c
kubectl -n pruefung get httplocalratelimitpolicy
sleep 30
kubectl -n pruefung logs deploy/last -c last --since=40s | awk '{print $2, $3}' \
  | sort | uniq -c
linkerd diagnostics proxy-metrics -n pruefung deploy/helper \
  | grep '^inbound_http_local_ratelimit' \
  | grep -oE 'ratelimit_scope="[^"]*"|client_id="[a-z]+|\} [0-9]+' | paste - - -

Erwartet (Zahlen schwanken):

      9 200
     31 429
NAME        TARGET_KIND   TARGET_NAME   TOTAL_RPS   IDENTITY_RPS
helper-rl   Server        helper-http   50          2
     53 /api/notes 200
      1 /api/notes 500
     27 /flaky 200
ratelimit_scope="identity"  client_id="bericht  } 31

Alle 429 entfallen auf bericht im Scope identity. total steht bewusst hoch: Auch abgelehnte Requests verbrauchen den gemeinsamen Topf und träfen sonst web (Tag 8, Drill 6). Die eine 500 auf /api/notes ist wieder der Probe-Request aus Aufgabe 8.

Lösung 10

helper-v2 hat ein eigenes Label – der Service helper wählt ihn also nicht, und der Server helper-http deckt ihn nicht ab. Unter Default-Deny braucht er einen eigenen Server mit Regel, sonst bekäme web dort 403:

cat > helper-v2.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: helper-v2, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: helper-v2}}
  template:
    metadata: {labels: {app: helper-v2}}
    spec:
      serviceAccountName: helper
      containers:
      - name: helper
        image: ghcr.io/mccutchen/go-httpbin:2.26.0
        ports: [{containerPort: 8080, name: http}]
        readinessProbe:
          httpGet: {path: /status/200, port: http}
---
apiVersion: v1
kind: Service
metadata: {name: helper-v2, namespace: pruefung}
spec:
  selector: {app: helper-v2}
  ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: policy.linkerd.io/v1beta3
kind: Server
metadata: {name: helper-v2-http, namespace: pruefung}
spec:
  podSelector: {matchLabels: {app: helper-v2}}
  port: http
  proxyProtocol: HTTP/1
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata: {name: helper-v2-von-web, namespace: pruefung}
spec:
  targetRef: {group: policy.linkerd.io, kind: Server, name: helper-v2-http}
  requiredAuthenticationRefs:
  - {group: policy.linkerd.io, kind: MeshTLSAuthentication, name: web}
EOF
kubectl apply -f helper-v2.yaml
kubectl -n pruefung rollout status deploy/helper-v2 --timeout=120s

Die Gewichte kommen in die bestehenden Routen helper-unstable und helper-rest. Eine zweite Route nur für den Canary würde mit ihnen um dieselben Pfade konkurrieren:

B='[{"name":"helper","port":80,"weight":80},{"name":"helper-v2","port":80,"weight":20}]'
for r in helper-unstable helper-rest; do
  kubectl -n pruefung patch httproute $r --type=json \
    -p "[{\"op\":\"add\",\"path\":\"/spec/rules/0/backendRefs\",\"value\":$B}]"
done
sleep 70
kubectl -n pruefung logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c
linkerd viz stat -n pruefung deploy --from deploy/web

Erwartet (gekürzt, Zahlen schwanken):

httproute.gateway.networking.k8s.io/helper-unstable patched
httproute.gateway.networking.k8s.io/helper-rest patched
     77 /api/notes 200
      1 /api/notes 500
     39 /flaky 200
NAME               MESHED   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   ...
helper                1/1    71.43%   0.8rps          15ms         170ms   ...
helper-v2             1/1    53.33%   0.2rps          25ms         185ms   ...
notes-api             1/1   100.00%   1.4rps          12ms          43ms   ...
notes-api-kaputt      1/1     0.00%   0.0rps           0ms           0ms   ...

0,8 zu 0,2 – genau 80/20, und /flaky bleibt dank Retries bei fast 100 Prozent. linkerd viz stat-outbound zeigt unter der Route helper-unstable jetzt zwei Backends, helper:80 und helper-v2:80; direkt nach einem Neustart von web schwanken die Anteile dort stark, warte eine Minute. helper-delay bleibt unverändert, so wie die Aufgabe es für /delay verlangt.

Lösung 11

cat > gateway.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata: {name: pruefung, namespace: pruefung}
spec:
  gatewayClassName: cilium
  listeners:
  - {name: http, protocol: HTTP, port: 80}
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: {name: web, namespace: pruefung}
spec:
  parentRefs:
  - {name: pruefung}
  hostnames: [pruefung.lab.internal]
  rules:
  - backendRefs:
    - {name: web, port: 80}
EOF
kubectl apply -f gateway.yaml
sleep 15
NP=$(kubectl -n pruefung get svc cilium-gateway-pruefung \
  -o jsonpath='{.spec.ports[?(@.port==80)].nodePort}')
echo $NP
curl -s -o /dev/null -w '%{http_code}\n' -H 'Host: pruefung.lab.internal' \
  http://172.16.0.126:$NP/api/notes
kubectl get ciliumnodes \
  -o jsonpath='{range .items[*]}{.metadata.name} {.spec.ingress.ipv4}{"\n"}{end}'

Erwartet:

gateway.gateway.networking.k8s.io/pruefung created
httproute.gateway.networking.k8s.io/web created
30555
403
cp1 10.0.0.235
worker1 10.0.1.169
worker2 10.0.2.57

403: Der Server web-http lässt nur last herein, und Ciliums Envoy kommt ohne Identität von den Ingress-IPs der Nodes (Tag 10, Drill 4). Genau diese drei Adressen erlaubst du (bei dir andere IPs):

cat > ingress-authz.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: NetworkAuthentication
metadata: {name: cilium-ingress, namespace: pruefung}
spec:
  networks:
  - cidr: 10.0.0.235/32
  - cidr: 10.0.1.169/32
  - cidr: 10.0.2.57/32
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata: {name: web-von-gateway, namespace: pruefung}
spec:
  targetRef: {group: policy.linkerd.io, kind: Server, name: web-http}
  requiredAuthenticationRefs:
  - {group: policy.linkerd.io, kind: NetworkAuthentication, name: cilium-ingress}
EOF
kubectl apply -f ingress-authz.yaml
sleep 5
for h in 172.16.0.126 172.16.0.228 172.16.0.83; do
  curl -s -o /dev/null -w "$h %{http_code}\n" -H 'Host: pruefung.lab.internal' \
    http://$h:$NP/api/notes
done
kubectl -n pruefung run ohne --image=docker.io/curlimages/curl:8.23.0 \
  --restart=Never --annotations=linkerd.io/inject=disabled --command -- sleep 3600
kubectl -n pruefung wait --for=condition=Ready pod/ohne --timeout=60s
kubectl -n pruefung exec ohne -- curl -s -o /dev/null -w '%{http_code}\n' \
  http://web/api/notes

Erwartet:

networkauthentication.policy.linkerd.io/cilium-ingress created
authorizationpolicy.policy.linkerd.io/web-von-gateway created
172.16.0.126 200
172.16.0.228 200
172.16.0.83 200
pod/ohne created
pod/ohne condition met
403

Jeder Node nimmt den NodePort an und schickt von seiner eigenen Ingress-IP weiter – darum alle drei. ohne hat eine Pod-IP aus dem Pod-Netz und bleibt draußen.

Lösung 12

kubectl -n pruefung exec deploy/last -c last -- curl -s http://web/api/upstream; echo
cat > egress.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: EgressNetwork
metadata: {name: internet, namespace: pruefung}
spec:
  trafficPolicy: Deny
---
apiVersion: gateway.networking.k8s.io/v1
kind: TLSRoute
metadata: {name: example-com, namespace: pruefung}
spec:
  parentRefs:
  - {group: policy.linkerd.io, kind: EgressNetwork, name: internet, port: 443}
  hostnames: [example.com]
  rules:
  - backendRefs:
    - {group: policy.linkerd.io, kind: EgressNetwork, name: internet}
EOF
kubectl apply -f egress.yaml
sleep 5
kubectl -n pruefung exec deploy/last -c last -- \
  curl -s -o /dev/null -w '%{http_code}\n' https://linkerd.io
kubectl -n pruefung exec deploy/last -c last -- \
  curl -s -o /dev/null -w '%{http_code}\n' https://example.com
kubectl -n pruefung exec deploy/last -c last -- \
  curl -s -o /dev/null -w '%{http_code}\n' http://example.com

Erwartet:

{"status":200,"url":"https://example.com"}
egressnetwork.policy.linkerd.io/internet created
tlsroute.gateway.networking.k8s.io/example-com created
000
command terminated with exit code 35
200
403

HTTP beantwortet der Proxy mit 403, HTTPS bricht er im Handshake ab (Exit-Code 35). Jetzt die frischen Verbindungen: notes-api hält seine Verbindung zu example.com per Keep-Alive offen, und eine Policy wirkt nur auf neue Verbindungen (Tag 11, Drill 3):

kubectl -n pruefung rollout restart deploy/notes-api
kubectl -n pruefung rollout status deploy/notes-api
kubectl -n pruefung exec deploy/last -c last -- curl -s http://web/api/upstream; echo

Erwartet:

deployment.apps/notes-api restarted
deployment "notes-api" successfully rolled out
{"status":200,"url":"https://example.com"}

Mit neuem Pod und neuer Verbindung kommt notes-api weiter durch – der Beleg, dass die TLSRoute greift und nicht nur eine alte Verbindung. Gegenprobe ohne Route wäre connection reset by peer.

Lösung 13

Tag 13 hat beim Aufräumen den Link und den Controller controller-west gelöscht. Die Werte der Extension auf ost enthalten ihn aber noch – erneut anwenden legt nur die fehlenden Teile an:

linkerd --context ost multicluster install -f ~/linkerd/tag12/mc-ost-gw.yaml \
  > mc-ost.yaml
kubectl --context ost apply -f mc-ost.yaml | grep -v unchanged
linkerd --context west multicluster link-gen --cluster-name west > link-west.yaml
grep -E '^kind:|gatewayAddress|gatewayPort' link-west.yaml
kubectl --context ost apply -f link-west.yaml
kubectl --context ost -n linkerd-multicluster rollout status deploy/controller-west \
  --timeout=120s

Erwartet (gekürzt):

deployment.apps/controller-west created
service/probe-west created
serviceaccount/controller-west created
...
kind: Secret
kind: Secret
kind: Link
  gatewayAddress: 172.16.0.182
  gatewayPort: "4143"
secret/cluster-credentials-west created
secret/cluster-credentials-west created
link.multicluster.linkerd.io/west created
deployment "controller-west" successfully rolled out

link-gen läuft auch gegen das Helm-verwaltete west unverändert (Tag 15). Vorher kubectl diff -f mc-ost.yaml zeigt: Nur die Objekte für den Controller kommen dazu. Jetzt der Dienst in west – der Namespace pruefung existiert in ost schon:

kubectl --context west create namespace pruefung
kubectl --context west annotate namespace pruefung linkerd.io/inject=enabled
kubectl --context west -n pruefung create deployment helper \
  --image=ghcr.io/mccutchen/go-httpbin:2.26.0 --port=8080
kubectl --context west -n pruefung set env deploy/helper USE_REAL_HOSTNAME=true
kubectl --context west -n pruefung expose deploy helper --port=80 --target-port=8080
kubectl --context west -n pruefung rollout status deploy/helper --timeout=120s
kubectl --context west -n pruefung label service helper mirror.linkerd.io/exported=true
sleep 60
kubectl --context ost -n pruefung get svc helper-west
linkerd --context ost multicluster gateways
kubectl --context ost -n pruefung exec deploy/last -c last -- \
  curl -s http://helper-west/hostname

Erwartet (gekürzt):

service/helper labeled
NAME          TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
helper-west   ClusterIP   10.103.87.18   <none>        80/TCP    40s
CLUSTER  ALIVE    NUM_SVC      LATENCY
west     True           1         60ms
{
  "hostname": "helper-74b8b7dccf-dbxlc"
}

Achtung: Der neue controller-west wartet zunächst rund 30 Sekunden im Log auf Attempting to acquire leader lease – die Lease seines Vorgängers aus Tag 12 liegt noch in linkerd-multicluster. Erst danach spiegelt er. Wer sofort nachsieht, findet helper-west noch nicht.

Wer kommt in west an?

linkerd --context west diagnostics proxy-metrics -n linkerd-multicluster \
  deploy/linkerd-gateway \
  | grep '^tcp_open_total{direction="inbound",peer="src"' \
  | grep -oE '(target_port|client_id|no_tls_reason)="[^"]*"|[0-9]+$' | paste - - -
linkerd --context ost multicluster check 2>&1 | grep -A1 'trust anchors'

Erwartet (gekürzt):

target_port="4191"  no_tls_reason="no_tls_from_remote"                       888
target_port="4191"  client_id="controller-west.linkerd-multicluster.servic…"  1
target_port="4143"  client_id="last.pruefung.serviceaccount.identity.linke…"  1
√ clusters share trust anchors
    * west

Port 4143 ist der Tunnel: last aus ost mit voller Identität. Der Check vergleicht den Anchor aus linkerd-config beider Cluster – grün, weil values-west.yaml aus Tag 14 ihn als identityTrustAnchorsPEM mitbringt.

Achtung: Hast du in Tag 14 die Zeile identityTrustAnchorsPEM weggelassen, meldet der Check hier × clusters share trust anchors mit Problematic clusters: * west. Mit identity.externalCA=true steht dann in linkerd-config von west identityTrustAnchorsPEM: "", der Anchor liegt nur in der ConfigMap. Der Fingerprint-Vergleich aus Tag 12, Drill 4 zeigt trotzdem zweimal 8b44a80f…bab81, und der mTLS-Aufruf oben funktioniert – ein Fehlalarm. Die Abhilfe (Zeile ergänzen, helm upgrade mit den Values-Dateien) ist in der Prüfung nicht verlangt.

Lösung 14

Erst das Symptom, dann die Sicht von Postgres:

kubectl -n pruefung logs deploy/statistik -c statistik --tail=3 | cut -c1-80
kubectl -n pruefung logs postgres-0 -c linkerd-proxy --since=1m \
  | grep 'Connection denied' | tail -1 \
  | grep -oE 'server.name=[^ ]*|tls=[^ ]*|client=[^ ]*'
kubectl -n pruefung get pod -l app=statistik -o wide | awk '{print $1, $6}'
kubectl -n pruefung get deploy statistik \
  -o jsonpath='{.spec.template.metadata.annotations}{"\n"}' | cut -c1-80

Erwartet (gekürzt):

21:39:34 psql: error: connection to server at "postgres" (10.100.217.87), port 543
    This probably means the server terminated abnormally
    before or while processing the request.
server.name=postgres
tls=None(PortSkipped)
client=10.0.2.173:56718
NAME IP
statistik-597fcff454-2qpqf 10.0.2.173
{"config.linkerd.io/skip-outbound-ports":"5432","kubectl.kubernetes.io/restartedAt

PortSkipped von der IP des statistik-Pods: Der Proxy von statistik lässt Port 5432 aus, psql spricht Klartext am Mesh vorbei (Tag 16, Drill 5). Vor Aufgabe 6 wurde das angenommen – das waren die Klartext-Verbindungen aus Aufgabe 3. Fehler eins:

kubectl -n pruefung patch deploy statistik --type=json -p '[{"op":"remove",
  "path":"/spec/template/metadata/annotations/config.linkerd.io~1skip-outbound-ports"}]'
kubectl -n pruefung rollout status deploy/statistik --timeout=120s
sleep 25
kubectl -n pruefung logs deploy/statistik -c statistik --tail=1
kubectl -n pruefung logs postgres-0 -c linkerd-proxy --since=20s \
  | grep 'Connection denied' | tail -1 | grep -oE 'server.name=[^ ]*|Name\("[^"]*'

Erwartet (gekürzt):

deployment "statistik" successfully rolled out
    before or while processing the request.
server.name=postgres
Name("statistik.pruefung.serviceaccount.identity.linkerd.cluster.local

Jetzt kommt statistik mit mTLS und eigener Identität – und wird trotzdem abgelehnt. Fehler zwei: Die Regel postgres-von-notes-api kennt nur notes-api. Eine eigene Regel für statistik, ohne die bestehende anzufassen:

cat > statistik-authz.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: MeshTLSAuthentication
metadata: {name: statistik, namespace: pruefung}
spec:
  identityRefs: [{kind: ServiceAccount, name: statistik}]
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata: {name: postgres-von-statistik, namespace: pruefung}
spec:
  targetRef: {group: policy.linkerd.io, kind: Server, name: postgres}
  requiredAuthenticationRefs:
  - {group: policy.linkerd.io, kind: MeshTLSAuthentication, name: statistik}
EOF
kubectl apply -f statistik-authz.yaml
sleep 25
kubectl -n pruefung logs deploy/statistik -c statistik --tail=2
linkerd diagnostics proxy-metrics -n pruefung po/postgres-0 \
  | grep '^inbound_tcp_authz_allow_total' \
  | grep -oE '(authz_name|client_id)="[^"]*"|\} [0-9]+' | paste - - -

Erwartet (gekürzt):

meshtlsauthentication.policy.linkerd.io/statistik created
authorizationpolicy.policy.linkerd.io/postgres-von-statistik created
21:40:46 0
21:40:56 0
authz_name="postgres-von-statistik"  client_id="statistik.pruefung.serviceac…"  } 3
authz_name="postgres-von-notes-api"  client_id="notes-api.pruefung.serviceac…"  } 8

Wer nur die Annotation entfernt oder nur die Regel anlegt, bekommt keine Punkte – erst beides zusammen bringt statistik zurück. Postgres in pruefung per NetworkAuthentication für das Pod-Netz zu öffnen, wäre die verbotene Abkürzung.

Lösung 15

helm --kube-context west list -n linkerd -o json | jq -r \
  '.[] | select(.name=="linkerd-control-plane") | .chart + " " + .revision' > 15.txt
helm --kube-context west get values linkerd-control-plane -n linkerd --all \
  | grep -E '^(controllerReplicas|webhookFailurePolicy):' >> 15.txt
kubectl --context west -n linkerd get deploy linkerd-destination \
  -o jsonpath='{.status.readyReplicas}{"\n"}' >> 15.txt
cat 15.txt

Erwartet:

linkerd-control-plane-2026.11.2 5
controllerReplicas: 2
webhookFailurePolicy: Fail
2

Revision 5 nach Installation, Anti-Affinity-Korrektur, Upgrade, Rollback und erneutem Upgrade (Tag 14 und 15). Ohne --all stünde webhookFailurePolicy nur da, weil es in values-ha.yaml gesetzt ist – --all zeigt den wirksamen Wert, egal woher er kommt.

Lösung 16

kubectl -n pruefung get pod -l app=web -o jsonpath='{.items[0].status.qosClass}{"\n"}'
kubectl -n pruefung patch deploy web -p '{"spec":{"template":{"metadata":{
  "annotations":{"config.linkerd.io/proxy-cpu-request":"50m",
  "config.linkerd.io/proxy-memory-request":"32Mi",
  "config.linkerd.io/proxy-memory-limit":"128Mi"}}}}}'
kubectl -n pruefung rollout status deploy/web --timeout=120s
kubectl -n pruefung get pod -l app=web -o \
  jsonpath='{.items[0].spec.initContainers[?(@.name=="linkerd-proxy")].resources}'
echo
kubectl -n pruefung get pod -l app=web -o jsonpath='{.items[0].status.qosClass}{"\n"}'

Erwartet:

BestEffort
deployment.apps/web patched
deployment "web" successfully rolled out
{"limits":{"memory":"128Mi"},"requests":{"cpu":"50m","memory":"32Mi"}}
Burstable

Ohne Annotation hat der Proxy keine Ressourcen, und der ganze Pod ist BestEffort – auf vollen Workern zuerst benachteiligt (Tag 17). Der Proxy ist ein nativer Sidecar, darum steht er unter initContainers. Ein CPU-Limit hast du bewusst nicht gesetzt: Es würde auch die Zahl der Worker-Threads des Proxys festlegen (Tag 17, Drill 8).

Auswertung

Zähle die Gewichte der Aufgaben, die vollständig und nachweisbar gelöst sind – Teilpunkte gibt es nicht. Wer eine Vorgabe umgeht, bekommt für die Aufgabe null: Default-Deny abschalten oder accessPolicy: all-unauthenticated, das Pod-Netz für web oder postgres freigeben, den kaputten Pod löschen, trafficPolicy: Allow, linkerd upgrade oder helm upgrade.

Ergebnis Einschätzung
85–100 % sicher im Betrieb – vom ersten Proxy bis zum zweiten Cluster
70–84 % das Handwerk sitzt; Schwachstellen gezielt wiederholen
unter 70 % die Tage zu den verfehlten Aufgaben wiederholen und neu starten
Aufgaben Bereich Tage
1–3 Installation, Injection, mTLS (18 %) 1–3
4–5 Beobachten und Zertifikate (11 %) 4, 5
6, 14 Autorisierung und Fehlersuche (15 %) 6, 16
7–10 Retries, Circuit Breaking, Rate Limit, Canary (26 %) 7–9
11–12 Ingress und Egress (13 %) 10, 11
13, 15 Multicluster und Helm (12 %) 12–15
16 Proxy-Ressourcen (5 %) 17

Nicht abgefragt: Rotation des Trust Anchors (Tag 5), föderierte Dienste und Clusterausfall (Tag 13), Upgrade und Rollback (Tag 15) – sie verändern den ganzen Cluster und passen nicht in eine Prüfung neben laufenden Diensten. Geh diese Tage zum Abschluss noch einmal durch.

Aufräumen

Zuerst der Export und der Link, dann die Namespaces. Seit Linkerd 2.18 gibt es kein multicluster unlink, du entfernst die Teile einzeln wie in Tag 13:

kubectl --context west -n pruefung label service helper mirror.linkerd.io/exported-
kubectl --context ost get svc -A -l mirror.linkerd.io/mirrored-service=true
kubectl --context ost -n linkerd-multicluster delete link west
kubectl --context ost delete -l mirror.linkerd.io/cluster-name=west -f mc-ost.yaml
kubectl --context ost -n linkerd-multicluster delete secret cluster-credentials-west
kubectl --context ost -n linkerd delete secret cluster-credentials-west
rm link-west.yaml

Erwartet (gekürzt):

service/helper unlabeled
No resources found
link.multicluster.linkerd.io "west" deleted from linkerd-multicluster namespace
deployment.apps "controller-west" deleted from linkerd-multicluster namespace
service "probe-west" deleted from linkerd-multicluster namespace
...
secret "cluster-credentials-west" deleted from linkerd namespace

link-west.yaml enthält Zugangsdaten zur API von west – sie gehört nicht in einen Arbeitsordner. Dann die Namespaces:

kubectl get endpointslices -A | grep cilium-gateway
kubectl --context west delete namespace pruefung
kubectl delete namespace pruefung --timeout=180s
kubectl get endpointslices -A | grep cilium-gateway | grep -c pruefung

Erwartet (gekürzt):

pruefung   cilium-gateway-helper     IPv4   9999   192.192.192.192   13m
pruefung   cilium-gateway-pruefung   IPv4   9999   192.192.192.192   6m20s
namespace "pruefung" deleted
namespace "pruefung" deleted
0

Mit dem Namespace verschwinden Routen, Gateway, Policies, EgressNetwork, PVC und beide EndpointSlices von Cilium – auch cilium-gateway-helper, die beim Löschen einer einzelnen Route liegen geblieben wäre (Tag 9, Drill 7). Die Dateien in ~/linkerd/pruefung bleiben als Vorlage.

Kontrollpunkt

kubectl get ns | grep -c pruefung
kubectl --context west get ns | grep -c pruefung
kubectl get pv | grep -c pruefung
kubectl get links -A

Erwartet: dreimal 0, dann No resources found – kein Link aktiv, wie nach Tag 13.

linkerd --context ost multicluster check 2>&1 | tail -1
linkerd --context ost multicluster gateways

Erwartet:

Status check results are √
CLUSTER  ALIVE    NUM_SVC      LATENCY

Ohne Link prüft der Check keine Trust Anchors mehr – auch nicht den Fehlalarm aus Lösung 13, falls du ihn hattest.

kubectl -n notes get pods
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): alle acht Pods 2/2 Running, dann

     85 /api/notes 200
     31 /flaky 200
     12 /flaky 500
Status check results are √

notes hat von der ganzen Prüfung nichts gemerkt. Damit ist das Trainingslager geschafft.