Zum Inhalt springen
Trainingslager IT-Trainingslager

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 notes auf, an der du das ganze Buch übst.
  • web (nginx) ist der Eingang. Er leitet /api/ an notes-api weiter, /flaky und /slow an helper. helper scheitert absichtlich bei 30 Prozent der Aufrufe.
  • notes-api speichert in postgres. last ruft ohne Pause web auf 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 --short

Erwartet:

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/cilium

Nutzt 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-123

Erwartet:

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=180s

Erwartet:

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 migrate

Erwartet (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=180s

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

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

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

  1. Zeig alle Pods in notes mit dem Node, auf dem sie laufen. Zeitziel: 15 s
  2. Zähl die Notizen direkt in Postgres. Zeitziel: 45 s
  3. Zeig die letzten fünf Zeilen des Lastgenerators. Zeitziel: 15 s
  4. Zeig, auf welche Pod-IPs der Service helper zeigt. 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=helper

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

kubectl -n notes get deploy

Erwartet:

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 postgres

Erwartet:

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

Erwartet:

     22 200
     21 500

Zurück auf 30 Prozent:

kubectl apply -f ~/linkerd/tag00/web.yaml
kubectl -n notes rollout restart deploy/web

Schau 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.