Tag 5: Canary und Blue-Green
Ziel: Du verschiebst Traffic kontrolliert zwischen zwei Versionen – nach Gewicht, nach Header und per Umschalter – und misst, was wirklich ankommt. · Dauer: ca. 60 min · Voraussetzung: Tag 4
Briefing
- Mehrere
backendRefsin einer Regel mitweight= gewichtete Verteilung. Das ist Core-Feature, keine Annotation wiecanary-weightbei ingress-nginx. - Gewichte sind relativ: 90/10, 9/1 und 900/100 bedeuten dasselbe.
weight: 0= kein Traffic. - Header-Canary = eigene Regel mit
matches.headers. Spezifischere Regeln gewinnen. - Blue-Green = zwei Deployments, die Default-Regel zeigt auf genau eins. Umschalten ist ein einziger Patch.
- Glaub keiner Prozentangabe ohne Messung: Wir zählen 200 Antworten.
┌─ weight 90 ─> shop-v1 (stable / blue)
HTTPRoute shop┤
└─ weight 10 ─> shop-v2 (canary / green)
x-canary: always ──────────> shop-v2
Drill 1: Das Messgerät
echo-basic liefert den Service-Namen im JSON. Das Skript
zählt ihn über N Requests.
mkdir -p ~/gw-lab/tag05 && cd ~/gw-lab/tag05
export GW_IP=$(gw-ip.sh)
cat > measure.sh <<'EOF'
#!/usr/bin/env bash
# Schickt N Requests an den Shop und zählt die Antworten pro Backend.
# Aufruf: measure.sh [N] [zusätzliche curl-Argumente ...]
set -uo pipefail
n="${1:-200}"; shift || true
GW_IP="${GW_IP:-$(gw-ip.sh)}"
CA="${CA:-$HOME/gw-lab/tag04/lab-ca.crt}"
for _ in $(seq "$n"); do
body=$(curl -s --max-time 2 --cacert "$CA" \
--resolve "shop.gw.localtest.me:443:$GW_IP" "$@" \
https://shop.gw.localtest.me/)
jq -er .service <<<"$body" 2>/dev/null || echo FEHLER
done | sort | uniq -c
EOF
chmod +x measure.sh
./measure.sh 20Erwartet:
20 shop-v1
Alles, was kein JSON mit service ist (Timeout, 503 von
Envoy), zählt als FEHLER.
Fortschritt speichern? Kostenlos registrieren
Drill 2: 90/10 nach Gewicht
cat > canary-weights.yaml <<'EOF'
# 90/10-Canary: 10 % der Requests gehen an shop-v2
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: shop
namespace: shop
spec:
parentRefs:
- name: web
namespace: infra
sectionName: https-shop
hostnames:
- shop.gw.localtest.me
rules:
- backendRefs:
- name: shop-v1
port: 80
weight: 90
- name: shop-v2
port: 80
weight: 10
EOF
kubectl apply -f canary-weights.yaml
sleep 3
./measure.sh 200Erwartet (Zahlen schwanken):
httproute.gateway.networking.k8s.io/shop configured
179 shop-v1
21 shop-v2
21 statt 20 ist kein Fehler: Envoy würfelt pro Request. Bei 200 Requests sind ±6 normal. Für knappe Gates (z. B. 1 %) brauchst du deutlich mehr Requests oder echte Metriken (Tag 11).
Tipp: Gewicht ≠ Benutzer. Ohne Session-Affinität kann derselbe Kunde zwischen v1 und v2 springen. Für konsistentes Verhalten pro Kunde: Header-Canary (Drill 3).
Fortschritt speichern? Kostenlos registrieren
Drill 3: Header-Canary für Tester
Tester mit x-canary: always sehen immer v2, alle anderen
v1:
cat > canary-header.yaml <<'EOF'
# Header-Canary: Tester mit x-canary: always landen immer auf v2
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: shop
namespace: shop
spec:
parentRefs:
- name: web
namespace: infra
sectionName: https-shop
hostnames:
- shop.gw.localtest.me
rules:
- matches:
- headers:
- name: x-canary
value: always
backendRefs:
- name: shop-v2
port: 80
- backendRefs:
- name: shop-v1
port: 80
weight: 100
- name: shop-v2
port: 80
weight: 0
EOF
kubectl apply -f canary-header.yaml
sleep 3
./measure.sh 50
./measure.sh 50 -H 'x-canary: always'
./measure.sh 20 -H 'X-Canary: always'
./measure.sh 20 -H 'x-canary: ALWAYS'Erwartet:
httproute.gateway.networking.k8s.io/shop configured
50 shop-v1
50 shop-v2
20 shop-v2
20 shop-v1
Header-Namen sind case-insensitiv,
Werte nicht. weight: 0 hält shop-v2 in der
Default-Regel bereit – gleich drehen wir dort auf.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Schrittweiser Rollout per Skript
Das Skript dreht das Gewicht von shop-v2 in Stufen hoch, misst nach
jeder Stufe und bricht bei Fehlern ab. Es patcht rules[0] –
also zurück zur reinen Gewichts-Route.
cat > rollout.sh <<'EOF'
#!/usr/bin/env bash
# Schrittweiser Canary: Gewicht von shop-v2 erhöhen, nach jedem Schritt messen.
# Bei Fehlern sofort zurück auf 100 % shop-v1.
# Aufruf: rollout.sh [Schritte ...] Default: 10 25 50 100
set -euo pipefail
if [ $# -gt 0 ]; then steps=("$@"); else steps=(10 25 50 100); fi
N="${N:-200}"
MAX_ERR="${MAX_ERR:-0}"
set_weights() { # $1 = Gewicht v1, $2 = Gewicht v2
kubectl -n shop patch httproute shop --type=json -p "[
{\"op\":\"replace\",\"path\":\"/spec/rules/0/backendRefs/0/weight\",\"value\":$1},
{\"op\":\"replace\",\"path\":\"/spec/rules/0/backendRefs/1/weight\",\"value\":$2}
]" >/dev/null
}
for w in "${steps[@]}"; do
set_weights $((100 - w)) "$w"
sleep "${SETTLE:-3}"
result=$("$(dirname "$0")/measure.sh" "$N")
v2=$(awk '$2=="shop-v2"{print $1}' <<<"$result"); v2=${v2:-0}
err=$(awk '$2=="FEHLER"{print $1}' <<<"$result"); err=${err:-0}
printf 'Schritt %3s%%: shop-v2=%3s/%s Fehler=%s\n' "$w" "$v2" "$N" "$err"
if [ "$err" -gt "$MAX_ERR" ]; then
set_weights 100 0
echo "ROLLBACK: $err Fehler > $MAX_ERR – zurück auf 100 % shop-v1"
exit 1
fi
done
echo "Rollout fertig: 100 % shop-v2"
EOF
chmod +x rollout.sh
kubectl apply -f canary-weights.yaml
./rollout.sh
kubectl -n shop get httproute shop \
-o jsonpath='{range .spec.rules[0].backendRefs[*]}{.name}={.weight} {end}{"\n"}'Erwartet (Zahlen schwanken):
httproute.gateway.networking.k8s.io/shop configured
Schritt 10%: shop-v2= 20/200 Fehler=0
Schritt 25%: shop-v2= 50/200 Fehler=0
Schritt 50%: shop-v2=101/200 Fehler=0
Schritt 100%: shop-v2=200/200 Fehler=0
Rollout fertig: 100 % shop-v2
shop-v1=0 shop-v2=100
Das ist im Kern, was Argo Rollouts oder Flagger tun – nur mit Prometheus-Abfragen statt Zählschleife und mit Pausen zwischen den Stufen.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Rollback, wenn v2 kaputt ist
Simuliere eine defekte v2: keine Pods mehr hinter dem Service. Envoy antwortet für diesen Anteil mit 503.
kubectl apply -f canary-weights.yaml
kubectl -n shop scale deploy shop-v2 --replicas=0
sleep 5
./rollout.sh 10 50 100; echo "Exit: $?"
kubectl -n shop get httproute shop \
-o jsonpath='{range .spec.rules[0].backendRefs[*]}{.name}={.weight} {end}{"\n"}'
./measure.sh 20
kubectl -n shop scale deploy shop-v2 --replicas=1Erwartet (Zahlen schwanken):
httproute.gateway.networking.k8s.io/shop configured
deployment.apps/shop-v2 scaled
Schritt 10%: shop-v2= 0/200 Fehler=22
ROLLBACK: 22 Fehler > 0 – zurück auf 100 % shop-v1
Exit: 1
shop-v1=100 shop-v2=0
20 shop-v1
deployment.apps/shop-v2 scaled
Der Rollback ist derselbe Mechanismus wie der Rollout: ein Patch der Gewichte. Kein Redeploy, keine neue Pod-Generation, wirksam in Sekunden.
Achtung: Gewichtete Verteilung kennt keine Health. Ein Backend ohne Endpunkte bekommt trotzdem seinen Anteil – und liefert 503. Gate immer auf Fehlerrate, nicht nur auf „Pods Ready”.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Blue-Green mit Vorschau und Umschalter
Blue (shop-v1) ist live. Green (shop-v2) ist nur mit
x-env: green erreichbar – zum Abnehmen vor dem
Umschalten.
cat > blue-green.yaml <<'EOF'
# Blue-Green: blue (shop-v1) bekommt alles, green (shop-v2) nur mit x-env: green
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: shop
namespace: shop
spec:
parentRefs:
- name: web
namespace: infra
sectionName: https-shop
hostnames:
- shop.gw.localtest.me
rules:
- matches:
- headers:
- name: x-env
value: green
backendRefs:
- name: shop-v2
port: 80
- backendRefs:
- name: shop-v1
port: 80
EOF
cat > switch.sh <<'EOF'
#!/usr/bin/env bash
# Schaltet die Default-Regel der Route shop atomar auf blue (v1) oder green (v2).
# Aufruf: switch.sh blue|green
set -euo pipefail
case "${1:-}" in
blue) svc=shop-v1 ;;
green) svc=shop-v2 ;;
*) echo "Aufruf: $0 blue|green" >&2; exit 2 ;;
esac
kubectl -n shop patch httproute shop --type=json -p "[
{\"op\":\"replace\",\"path\":\"/spec/rules/1/backendRefs/0/name\",\"value\":\"$svc\"}
]"
echo "live: $1 ($svc)"
EOF
chmod +x switch.sh
kubectl -n shop rollout status deploy/shop-v2 --timeout=60s
kubectl apply -f blue-green.yaml
sleep 3
./measure.sh 20
./measure.sh 20 -H 'x-env: green'Erwartet:
deployment "shop-v2" successfully rolled out
httproute.gateway.networking.k8s.io/shop configured
20 shop-v1
20 shop-v2
Jetzt umschalten – während im Hintergrund 300 Requests laufen:
./measure.sh 300 > waehrend.txt &
sleep 0.5
./switch.sh green
wait
cat waehrend.txt
./measure.sh 20Erwartet (Verteilung schwankt):
httproute.gateway.networking.k8s.io/shop patched
live: green (shop-v2)
76 shop-v1
224 shop-v2
20 shop-v2
Kein einziger FEHLER: Envoy tauscht die
Route-Konfiguration ohne Verbindungsabbruch. Rollback ist
./switch.sh blue.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Argo Rollouts und Flagger (Ausblick)
Beide Werkzeuge patchen genau die Gewichte, die du gerade von Hand
gedreht hast – nur gesteuert durch Metriken. Argo Rollouts braucht dafür
das Plugin argoproj-labs/gatewayAPI, Flagger kennt Gateway
API als Provider gatewayapi:v1.
# Argo Rollouts: Ausschnitt eines Rollout (Plugin argoproj-labs/gatewayAPI)
apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
name: shop
namespace: shop
spec:
strategy:
canary:
stableService: shop-stable
canaryService: shop-canary
trafficRouting:
plugins:
argoproj-labs/gatewayAPI:
httpRoute: shop
namespace: shop
steps:
- setWeight: 10
- pause: {duration: 5m}
- setWeight: 50
- pause: {duration: 10m}(gekürzt, kann je nach Version abweichen)
| Werkzeug | Gateway-API-Anbindung | Gate |
|---|---|---|
| Argo Rollouts | Plugin argoproj-labs/gatewayAPI |
AnalysisTemplate (Prometheus u. a.) |
| Flagger | Canary mit provider: gatewayapi:v1 |
MetricTemplate, Webhooks |
| Eigenes Skript | kubectl patch (Drill 4) |
was du misst |
Beide verwalten die Route selbst: Wer parallel von Hand patcht, kämpft gegen den Controller.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cd ~/gw-lab/tag05
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
export GW_IP=$(gw-ip.sh)
check "measure.sh und rollout.sh ausführbar" '[ -x measure.sh ] && [ -x rollout.sh ]'
check "shop-v2 hat Endpunkte" \
'[ -n "$(kubectl -n shop get endpointslice -l kubernetes.io/service-name=shop-v2 \
-o jsonpath="{.items[*].endpoints[*].addresses[0]}")" ]'
check "Route shop Accepted" \
'conds.sh httproute shop shop | grep -q "Accepted=True"'
check "Vorschau x-env: green -> shop-v2" \
'./measure.sh 5 -H "x-env: green" | grep -q "5 shop-v2"'
check "keine Fehler in 50 Requests" '! ./measure.sh 50 | grep -q FEHLER'Erwartet:
✔ measure.sh und rollout.sh ausführbar
✔ shop-v2 hat Endpunkte
✔ Route shop Accepted
✔ Vorschau x-env: green -> shop-v2
✔ keine Fehler in 50 Requests
Challenge
Das QA-Team (Header x-team: qa) soll immer v2 sehen,
alle anderen bekommen 95/5. Beweise die Verteilung mit je 200 Requests
und stelle danach den Stand von Tag 4 wieder her (100 % shop-v1).
Hinweis: Zwei Regeln – die Header-Regel ist spezifischer und gewinnt.
Lösung
cat > qa-canary.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
name: shop
namespace: shop
spec:
parentRefs:
- name: web
namespace: infra
sectionName: https-shop
hostnames:
- shop.gw.localtest.me
rules:
- matches:
- headers:
- name: x-team
value: qa
backendRefs:
- name: shop-v2
port: 80
- backendRefs:
- name: shop-v1
port: 80
weight: 95
- name: shop-v2
port: 80
weight: 5
EOF
kubectl apply -f qa-canary.yaml
sleep 3
./measure.sh 200
./measure.sh 200 -H 'x-team: qa'
kubectl apply -f ~/gw-lab/tag04/routes-https.yamlErwartet (Zahlen schwanken):
httproute.gateway.networking.k8s.io/shop configured
191 shop-v1
9 shop-v2
200 shop-v2
httproute.gateway.networking.k8s.io/shop configured
httproute.gateway.networking.k8s.io/api unchanged
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Gewichte von Hand nur im Notfall. Im Alltag steuert Argo Rollouts oder Flagger die Route, gated auf Fehlerrate und Latenz aus Prometheus (Tag 11).
- Wer die Route besitzt, muss klar sein: GitOps (Argo CD/Flux) und
Rollout-Controller ändern sonst dasselbe Objekt –
ignoreDifferencesfürbackendRefs[].weightsetzen. - Canary über Gewichte braucht Volumen: Bei wenig Traffic lieber Header- oder Cookie-basiert testen und dann umschalten.
- Datenbank-Migrationen müssen v1 und v2 gleichzeitig vertragen (expand/contract), sonst ist der schnelle Rollback nur scheinbar schnell.
- Blue-Green kostet doppelte Kapazität während der Umschaltphase – im Kapazitätsplan und in ResourceQuotas berücksichtigen.