Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 0: Das Trainingsgelände aufbauen

Ziel: kind-Cluster gw-lab läuft, LoadBalancer-IPs funktionieren, die Demo-Apps antworten. · Dauer: ca. 40 min · Voraussetzung: keine

Briefing

  • Teil A und B laufen auf einem kind-Cluster gw-lab mit 1 Control-Plane- und 1 Worker-Node.
  • cloud-provider-kind vergibt echte LoadBalancer-IPs aus dem Docker-Netz kind. Jedes Gateway bekommt so eine eigene Adresse – wie später auf RKE2 mit Cilium LB-IPAM.
  • *.gw.localtest.me zeigt öffentlich auf 127.0.0.1. Wir schicken die Requests mit curl --resolve an die Gateway-IP, Host-Header und SNI bleiben dabei korrekt.
  • Alle Demo-Apps nutzen ein 5-MB-Image: echo-basic aus dem Gateway-API-Projekt. Es spiegelt Pfad, Host und Header als JSON zurück.

Drill 1: Werkzeuge installieren

macOS mit Homebrew:

brew install kind kubectl helm jq cloud-provider-kind grpcurl
brew list --versions kind kubernetes-cli helm jq cloud-provider-kind grpcurl

Erwartet (Versionen können abweichen):

cloud-provider-kind 0.12.0
grpcurl 1.9.4
helm 4.3.0
jq 1.8.2
kind 0.33.0
kubernetes-cli 1.37.1

Linux: kind, kubectl, helm und grpcurl von den offiziellen Release-Seiten, jq über den Paketmanager. cloud-provider-kind gibt es als Binary unter https://github.com/kubernetes-sigs/cloud-provider-kind/releases oder per Go:

go install sigs.k8s.io/[email protected]

grpcurl brauchst du erst an Tag 6, cloud-provider-kind ab Drill 5.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Versionen und Docker prüfen

kind version
kubectl version --client | head -1
helm version --short
cloud-provider-kind version
docker version --format '{{.Client.Version}} / {{.Server.Version}}'

Erwartet:

kind v0.33.0 go1.27.0 darwin/arm64
Client Version: v1.37.1
v4.3.0+gbec5b06
cloud-provider-kind 0.12.0
29.9.0 / 29.5.2
docker info --format 'CPUs: {{.NCPU}}  RAM: {{.MemTotal}}'

Erwartet (kann abweichen):

CPUs: 4  RAM: 8307167232

4 CPUs und 8 GB RAM für die Docker-VM (Docker Desktop, Colima, OrbStack) reichen. Plane etwa 3 GB Platz für Node-Image und Container-Images ein.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Arbeitsverzeichnis anlegen

mkdir -p ~/gw-lab/code/demo
mkdir -p ~/gw-lab/tag{01,02,03,04,05,06,07,08,09,10,11,12,13,14}
cd ~/gw-lab && ls -m

Erwartet:

code, tag01, tag02, tag03, tag04, tag05, tag06, tag07, tag08, tag09, tag10,
tag11, tag12, tag13, tag14

In ~/gw-lab/code/demo landet alles, was mehrere Tage brauchen: Cluster-Konfiguration, Demo-Apps, Hilfsskripte. Die Kapitel-Dateien liegen in tagNN.

Ab Tag 4 wendest du auch Dateien an, die das Buch nicht vollständig abdruckt. Sie liegen kostenlos im Begleitcode auf GitHub: https://github.com/thomaszachmann/gateway-api-zum-anfassen. Hol ihn jetzt:

git clone https://github.com/thomaszachmann/gateway-api-zum-anfassen.git \
  ~/gateway-api-zum-anfassen 2>/dev/null || git -C ~/gateway-api-zum-anfassen pull
cp -R ~/gateway-api-zum-anfassen/* ~/gw-lab/code/
ls ~/gw-lab/code

Die Dateien, die du in den Drills selbst schreibst, ersetzen dabei die gleichnamigen Dateien aus dem Begleitcode. Das ist gewollt: Inhaltlich sind sie identisch.

Fortschritt speichern? Kostenlos registrieren

Drill 4: kind-Cluster bauen

cat > ~/gw-lab/code/demo/kind-gw-lab.yaml <<'EOF'
# kind-Cluster für "Gateway API zum Anfassen" (Teil A/B)
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: gw-lab
nodes:
  - role: control-plane
  - role: worker
EOF
kind create cluster --config ~/gw-lab/code/demo/kind-gw-lab.yaml
kubectl get nodes

Erwartet (gekürzt, kann je nach Version abweichen):

Creating cluster "gw-lab" ...
 ✓ Ensuring node image (kindest/node:v1.37.0)
 ✓ Preparing nodes
 ...
Set kubectl context to "kind-gw-lab"
NAME                   STATUS   ROLES           AGE   VERSION
gw-lab-control-plane   Ready    control-plane   40s   v1.37.0
gw-lab-worker          Ready    <none>          25s   v1.37.0

Warum keine extraPortMappings für 80/443? Jedes Gateway bekommt einen eigenen LoadBalancer-Service. Feste Host-Ports würden bei zwei Gateways kollidieren – die LB-IPs von cloud-provider-kind nicht.

Tipp: Die Envoy-Gateway-Kompatibilitätsmatrix nennt für v1.9 Kubernetes 1.33–1.36. Das Buch läuft mit dem kind-Default 1.37.0 ohne Auffälligkeiten. Willst du exakt in der Matrix bleiben, setze in der kind-Config image: kindest/node:v1.36.x pro Node.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Namespaces und Demo-Apps

Drei Namespaces, drei Teams: infra gehört dem Plattform-Team (Gateways), shop und payments den App-Teams.

cd ~/gw-lab/code/demo
cat > namespaces.yaml <<'EOF'
# Plattform-Team: infra · App-Teams: shop, payments
apiVersion: v1
kind: Namespace
metadata:
  name: infra
  labels:
    gw-lab/team: platform
---
apiVersion: v1
kind: Namespace
metadata:
  name: shop
  labels:
    gw-lab/team: shop
---
apiVersion: v1
kind: Namespace
metadata:
  name: payments
  labels:
    gw-lab/team: payments
EOF

Der Shop in Version 1:

cat > shop-v1.yaml <<'EOF'
# Demo-Shop: Echo-Server, das Antwort-JSON enthält den Service-Namen
apiVersion: apps/v1
kind: Deployment
metadata:
  name: shop-v1
  namespace: shop
  labels: {app: shop, version: v1}
spec:
  replicas: 1
  selector:
    matchLabels: {app: shop, version: v1}
  template:
    metadata:
      labels: {app: shop, version: v1}
    spec:
      containers:
        - name: echo
          image: registry.k8s.io/gateway-api/echo-basic:v1.6.0
          env:
            - name: SERVICE_NAME
              value: shop-v1
            - name: POD_NAME
              valueFrom: {fieldRef: {fieldPath: metadata.name}}
            - name: NAMESPACE
              valueFrom: {fieldRef: {fieldPath: metadata.namespace}}
          ports:
            - {name: http, containerPort: 3000}
          readinessProbe:
            httpGet: {path: /health, port: http}
          resources:
            requests: {cpu: 10m, memory: 16Mi}
            limits: {memory: 64Mi}
---
apiVersion: v1
kind: Service
metadata:
  name: shop-v1
  namespace: shop
  labels: {app: shop, version: v1}
spec:
  selector: {app: shop, version: v1}
  ports:
    - {name: http, port: 80, targetPort: http}
EOF
sed 's/shop-v1/shop-v2/g; s/version: v1/version: v2/g' shop-v1.yaml > shop-v2.yaml

Der gRPC-Dienst payments – dasselbe Image im gRPC-Modus, mit Server Reflection:

cat > payments.yaml <<'EOF'
# Demo-gRPC-Dienst: GrpcEcho mit Server Reflection auf Port 3000 (h2c)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: payments
  namespace: payments
  labels: {app: payments}
spec:
  replicas: 1
  selector:
    matchLabels: {app: payments}
  template:
    metadata:
      labels: {app: payments}
    spec:
      containers:
        - name: grpc-echo
          image: registry.k8s.io/gateway-api/echo-basic:v1.6.0
          env:
            - name: GRPC_ECHO_SERVER
              value: "1"
            - name: SERVICE_NAME
              value: payments
            - name: POD_NAME
              valueFrom: {fieldRef: {fieldPath: metadata.name}}
            - name: NAMESPACE
              valueFrom: {fieldRef: {fieldPath: metadata.namespace}}
          ports:
            - {name: grpc, containerPort: 3000}
          readinessProbe:
            tcpSocket: {port: grpc}
          resources:
            requests: {cpu: 10m, memory: 16Mi}
            limits: {memory: 64Mi}
---
apiVersion: v1
kind: Service
metadata:
  name: payments
  namespace: payments
  labels: {app: payments}
spec:
  selector: {app: payments}
  ports:
    - name: grpc
      port: 3000
      targetPort: grpc
      appProtocol: kubernetes.io/h2c
EOF
kubectl apply -f namespaces.yaml -f shop-v1.yaml -f shop-v2.yaml -f payments.yaml
kubectl get pods -A -l 'app in (shop,payments)'

Erwartet (gekürzt):

NAMESPACE   NAME                        READY   STATUS    RESTARTS   AGE
payments    payments-6cfbdd9c64-94c5d   1/1     Running   0          44s
shop        shop-v1-78db96c8d9-n4t9k    1/1     Running   0          44s
shop        shop-v2-8b7c8fcd7-c7snd     1/1     Running   0          44s

appProtocol: kubernetes.io/h2c sagt dem Gateway später, dass hinter dem Service HTTP/2 ohne TLS spricht – Pflicht für gRPC (Tag 6).

Fortschritt speichern? Kostenlos registrieren

Drill 6: Echo-Server kennenlernen

kubectl -n shop port-forward svc/shop-v1 8080:80 >/dev/null &
sleep 2
curl -s localhost:8080/hallo

Erwartet:

{
 "path": "/hallo",
 "host": "localhost:8080",
 "method": "GET",
 "proto": "HTTP/1.1",
 "headers": {
  "Accept": [
   "*/*"
  ],
  "User-Agent": [
   "curl/8.7.1"
  ]
 },
 "httpPort": "3000",
 "namespace": "shop",
 "ingress": "",
 "service": "shop-v1",
 "pod": "shop-v1-78db96c8d9-n4t9k"
}
curl -s localhost:8080/hallo | jq -r .service
curl -s -o /dev/null -w '%{http_code} %{time_total}s\n' 'localhost:8080/x?delay=1s'
kill %1

Erwartet:

shop-v1
200 1.006343s

Merke dir die Spezialpfade: ?delay=3s verzögert die Antwort (Timeouts, Tag 3), /status/503 liefert einen beliebigen Statuscode und /retry/?uuid=…&succeedAfter=N scheitert N-mal, bevor es antwortet (Retries, Tag 3). kubectl -n shop logs zeigt jede Anfrage als Echoing back request made to ….

Fortschritt speichern? Kostenlos registrieren

Drill 7: cloud-provider-kind starten

Öffne ein zweites Terminal und lass es während aller kind-Tage laufen.

macOS (Docker läuft in einer VM, deshalb Tunnel über ein lo0-Alias – braucht sudo):

sudo cloud-provider-kind --gateway-channel disabled

Linux (die LB-IPs liegen direkt auf der Docker-Bridge):

cloud-provider-kind --gateway-channel disabled

Erwartet (gekürzt):

I1009 22:44:02.545791 app.go:228] Detect runtime: docker
I1009 22:44:02.751287 controller.go:169] "Connected successfully" cluster="gw-lab" ...
I1009 22:44:02.751299 controller.go:96] "Creating new cloud provider" cluster="gw-lab"

Warum --gateway-channel disabled? Ohne das Flag installiert cloud-provider-kind eigene Gateway-API-CRDs und eine GatewayClass cloud-provider-kind. Wir wollen Envoy Gateway (Tag 1) – und genau eine Quelle für die CRDs.

Test im ersten Terminal:

kubectl -n shop expose deployment shop-v1 --name lb-test \
  --type LoadBalancer --port 80 --target-port 3000
kubectl -n shop get svc lb-test -w

Erwartet (nach 10–60 s, IP kann abweichen; Ctrl+C beendet -w):

NAME      TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
lb-test   LoadBalancer   10.96.228.108   <pending>     80:30205/TCP   1s
lb-test   LoadBalancer   10.96.228.108   172.18.0.10   80:30205/TCP   12s
LB_IP=$(kubectl -n shop get svc lb-test \
  -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
curl -s "http://$LB_IP/lb" | jq -c '{path, service}'
docker ps --filter label=io.x-k8s.cloud-provider-kind.cluster=gw-lab \
  --format '{{.Names}} {{.Image}}'
kubectl -n shop delete svc lb-test

Erwartet:

{"path":"/lb","service":"shop-v1"}
kindccm-ee2e011807f7 envoyproxy/envoy:v1.33.2
service "lb-test" deleted from shop namespace

Pro LoadBalancer-Service startet cloud-provider-kind einen kleinen Envoy-Container (kindccm-…) im Docker-Netz kind. Er bekommt die externe IP und leitet auf die NodePorts weiter.

Achtung: cloud-provider-kind bedient alle kind-Cluster auf deinem Rechner. Hast du weitere Cluster mit LoadBalancer-Services, bekommen die ebenfalls IPs.

Tipp: Kein sudo möglich? Starte mit --enable-lb-port-mapping. Dann veröffentlicht der kindccm-Container Port 80 auf einem zufälligen Host-Port, den du mit docker port <container> 80/tcp findest. Statt --resolve host:80:$GW_IP nimmst du --connect-to ::127.0.0.1:<port>.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Hilfsskripte und das curl-Muster

Ab Tag 2 hat jedes Gateway eine Adresse in status.addresses. Dieses Skript liest sie aus:

cat > ~/gw-lab/code/demo/gw-ip.sh <<'EOF'
#!/usr/bin/env bash
# Gibt die Adresse eines Gateways aus (status.addresses[0].value).
# Aufruf: gw-ip.sh [gateway] [namespace]   Default: web infra
set -euo pipefail
gw="${1:-web}"
ns="${2:-infra}"
ip=$(kubectl -n "$ns" get gateway "$gw" \
  -o jsonpath='{.status.addresses[0].value}' 2>/dev/null || true)
if [ -z "$ip" ]; then
  echo "Gateway $ns/$gw hat (noch) keine Adresse – läuft cloud-provider-kind?" >&2
  exit 1
fi
echo "$ip"
EOF
chmod +x ~/gw-lab/code/demo/gw-ip.sh
~/gw-lab/code/demo/gw-ip.sh; echo "Exit: $?"

Erwartet (noch gibt es kein Gateway):

Gateway infra/web hat (noch) keine Adresse – läuft cloud-provider-kind?
Exit: 1

Das Muster für alle folgenden Tage:

dig +short shop.gw.localtest.me

Erwartet:

127.0.0.1
GW_IP=$(~/gw-lab/code/demo/gw-ip.sh)
curl -s --resolve shop.gw.localtest.me:80:$GW_IP http://shop.gw.localtest.me/

Warum --resolve? Der Name löst öffentlich auf 127.0.0.1 auf, das Gateway lauscht aber auf $GW_IP. --resolve biegt nur die Namensauflösung um. Host-Header und – ab Tag 4 – SNI bleiben shop.gw.localtest.me. Genau so verhält sich später ein echter DNS-Eintrag.

Im Begleitcode unter code/demo liegen zusätzlich up.sh (baut das Lab auf den Stand nach Tag 2) und down.sh (löscht den Cluster). Damit kannst du jeden späteren Tag frisch beginnen.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "kind-Cluster gw-lab existiert" 'kind get clusters | grep -qx gw-lab'
check "Kontext kind-gw-lab aktiv" \
  '[ "$(kubectl config current-context)" = kind-gw-lab ]'
check "alle Nodes Ready" \
  '! kubectl get nodes --no-headers | grep -v " Ready "'
check "shop-v1/v2 verfügbar" \
  'kubectl -n shop wait deploy/shop-v1 deploy/shop-v2 --for=condition=Available \
     --timeout=5s'
check "payments verfügbar" \
  'kubectl -n payments wait deploy/payments --for=condition=Available --timeout=5s'
check "cloud-provider-kind läuft" 'pgrep -f cloud-provider-kind'
check "gw-ip.sh ausführbar" '[ -x ~/gw-lab/code/demo/gw-ip.sh ]'

Erwartet:

✔ kind-Cluster gw-lab existiert
✔ Kontext kind-gw-lab aktiv
✔ alle Nodes Ready
✔ shop-v1/v2 verfügbar
✔ payments verfügbar
✔ cloud-provider-kind läuft
✔ gw-ip.sh ausführbar

Challenge

Skaliere shop-v2 auf zwei Replicas und beweise über einen LoadBalancer-Service, dass die Antworten von zwei verschiedenen Pods kommen. Räume danach auf.

Hinweis: Das Feld pod im Antwort-JSON verrät, wer geantwortet hat.

Lösung

kubectl -n shop scale deploy shop-v2 --replicas=2
kubectl -n shop rollout status deploy shop-v2
kubectl -n shop expose deployment shop-v2 --name lb-v2 \
  --type LoadBalancer --port 80 --target-port 3000
until IP=$(kubectl -n shop get svc lb-v2 \
  -o jsonpath='{.status.loadBalancer.ingress[0].ip}') && [ -n "$IP" ]; do sleep 2; done
for i in $(seq 1 20); do curl -s "http://$IP/" | jq -r .pod; done | sort | uniq -c
kubectl -n shop delete svc lb-v2
kubectl -n shop scale deploy shop-v2 --replicas=1

Erwartet (Pod-Namen und Verteilung weichen ab):

  10 shop-v2-8b7c8fcd7-c7snd
  10 shop-v2-8b7c8fcd7-tvmxw

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • kind ersetzt keinen Mehrknoten-Cluster: kein echtes Netzwerk zwischen Zonen, kein externes DNS. Das kommt ab Tag 8 auf RKE2.
  • Statt cloud-provider-kind übernimmt in Produktion ein Cloud-LB, MetalLB oder Cilium LB-IPAM mit L2/BGP die externen IPs (Tag 9).
  • Demo-Images aus Test-Registries gehören nicht in Produktion. Echte Workloads: Images per Digest pinnen und aus einer internen Registry ziehen.
  • Interne Namen wie *.gw.localtest.me ersetzt du durch eine eigene Zone mit Wildcard- Eintrag auf die Gateway-IP (Tag 9: *.apps.lab.internal).