Zum Inhalt springen
Trainingslager IT-Trainingslager

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 backendRefs in einer Regel mit weight = gewichtete Verteilung. Das ist Core-Feature, keine Annotation wie canary-weight bei 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 20

Erwartet:

  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 200

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

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

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

Erwartet (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 – ignoreDifferences für backendRefs[].weight setzen.
  • 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.