Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 10: Gateway API

Ziel: Du schaltest Ciliums Gateway-Controller ein, veröffentlichst Dienste über ein Gateway und steuerst Verkehr mit HTTPRoute und GRPCRoute nach Pfad, Header und Gewicht – und liest an den Status-Conditions ab, warum eine Route nicht greift. · Dauer: ca. 90 min · Voraussetzung: Tag 6

Briefing

  • CKNE: Advanced Traffic Management – „Managing Traffic with the Gateway API“.
  • Rollen: Die GatewayClass gehört dem Plattform-Team (welcher Controller), das Gateway dem Cluster-Betrieb (welche Ports und Hosts), die Routen den App-Teams.
  • Cilium setzt jedes Gateway in Envoy um (DaemonSet cilium-envoy) und erzeugt dafür einen Service cilium-gateway-<name>.
  • Status lesen ist die halbe Prüfung: Accepted, Programmed, ResolvedRefs.
 cp1/router ── Host: shop.example.com ──> <Node-IP>:<NodePort>
                                           │  Service cilium-gateway-web
                                           v
                                  Envoy (Gateway web, Listener http:80)
                    HTTPRoute match/canary/filter ─┬─> echo-v1 / echo-v2   (tag10)
                    HTTPRoute billing + ReferenceGrant ─> billing (tag10-backend)
                    GRPCRoute grpc ─────────────────────> grpc-echo        (tag10)

Drill 1: CRDs und Controller einschalten

Die Gateway API ist nicht Teil von Kubernetes – ihre CRDs kommen getrennt. Cilium 1.20.5 verlangt laut Doku Gateway API v1.6.3; das Standard-Paket enthält schon GRPCRoute, TLSRoute und BackendTLSPolicy, der experimentelle Kanal ist nicht nötig:

mkdir -p ~/ckne/tag10 && cd ~/ckne/tag10
GWAPI=https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.6.3
k apply --server-side -f $GWAPI/standard-install.yaml
k get crd | grep gateway.networking

Erwartet (gekürzt):

customresourcedefinition.apiextensions.k8s.io/gatewayclasses.gateway.networking.k8s.io
serverside-applied
...
validatingadmissionpolicy.admissionregistration.k8s.io/safe-upgrades.gateway.networking
.k8s.io serverside-applied
backendtlspolicies.gateway.networking.k8s.io   Namespaced   v1(storage)
gatewayclasses.gateway.networking.k8s.io       Cluster      v1(storage),v1beta1
gateways.gateway.networking.k8s.io             Namespaced   v1(storage),v1beta1
grpcroutes.gateway.networking.k8s.io           Namespaced   v1(storage)
httproutes.gateway.networking.k8s.io           Namespaced   v1(storage),v1beta1
listenersets.gateway.networking.k8s.io         Namespaced   v1(storage)
referencegrants.gateway.networking.k8s.io      Namespaced   v1,v1beta1(storage)
tcproutes.gateway.networking.k8s.io            Namespaced   v1(storage)
tlsroutes.gateway.networking.k8s.io            Namespaced   v1(storage)
udproutes.gateway.networking.k8s.io            Namespaced   v1(storage)

Jetzt den Controller in Cilium. Voraussetzungen erfüllt das Labor seit Tag 0: kubeProxyReplacement=true und der L7-Proxy (Standard). Der Agent liest die Konfiguration nur beim Start, deshalb danach beide Komponenten neu starten:

helm get values cilium -n kube-system -o yaml > values-vorher.yaml
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 \
  --reuse-values --set gatewayAPI.enabled=true
k -n kube-system rollout restart deployment/cilium-operator
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium
cilium status --wait
cilium config view | grep -E '^enable-gateway-api |gateway-api-hostnetwork-enabled'
k get gatewayclass

Erwartet (gekürzt):

daemon set "cilium" successfully rolled out
    /¯¯\
 /¯¯\__/¯¯\    Cilium:             OK
 \__/¯¯\__/    Operator:           OK
 /¯¯\__/¯¯\    Envoy DaemonSet:    OK
enable-gateway-api                                true
gateway-api-hostnetwork-enabled                   false
NAME     CONTROLLER                     ACCEPTED   AGE
cilium   io.cilium/gateway-controller   True       91s

Die GatewayClass cilium legt das Helm-Chart selbst an. Was der Controller kann, steht in ihrem Status:

k get gatewayclass cilium -o jsonpath='{.status.supportedFeatures[*].name}' \
  | tr ' ' '\n' \
  | grep -E '^(GRPCRoute|BackendTLSPolicy|HTTPRouteRequestMirror|TLSRoute)$'

Erwartet:

BackendTLSPolicy
GRPCRoute
HTTPRouteRequestMirror
TLSRoute

Fortschritt speichern? Kostenlos registrieren

Drill 2: Erstes Gateway – und warum es nicht „Programmed“ wird

Als Backend dient echo-basic aus den Conformance-Tests der Gateway API (amd64 und arm64; das Image hat eigene Tags – ein v1.6.3 gibt es nicht, v1.5.1 läuft unverändert mit den CRDs v1.6.3): Es antwortet mit Pfad, Host, Headern und Pod-Namen als JSON. Den Pod-Namen liest es aus der Variable POD_NAME, deshalb ein kurzes Manifest statt k create deployment:

k create namespace tag10
k config set-context --current --namespace=tag10
cat > echo.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: echo-v1
spec:
  selector:
    matchLabels: {app: echo, version: v1}
  template:
    metadata:
      labels: {app: echo, version: v1}
    spec:
      containers:
      - name: echo
        image: registry.k8s.io/gateway-api/echo-basic:v1.5.1
        env:
        - name: POD_NAME
          valueFrom: {fieldRef: {fieldPath: metadata.name}}
        - name: NAMESPACE
          valueFrom: {fieldRef: {fieldPath: metadata.namespace}}
EOF
sed -e 's/echo-v1/echo-v2/' -e 's/version: v1/version: v2/g' echo.yaml > echo-v2.yaml
k apply -f echo.yaml -f echo-v2.yaml
k expose deployment echo-v1 --port=8080 --target-port=3000
k expose deployment echo-v2 --port=8080 --target-port=3000
k rollout status deployment echo-v2

Nun das Gateway. Es gibt keinen k create gateway – YAML aus der Doku oder k explain gateway.spec.listeners hilft:

cat > gw.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: web
spec:
  gatewayClassName: cilium
  listeners:
  - name: http
    protocol: HTTP
    port: 80
    allowedRoutes:
      namespaces:
        from: Same
EOF
k apply -f gw.yaml
k get gateway web
k get svc cilium-gateway-web
k get gateway web -o jsonpath=\
'{range .status.conditions[*]}{.type}={.status} {.reason}: {.message}{"\n"}{end}'

Erwartet:

gateway.gateway.networking.k8s.io/web created
NAME   CLASS    ADDRESS   PROGRAMMED   AGE
web    cilium             False        11s
NAME                 TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
cilium-gateway-web   LoadBalancer   10.109.212.37   <pending>     80:30285/TCP   11s
Accepted=True Accepted: Gateway successfully scheduled
Programmed=False AddressNotAssigned: Gateway waiting for address

Der erste typische Fehler: Cilium baut für das Gateway einen LoadBalancer-Service, und ohne LB-IPAM-Pool (Tag 15) bekommt der keine IP. Einen Pool aus dem Labornetz 172.16.0.0/24 legst du hier bewusst nicht an – im Heimnetz verteilt der Router per DHCP, freie Adressen sind nicht garantiert. Auch der Host-Network-Modus (gatewayAPI.hostNetwork.enabled) scheidet aus: Er gilt clusterweit, schließt den LoadBalancer-Modus für alle Gateways aus und braucht wieder Agent-Neustarts. Bleibt der saubere Weg pro GatewayClass – ein CiliumGatewayClassConfig mit Service-Typ NodePort:

k explain ciliumgatewayclassconfig.spec.service.type
cat > nodeport.yaml <<'EOF'
apiVersion: cilium.io/v2alpha1
kind: CiliumGatewayClassConfig
metadata:
  name: nodeport
spec:
  service:
    type: NodePort
---
apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: tag10-nodeport
spec:
  controllerName: io.cilium/gateway-controller
  parametersRef:
    group: cilium.io
    kind: CiliumGatewayClassConfig
    name: nodeport
    namespace: tag10
EOF
k apply -f nodeport.yaml
sed -i 's/gatewayClassName: cilium/gatewayClassName: tag10-nodeport/' gw.yaml
k apply -f gw.yaml
k get gatewayclass
k get gateway web
k get svc cilium-gateway-web

Erwartet (gekürzt):

  enum: LoadBalancer, NodePort
ciliumgatewayclassconfig.cilium.io/nodeport created
gatewayclass.gateway.networking.k8s.io/tag10-nodeport created
gateway.gateway.networking.k8s.io/web configured
NAME             CONTROLLER                     ACCEPTED   AGE
cilium           io.cilium/gateway-controller   True       4m23s
tag10-nodeport   io.cilium/gateway-controller   True       17s
NAME   CLASS            ADDRESS       PROGRAMMED   AGE
web    tag10-nodeport   172.16.0.83   True         73s
NAME                 TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
cilium-gateway-web   NodePort   10.109.212.37   <none>        80:30285/TCP   73s

Als Adressen meldet das Gateway jetzt die Node-IPs, der Listener-Port 80 wird zum NodePort. Die naheliegende Abkürzung, spec.infrastructure.parametersRef direkt am Gateway, lehnt Cilium 1.20 ab („InvalidParameters: spec.infrastructure.parametersRef is not supported“) – Parameter nur über die GatewayClass.

NP=$(k get svc cilium-gateway-web -o jsonpath='{.spec.ports[0].nodePort}')
G=172.16.0.228:$NP; echo $G
k get ciliumenvoyconfig
k get endpointslices -l io.cilium.gateway/owning-gateway=web
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
  | grep -A1 ":$NP/"

Erwartet:

172.16.0.228:30285
NAME                 AGE
cilium-gateway-web   4m44s
NAME                 ADDRESSTYPE   PORTS   ENDPOINTS         AGE
cilium-gateway-web   IPv4          9999    192.192.192.192   4m45s
31   0.0.0.0:30285/TCP         NodePort       1 => 127.0.0.1:18532/TCP (active)

Der Service hat nur einen Platzhalter-Endpunkt; in Wahrheit leitet Cilium den Port per eBPF an den Envoy-Listener (127.0.0.1:18532) weiter. Die Envoy-Konfiguration selbst steht im CiliumEnvoyConfig mit gleichem Namen.

Fortschritt speichern? Kostenlos registrieren

Drill 3: HTTPRoute nach Host, Pfad und Header

Regeln werden nicht der Reihe nach geprüft, sondern nach Spezifität: zuerst der genaueste bzw. längste Pfad, bei Gleichstand mehr Header-Treffer; die Regel ohne matches fängt den Rest.

cat > route-match.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: match
spec:
  parentRefs:
  - name: web
  hostnames:
  - shop.example.com
  rules:
  - matches:
    - headers:
      - name: x-version
        value: v2
    backendRefs:
    - name: echo-v2
      port: 8080
  - matches:
    - path:
        type: PathPrefix
        value: /v2
    backendRefs:
    - name: echo-v2
      port: 8080
  - backendRefs:
    - name: echo-v1
      port: 8080
EOF
k apply -f route-match.yaml
H='Host: shop.example.com'
curl -s -H "$H" http://$G/ | grep -E '"(path|pod)"'
curl -s -H "$H" http://$G/v2/cart | grep -E '"(path|pod)"'
curl -s -H "$H" http://$G/v2x | grep -E '"(path|pod)"'
curl -s -H "$H" -H 'x-version: v2' http://$G/ | grep -E '"(path|pod)"'
curl -s -o /dev/null -w '%{http_code}\n' -H 'Host: other.example.com' http://$G/

Erwartet:

httproute.gateway.networking.k8s.io/match created
 "path": "/",
 "pod": "echo-v1-5dbcd994f5-vq56q"
 "path": "/v2/cart",
 "pod": "echo-v2-5484b4fc56-bq4sg"
 "path": "/v2x",
 "pod": "echo-v1-5dbcd994f5-vq56q"
 "path": "/",
 "pod": "echo-v2-5484b4fc56-bq4sg"
404

PathPrefix vergleicht ganze Pfadsegmente: /v2x ist kein Treffer für /v2. Unbekannte Hosts beantwortet Envoy mit 404. Dasselbe von außerhalb des Clusters – vom router, diesmal über worker2:

ssh [email protected] \
  "curl -s -H 'Host: shop.example.com' http://172.16.0.83:$NP/v2/" \
  | grep -E '"pod"|X-Forwarded-For' -A1
k get httproute match -o jsonpath=\
'{range .status.parents[*].conditions[*]}{.type}={.status} {.reason}{"\n"}{end}'
k get gateway web -o jsonpath='{.status.listeners[0].attachedRoutes}{"\n"}'

Erwartet:

  "X-Forwarded-For": [
   "172.16.0.123"
--
 "pod": "echo-v2-5484b4fc56-bq4sg"
Accepted=True Accepted
ResolvedRefs=True ResolvedRefs
1

Fortschritt speichern? Kostenlos registrieren

Drill 4: Canary 90/10 mit Zählung

cat > route-canary.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: canary
spec:
  parentRefs:
  - name: web
  hostnames:
  - canary.example.com
  rules:
  - backendRefs:
    - name: echo-v1
      port: 8080
      weight: 90
    - name: echo-v2
      port: 8080
      weight: 10
EOF
k apply -f route-canary.yaml
for i in $(seq 200); do
  curl -s -H 'Host: canary.example.com' http://$G/
done | grep -o '"pod": "echo-v[12]' | sort | uniq -c

Erwartet (Zahlen schwanken):

httproute.gateway.networking.k8s.io/canary created
    183 "pod": "echo-v1
     17 "pod": "echo-v2

Gewichte sind relativ (90:10 = 9:1) und gelten pro Anfrage, nicht pro Client – kein Sticky. Gewicht 0 nimmt ein Backend aus der Verteilung, ohne die Route zu ändern.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Filter – Header, Redirect, Rewrite

cat > route-filter.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: filter
spec:
  parentRefs:
  - name: web
  hostnames:
  - api.example.com
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /old
    filters:
    - type: RequestRedirect
      requestRedirect:
        path:
          type: ReplacePrefixMatch
          replacePrefixMatch: /new
        statusCode: 301
  - matches:
    - path:
        type: PathPrefix
        value: /api/v1
    filters:
    - type: URLRewrite
      urlRewrite:
        path:
          type: ReplacePrefixMatch
          replacePrefixMatch: /
    backendRefs:
    - name: echo-v1
      port: 8080
  - filters:
    - type: RequestHeaderModifier
      requestHeaderModifier:
        add:
        - name: x-team
          value: blue
        set:
        - name: user-agent
          value: gateway
        remove:
        - x-debug
    backendRefs:
    - name: echo-v1
      port: 8080
EOF
k apply -f route-filter.yaml
H='Host: api.example.com'
curl -si -H "$H" http://$G/old/page | grep -iE '^HTTP|^location'
curl -s -H "$H" http://$G/api/v1/users | grep '"path"'
curl -s -H "$H" -H 'x-debug: 1' http://$G/ | sed -n '/headers/,/httpPort/p'

Erwartet (gekürzt):

HTTP/1.1 301 Moved Permanently
location: http://api.example.com:80/new/page
 "path": "/users",
 "headers": {
  "User-Agent": [
   "gateway"
  ],
  "X-Envoy-Internal": [
   "true"
  ],
  "X-Forwarded-For": [
   "172.16.0.126"
  ],
  "X-Team": [
   "blue"
  ]
 },

Ein Redirect geht zurück an den Client, ein Rewrite bleibt unsichtbar für ihn – das Backend sieht /users. x-debug ist weg, X-Team neu. Die location nennt Port 80, den Listener-Port; hinter einem NodePort würdest du requestRedirect.port setzen.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Über Namespaces mit ReferenceGrant

k create namespace tag10-backend
k -n tag10-backend apply -f echo.yaml
k -n tag10-backend expose deployment echo-v1 --name=billing --port=8080 \
  --target-port=3000
cat > route-billing.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: billing
spec:
  parentRefs:
  - name: web
  hostnames:
  - billing.example.com
  rules:
  - backendRefs:
    - name: billing
      namespace: tag10-backend
      port: 8080
EOF
k apply -f route-billing.yaml
RC='{range .status.parents[*].conditions[*]}{.type}={.status} '\
'{.reason}: {.message}{"\n"}{end}'
k get httproute billing -o jsonpath="$RC"
curl -s -w ' %{http_code}\n' -H 'Host: billing.example.com' http://$G/

Erwartet:

httproute.gateway.networking.k8s.io/billing created
Accepted=True Accepted: Accepted HTTPRoute
ResolvedRefs=False RefNotPermitted: Cross namespace references are not allowed
 500

Ein Verweis in einen fremden Namespace braucht dessen Zustimmung: Der Ziel-Namespace legt einen ReferenceGrant an, der sagt, wer worauf zeigen darf.

cat > grant.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: ReferenceGrant
metadata:
  name: tag10-routes
  namespace: tag10-backend
spec:
  from:
  - group: gateway.networking.k8s.io
    kind: HTTPRoute
    namespace: tag10
  to:
  - group: ""
    kind: Service
EOF
k apply -f grant.yaml
k get httproute billing -o jsonpath=\
'{range .status.parents[*].conditions[*]}{.type}={.status} {.reason}{"\n"}{end}'
curl -s -H 'Host: billing.example.com' http://$G/ | grep -E '"(namespace|pod)"'

Erwartet:

referencegrant.gateway.networking.k8s.io/tag10-routes created
Accepted=True Accepted
ResolvedRefs=True ResolvedRefs
 "namespace": "tag10-backend",
 "pod": "echo-v1-5dbcd994f5-7tfsx"

Die umgekehrte Richtung – eine Route aus tag10-backend an das Gateway in tag10 – regelt nicht der ReferenceGrant, sondern allowedRoutes am Listener (Drill 8).

Fortschritt speichern? Kostenlos registrieren

Drill 7: GRPCRoute

echo-basic spricht mit GRPC_ECHO_SERVER=1 gRPC (inklusive Reflection). Envoy muss wissen, dass das Backend HTTP/2 ohne TLS erwartet – dafür steht am Service-Port appProtocol: kubernetes.io/h2c:

sed -e 's/echo-v1/grpc-echo/' -e 's/version: v1/version: grpc/g' echo.yaml \
  > grpc-echo.yaml
cat >> grpc-echo.yaml <<'EOF'
        - name: GRPC_ECHO_SERVER
          value: "1"
EOF
k apply -f grpc-echo.yaml
k expose deployment grpc-echo --port=8080 --target-port=3000 $do > grpc-svc.yaml
sed -i 's/^  - port: 8080/  - port: 8080\n    appProtocol: kubernetes.io\/h2c/' \
  grpc-svc.yaml
k apply -f grpc-svc.yaml
cat > grpcroute.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: GRPCRoute
metadata:
  name: grpc
spec:
  parentRefs:
  - name: web
  hostnames:
  - grpc.example.com
  rules:
  - matches:
    - method:
        service: gateway_api_conformance.echo_basic.grpcecho.GrpcEcho
    backendRefs:
    - name: grpc-echo
      port: 8080
EOF
k apply -f grpcroute.yaml
k get grpcroute
k run grpcurl --image=fullstorydev/grpcurl:v1.9.3 --restart=Never -- \
  -plaintext -authority grpc.example.com $G list
k logs grpcurl; k delete pod grpcurl

Erwartet (gekürzt):

grpcroute.gateway.networking.k8s.io/grpc created
NAME   HOSTNAMES              AGE
grpc   ["grpc.example.com"]   3s
pod/grpcurl created
Failed to list services: server does not support the reflection API

Die Route ist korrekt – sie lässt aber nur den Dienst GrpcEcho durch. grpcurl list fragt den Reflection-Dienst, und den routet niemand. Also zweite Regel:

cat >> grpcroute.yaml <<'EOF'
  - matches:
    - method:
        service: grpc.reflection.v1.ServerReflection
    - method:
        service: grpc.reflection.v1alpha.ServerReflection
    backendRefs:
    - name: grpc-echo
      port: 8080
EOF
k apply -f grpcroute.yaml
k run grpcurl --image=fullstorydev/grpcurl:v1.9.3 --restart=Never -- \
  -plaintext -authority grpc.example.com $G list
k logs grpcurl; k delete pod grpcurl
k run grpcurl --image=fullstorydev/grpcurl:v1.9.3 --restart=Never -- \
  -plaintext -authority grpc.example.com $G \
  gateway_api_conformance.echo_basic.grpcecho.GrpcEcho/Echo
k logs grpcurl | grep -E 'fullyQualifiedMethod|"pod"'; k delete pod grpcurl

Erwartet (gekürzt):

gateway_api_conformance.echo_basic.grpcecho.GrpcEcho
grpc.reflection.v1.ServerReflection
grpc.reflection.v1alpha.ServerReflection
"fullyQualifiedMethod": "/gateway_api_conformance.echo_basic.grpcecho.GrpcEcho/Echo",
      "pod": "grpc-echo-55f498c9b8-wlv5s"

Kommt k logs zu früh („ContainerCreating“), kurz warten – der Pod läuft nur Sekunden. HTTP- und gRPC-Routen teilen sich hier denselben HTTP-Listener; der Unterschied liegt nur im Match (Service/Methode statt Pfad).

Fortschritt speichern? Kostenlos registrieren

Drill 8: Status lesen und typische Fehler

Drei typische Fehler: in route-bad.yaml ein Listener-Name, den es nicht gibt, und ein fehlender Service, danach eine Route aus einem fremden Namespace:

cat > route-bad.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: bad
spec:
  parentRefs:
  - name: web
    sectionName: https
  rules:
  - backendRefs:
    - name: echo-v3
      port: 8080
EOF
k apply -f route-bad.yaml
k get httproute bad -o jsonpath="$RC"
sed -i '/sectionName/d' route-bad.yaml
k apply -f route-bad.yaml
k get httproute bad -o jsonpath="$RC"

Erwartet:

httproute.gateway.networking.k8s.io/bad created
Accepted=False NoMatchingParent: No matching listener with sectionName https
ResolvedRefs=False BackendNotFound: Service "echo-v3" not found
httproute.gateway.networking.k8s.io/bad configured
Accepted=True Accepted: Accepted HTTPRoute
ResolvedRefs=False BackendNotFound: Service "echo-v3" not found
k -n tag10-backend apply -f - <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: fremd
spec:
  parentRefs:
  - name: web
    namespace: tag10
  rules:
  - backendRefs:
    - name: billing
      port: 8080
EOF
k -n tag10-backend get httproute fremd -o jsonpath="$RC"
k delete httproute bad; k -n tag10-backend delete httproute fremd

Erwartet:

httproute.gateway.networking.k8s.io/fremd created
Accepted=False NotAllowedByListeners: HTTPRoute is not allowed to attach to this Gateway
due to namespace restrictions
ResolvedRefs=True ResolvedRefs: Service reference is valid
Condition Objekt typischer Grund bei False
Accepted Gateway InvalidParameters, unbekannte GatewayClass
Programmed Gateway AddressNotAssigned (kein LB-IPAM-Pool)
Accepted Route NoMatchingParent, NotAllowedByListeners
ResolvedRefs Route BackendNotFound, RefNotPermitted

Wer schickt den Verkehr eigentlich? Hubble zeigt Gateway-Verkehr mit der reservierten Identität ingress – wichtig für Policies in Tag 12 und 14:

for i in 1 2 3; do curl -s -o /dev/null -H 'Host: shop.example.com' http://$G/v2/x; done
hubble observe -P --port-forward-port 0 --to-namespace tag10 \
  --to-label version=v2 --type l7 --last 2

Erwartet (gekürzt):

Nov 18 23:49:29.563: 127.0.0.1:53126 (ingress) -> tag10/echo-v2-5484b4fc56-bq4sg:3000
(ID:25858) http-request FORWARDED (HTTP/1.1 GET http://shop.example.com/v2/x)
Nov 18 23:49:29.597: 127.0.0.1:53136 (ingress) -> tag10/echo-v2-5484b4fc56-bq4sg:3000
(ID:25858) http-request FORWARDED (HTTP/1.1 GET http://shop.example.com/v2/x)

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Lege eine HTTPRoute docs für docs.example.com an, die nur GET auf den exakten Pfad /info an echo-v2 leitet. Zeitziel: 3 min
  2. Stelle canary auf 50/50 um, ohne die Datei zu öffnen. Zeitziel: 60 s
  3. Ergänze an docs den Antwort-Header x-served-by: gateway. Zeitziel: 2 min
  4. Zeige für alle HTTPRoutes in tag10 Name, Accepted-Status und ResolvedRefs-Grund in einer Tabelle. Zeitziel: 90 s

Lösung

cat > route-docs.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: docs
spec:
  parentRefs:
  - name: web
  hostnames:
  - docs.example.com
  rules:
  - matches:
    - path:
        type: Exact
        value: /info
      method: GET
    backendRefs:
    - name: echo-v2
      port: 8080
EOF
k apply -f route-docs.yaml
for p in /info /info/x; do
  curl -s -o /dev/null -w '%{http_code}\n' -H 'Host: docs.example.com' http://$G$p
done
curl -s -o /dev/null -w '%{http_code}\n' -X POST -H 'Host: docs.example.com' \
  http://$G/info
k patch httproute canary --type=json -p '[
 {"op":"replace","path":"/spec/rules/0/backendRefs/0/weight","value":50},
 {"op":"replace","path":"/spec/rules/0/backendRefs/1/weight","value":50}]'
for i in $(seq 100); do curl -s -H 'Host: canary.example.com' http://$G/; done \
  | grep -o '"pod": "echo-v[12]' | sort | uniq -c
k patch httproute docs --type=json -p '[{"op":"add","path":"/spec/rules/0/filters",
 "value":[{"type":"ResponseHeaderModifier",
 "responseHeaderModifier":{"add":[{"name":"x-served-by","value":"gateway"}]}}]}]'
curl -si -H 'Host: docs.example.com' http://$G/info | grep -i x-served-by
k get httproute -o custom-columns='NAME:.metadata.name,'\
'ACCEPTED:.status.parents[0].conditions[?(@.type=="Accepted")].status,'\
'REFS:.status.parents[0].conditions[?(@.type=="ResolvedRefs")].reason'

Erwartet (gekürzt):

200
404
404
httproute.gateway.networking.k8s.io/canary patched
     41 "pod": "echo-v1
     59 "pod": "echo-v2
httproute.gateway.networking.k8s.io/docs patched
x-served-by: gateway
NAME      ACCEPTED   REFS
billing   True       ResolvedRefs
canary    True       ResolvedRefs
docs      True       ResolvedRefs
filter    True       ResolvedRefs
match     True       ResolvedRefs

Achtung bei Testpfaden: echo-basic beantwortet /status selbst mit einem 301 auf /status/ – dann ist nicht das Gateway schuld.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

k get gatewayclass

Erwartet: cilium und tag10-nodeport, beide ACCEPTED True.

k get gateway web

Erwartet: CLASS tag10-nodeport, eine Node-IP als ADDRESS, PROGRAMMED True.

curl -s -H 'Host: shop.example.com' http://$G/v2/ | grep '"pod"'

Erwartet: ein Pod echo-v2-….

k get httproute billing -o jsonpath='{.status.parents[0].conditions[1].reason}{"\n"}'

Erwartet: ResolvedRefs (dank ReferenceGrant).

cilium config view | grep '^enable-gateway-api '

Erwartet: enable-gateway-api true – bleibt für Tag 11 und Tag 18 an, ebenso die Gateway-API-CRDs v1.6.3.

Challenge

Spiegele allen Verkehr an mirror.example.com zusätzlich an echo-v2, während die Antworten weiter von echo-v1 kommen. Weise die gespiegelten Anfragen nach.

Hinweis: Der Filter heißt RequestMirror; echo-basic protokolliert jede Anfrage.

Lösung

cat > route-mirror.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: mirror
spec:
  parentRefs:
  - name: web
  hostnames:
  - mirror.example.com
  rules:
  - filters:
    - type: RequestMirror
      requestMirror:
        backendRef:
          name: echo-v2
          port: 8080
    backendRefs:
    - name: echo-v1
      port: 8080
EOF
k apply -f route-mirror.yaml
for i in 1 2 3; do
  curl -s -H 'Host: mirror.example.com' http://$G/schatten-$i | grep '"pod"'
done
k logs deploy/echo-v2 --tail=3

Erwartet:

httproute.gateway.networking.k8s.io/mirror created
 "pod": "echo-v1-5dbcd994f5-vq56q"
 "pod": "echo-v1-5dbcd994f5-vq56q"
 "pod": "echo-v1-5dbcd994f5-vq56q"
Echoing back request made to /schatten-1 to client (10.0.0.88:32848)
Echoing back request made to /schatten-2 to client (10.0.0.88:32850)
Echoing back request made to /schatten-3 to client (10.0.0.88:32864)

Envoy schickt die Kopie „fire and forget“ – ihre Antwort verwirft er. So testest du eine neue Version mit echtem Verkehr, ohne dass ein Nutzer sie sieht.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

k delete namespace tag10 tag10-backend
k delete gatewayclass tag10-nodeport
k config set-context --current --namespace=default

Gateway-API-CRDs und gatewayAPI.enabled=true bleiben für Tag 11 und Tag 18. Ganz zurück (nur wenn du keine Folgetage machst): helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 --reuse-values --set gatewayAPI.enabled=false, Operator und Agenten neu starten.

Prüfungstipp

  • Kein k create für Gateway-Objekte: Beispiele aus gateway-api.sigs.k8s.io („Guides“) kopieren, Felder mit k explain httproute.spec.rules prüfen.
  • Erst Accepted/Programmed am Gateway, dann Accepted/ResolvedRefs an der Route lesen – der reason sagt fast immer, was fehlt (Listener-Name, Service, ReferenceGrant, allowedRoutes).
  • ReferenceGrant liegt im Namespace des Ziels; allowedRoutes steht am Gateway.

Enterprise-Notiz

  • In Produktion bekommt das Gateway eine echte LoadBalancer-IP (LB-IPAM mit BGP oder L2, Tag 15, oder Cloud-LB); NodePort ist eine Labor- und Notlösung.
  • Ein Gateway pro Team oder Umgebung, gemeinsame Gateways mit allowedRoutes.namespaces.from: Selector und Namespace-Labels.
  • Gateway-API-CRDs gehören dem Plattform-Team: Version an die Controller-Version koppeln, Upgrades über --server-side und die mitgelieferte safe-upgrades-ValidatingAdmissionPolicy.
  • Canary-Gewichte steuern Werkzeuge wie Argo Rollouts oder Flagger automatisch über dieselben weight-Felder.
  • Envoy läuft als eigenes DaemonSet cilium-envoy: Ressourcen-Limits und Updates getrennt vom Agenten planen.