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
parentRefgilt für alle Clients, die diesen Service aufrufen. IhrebackendRefsmitweightverteilen 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
tag09mit eigener Kopie vonnotes-apiin 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 -cErwartet (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/lastErwartet (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 endpointslicesErwartet (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 --nowErwartet (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.parentsund 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 -cErwartet (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 -cErwartet:
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=8sErwartet (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
v2ganz aus (keine Endpunkte), nimmt Linkerd das Backend aus der Verteilung. Im Test kam beim Abskalieren genau ein504, dann nur nochv1. 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)"
doneErwartet:
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-apiErwartet:
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"}}}'- Leg die Route aus
route.yamlan und zeig, welche Controller sie angenommen haben. Zeitziel: 30 s - Stell die Route mit einem Befehl auf 80/20. Zeitziel: 60 s
- Zeig die Verteilung der letzten Minute aus Sicht von
lastmitviz. Zeitziel: 15 s - Schick einen Request mit
x-canary: trueauslastund 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/versionErwartet (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 podsErwartet: last,
notes-api-v1 und notes-api-v2 je
2/2 Running.
linkerd viz stat -n tag09 deploy --from deploy/lastErwartet: 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 -cErwartet (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 tag09Mit 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;
backendRefsmit Gewichten verteilen im Client-Proxy. Ältere Anleitungen nutzen die SMI-RessourceTrafficSplit– 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.parentsjeder 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.