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 explainund deine eigenen Dateien unter~/linkerd/tagNNals Vorlage. Nicht erlaubt: dieses Buch während der Zeit. - Alles läuft auf
cp1im Namespacepruefung, Dateien in~/linkerd/pruefung. Aufgabe 13 und 15 sprechen zusätzlichwestan (--context west). notesfasst du nicht an. Keine clusterweiten Änderungen: keinlinkerd upgrade, keinhelm 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=240sFü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}}]
EOFNach 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=2Erwartet (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.txtErwartet:
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 deployErwartet (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.txtErwartet (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.txtErwartet (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/getErwartet (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 %1Erwartet (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 %1Erwartet (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/webErwartet (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/webErwartet (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 -cErwartet (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=120sDie 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/webErwartet (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/notesErwartet:
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.comErwartet:
{"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; echoErwartet:
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=120sErwartet (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/hostnameErwartet (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-westwartet zunächst rund 30 Sekunden im Log aufAttempting to acquire leader lease– die Lease seines Vorgängers aus Tag 12 liegt noch inlinkerd-multicluster. Erst danach spiegelt er. Wer sofort nachsieht, findethelper-westnoch 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
identityTrustAnchorsPEMweggelassen, meldet der Check hier× clusters share trust anchorsmitProblematic clusters: * west. Mitidentity.externalCA=truesteht dann inlinkerd-configvonwestidentityTrustAnchorsPEM: "", der Anchor liegt nur in der ConfigMap. Der Fingerprint-Vergleich aus Tag 12, Drill 4 zeigt trotzdem zweimal8b44a80f…bab81, und der mTLS-Aufruf oben funktioniert – ein Fehlalarm. Die Abhilfe (Zeile ergänzen,helm upgrademit 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-80Erwartet (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.txtErwartet:
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.yamlErwartet (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 pruefungErwartet (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 -AErwartet: 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 gatewaysErwartet:
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 -1Erwartet (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.