Zum Inhalt springen
Trainingslager IT-Trainingslager

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/inject am 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 pods

Erwartet (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 pods

Erwartet (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 -1

Erwartet (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=1

Erwartet:

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 notes

Erwartet (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 opaque

Erwartet:

√ 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/tag00 anwenden – 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=ohne

Erwartet:

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 -c

Erwartet (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

  1. Zeig, welche Pods in notes einen Proxy haben. Zeitziel: 30 s
  2. Zeig die Proxy-Version in notes. Zeitziel: 20 s
  3. Zeig die ersten Logzeilen des Proxys von helper. Zeitziel: 20 s
  4. 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/inject

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

kubectl -n notes get pods

Erwartet: alle Pods 2/2 Running.

linkerd check --proxy -n notes 2>&1 | tail -1

Erwartet:

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=mit

Erwartet:

NAME                   READY   STATUS    RESTARTS   AGE
mit-56456f7865-t7gxm   2/2     Running   0          6s

Fortschritt speichern? Kostenlos registrieren

Aufräumen

kubectl delete namespace tag02

Interview-Notiz

  • Wie kommt der Proxy in den Pod? Ein Mutating Webhook ergänzt beim Anlegen linkerd-init und linkerd-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 default nutzen.
  • Neustarts für die Injection in Wartungsfenster legen und per PodDisruptionBudget absichern.