Tag 10: Ingress mit Gateway API
Ziel: Die App ist von außen per HTTPS erreichbar – einmal über ein Gateway außerhalb des Mesh, einmal über einen Proxy im Mesh – und du weißt, was das für mTLS und Policies bedeutet. · Dauer: ca. 75 min · Voraussetzung: Tag 9
Briefing
- Linkerd bringt keinen Ingress mit. Es arbeitet mit dem Gateway oder Ingress-Controller, den du schon hast.
- Variante A: Gateway außerhalb des Mesh – hier Cilium (Envoy auf jedem Node). Der erste Hop ins Mesh ist kein mTLS, das Ziel sieht nur eine IP. Policies brauchen dafür eine NetworkAuthentication.
- Variante B: Ingress-Proxy im Mesh – ab dem Eingangs-Pod läuft alles mit mTLS und Identität.
- Im Labor gibt es keine LoadBalancer-IPs; du erreichst beide über NodePorts.
- Heute in
tag10mit eigener Kopie vonwebundnotes-api.
Laptop ─HTTPS─> cp1:NodePort ─> Cilium-Envoy ──Klartext──> web ─mTLS─> notes-api
Laptop ─HTTPS─> cp1:30443 ───> edge (im Mesh) ──mTLS─────> web ─mTLS─> notes-api
Drill 1: Die App für heute
mkdir -p ~/linkerd/tag10 && cd ~/linkerd/tag10
kubectl create namespace tag10
kubectl annotate namespace tag10 linkerd.io/inject=enabled
cat > app.yaml <<'EOF'
apiVersion: v1
kind: ServiceAccount
metadata: {name: web, namespace: tag10}
---
apiVersion: v1
kind: ServiceAccount
metadata: {name: notes-api, namespace: tag10}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: notes-api, namespace: tag10}
spec:
replicas: 1
selector: {matchLabels: {app: notes-api}}
template:
metadata: {labels: {app: notes-api}}
spec:
serviceAccountName: notes-api
containers:
- name: notes-api
image: ghcr.io/thomaszachmann/notes-api:0.7.1
env: [{name: NOTES_API_KEY, value: lab-key-123}]
ports: [{containerPort: 8080, name: http}]
readinessProbe:
httpGet: {path: /healthz, port: http}
---
apiVersion: v1
kind: Service
metadata: {name: notes-api, namespace: tag10}
spec:
selector: {app: notes-api}
ports: [{port: 80, targetPort: http, name: http}]
---
apiVersion: v1
kind: ConfigMap
metadata: {name: web-conf, namespace: tag10}
data:
default.conf: |
server {
listen 8080;
location = / { default_type text/plain; return 200 "notes web\n"; }
location /api/ {
proxy_set_header X-API-Key lab-key-123;
proxy_pass http://notes-api.tag10.svc.cluster.local/;
}
}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: web, namespace: tag10}
spec:
replicas: 1
selector: {matchLabels: {app: web}}
template:
metadata: {labels: {app: web}}
spec:
serviceAccountName: web
containers:
- name: web
image: docker.io/nginxinc/nginx-unprivileged:1.31.7-alpine
ports: [{containerPort: 8080, name: http}]
volumeMounts: [{name: conf, mountPath: /etc/nginx/conf.d}]
volumes: [{name: conf, configMap: {name: web-conf}}]
---
apiVersion: v1
kind: Service
metadata: {name: web, namespace: tag10}
spec:
selector: {app: web}
ports: [{port: 80, targetPort: http, name: http}]
EOF
kubectl apply -f app.yaml
kubectl -n tag10 rollout status deploy --timeout=180s
kubectl -n tag10 get podsErwartet (gekürzt):
NAME READY STATUS RESTARTS AGE
notes-api-7d55845b4f-cmmlx 2/2 Running 0 10s
web-7d94ccc84d-ngbvt 2/2 Running 0 10s
notes-api läuft ohne Datenbank mit einem Speicher im RAM
– für heute reicht das.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Ein Gateway mit Cilium
kubectl get gatewayclass
cat > gateway.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata: {name: notes, namespace: tag10}
spec:
gatewayClassName: cilium
listeners:
- {name: http, protocol: HTTP, port: 80}
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: {name: web, namespace: tag10}
spec:
parentRefs:
- {name: notes}
hostnames: [notes.lab.internal]
rules:
- backendRefs:
- {name: web, port: 80}
EOF
kubectl apply -f gateway.yaml
sleep 15
kubectl -n tag10 get gateway notes
kubectl -n tag10 get svc cilium-gateway-notesErwartet (gekürzt):
NAME CONTROLLER ACCEPTED AGE
cilium io.cilium/gateway-controller True 12h
NAME CLASS ADDRESS PROGRAMMED AGE
notes cilium False 16s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
cilium-gateway-notes LoadBalancer 10.99.157.141 <pending> 80:31972/TCP 16s
Der Parent ist jetzt ein Gateway, kein Service wie
an Tag 9. Cilium legt dafür einen Service vom Typ
LoadBalancer an. Die IP bleibt
<pending>: Cilium könnte sie vergeben (LB-IPAM ist
an), aber im Labor gibt es keinen IP-Pool und keine L2-Ankündigung.
PROGRAMMED False heißt genau das
(AddressNotAssigned). Jeder LoadBalancer-Service hat aber
auch einen NodePort – der reicht fürs Labor:
NP=$(kubectl -n tag10 get svc cilium-gateway-notes \
-o jsonpath='{.spec.ports[?(@.port==80)].nodePort}')
curl -s -i -H 'Host: notes.lab.internal' http://172.16.0.126:$NP/ | head -2
curl -s -H 'Host: notes.lab.internal' http://172.16.0.228:$NP/api/notes; echo
curl -s -o /dev/null -w '%{http_code}\n' http://172.16.0.126:$NP/Erwartet:
HTTP/1.1 200 OK
server: envoy
[]
404
Jeder Node nimmt den NodePort an, auch worker1. Ohne
passenden Host-Header antwortet Envoy mit 404 – die Route
gilt nur für notes.lab.internal.
Wer bedient welche Route? Das entscheidet der
parentRef:
kubectl -n tag10 get httproute web \
-o jsonpath='{.status.parents[*].controllerName}{"\n"}'
kubectl -n tag10 get endpointslices -l io.cilium.gateway/owning-gateway=notesErwartet:
io.cilium/gateway-controller
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
cilium-gateway-notes IPv4 9999 192.192.192.192 16s
| parentRef | wer setzt um | wo |
|---|---|---|
Gateway notes |
Cilium | Envoy auf dem Node, Nord-Süd |
| Service (Tag 9) | Linkerd und Cilium | Client-Proxy bzw. Envoy, Ost-West |
Diese Route kennt nur Cilium; Linkerd ignoriert Routen mit
Gateway-Parent. Die EndpointSlice mit 192.192.192.192:9999
ist Ciliums Platzhalter für den Gateway-Service und gehört dem Gateway –
sie verschwindet mit ihm. Anders bei Routen mit Service-Parent: Dort
bleibt sie nach dem Löschen der Route liegen (Tag 9, Drill 7).
Fortschritt speichern? Kostenlos registrieren
Drill 3: HTTPS mit cert-manager
Eine kleine Labor-CA in tag10, daraus ein Zertifikat für
notes.lab.internal:
cat > tls.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: Issuer
metadata: {name: selfsigned, namespace: tag10}
spec:
selfSigned: {}
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata: {name: lab-ca, namespace: tag10}
spec:
isCA: true
commonName: lab-ca.tag10
secretName: lab-ca
privateKey: {algorithm: ECDSA, size: 256}
issuerRef: {name: selfsigned, kind: Issuer}
---
apiVersion: cert-manager.io/v1
kind: Issuer
metadata: {name: lab-ca, namespace: tag10}
spec:
ca: {secretName: lab-ca}
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata: {name: notes-tls, namespace: tag10}
spec:
secretName: notes-tls
dnsNames: [notes.lab.internal]
duration: 720h
privateKey: {algorithm: ECDSA, size: 256}
issuerRef: {name: lab-ca, kind: Issuer}
EOF
kubectl apply -f tls.yaml
kubectl -n tag10 wait --for=condition=Ready certificate --all --timeout=60s
cat > gateway-tls.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata: {name: notes, namespace: tag10}
spec:
gatewayClassName: cilium
listeners:
- {name: http, protocol: HTTP, port: 80}
- name: https
protocol: HTTPS
port: 443
hostname: notes.lab.internal
tls:
mode: Terminate
certificateRefs: [{name: notes-tls}]
EOF
kubectl apply -f gateway-tls.yaml
sleep 15
kubectl -n tag10 get svc cilium-gateway-notesErwartet (gekürzt):
certificate.cert-manager.io/lab-ca condition met
certificate.cert-manager.io/notes-tls condition met
gateway.gateway.networking.k8s.io/notes configured
NAME TYPE ... EXTERNAL-IP PORT(S)
cilium-gateway-notes LoadBalancer ... <pending> 80:31972/TCP,443:32290/TCP
Die Route aus Drill 2 hängt ohne sectionName an beiden
Listenern. Jetzt mit der CA prüfen statt mit -k:
kubectl -n tag10 get secret lab-ca -o jsonpath='{.data.ca\.crt}' | base64 -d \
> lab-ca.crt
NP=$(kubectl -n tag10 get svc cilium-gateway-notes \
-o jsonpath='{.spec.ports[?(@.port==443)].nodePort}')
G="--cacert lab-ca.crt --resolve notes.lab.internal:$NP:172.16.0.126 \
https://notes.lab.internal:$NP"
curl -s -w ' %{http_code}\n' $G/api/notes
curl -sv $G/ 2>&1 | grep -E 'SSL connection|issuer:|^< server'Erwartet:
[]
200
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384 / X25519 / id-ecPublicKey
* issuer: CN=lab-ca.tag10
< server: envoy
Vom Laptop aus geht es genauso – CA holen, dann curl mit
derselben Adresse:
scp [email protected]:linkerd/tag10/lab-ca.crt .
curl -s -w ' %{http_code}\n' --cacert lab-ca.crt \
--resolve notes.lab.internal:32290:172.16.0.126 \
https://notes.lab.internal:32290/api/notesErwartet:
[]
200
Setz statt 32290 deinen NodePort ein. Cilium liest das
Secret notes-tls selbst und spiegelt es nach
cilium-secrets – ein Neustart ist nicht nötig.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Was das Mesh davon sieht
timeout 20 linkerd viz tap -n tag10 deploy/web --path /api/notes > tap.txt &
sleep 3
for i in 1 2 3; do curl -s -o /dev/null $G/api/notes; done
wait
head -2 tap.txt
kubectl get ciliumnodes \
-o jsonpath='{range .items[*]}{.metadata.name} {.spec.ingress.ipv4}{"\n"}{end}'Erwartet (gekürzt):
req id=0:0 proxy=in src=10.0.0.235:41865 dst=10.0.1.28:8080 tls=no_tls_from_remote ...
rsp id=0:0 proxy=in src=10.0.0.235:41865 dst=10.0.1.28:8080 tls=no_tls_from_remote ...
cp1 10.0.0.235
worker1 10.0.1.169
worker2 10.0.2.57
tls=no_tls_from_remote: Der Request kam im Klartext,
ohne Identität. Absender ist keine Pod-IP, sondern die
Ingress-IP von Cilium auf cp1 – der Node,
auf dem der NodePort getroffen wurde. Jeder Node hat eine eigene. Das
Gateway selbst kannst du nicht ins Mesh holen: Ciliums Envoy läuft als
DaemonSet cilium-envoy im Host-Netz, nicht als Pod mit
Sidecar.
Achtung: Der Weg Laptop → Envoy ist TLS, Envoy →
webist Klartext über das Pod-Netz. Abwebübernimmt Linkerd. Brauchst du Verschlüsselung bis zum ersten Pod, ist das ein Argument für Variante B.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Das Gateway in die Policy aufnehmen
Ab Tag 6 kennst du Server und
AuthorizationPolicy. Ein Server ohne Policy sperrt
alles:
cat > server.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1beta3
kind: Server
metadata: {name: web-http, namespace: tag10}
spec:
podSelector: {matchLabels: {app: web}}
port: http
EOF
kubectl apply -f server.yaml
sleep 5
curl -s -w ' %{http_code}\n' $G/api/notesErwartet:
server.policy.linkerd.io/web-http created
403
Eine MeshTLSAuthentication hilft hier nicht – Envoy hat
keine Identität. Bleibt die Absender-IP. Trag die Ingress-IPs aus Drill
4 ein:
cat > authz-gateway.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: NetworkAuthentication
metadata: {name: cilium-ingress, namespace: tag10}
spec:
networks:
- cidr: 10.0.0.235/32
- cidr: 10.0.1.169/32
- cidr: 10.0.2.57/32
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata: {name: web-from-gateway, namespace: tag10}
spec:
targetRef: {group: policy.linkerd.io, kind: Server, name: web-http}
requiredAuthenticationRefs:
- {group: policy.linkerd.io, kind: NetworkAuthentication, name: cilium-ingress}
EOF
kubectl apply -f authz-gateway.yaml
sleep 5
curl -s -w ' %{http_code}\n' $G/api/notes
kubectl -n tag10 run ohne --image=curlimages/curl:8.23.0 --restart=Never \
--annotations=linkerd.io/inject=disabled --command -- sleep 3600
kubectl -n tag10 wait --for=condition=Ready pod/ohne --timeout=60s
kubectl -n tag10 exec ohne -- curl -s -w ' %{http_code}\n' http://web/api/notesErwartet:
networkauthentication.policy.linkerd.io/cilium-ingress created
authorizationpolicy.policy.linkerd.io/web-from-gateway created
[]
200
pod/ohne created
pod/ohne condition met
403
Das Gateway kommt durch, ein Pod ohne Proxy direkt auf
web nicht. Der Preis: Die Regel hängt an IP-Adressen. Kommt
ein Node dazu, braucht die Liste einen Eintrag – ein ganzes Pod-CIDR
einzutragen würde jeden Pod ohne Proxy hereinlassen.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Ein Ingress-Proxy im Mesh
Variante B: ein nginx als Eingang, mit Proxy, TLS mit demselben Secret, per NodePort 30443 erreichbar:
cat > edge.yaml <<'EOF'
apiVersion: v1
kind: ServiceAccount
metadata: {name: edge, namespace: tag10}
---
apiVersion: v1
kind: ConfigMap
metadata: {name: edge-conf, namespace: tag10}
data:
default.conf: |
server {
listen 8443 ssl;
server_name notes.lab.internal;
ssl_certificate /tls/tls.crt;
ssl_certificate_key /tls/tls.key;
location / {
proxy_pass http://web.tag10.svc.cluster.local;
}
}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: edge, namespace: tag10}
spec:
replicas: 1
selector: {matchLabels: {app: edge}}
template:
metadata: {labels: {app: edge}}
spec:
serviceAccountName: edge
containers:
- name: nginx
image: docker.io/nginxinc/nginx-unprivileged:1.31.7-alpine
ports: [{containerPort: 8443, name: https}]
volumeMounts:
- {name: conf, mountPath: /etc/nginx/conf.d}
- {name: tls, mountPath: /tls, readOnly: true}
volumes:
- {name: conf, configMap: {name: edge-conf}}
- {name: tls, secret: {secretName: notes-tls}}
---
apiVersion: v1
kind: Service
metadata: {name: edge, namespace: tag10}
spec:
type: NodePort
selector: {app: edge}
ports: [{port: 443, targetPort: https, nodePort: 30443, name: https}]
EOF
kubectl apply -f edge.yaml
kubectl -n tag10 rollout status deploy/edge --timeout=120s
sleep 10
E="--cacert lab-ca.crt --resolve notes.lab.internal:30443:172.16.0.126 \
https://notes.lab.internal:30443"
curl -s -w ' %{http_code}\n' $E/api/notesErwartet:
deployment "edge" successfully rolled out
403
Richtig so: web lässt nur das Gateway herein.
edge hat aber eine Identität – die Freigabe läuft deshalb
über mTLS statt über IPs:
cat > authz-edge.yaml <<'EOF'
apiVersion: policy.linkerd.io/v1alpha1
kind: MeshTLSAuthentication
metadata: {name: edge, namespace: tag10}
spec:
identityRefs:
- {kind: ServiceAccount, name: edge}
---
apiVersion: policy.linkerd.io/v1alpha1
kind: AuthorizationPolicy
metadata: {name: web-from-edge, namespace: tag10}
spec:
targetRef: {group: policy.linkerd.io, kind: Server, name: web-http}
requiredAuthenticationRefs:
- {group: policy.linkerd.io, kind: MeshTLSAuthentication, name: edge}
EOF
kubectl apply -f authz-edge.yaml
sleep 5
for i in $(seq 20); do curl -s -o /dev/null -w '%{http_code}\n' $E/api/notes; done \
| sort | uniq -cErwartet:
20 200
nginx spricht den Service web an. Der
Proxy im edge-Pod erkennt das Ziel, macht Load Balancing, mTLS und – mit
HTTPRoutes – Retries und Canaries wie für jeden anderen Client.
Controller, die selbst Endpunkte auswählen, brauchen dafür
linkerd.io/inject: ingress (siehe Enterprise-Notiz).
Fortschritt speichern? Kostenlos registrieren
Drill 7: Beide Eingänge im Vergleich
for i in $(seq 90); do
curl -s -o /dev/null $E/api/notes; curl -s -o /dev/null $G/api/notes; sleep 0.5
done
linkerd viz edges -n tag10 deploy
linkerd viz authz -n tag10 deploy/web | grep -E 'ROUTE|web-http'Erwartet (gekürzt, Zahlen schwanken):
SRC DST SRC_NS DST_NS SECURED
edge web tag10 tag10 √
web notes-api tag10 tag10 √
ROUTE SERVER AUTHORIZATION UNAUTHORIZED SUCCESS RPS
default web-http authorizationpolicy/web-from-edge 0.0rps 100.00% 1.5rps
default web-http authorizationpolicy/web-from-gateway 0.0rps 100.00% 1.5rps
Beide Wege tragen gleich viel Verkehr, aber nur einer ist eine Kante
im Mesh: Für edges existiert das Gateway nicht.
authz zeigt, welche Policy welchen Verkehr durchlässt – das
ist dein Nachweis für Variante A.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeig die beiden NodePorts des Gateways. Zeitziel: 20 s
- Zeig, wann
notes-tlsabläuft und wann cert-manager es erneuert. Zeitziel: 30 s - Zeig den Aussteller des Zertifikats, das
edgeausliefert. Zeitziel: 45 s - Zeig, welche Policies den Verkehr auf
webzulassen. Zeitziel: 15 s
Lösung
kubectl -n tag10 get svc cilium-gateway-notes \
-o jsonpath='{.spec.ports[*].nodePort}{"\n"}'
kubectl -n tag10 get certificate notes-tls \
-o jsonpath='{.status.notAfter} {.status.renewalTime}{"\n"}'
echo | openssl s_client -connect 172.16.0.126:30443 -servername notes.lab.internal \
2>/dev/null | openssl x509 -noout -issuer
linkerd viz authz -n tag10 deploy/webErwartet (Auszug):
31972 32290
2026-12-19T16:29:52Z 2026-12-09T16:29:52Z
issuer=CN = lab-ca.tag10
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
curl -s -o /dev/null -w '%{http_code}\n' $G/api/notes
curl -s -o /dev/null -w '%{http_code}\n' $E/api/notesErwartet: zweimal 200.
kubectl -n tag10 exec ohne -- curl -s -o /dev/null -w '%{http_code}\n' http://web/Erwartet: 403
linkerd viz edges -n tag10 deploy | grep edgeErwartet:
edge web tag10 tag10 √
Challenge
Erneuere notes-tls mit cmctl renew und prüf
mit openssl, welcher der beiden Eingänge ($NP
aus Drill 3 und 30443) das neue Zertifikat sofort ausliefert. Bring den
anderen dazu, es ebenfalls zu tun.
Hinweis: Vergleiche die Seriennummern; nginx liest Zertifikate nur beim Start.
Lösung
cmctl renew -n tag10 notes-tls
kubectl -n tag10 wait --for=condition=Ready certificate/notes-tls
sleep 10
for p in $NP 30443; do
echo | openssl s_client -connect 172.16.0.126:$p -servername notes.lab.internal \
2>/dev/null | openssl x509 -noout -serial
done
kubectl -n tag10 rollout restart deploy/edge
kubectl -n tag10 rollout status deploy/edge
echo | openssl s_client -connect 172.16.0.126:30443 -servername notes.lab.internal \
2>/dev/null | openssl x509 -noout -serialErwartet (Seriennummern abweichend):
Manually triggered issuance of Certificate tag10/notes-tls
serial=2A1C7A9FB13DCC28AFD893690D4229F7F6E2CB1D
serial=716A09D2B37D8E82BA2C8C87F6C32E746E9AEE05
deployment "edge" successfully rolled out
serial=2A1C7A9FB13DCC28AFD893690D4229F7F6E2CB1D
Cilium beobachtet das Secret und liefert sofort das neue Zertifikat
aus. Der kubelet aktualisiert zwar das gemountete Secret in
edge nach ein bis zwei Minuten, nginx liest es aber nicht
neu. Ein echter Ingress-Controller beobachtet Secrets selbst; ein
selbstgebauter Eingang braucht einen Reload – oder läuft beim nächsten
Ablauf ins Leere.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
kubectl delete namespace tag10Interview-Notiz
- Muss der Ingress im Mesh sein? Nein, aber nur dann gibt es ab dem ersten Pod mTLS, Identität für Policies und Linkerd-Metriken pro Kante.
- Wie lässt du ein Gateway außerhalb des Mesh durch eine
Default-Deny-Policy? Mit einer
NetworkAuthenticationauf die Absender-IPs des Gateways – und nur diese. - Was ist der Ingress-Modus?
linkerd.io/inject: ingresslässt den Proxy das Ziel aus dem Headerl5d-dst-overrideoder dem Host lesen – für Controller, die selbst Endpunkte auswählen.
Enterprise-Notiz
- In Produktion bekommt das Gateway eine echte LoadBalancer-IP (Cilium LB-IPAM mit L2/BGP, MetalLB oder Cloud-LB) und ein Zertifikat aus ACME oder der Firmen-CA.
- Gängige Controller im Mesh: Envoy Gateway, Traefik, Contour, Emissary. Jeder Controller hat in der Linkerd-Doku („Handling ingress traffic“) eigene Hinweise.
- Im Ingress-Modus muss der Controller
l5d-dst-overrideaus Client-Requests entfernen – sonst wird er zum offenen Relay in den Cluster. - Die Annotation
ingressgehört an das Deployment des Controllers, nicht an den Namespace. - Der Weg Gateway → Pod ohne mTLS ist für viele Prüfer ein Befund. Ein
Gateway außerhalb des Mesh braucht dann Verschlüsselung zum Backend
(
BackendTLSPolicy) oder Variante B.