Tag 2: Pods ins Mesh holen
Ziel: Die ganze App läuft mit Linkerd-Proxy, jeder Dienst hat eine eigene Identität und du weißt, wann ein Container am Mesh vorbeiläuft. · Dauer: ca. 60 min · Voraussetzung: Tag 1
Briefing
- Der Proxy kommt per Webhook in den Pod, beim Anlegen. Laufende Pods ändern sich nicht – du musst sie neu starten.
- Gesteuert wird mit der Annotation
linkerd.io/injectam Namespace oder am Pod-Template. Die Pod-Annotation gewinnt. - Die Identität eines Proxys ist sein ServiceAccount.
Teilen sich alle Dienste
default, kann Linkerd sie später nicht unterscheiden. - Protokolle, bei denen die Erkennung nicht entscheiden kann, wie Postgres oder MySQL, brauchen Opaque Ports.
Pod notes-api
┌──────────────────────────────────────────────────────┐
│ init: linkerd-init iptables: alles über den Proxy │
│ init: linkerd-proxy nativer Sidecar, läuft weiter │
│ init: migrate spricht schon durch den Proxy │
│ notes-api die App │
└──────────────────────────────────────────────────────┘
Drill 1: Den Namespace markieren
mkdir -p ~/linkerd/tag02 && cd ~/linkerd/tag02
kubectl annotate namespace notes linkerd.io/inject=enabled
kubectl -n notes get podsErwartet (gekürzt):
namespace/notes annotated
NAME READY STATUS RESTARTS AGE
helper-564786ddcd-2dxzp 1/1 Running 0 3h50m
...
web-84fb8799ff-nl4jl 1/1 Running 0 3h47m
Nichts passiert: Der Webhook greift nur bei neuen Pods. Also neu starten:
kubectl -n notes rollout restart deploy/notes-api deploy/helper deploy/web deploy/last
kubectl -n notes rollout restart statefulset/postgres
kubectl -n notes rollout status deploy/notes-api --timeout=180s
kubectl -n notes rollout status statefulset/postgres --timeout=180s
kubectl -n notes get podsErwartet (gekürzt):
NAME READY STATUS RESTARTS AGE
helper-54d9fbb894-4dhxf 2/2 Running 0 13s
helper-54d9fbb894-7mwbz 2/2 Running 0 25s
last-5d56df4dc9-j7fn4 2/2 Running 0 25s
notes-api-745cf7dd7c-d778n 2/2 Running 0 25s
notes-api-745cf7dd7c-m9fl8 2/2 Running 0 10s
postgres-0 2/2 Running 0 24s
web-85577d96fd-5q5zk 2/2 Running 0 25s
web-85577d96fd-ptnnm 2/2 Running 0 13s
2/2: App plus Proxy. Der Proxy zählt als Container,
obwohl er technisch ein Init-Container mit Dauerbetrieb ist.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Was der Webhook geändert hat
kubectl -n notes get pod -l app=notes-api \
-o jsonpath='{.items[0].spec.initContainers[*].name}{"\n"}'
kubectl -n notes get pod -l app=notes-api \
-o jsonpath='{.items[0].spec.initContainers[*].restartPolicy}{"\n"}'
kubectl -n notes get pod -l app=notes-api \
-o jsonpath='{.items[0].metadata.annotations}' \
| tr ',' '\n' | grep linkerd
kubectl -n notes logs deploy/notes-api -c migrate | tail -1Erwartet (gekürzt):
linkerd-init linkerd-proxy migrate
Always
"linkerd.io/created-by":"linkerd/proxy-injector edge-26.11.2"
"linkerd.io/inject":"enabled"
"linkerd.io/proxy-version":"edge-26.11.2"
"linkerd.io/trust-root-sha256":"1f3f4f01141d3508be8970d5ecc349ff3a2381b5805f4e..."
time=2026-11-19T15:06:23.635Z level=INFO msg="migration complete" table=notes
Die Reihenfolge ist wichtig: linkerd-init setzt die
iptables-Regeln, dann startet der Proxy als nativer Sidecar,
dann erst dein Init-Container migrate.
Seine Verbindung zu Postgres läuft deshalb schon durch das Mesh.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Ohne nativen Sidecar
Ältere Linkerd-Versionen und Cluster ohne native Sidecars kennen das anders. Du kannst das alte Verhalten pro Pod einschalten:
kubectl create namespace tag02
kubectl annotate namespace tag02 linkerd.io/inject=enabled
kubectl -n tag02 create secret generic notes-db --from-literal=url=\
'postgres://notes:[email protected]:5432/notes?sslmode=disable'
cat > migrate-alt.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: migrate-alt, namespace: tag02}
spec:
replicas: 1
selector: {matchLabels: {app: migrate-alt}}
template:
metadata:
labels: {app: migrate-alt}
annotations:
config.beta.linkerd.io/proxy-enable-native-sidecar: "false"
spec:
initContainers:
- name: migrate
image: ghcr.io/thomaszachmann/notes-api:0.7.1
args: [migrate]
env:
- name: NOTES_DB_URL
valueFrom: {secretKeyRef: {name: notes-db, key: url}}
containers:
- name: pause
image: registry.k8s.io/pause:3.10
EOF
kubectl apply -f migrate-alt.yaml
sleep 30
P=$(kubectl -n tag02 get pod -l app=migrate-alt -o name)
kubectl -n tag02 get $P -o jsonpath='{.spec.initContainers[*].name}{"\n"}'
kubectl -n tag02 logs $P -c migrate --tail=1Erwartet:
migrate linkerd-init
time=2026-11-19T15:06:55.244Z level=INFO msg="migration complete" table=notes
migrate läuft jetzt vor
linkerd-init, der Proxy ist ein normaler Container und
startet erst danach. migrate läuft also ganz ohne Proxy:
unverschlüsselt und ohne Identität. Heute klappt das. Sobald Postgres an
Tag 6 nur noch Verbindungen aus dem Mesh annimmt, scheitert genau dieser
Container. Bleib bei nativen Sidecars.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Opaque Ports
linkerd check --proxy -n notesErwartet (gekürzt):
linkerd-data-plane
------------------
√ data plane namespace exists
√ data plane proxies are ready
...
‼ opaque ports are properly annotated
* service postgres targets the opaque port postgres through 5432; add 5432 to its
config.linkerd.io/opaque-ports annotation
Bei Postgres schickt der Client nur eine kurze Startnachricht und wartet dann auf den Server. Daran erkennt der Proxy kein Protokoll und wartet bis zum Timeout von 10 Sekunden. Auf einem Opaque Port behandelt er die Verbindung sofort als TCP-Strom. Für Port 5432 weiß Linkerd das schon:
kubectl -n linkerd get configmap linkerd-config -o yaml | grep -o 'opaquePorts:.*'Erwartet:
opaquePorts: 25,587,3306,4444,5432,6379,9300,11211
Der Service verweist aber auf den benannten Port
postgres. linkerd check verlangt die
Annotation trotzdem am Service – also explizit annotieren:
kubectl -n notes annotate service postgres config.linkerd.io/opaque-ports=5432
linkerd check --proxy -n notes 2>&1 | grep -A2 opaqueErwartet:
√ opaque ports are properly annotated
Status check results are √
Fortschritt speichern? Kostenlos registrieren
Drill 5: Eine Identität pro Dienst
kubectl -n notes logs deploy/web -c linkerd-proxy | grep -E 'release|identity'Erwartet (gekürzt):
INFO ThreadId(01) linkerd2_proxy: release 2.374.0 (16d3717) by linkerd on 2026-11-11...
INFO ThreadId(01) linkerd2_proxy: SNI is default.notes.serviceaccount.identity.link...
INFO ThreadId(01) linkerd2_proxy: Local identity is default.notes.serviceaccount.ide...
Alle Dienste heißen default.notes – Linkerd kann
web nicht von helper unterscheiden. Jeder
Dienst bekommt deshalb seinen eigenen ServiceAccount:
for a in web notes-api helper last postgres; do
kubectl -n notes create serviceaccount $a
done
for d in web notes-api helper last; do
kubectl -n notes set serviceaccount deploy/$d $d
done
kubectl -n notes set serviceaccount statefulset/postgres postgres
kubectl -n notes rollout status deploy/web --timeout=180s
kubectl -n notes rollout status statefulset/postgres --timeout=180s
kubectl -n notes logs deploy/web -c linkerd-proxy | grep 'Local identity'Erwartet (gekürzt):
INFO ThreadId(01) linkerd2_proxy: Local identity is web.notes.serviceaccount.identity...
Achtung: Ab jetzt nicht mehr die Manifeste aus
~/linkerd/tag00anwenden – sie kennen die ServiceAccounts nicht.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Von Hand injizieren und ausnehmen
Die CLI kann ein Manifest vorbereiten. Ohne Option setzt sie nur die
Annotation, mit --manual schreibt sie den Proxy direkt
hinein:
kubectl -n tag02 create deployment plain --image=registry.k8s.io/pause:3.10 \
--dry-run=client -o yaml > plain.yaml
linkerd inject plain.yaml | grep -A2 'annotations'
linkerd inject --manual plain.yaml | grep -E 'name: linkerd-(init|proxy)$'Erwartet:
deployment "plain" injected
annotations:
linkerd.io/inject: enabled
labels:
deployment "plain" injected
name: linkerd-init
name: linkerd-proxy
Der Weg über die Annotation ist besser: Bei Upgrades bekommt der Pod beim nächsten Neustart den neuen Proxy, ohne dass du Manifeste neu erzeugst.
Ausnehmen geht pro Pod:
kubectl -n tag02 create deployment ohne --image=registry.k8s.io/pause:3.10
kubectl -n tag02 patch deploy ohne -p \
'{"spec":{"template":{"metadata":{"annotations":{"linkerd.io/inject":"disabled"}}}}}'
kubectl -n tag02 rollout status deploy/ohne
kubectl -n tag02 get pods -l app=ohneErwartet:
NAME READY STATUS RESTARTS AGE
ohne-58b54f56-fs5bd 1/1 Running 0 15s
Fortschritt speichern? Kostenlos registrieren
Drill 7: Hat das Mesh etwas verändert?
sleep 60
kubectl -n notes logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
| sort | uniq -cErwartet (Zahlen schwanken):
92 /api/notes 200
29 /flaky 200
17 /flaky 500
Gleiche Fehlerquote wie an Tag 0. Linkerd ändert nichts am Verhalten,
solange du nichts konfigurierst. Beachte -c last: Der Pod
hat jetzt zwei Container.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeig, welche Pods in
noteseinen Proxy haben. Zeitziel: 30 s - Zeig die Proxy-Version in
notes. Zeitziel: 20 s - Zeig die ersten Logzeilen des Proxys von
helper. Zeitziel: 20 s - Zeig, welche Namespaces wie annotiert sind. Zeitziel: 40 s
Lösung
kubectl -n notes get pods -o custom-columns=\
NAME:.metadata.name,PROXY:.metadata.annotations.linkerd\\.io/proxy-version
linkerd version --proxy -n notes
kubectl -n notes logs deploy/helper -c linkerd-proxy | head -5
kubectl get ns -o \
custom-columns=NAME:.metadata.name,INJECT:.metadata.annotations.linkerd\\.io/injectFortschritt speichern? Kostenlos registrieren
Kontrollpunkt
kubectl -n notes get podsErwartet: alle Pods 2/2 Running.
linkerd check --proxy -n notes 2>&1 | tail -1Erwartet:
Status check results are √
kubectl -n notes get deploy notes-api \
-o jsonpath='{.spec.template.spec.serviceAccountName}'Erwartet: notes-api
Challenge
Stell tag02 so um, dass dort standardmäßig
kein Proxy injiziert wird, aber ein neues Deployment
mit trotzdem einen bekommt.
Hinweis: Die Pod-Annotation gewinnt gegen die Namespace-Annotation.
Lösung
kubectl annotate namespace tag02 linkerd.io/inject=disabled --overwrite
kubectl -n tag02 create deployment mit --image=registry.k8s.io/pause:3.10
kubectl -n tag02 patch deploy mit -p \
'{"spec":{"template":{"metadata":{"annotations":{"linkerd.io/inject":"enabled"}}}}}'
kubectl -n tag02 rollout status deploy/mit
kubectl -n tag02 get pods -l app=mitErwartet:
NAME READY STATUS RESTARTS AGE
mit-56456f7865-t7gxm 2/2 Running 0 6s
Fortschritt speichern? Kostenlos registrieren
Aufräumen
kubectl delete namespace tag02Interview-Notiz
- Wie kommt der Proxy in den Pod? Ein Mutating Webhook
ergänzt beim Anlegen
linkerd-initundlinkerd-proxy. Bestehende Pods brauchen einen Neustart. - Woher kommt die Identität eines Workloads? Aus seinem ServiceAccount – deshalb braucht jeder Dienst einen eigenen.
- Was sind Opaque Ports? Ports, auf denen der Proxy kein Protokoll erkennt, sondern TCP weiterreicht – etwa bei Datenbanken wie Postgres oder MySQL, wo die Erkennung sonst bis zu 10 s hängt.
Enterprise-Notiz
- Injection pro Namespace einschalten, Ausnahmen pro Workload dokumentieren.
- Jobs und CronJobs: Der native Sidecar endet mit dem Job. Mit alten Sidecars blieben Jobs hängen – ein häufiger Grund für Unmut über Service Meshes.
- Admission-Policies (Kyverno, Gatekeeper) können erzwingen, dass Pods
nie den ServiceAccount
defaultnutzen. - Neustarts für die Injection in Wartungsfenster legen und per PodDisruptionBudget absichern.