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 Servicecilium-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.networkingErwartet (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 gatewayclassErwartet (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-v2Nun 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-webErwartet (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 -cErwartet (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 grpcurlErwartet (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 grpcurlErwartet (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 fremdErwartet:
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 2Erwartet (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
- Lege eine HTTPRoute
docsfürdocs.example.coman, die nurGETauf den exakten Pfad/infoanecho-v2leitet. Zeitziel: 3 min - Stelle
canaryauf 50/50 um, ohne die Datei zu öffnen. Zeitziel: 60 s - Ergänze an
docsden Antwort-Headerx-served-by: gateway. Zeitziel: 2 min - Zeige für alle HTTPRoutes in
tag10Name,Accepted-Status undResolvedRefs-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 gatewayclassErwartet: cilium und
tag10-nodeport, beide ACCEPTED True.
k get gateway webErwartet: 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=3Erwartet:
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=defaultGateway-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 createfür Gateway-Objekte: Beispiele aus gateway-api.sigs.k8s.io („Guides“) kopieren, Felder mitk explain httproute.spec.rulesprüfen. - Erst
Accepted/Programmedam Gateway, dannAccepted/ResolvedRefsan der Route lesen – derreasonsagt fast immer, was fehlt (Listener-Name, Service, ReferenceGrant,allowedRoutes). - ReferenceGrant liegt im Namespace des Ziels;
allowedRoutessteht 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: Selectorund Namespace-Labels. - Gateway-API-CRDs gehören dem Plattform-Team: Version an die
Controller-Version koppeln, Upgrades über
--server-sideund die mitgeliefertesafe-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.