Tag 0: Das Trainingsgelände
Ziel: Ein Cluster mit einer kleinen App aus vier Diensten und einem Lastgenerator – noch ohne Mesh, damit du später jeden Unterschied messen kannst. · Dauer: ca. 45 min · Voraussetzung: Kubernetes-Cluster mit drei Nodes, kubectl und Helm
Briefing
- Linkerd zeigt seinen Wert erst bei echtem Verkehr zwischen mehreren
Diensten. Deshalb baust du heute die App
notesauf, an der du das ganze Buch übst. web(nginx) ist der Eingang. Er leitet/api/annotes-apiweiter,/flakyund/slowanhelper.helperscheitert absichtlich bei 30 Prozent der Aufrufe.notes-apispeichert inpostgres.lastruft ohne Pausewebauf und schreibt jeden Statuscode ins Log – das ist dein Messgerät.- Heute läuft alles ohne Mesh. Die Zahlen von heute sind die Baseline für Tag 1 bis 17.
last ──> web ──/api/──> notes-api ──> postgres
│
└──/flaky, /slow──> helper (30 % Fehler, 2 s Verzögerung)
Drill 1: Den Cluster prüfen
Das Buch wurde auf einem kubeadm-Cluster mit drei Nodes getestet:
cp1 (4 vCPU, 12 GB) und zwei Workern (je 2 vCPU, 4 GB). Wie
du so einen Cluster baust, zeigen „CKA zum Anfassen“ und „Cilium zum
Anfassen“. Alle Befehle laufen auf cp1.
kubectl get nodes
kubectl version | head -2
kubectl get storageclass
helm version --shortErwartet:
NAME STATUS ROLES AGE VERSION
cp1 Ready control-plane 12h v1.37.2
worker1 Ready <none> 12h v1.37.2
worker2 Ready <none> 12h v1.37.2
Client Version: v1.37.2
Kustomize Version: v5.8.1
NAME PROVISIONER RECLAIMPOLICY VOLUMEBINDINGMODE ...
local-path (default) rancher.io/local-path Delete WaitForFirstConsumer ...
v4.3.2+g8346aaa
Ohne StorageClass bleibt Postgres später in Pending.
Dann installierst du den local-path-provisioner von Rancher.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Cilium für Linkerd prüfen
Ersetzt Cilium kube-proxy, kann es Service-Adressen schon im Socket umschreiben. Dann sieht der Linkerd-Proxy nur noch Pod-IPs und weiß nicht mehr, welchen Service die App gemeint hat. Retries, Routen und Traffic-Splitting greifen dann nicht.
kubectl -n kube-system get configmap cilium-config \
-o jsonpath='{.data.bpf-lb-sock} {.data.bpf-lb-sock-hostns-only}{"\n"}'Erwartet:
false true
false heißt: Socket-Loadbalancing ist aus, alles passt.
Steht dort true true, ist ebenfalls alles gut. Nur bei
true false stellst du um:
helm upgrade cilium cilium/cilium -n kube-system --reuse-values \
--set socketLB.hostNamespaceOnly=true
kubectl -n kube-system rollout restart daemonset/ciliumNutzt du ein anderes CNI wie Calico oder Flannel, überspringst du diesen Drill.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Namespace und Secrets
mkdir -p ~/linkerd/tag00 && cd ~/linkerd/tag00
kubectl create namespace notes
kubectl -n notes 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 notes create secret generic notes-api-key --from-literal=key=lab-key-123Erwartet:
namespace/notes created
secret/notes-db created
secret/notes-api-key created
Die Werte sind Laborwerte. sslmode=disable ist hier
Absicht: Ab Tag 3 verschlüsselt Linkerd die Verbindung, ohne dass die
App etwas davon weiß.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Postgres
cat > postgres.yaml <<'EOF'
apiVersion: apps/v1
kind: StatefulSet
metadata: {name: postgres, namespace: notes}
spec:
serviceName: postgres
replicas: 1
selector: {matchLabels: {app: postgres}}
template:
metadata: {labels: {app: postgres}}
spec:
containers:
- name: postgres
image: docker.io/library/postgres:18.7-alpine
env:
- {name: POSTGRES_USER, value: notes}
- {name: POSTGRES_DB, value: notes}
- name: POSTGRES_PASSWORD
valueFrom: {secretKeyRef: {name: notes-db, key: password}}
- {name: PGDATA, value: /var/lib/postgresql/data/pgdata}
ports: [{containerPort: 5432, name: postgres}]
readinessProbe:
exec: {command: [pg_isready, -U, notes, -d, notes]}
volumeMounts: [{name: data, mountPath: /var/lib/postgresql/data}]
volumeClaimTemplates:
- metadata: {name: data}
spec:
accessModes: [ReadWriteOnce]
resources: {requests: {storage: 1Gi}}
---
apiVersion: v1
kind: Service
metadata: {name: postgres, namespace: notes}
spec:
selector: {app: postgres}
ports: [{port: 5432, targetPort: postgres, name: postgres}]
EOF
kubectl apply -f postgres.yaml
kubectl -n notes rollout status statefulset/postgres --timeout=180sErwartet:
statefulset.apps/postgres created
service/postgres created
Waiting for 1 pods to be ready...
partitioned roll out complete: 1 new pods have been updated...
Fortschritt speichern? Kostenlos registrieren
Drill 5: notes-api
Der Init-Container migrate legt die Tabelle an, bevor
die App startet. Merk ihn dir – an Tag 2 wird er dir begegnen.
cat > notes-api.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: notes-api, namespace: notes}
spec:
replicas: 2
selector: {matchLabels: {app: notes-api}}
template:
metadata: {labels: {app: notes-api}}
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: notes-api
image: ghcr.io/thomaszachmann/notes-api:0.7.1
ports: [{containerPort: 8080, name: http}]
env:
- name: NOTES_DB_URL
valueFrom: {secretKeyRef: {name: notes-db, key: url}}
- name: NOTES_API_KEY
valueFrom: {secretKeyRef: {name: notes-api-key, key: key}}
readinessProbe:
httpGet: {path: /healthz, port: http}
---
apiVersion: v1
kind: Service
metadata: {name: notes-api, namespace: notes}
spec:
selector: {app: notes-api}
ports: [{port: 80, targetPort: http, name: http}]
EOF
kubectl apply -f notes-api.yaml
kubectl -n notes rollout status deploy/notes-api --timeout=180s
kubectl -n notes logs deploy/notes-api -c migrateErwartet (gekürzt):
deployment "notes-api" successfully rolled out
Found 2 pods, using pod/notes-api-6d87674cb5-z7kc6
time=2026-11-19T11:16:01.348Z level=INFO msg="migration complete" table=notes
Fortschritt speichern? Kostenlos registrieren
Drill 6: helper und web
helper ist go-httpbin.
/unstable?failure_rate=0.3 antwortet in 30 Prozent der
Fälle mit 500, /delay/2 wartet zwei Sekunden.
web setzt den API-Key für notes-api.
cat > helper.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: helper, namespace: notes}
spec:
replicas: 2
selector: {matchLabels: {app: helper}}
template:
metadata: {labels: {app: helper}}
spec:
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, namespace: notes}
spec:
selector: {app: helper}
ports: [{port: 80, targetPort: http, name: http}]
EOF
cat > web.yaml <<'EOF'
apiVersion: v1
kind: ConfigMap
metadata: {name: web-conf, namespace: notes}
data:
default.conf: |
server {
listen 8080;
location = / { default_type text/plain; return 200 "notes web\n"; }
location /api/ {
proxy_set_header X-API-Key lab-key-123;
proxy_pass http://notes-api.notes.svc.cluster.local/;
}
location /flaky {
proxy_pass http://helper.notes.svc.cluster.local/unstable?failure_rate=0.3;
}
location /slow {
proxy_pass http://helper.notes.svc.cluster.local/delay/2;
}
}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: web, namespace: notes}
spec:
replicas: 2
selector: {matchLabels: {app: web}}
template:
metadata: {labels: {app: web}}
spec:
containers:
- name: web
image: docker.io/nginxinc/nginx-unprivileged:1.31.7-alpine
ports: [{containerPort: 8080, name: http}]
volumeMounts: [{name: conf, mountPath: /etc/nginx/conf.d}]
volumes: [{name: conf, configMap: {name: web-conf}}]
---
apiVersion: v1
kind: Service
metadata: {name: web, namespace: notes}
spec:
selector: {app: web}
ports: [{port: 80, targetPort: http, name: http}]
EOF
kubectl apply -f helper.yaml -f web.yaml
kubectl -n notes rollout status deploy/helper --timeout=180s
kubectl -n notes rollout status deploy/web --timeout=180sErwartet (gekürzt):
deployment.apps/helper created
service/helper created
configmap/web-conf created
deployment.apps/web created
service/web created
deployment "helper" successfully rolled out
deployment "web" successfully rolled out
Teste den Weg einmal von Hand, mit einem Wegwerf-Pod:
kubectl -n notes run t --rm -i -q --image=docker.io/curlimages/curl:8.23.0 \
--restart=Never -- sh -c 'curl -s -X POST -H "Content-Type: application/json" \
-d "{\"text\":\"Tag 0\"}" http://web/api/notes; echo; \
curl -s -o /dev/null -w "%{time_total}s\n" http://web/slow'Erwartet:
{"id":"3eb62b56-978a-4899-8540-b971f6a1ef87","text":"Tag 0"}
2.012089s
Fortschritt speichern? Kostenlos registrieren
Drill 7: Lastgenerator und Baseline
cat > last.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: last, namespace: notes}
spec:
replicas: 1
selector: {matchLabels: {app: last}}
template:
metadata: {labels: {app: last}}
spec:
containers:
- name: last
image: docker.io/curlimages/curl:8.23.0
command: [sh, -c]
args:
- |
while true; do
for p in /api/notes /api/notes /flaky; do
code=$(curl -s -o /dev/null -w '%{http_code}' -m 5 http://web$p)
echo "$(date +%T) $p $code"
done
sleep 1
done
EOF
kubectl apply -f last.yaml
kubectl -n notes rollout status deploy/lastErwartet (gekürzt):
deployment "last" successfully rolled out
Warte eine Minute. Dann zählst du die Statuscodes je Pfad:
kubectl -n notes logs deploy/last --since=60s | awk '{print $2, $3}' | sort | uniq -cErwartet (Zahlen schwanken):
92 /api/notes 200
34 /flaky 200
12 /flaky 500
/api/notes gelingt immer, /flaky in rund 70
Prozent der Fälle. Schreib dir beide Zahlen auf: Das ist die Baseline
ohne Mesh.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeig alle Pods in
notesmit dem Node, auf dem sie laufen. Zeitziel: 15 s - Zähl die Notizen direkt in Postgres. Zeitziel: 45 s
- Zeig die letzten fünf Zeilen des Lastgenerators. Zeitziel: 15 s
- Zeig, auf welche Pod-IPs der Service
helperzeigt. Zeitziel: 20 s
Lösung
kubectl -n notes get pods -o wide
kubectl -n notes exec postgres-0 -- \
psql -U notes -d notes -c 'select count(*) from notes'
kubectl -n notes logs deploy/last --tail=5
kubectl -n notes get endpointslices -l kubernetes.io/service-name=helperFortschritt speichern? Kostenlos registrieren
Kontrollpunkt
kubectl -n notes get deployErwartet:
NAME READY UP-TO-DATE AVAILABLE AGE
helper 2/2 2 2 5m
last 1/1 1 1 4m
notes-api 2/2 2 2 6m
web 2/2 2 2 5m
kubectl -n notes get statefulset postgresErwartet:
NAME READY AGE
postgres 1/1 7m
kubectl -n notes logs deploy/last --tail=30 | grep -c ' 200$'Erwartet: eine Zahl um 27 – rund neun von zehn Aufrufen gelingen.
Challenge
Stell die Fehlerquote von /flaky auf 50 Prozent und miss
eine Minute lang nach. Stell danach wieder 30 Prozent her.
Hinweis: nginx liest die ConfigMap nur beim Start.
Lösung
kubectl -n notes get configmap web-conf -o yaml \
| sed 's/failure_rate=0.3/failure_rate=0.5/' | kubectl apply -f -
kubectl -n notes rollout restart deploy/web
kubectl -n notes rollout status deploy/web
sleep 60
kubectl -n notes logs deploy/last --since=50s | awk '$2=="/flaky" {print $3}' \
| sort | uniq -cErwartet:
22 200
21 500
Zurück auf 30 Prozent:
kubectl apply -f ~/linkerd/tag00/web.yaml
kubectl -n notes rollout restart deploy/webSchau dir danach die letzten Zeilen von last an. Während
des Neustarts taucht oft ein 000 auf: Eine Verbindung ging
ins Leere, weil ein alter nginx-Pod schon beendet war. Auch das misst du
später mit Mesh noch einmal.
Fortschritt speichern? Kostenlos registrieren
Interview-Notiz
- Warum zuerst ohne Mesh messen? Ohne Baseline kannst du nicht belegen, was das Mesh bringt oder kostet – weder bei Fehlern noch bei der Latenz.
- Was ist ein Service Mesh? Ein Proxy neben jedem Pod, der Verbindungen verschlüsselt, misst und steuert, plus eine Control Plane, die diese Proxys konfiguriert.
Enterprise-Notiz
- Eine Test-App mit absichtlichen Fehlern gehört in jede Mesh-Einführung – mit echten Diensten siehst du nicht, ob ein Retry geholfen hat.
- Lastgeneratoren in Produktion: k6, Fortio oder vegeta mit festen Raten statt curl-Schleife.
- Prüfe das CNI vor der Einführung. Socket-Loadbalancing, eigene Netzwerk-Policies und CNI-Chaining entscheiden, wie Linkerd installiert wird.