Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 9: Traffic Shifting

Ziel: Du schiebst Verkehr schrittweise von einer alten auf eine neue Version, lässt Tester per Header gezielt auf die neue Version und rollst in Sekunden zurück. · Dauer: ca. 60 min · Voraussetzung: Tag 8

Briefing

  • Eine HTTPRoute mit einem Service als parentRef gilt für alle Clients, die diesen Service aufrufen. Ihre backendRefs mit weight verteilen die Requests.
  • Der Client-Proxy entscheidet. Clients ohne Proxy merken von der Route nichts.
  • Der Service bleibt die stabile Adresse. Kein Client und kein Pod wird geändert, kein Neustart – Gewichte wirken sofort.
  • Statt Zufall kann ein Header entscheiden: Dark Launch für Tester.
  • Heute in tag09 mit eigener Kopie von notes-api in zwei Versionen, ohne Datenbank.
                      HTTPRoute notes-api-canary
 last ─> proxy ──┬── 90 % ──> Service notes-api    ──> notes-api-v1 (0.5.2)
                 └── 10 % ──> Service notes-api-v2 ──> notes-api-v2 (0.7.1)

Drill 1: Zwei Versionen nebeneinander

notes-api startet ohne NOTES_DB_URL mit einem Speicher im RAM und meldet unter /version seine Version – genau richtig für heute.

mkdir -p ~/linkerd/tag09 && cd ~/linkerd/tag09
kubectl create namespace tag09
kubectl annotate namespace tag09 linkerd.io/inject=enabled
cat > app.yaml <<'EOF'
apiVersion: v1
kind: ServiceAccount
metadata: {name: notes-api, namespace: tag09}
---
apiVersion: v1
kind: ServiceAccount
metadata: {name: last, namespace: tag09}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: notes-api-v1, namespace: tag09}
spec:
  replicas: 1
  selector: {matchLabels: {app: notes-api, version: v1}}
  template:
    metadata: {labels: {app: notes-api, version: v1}}
    spec:
      serviceAccountName: notes-api
      containers:
      - name: notes-api
        image: ghcr.io/thomaszachmann/notes-api:0.5.2
        env: [{name: NOTES_API_KEY, value: lab-key-123}]
        ports: [{containerPort: 8080, name: http}]
        readinessProbe:
          httpGet: {path: /healthz, port: http}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: notes-api-v2, namespace: tag09}
spec:
  replicas: 1
  selector: {matchLabels: {app: notes-api, version: v2}}
  template:
    metadata: {labels: {app: notes-api, version: v2}}
    spec:
      serviceAccountName: notes-api
      containers:
      - name: notes-api
        image: ghcr.io/thomaszachmann/notes-api:0.7.1
        env: [{name: NOTES_API_KEY, value: lab-key-123}]
        ports: [{containerPort: 8080, name: http}]
        readinessProbe:
          httpGet: {path: /healthz, port: http}
---
apiVersion: v1
kind: Service
metadata: {name: notes-api, namespace: tag09}
spec:
  selector: {app: notes-api, version: v1}
  ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: v1
kind: Service
metadata: {name: notes-api-v2, namespace: tag09}
spec:
  selector: {app: notes-api, version: v2}
  ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: last, namespace: tag09}
spec:
  replicas: 1
  selector: {matchLabels: {app: last}}
  template:
    metadata: {labels: {app: last}}
    spec:
      serviceAccountName: last
      containers:
      - name: last
        image: docker.io/curlimages/curl:8.23.0
        env: [{name: URL, value: http://notes-api/version}]
        command: [sh, -c]
        args:
        - |
          while true; do
            code=$(curl -s -m 5 -o /tmp/v -w '%{http_code}' $URL)
            echo "$(date +%T) $(cat /tmp/v) $code"
            sleep 0.5
          done
EOF
kubectl apply -f app.yaml
kubectl -n tag09 rollout status deploy --timeout=180s
kubectl -n tag09 get pods
sleep 60
kubectl -n tag09 logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c

Erwartet (gekürzt, Zahlen schwanken):

NAME                            READY   STATUS    RESTARTS   AGE
last-7dc884997f-c87hf           2/2     Running   0          9s
notes-api-v1-7d9976cbdc-hc8jx   2/2     Running   0          9s
notes-api-v2-78bcbb6547-h9ms6   2/2     Running   0          9s
     92 0.5.2 200

Der Service notes-api wählt nur version: v1. v2 läuft, bekommt aber keinen Verkehr. Die Spalten im Log: Uhrzeit, Version, Statuscode.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Canary mit zehn Prozent

cat > route.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: {name: notes-api-canary, namespace: tag09}
spec:
  parentRefs:
  - {group: "", kind: Service, name: notes-api, port: 80}
  rules:
  - backendRefs:
    - {name: notes-api, port: 80, weight: 90}
    - {name: notes-api-v2, port: 80, weight: 10}
EOF
kubectl apply -f route.yaml
sleep 60
kubectl -n tag09 logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c
linkerd viz stat -n tag09 deploy --from deploy/last

Erwartet (Zahlen schwanken):

     78 0.5.2 200
      9 0.7.1 200
NAME           MESHED   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99   ...
notes-api-v1      1/1   100.00%   1.4rps           4ms          65ms          93ms   ...
notes-api-v2      1/1   100.00%   0.2rps          20ms          39ms          40ms   ...

Der Service notes-api steht als Parent und als Backend in der Route. Als Backend heißt er: seine eigenen Endpunkte, also v1. Ohne ihn in backendRefs ginge alles an v2. stat --from deploy/last zeigt die Verteilung aus Sicht des Clients – mit Erfolgsquote pro Version, das ist dein Entscheidungskriterium für den nächsten Schritt. group: "" ist die Core-API-Gruppe – Linkerds Doku und die übrigen Tage schreiben sie als group: core, beides meint dasselbe.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Wer teilt hier eigentlich?

kubectl -n tag09 get httproute notes-api-canary \
  -o jsonpath='{range .status.parents[*]}{.controllerName}{"\n"}{end}'
kubectl -n tag09 get ciliumenvoyconfig
kubectl -n tag09 get endpointslices

Erwartet (gekürzt):

io.cilium/gateway-controller
linkerd.io/policy-controller
NAME        AGE
notes-api   66s
NAME                       ADDRESSTYPE   PORTS   ENDPOINTS         AGE
cilium-gateway-notes-api   IPv4          9999    192.192.192.192   66s
notes-api-...              IPv4          8080    10.0.1.215        3m

Zwei Controller haben die Route angenommen. Cilium unterstützt Service-Parents ebenfalls (GAMMA, das Mesh-Profil der Gateway API) und leitet Verkehr an die ClusterIP von notes-api durch seinen Envoy; dafür legt es die CiliumEnvoyConfig und eine EndpointSlice mit der Platzhalter-Adresse 192.192.192.192:9999 an. Wer teilt also wirklich? Ein Client ohne Proxy gegen einen mit:

kubectl -n tag09 run ohne --image=curlimages/curl:8.23.0 --restart=Never \
  --annotations=linkerd.io/inject=disabled --command -- sleep 3600
kubectl -n tag09 wait --for=condition=Ready pod/ohne --timeout=60s
kubectl -n tag09 exec ohne -- sh -c 'for i in $(seq 50); do
  curl -s -i http://notes-api/version | grep -iE "^server|^0\."; done' | sort | uniq -c
kubectl -n tag09 exec deploy/last -c last -- sh -c 'for i in $(seq 50); do
  curl -s -i http://notes-api/version | grep -iE "^server|^0\."; done' | sort | uniq -c
kubectl -n tag09 delete pod ohne --now

Erwartet (Zahlen schwanken):

     47 0.5.2
      3 0.7.1
     50 server: envoy
     44 0.5.2
      6 0.7.1

Ohne Proxy teilt Ciliums Envoy (server: envoy). Mit Proxy teilt Linkerd: Der Proxy löst den Service selbst auf und verbindet sich direkt mit den Pod-IPs, an der ClusterIP vorbei – Ciliums Regel greift nie. Hier stimmt das Ergebnis zufällig überein. Sobald du Linkerd-eigene Funktionen wie Retries oder Timeouts in der Route nutzt, bekommen Clients ohne Proxy etwas anderes.

Achtung: Zwei GAMMA-Implementierungen in einem Cluster sind eine Falle. Prüf bei jeder Route status.parents und entscheide dich für ein Mesh, das Service-Routen umsetzt.

Fortschritt speichern? Kostenlos registrieren

Drill 4: 50/50, dann alles

Gewichte änderst du direkt in der Route, ohne Datei:

W=/spec/rules/0/backendRefs
kubectl -n tag09 patch httproute notes-api-canary --type=json -p \
  "[{\"op\":\"replace\",\"path\":\"$W/0/weight\",\"value\":50},
    {\"op\":\"replace\",\"path\":\"$W/1/weight\",\"value\":50}]"
sleep 60
kubectl -n tag09 logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c

Erwartet (Zahlen schwanken):

     50 0.5.2 200
     40 0.7.1 200

Weiter auf 0 zu 100:

kubectl -n tag09 patch httproute notes-api-canary --type=json -p \
  "[{\"op\":\"replace\",\"path\":\"$W/0/weight\",\"value\":0},
    {\"op\":\"replace\",\"path\":\"$W/1/weight\",\"value\":100}]"
kubectl -n tag09 get httproute notes-api-canary \
  -o jsonpath='{.spec.rules[*].backendRefs[*].weight}{"\n"}'
sleep 60
kubectl -n tag09 logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c

Erwartet:

0 100
     92 0.7.1 200

Kein Pod ist neu gestartet, kein Request ist fehlgeschlagen.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Rollback in Sekunden

Angenommen, v2 fällt bei 50 Prozent durch. Zurück auf 50/50, dann den Rückzug:

sed 's/weight: 90/weight: 50/; s/weight: 10/weight: 50/' route.yaml \
  | kubectl apply -f -
sleep 30
date +%T
kubectl -n tag09 delete httproute notes-api-canary
sleep 5
kubectl -n tag09 logs deploy/last -c last --since=8s

Erwartet (gekürzt):

16:23:21
httproute.gateway.networking.k8s.io "notes-api-canary" deleted from tag09 namespace
16:23:19 0.7.1 200
16:23:19 0.5.2 200
16:23:21 0.5.2 200
16:23:22 0.5.2 200
16:23:22 0.5.2 200

Ohne Route gilt wieder der Service selbst – also nur v1. Die Änderung ist nach weniger als einer Sekunde in allen Client-Proxys. Den Rollback per Löschen oder per Gewicht 0 bekommst du nur sauber hin, wenn v1 noch läuft: Skaliere die alte Version erst ab, wenn die neue fertig ist.

Tipp: Fällt v2 ganz aus (keine Endpunkte), nimmt Linkerd das Backend aus der Verteilung. Im Test kam beim Abskalieren genau ein 504, dann nur noch v1. Ein Ersatz für den Rollback ist das nicht: Eine fehlerhafte, aber laufende Version bekommt weiter ihren Anteil.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Dark Launch per Header

Erst einmal sollen nur Tester v2 sehen, alle anderen bleiben auf v1:

cat > route-header.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: {name: notes-api-dark, namespace: tag09}
spec:
  parentRefs:
  - {group: "", kind: Service, name: notes-api, port: 80}
  rules:
  - matches:
    - headers: [{name: x-canary, value: "true"}]
    backendRefs:
    - {name: notes-api-v2, port: 80}
  - backendRefs:
    - {name: notes-api, port: 80}
EOF
kubectl apply -f route-header.yaml
for h in "x-canary: true" "x-canary: false" "X-Canary: true"; do
  echo "$h -> $(kubectl -n tag09 exec deploy/last -c last -- \
    curl -s -H "$h" http://notes-api/version)"
done

Erwartet:

httproute.gateway.networking.k8s.io/notes-api-dark created
x-canary: true -> 0.7.1
x-canary: false -> 0.5.2
X-Canary: true -> 0.7.1

Header-Namen sind unabhängig von Groß- und Kleinschreibung, Werte nicht. Der Lastgenerator schickt keinen Header und bleibt komplett auf v1. Welcher Regel ein Request folgte, zählt der Client-Proxy pro Route und Backend – seit dem Start des Pods, deshalb hat die Route einen neuen Namen bekommen:

linkerd diagnostics proxy-metrics -n tag09 deploy/last \
  | grep ^outbound_http_route_backend_requests_total | grep notes-api-dark \
  | grep -oE 'backend_name="[^"]+"|[0-9]+$' | paste -d ' ' - -

Erwartet (Zahlen schwanken):

backend_name="notes-api-v2" 2
backend_name="notes-api" 5

Zwei Requests mit Header gingen an v2, alles andere an notes-api. Die zweite Zahl wächst mit dem Lastgenerator weiter, die erste nicht.

Wichtig: Header steuern nur, wenn sie bis zum Proxy des Aufrufers kommen. Ruft ein Browser web auf und web ruft notes-api, muss web den Header weiterreichen – nginx tut das von selbst, viele Frameworks nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Abschließen

Nach einem erfolgreichen Rollout gehört der Zustand zurück in den Service. Sonst hängt deine Produktion dauerhaft an einer Route mit Gewicht 0 zu 100:

W=/spec/rules/0/backendRefs
kubectl -n tag09 delete httproute notes-api-dark
kubectl apply -f route.yaml
kubectl -n tag09 patch httproute notes-api-canary --type=json -p \
  "[{\"op\":\"replace\",\"path\":\"$W/0/weight\",\"value\":0},
    {\"op\":\"replace\",\"path\":\"$W/1/weight\",\"value\":100}]"
kubectl -n tag09 patch service notes-api \
  -p '{"spec":{"selector":{"version":"v2"}}}'
kubectl -n tag09 delete httproute notes-api-canary
kubectl -n tag09 scale deploy/notes-api-v1 --replicas=0
sleep 60
kubectl -n tag09 logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c
kubectl -n tag09 get ciliumenvoyconfig
kubectl -n tag09 get endpointslices -l io.cilium.gateway/owning-gateway=notes-api
kubectl -n tag09 delete endpointslice -l io.cilium.gateway/owning-gateway=notes-api

Erwartet:

    112 0.7.1 200
No resources found in tag09 namespace.
NAME                       ADDRESSTYPE   PORTS   ENDPOINTS         AGE
cilium-gateway-notes-api   IPv4          9999    192.192.192.192   11m
endpointslice.discovery.k8s.io "cilium-gateway-notes-api" deleted from tag09 namespace

Die Reihenfolge zählt: Erst zeigt der Service auf v2, dann verschwindet die Route, dann geht v1. Kein Fehler im Log. Ciliums Envoy-Konfiguration ist mit der Route verschwunden, seine EndpointSlice aber nicht – die räumst du von Hand weg. Sie stört nicht (sie gehört zu keinem existierenden Service), verwirrt aber bei der Fehlersuche.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

Vorher v1 zurückholen:

kubectl -n tag09 scale deploy/notes-api-v1 --replicas=1
kubectl -n tag09 patch service notes-api \
  -p '{"spec":{"selector":{"version":"v1"}}}'
  1. Leg die Route aus route.yaml an und zeig, welche Controller sie angenommen haben. Zeitziel: 30 s
  2. Stell die Route mit einem Befehl auf 80/20. Zeitziel: 60 s
  3. Zeig die Verteilung der letzten Minute aus Sicht von last mit viz. Zeitziel: 15 s
  4. Schick einen Request mit x-canary: true aus last und zeig die Version. Zeitziel: 20 s

Lösung

kubectl apply -f route.yaml
kubectl -n tag09 get httproute notes-api-canary \
  -o jsonpath='{.status.parents[*].controllerName}{"\n"}'
kubectl -n tag09 patch httproute notes-api-canary --type=json -p \
  "[{\"op\":\"replace\",\"path\":\"$W/0/weight\",\"value\":80},
    {\"op\":\"replace\",\"path\":\"$W/1/weight\",\"value\":20}]"
linkerd viz stat -n tag09 deploy --from deploy/last
kubectl -n tag09 exec deploy/last -c last -- \
  curl -s -H 'x-canary: true' http://notes-api/version

Erwartet (Auszug):

linkerd.io/policy-controller io.cilium/gateway-controller
0.7.1

Bei Aufgabe 4 kommt mal 0.5.2, mal 0.7.1: route.yaml kennt keinen Header, es zählt nur das Gewicht. Dark Launch und Gewichte gleichzeitig zeigt die Challenge.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

kubectl -n tag09 get pods

Erwartet: last, notes-api-v1 und notes-api-v2 je 2/2 Running.

linkerd viz stat -n tag09 deploy --from deploy/last

Erwartet: zwei Zeilen notes-api-v1 und notes-api-v2, beide 100.00%, RPS im Verhältnis der Gewichte.

kubectl -n tag09 get httproute notes-api-canary \
  -o jsonpath='{.status.parents[*].conditions[?(@.type=="Accepted")].status}{"\n"}'

Erwartet: True True – Linkerd und Cilium haben die Route angenommen.

Challenge

Baue eine Route, mit der Tester per x-canary: true immer v2 bekommen, alle anderen aber 90/10 verteilt werden. Weise beides nach.

Hinweis: Eine Route darf mehrere Regeln haben; die mit matches gewinnt.

Lösung

cat > route-challenge.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: {name: notes-api-canary, namespace: tag09}
spec:
  parentRefs:
  - {group: "", kind: Service, name: notes-api, port: 80}
  rules:
  - matches:
    - headers: [{name: x-canary, value: "true"}]
    backendRefs:
    - {name: notes-api-v2, port: 80}
  - backendRefs:
    - {name: notes-api, port: 80, weight: 90}
    - {name: notes-api-v2, port: 80, weight: 10}
EOF
kubectl apply -f route-challenge.yaml
sleep 60
kubectl -n tag09 logs deploy/last -c last --since=55s | awk '{print $2, $3}' \
  | sort | uniq -c
for i in 1 2 3 4 5; do
  kubectl -n tag09 exec deploy/last -c last -- \
    curl -s -H 'x-canary: true' http://notes-api/version
done | sort | uniq -c

Erwartet (Zahlen schwanken):

     79 0.5.2 200
     12 0.7.1 200
      5 0.7.1

Fortschritt speichern? Kostenlos registrieren

Aufräumen

kubectl delete namespace tag09

Mit dem Namespace verschwinden auch Ciliums EndpointSlices. Hast du Routen mit Service-Parent in anderen Namespaces gelöscht, prüf dort kubectl get endpointslices -A | grep 192.192.192.192.

Interview-Notiz

  • Wie macht Linkerd einen Canary? Mit einer Gateway-API-HTTPRoute, deren Parent der Service ist; backendRefs mit Gewichten verteilen im Client-Proxy. Ältere Anleitungen nutzen die SMI-Ressource TrafficSplit – für Neues nimmst du HTTPRoute.
  • Warum sieht ein Client ohne Proxy die Route nicht? Die Route setzt der ausgehende Proxy des Aufrufers um. Ohne Proxy gilt nur der Service.
  • Wie rollst du zurück? Gewicht der neuen Version auf 0 oder Route löschen – wirkt sofort, ohne Neustart, solange die alte Version noch läuft.

Enterprise-Notiz

  • Von Hand ist das ein Lernwerkzeug. In Produktion schiebt Flagger oder Argo Rollouts (mit Gateway-API-Plugin) die Gewichte derselben HTTPRoute, misst die Erfolgsquote aus Prometheus und rollt bei Abweichung automatisch zurück.
  • Ein GitOps-Werkzeug darf die Gewichte dann nicht überschreiben – Felder ignorieren oder die Route ganz dem Rollout-Werkzeug überlassen.
  • Pro Service nur eine GAMMA-Implementierung: Läuft daneben Cilium mit Gateway API, nimmt es Routen mit Service-Parent ebenfalls an – status.parents jeder Route prüfen.
  • Header-Routing braucht Header-Weitergabe durch alle Dienste der Kette – wie beim Tracing.
  • Canary-Gewichte sind Request-Anteile, nicht Nutzer: Für „ein Nutzer bleibt auf einer Version“ brauchst du Header oder Cookies.