Tag 6: Services auf Layer 4
Ziel: Du setzt jeden Service-Typ und jede Traffic-Policy imperativ auf, misst ihre Wirkung mit curl und liest sie in EndpointSlices und den eBPF-Einträgen von Cilium. · Dauer: ca. 75 min · Voraussetzung: Tag 4
Briefing
- CKNE: Service Networking and DNS (25 %) – Service-Typen, Session
Affinity,
externalTrafficPolicyundinternalTrafficPolicygehören zum Kern. - Ohne kube-proxy setzt Cilium jeden Service als Eintrag in eBPF-Maps
um (
cilium-dbg service list), Verbindungen aus Pods übersetzt es schon am Socket. - Als Backend dient agnhost
netexec:/hostnamenennt den Pod,/clientipdie Absenderadresse, die beim Pod ankommt.
router .123 ── NodePort :30080 ──> cp1 / worker1 / worker2 ──┐
tag06/client (worker1) ── ClusterIP echo:80 ─────────────────┴─> echo-… :8080
(worker1, worker2)
Drill 1: ClusterIP und EndpointSlice
mkdir -p ~/ckne/tag06 && cd ~/ckne/tag06
k create ns tag06
k config set-context --current --namespace=tag06
k create deployment echo --image=registry.k8s.io/e2e-test-images/agnhost:2.66.1 \
--replicas=2 --port=8080 -- /agnhost netexec --http-port=8080
k run client --image=nicolaka/netshoot:v0.16 \
--overrides='{"spec":{"nodeName":"worker1"}}' -- sleep infinity
k rollout status deployment echo
k wait --for=condition=Ready pod/client
k get pods -o wide
k expose deployment echo --port=80 --target-port=8080
k get endpointslices -l kubernetes.io/service-name=echo
for i in 1 2 3 4; do k exec client -- curl -s http://echo/hostname; echo; doneErwartet (gekürzt):
deployment "echo" successfully rolled out
pod/client condition met
NAME READY STATUS ... IP NODE
client 1/1 Running ... 10.0.1.115 worker1
echo-cc8555f69-cvn8f 1/1 Running ... 10.0.1.166 worker1
echo-cc8555f69-kc99p 1/1 Running ... 10.0.2.114 worker2
service/echo exposed
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
echo-6lbgk IPv4 8080 10.0.2.114,10.0.1.166 0s
echo-cc8555f69-kc99p
echo-cc8555f69-cvn8f
echo-cc8555f69-cvn8f
echo-cc8555f69-kc99p
nodeName setzt den Client fest auf worker1
– das brauchst du in Drill 7. Der Service selbst kennt keine Pods: Der
EndpointSlice-Controller sammelt die Pod-IPs zum Selector
app=echo, Cilium liest die Slices und schreibt die
eBPF-Einträge:
CIP=$(k get svc echo -o jsonpath='{.spec.clusterIP}')
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
| grep -A1 "$CIP:"Erwartet:
28 10.97.228.80:80/TCP ClusterIP 1 => 10.0.1.166:8080/TCP (active)
2 => 10.0.2.114:8080/TCP (active)
Fortschritt speichern? Kostenlos registrieren
Drill 2: NodePort mit festem Port
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status --verbose \
| grep 'NodePort:'
k expose deployment echo --name=echo-np --type=NodePort --port=80 --target-port=8080
k get svc echo-np
k patch svc echo-np -p '{"spec":{"ports":[{"port":80,"nodePort":8080}]}}'
k patch svc echo-np -p '{"spec":{"ports":[{"port":80,"nodePort":30080}]}}'
k get svc echo-npErwartet (gekürzt):
- NodePort: Enabled (Range: 30000-32767)
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
echo-np NodePort 10.100.165.152 <none> 80:30152/TCP 0s
The Service "echo-np" is invalid: spec.ports[0].nodePort: Invalid value: 8080: provided
port is not in the valid range. The range of valid ports is 30000-32767
service/echo-np patched
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
echo-np NodePort 10.100.165.152 <none> 80:30080/TCP 1s
Den Bereich bestimmt der API-Server
(--service-node-port-range, Standard 30000–32767). Cilium
hat einen eigenen Bereich (nodePort.range, gleicher
Default) – bei Änderungen beide anpassen. Der Patch trifft den
Port-Eintrag über seinen Schlüssel port: 80. Jetzt vom
router aus, also von außerhalb des Clusters:
ssh [email protected]
for n in 172.16.0.126 172.16.0.228 172.16.0.83; do
curl -s -m3 http://$n:30080/hostname; echo " <- $n"
done
exit
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
| grep -A1 ':30080/'Erwartet:
echo-cc8555f69-cvn8f <- 172.16.0.126
echo-cc8555f69-kc99p <- 172.16.0.228
echo-cc8555f69-kc99p <- 172.16.0.83
32 0.0.0.0:30080/TCP NodePort 1 => 10.0.1.166:8080/TCP (active)
2 => 10.0.2.114:8080/TCP (active)
Jeder Node antwortet, auch cp1 ohne echo-Pod.
0.0.0.0:30080 heißt: auf allen Node-Adressen.
Fortschritt speichern? Kostenlos registrieren
Drill 3: LoadBalancer ohne IP
k expose deployment echo --name=echo-lb --type=LoadBalancer --port=80 \
--target-port=8080
k get svc echo-lb
k get svc echo-lb -o jsonpath='{.status}'; echo
cilium config view | grep -E 'enable-lb-ipam|default-lb-service-ipam'
k get ciliumloadbalancerippoolsErwartet:
service/echo-lb exposed
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
echo-lb LoadBalancer 10.103.31.143 <pending> 80:32063/TCP 6s
{"loadBalancer":{}}
default-lb-service-ipam lbipam
enable-lb-ipam true
No resources found
Ein LoadBalancer-Service ist ein NodePort-Service plus der Bitte „gib
mir eine externe IP“. Die erfüllt in der Cloud der
Cloud-Controller-Manager, hier wäre es Ciliums LB-IPAM – das ist zwar
eingeschaltet, hat aber keinen Pool. Also bleibt
<pending>, der NodePort 32063 funktioniert trotzdem.
Tag 15 legt den Pool an und kündigt die IPs per BGP und L2 an.
NP=$(k get svc echo-lb -o jsonpath='{.spec.ports[0].nodePort}')
curl -s -m3 http://172.16.0.228:$NP/hostname; echoErwartet: ein Pod-Name wie
echo-cc8555f69-kc99p.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Headless und ExternalName – Services nur im DNS
k expose deployment echo --name=echo-hl --cluster-ip=None --port=8080
k get svc echo-hl
k exec client -- dig +short echo-hl.tag06.svc.cluster.local
k exec client -- dig +short echo.tag06.svc.cluster.local
k exec client -- dig +short -t SRV echo-hl.tag06.svc.cluster.local
k exec client -- dig +short 10-0-1-166.echo-hl.tag06.svc.cluster.local
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
| grep -E ':8080/TCP +ClusterIP'Erwartet:
service/echo-hl exposed
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
echo-hl ClusterIP None <none> 8080/TCP 0s
10.0.1.166
10.0.2.114
10.97.228.80
0 50 8080 10-0-2-114.echo-hl.tag06.svc.cluster.local.
0 50 8080 10-0-1-166.echo-hl.tag06.svc.cluster.local.
10.0.1.166
Headless liefert die Pod-IPs als A-Records, der normale Service nur
seine ClusterIP. Es gibt keine virtuelle IP – also auch keinen
eBPF-Eintrag (das letzte grep bleibt leer), der Client
verteilt selbst. Das braucht etwa ein StatefulSet für feste Namen pro
Pod. ExternalName ist noch dünner – ein CNAME:
k create service externalname docs --external-name=kubernetes.io
k get svc docs
k exec client -- dig docs.tag06.svc.cluster.local +noall +answer
k exec client -- curl -sI -m5 http://docs | head -1
k exec client -- curl -sI -m5 -H 'Host: kubernetes.io' http://docs | head -1Erwartet:
service/docs created
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
docs ExternalName <none> kubernetes.io <none> 1s
docs.tag06.svc.cluster.local. 30 IN CNAME kubernetes.io.
kubernetes.io. 30 IN A 3.33.186.135
kubernetes.io. 30 IN A 15.197.167.90
HTTP/1.1 400 Bad Request
HTTP/1.1 301 Moved Permanently
Warum 400? Der CNAME ändert nur die Namensauflösung, nicht den
HTTP-Host-Header – der Webserver bekommt Host: docs und
lehnt ab. Bei TLS passt aus demselben Grund das Zertifikat nicht.
Fortschritt speichern? Kostenlos registrieren
Drill 5: sessionAffinity ClientIP
k patch svc echo -p '{"spec":{"sessionAffinity":"ClientIP"}}'
k get svc echo -o jsonpath='{.spec.sessionAffinityConfig}'; echo
for i in 1 2 3 4 5 6; do k exec client -- curl -s http://echo/hostname; echo; done
CP=$(k -n kube-system get pod -l k8s-app=cilium \
--field-selector spec.nodeName=worker1 -o name)
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg bpf lb list \
| grep "$CIP:80/TCP (0)"
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg map list | grep lb4_affinityErwartet:
service/echo patched
{"clientIP":{"timeoutSeconds":10800}}
echo-cc8555f69-cvn8f
echo-cc8555f69-cvn8f
echo-cc8555f69-cvn8f
echo-cc8555f69-cvn8f
echo-cc8555f69-cvn8f
echo-cc8555f69-cvn8f
10.97.228.80:80/TCP (0) 0.0.0.0:0 (30) (0) [ClusterIP, sessionAffinity, non-routable]
cilium_lb4_affinity 1 0 true
Alle Anfragen landen beim selben Pod, drei Stunden lang
(Standard-Timeout 10800 s). Die Zuordnung „Client-IP → Backend“ steht in
der Map cilium_lb4_affinity des Nodes, auf dem der Client
läuft – deshalb der Agent von worker1. Affinity hängt an
der Quell-IP: Hinter einem NAT teilen sich viele Clients einen Pod.
Fortschritt speichern? Kostenlos registrieren
Drill 6: externalTrafficPolicy Cluster und Local
Was sieht der Pod als Absender, wenn router den NodePort
aufruft?
k get ciliumnodes -o custom-columns='NAME:.metadata.name,'\
'HOSTIP:.spec.addresses[?(@.type=="CiliumInternalIP")].ip'
ssh [email protected]
for n in 172.16.0.126 172.16.0.228 172.16.0.83; do
for i in 1 2 3; do curl -s -m3 http://$n:30080/clientip; echo " <- $n"; done
done
exitErwartet:
NAME HOSTIP
cp1 10.0.0.88
worker1 10.0.1.116
worker2 10.0.2.241
10.0.0.88:52892 <- 172.16.0.126
10.0.0.88:52904 <- 172.16.0.126
10.0.0.88:52912 <- 172.16.0.126
172.16.0.123:37066 <- 172.16.0.228
172.16.0.123:37072 <- 172.16.0.228
172.16.0.123:37088 <- 172.16.0.228
10.0.2.241:58604 <- 172.16.0.83
172.16.0.123:58610 <- 172.16.0.83
10.0.2.241:58622 <- 172.16.0.83
Mit Cluster (Standard) wählt jeder Node unter allen
Backends. Liegt das Backend auf einem anderen Node, ersetzt Cilium die
Quelle durch die eigene cilium_host-Adresse (SNAT), damit
die Antwort zurückfindet – die echte Client-IP ist weg. Nur wenn das
Backend zufällig lokal ist, kommt 172.16.0.123 an.
k patch svc echo-np -p '{"spec":{"externalTrafficPolicy":"Local"}}'
ssh [email protected]
for n in 172.16.0.126 172.16.0.228 172.16.0.83; do
for i in 1 2; do curl -sS -m3 http://$n:30080/clientip; echo " <- $n"; done
done
exit
CP=$(k -n kube-system get pod -l k8s-app=cilium \
--field-selector spec.nodeName=cp1 -o name)
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg service list \
| grep -A1 ':30080/'Erwartet (gekürzt):
service/echo-np patched
curl: (7) Failed to connect to 172.16.0.126 port 30080 after 1 ms: Couldn't connect ...
<- 172.16.0.126
curl: (7) Failed to connect to 172.16.0.126 port 30080 after 0 ms: Couldn't connect ...
<- 172.16.0.126
172.16.0.123:37104 <- 172.16.0.228
172.16.0.123:37110 <- 172.16.0.228
172.16.0.123:58624 <- 172.16.0.83
172.16.0.123:58636 <- 172.16.0.83
32 0.0.0.0:30080/TCP NodePort
--
37 0.0.0.0:30080/TCP/i NodePort 1 => 10.0.1.166:8080/TCP (active)
2 => 10.0.2.114:8080/TCP (active)
Local erhält die Client-IP, aber nur Nodes mit eigenem
Backend antworten. Cilium legt dafür zwei Einträge an: den externen ohne
Backends auf cp1 (Verbindung abgelehnt) und /i
für cluster-interne Aufrufe, die weiter alle Backends nutzen. Ein
externer Load Balancer muss also wissen, welche Nodes Backends haben –
dazu mehr in der Challenge.
Fortschritt speichern? Kostenlos registrieren
Drill 7: internalTrafficPolicy Local
k run client2 --image=nicolaka/netshoot:v0.16 \
--overrides='{"spec":{"nodeName":"worker2"}}' -- sleep infinity
k wait --for=condition=Ready pod/client2
k expose deployment echo --name=echo-local --port=80 --target-port=8080 \
$do > echo-local.yaml
sed -i '/^ ports:/i\ internalTrafficPolicy: Local' echo-local.yaml
grep -B1 -A1 internalTrafficPolicy echo-local.yaml
k apply -f echo-local.yaml
for p in client client2; do
for i in 1 2 3; do
k exec $p -- curl -s http://echo-local/hostname; echo " <- $p"
done
done
LIP=$(k get svc echo-local -o jsonpath='{.spec.clusterIP}')
curl -sS -m3 http://$LIP/hostnameErwartet:
spec:
internalTrafficPolicy: Local
ports:
service/echo-local created
echo-cc8555f69-cvn8f <- client
echo-cc8555f69-cvn8f <- client
echo-cc8555f69-cvn8f <- client
echo-cc8555f69-kc99p <- client2
echo-cc8555f69-kc99p <- client2
echo-cc8555f69-kc99p <- client2
curl: (7) Failed to connect to 10.98.87.203 port 80 after 0 ms: Couldn't connect to ...
Jeder Client bleibt auf seinem Node; der letzte curl
läuft auf cp1 – dort gibt es kein Backend, also keine
Verbindung. Gut für node-lokale Dienste (Log-Agent, DNS-Cache),
gefährlich für alles andere. Der Blick in die Agenten von
worker1 und cp1 zeigt es:
CP=$(k -n kube-system get pod -l k8s-app=cilium \
--field-selector spec.nodeName=worker1 -o name)
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg service list \
| grep -A1 "$LIP:"
CP=$(k -n kube-system get pod -l k8s-app=cilium \
--field-selector spec.nodeName=cp1 -o name)
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg service list \
| grep -A1 "$LIP:"Erwartet:
42 10.98.87.203:80/TCP ClusterIP 1 => 10.0.1.166:8080/TCP (active)
40 10.98.87.203:80/TCP ClusterIP
Fortschritt speichern? Kostenlos registrieren
Drill 8: Service ohne Selector und eigene EndpointSlice
So bindest du einen Dienst außerhalb des Clusters unter einem
Cluster-Namen ein. Auf router in einem zweiten
Terminal einen Testserver starten:
mkdir -p ~/tag06 && cd ~/tag06
echo "hallo vom router" > index.html
python3 -m http.server 8000Zurück auf cp1:
k create service clusterip router --tcp=80:8000 $do > router-svc.yaml
sed -i '/selector:/,+1d' router-svc.yaml
cat > router-eps.yaml <<'EOF'
apiVersion: discovery.k8s.io/v1
kind: EndpointSlice
metadata:
name: router-1
labels:
kubernetes.io/service-name: router
endpointslice.kubernetes.io/managed-by: tag06.example.com
addressType: IPv4
ports:
- name: 80-8000
protocol: TCP
port: 8000
endpoints:
- addresses:
- 172.16.0.123
EOF
k apply -f router-svc.yaml -f router-eps.yaml
k get svc router -o wide
k get endpointslices -l kubernetes.io/service-name=router
k exec client -- curl -s -m3 http://router/
RIP=$(k get svc router -o jsonpath='{.spec.clusterIP}')
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
| grep -A1 "$RIP:"Erwartet:
service/router created
endpointslice.discovery.k8s.io/router-1 created
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE SELECTOR
router ClusterIP 10.106.226.85 <none> 80/TCP 0s <none>
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
router-1 IPv4 8000 172.16.0.123 0s
hallo vom router
43 10.106.226.85:80/TCP ClusterIP 1 => 172.16.0.123:8000/TCP (active)
Drei Dinge müssen passen: das Label
kubernetes.io/service-name verbindet Slice und Service, der
Port-Name in der Slice muss dem im Service gleichen
(80-8000, so benennt ihn k create service),
und managed-by darf nicht
endpointslice-controller.k8s.io heißen, sonst räumt der
Controller deine Slice weg. Den Selector erst nachträglich zu entfernen
hinterlässt eine veraltete Slice des Controllers – deshalb gleich ohne
Selector anlegen.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Lege für
deployment/echoeinen NodePort-Serviceweban, Port 80 → 8080, NodePort fest 31000. Zeitziel: 60 s - Begrenze die Session Affinity von Service
echoauf 60 Sekunden. Zeitziel: 30 s - Zeige Pod-IP, Pod-Name und Node jedes Endpunkts von
echoin einer Zeile. Zeitziel: 60 s - Zeige für alle Services in
tag06Typ,externalTrafficPolicyundinternalTrafficPolicy. Zeitziel: 45 s
Lösung
k expose deployment echo --name=web --type=NodePort --port=80 --target-port=8080
k patch svc web -p '{"spec":{"ports":[{"port":80,"nodePort":31000}]}}'
curl -s -m3 http://172.16.0.228:31000/hostname; echo
k patch svc echo -p \
'{"spec":{"sessionAffinityConfig":{"clientIP":{"timeoutSeconds":60}}}}'
k get svc echo -o jsonpath='{.spec.sessionAffinityConfig}'; echo
k get endpointslices -l kubernetes.io/service-name=echo -o jsonpath=\
'{range .items[*].endpoints[*]}{.addresses[0]} {.targetRef.name} {.nodeName}{"\n"}{end}'
k get svc -o custom-columns=NAME:.metadata.name,TYPE:.spec.type,\
ETP:.spec.externalTrafficPolicy,ITP:.spec.internalTrafficPolicyErwartet (gekürzt):
echo-cc8555f69-kc99p
{"clientIP":{"timeoutSeconds":60}}
10.0.2.114 echo-cc8555f69-kc99p worker2
10.0.1.166 echo-cc8555f69-cvn8f worker1
NAME TYPE ETP ITP
docs ExternalName <none> <none>
echo ClusterIP <none> Cluster
echo-hl ClusterIP <none> Cluster
echo-lb LoadBalancer Cluster Cluster
echo-local ClusterIP <none> Local
echo-np NodePort Local Cluster
router ClusterIP <none> Cluster
web NodePort Cluster Cluster
Kommt beim ersten curl direkt nach dem Patch nichts
zurück, eine Sekunde warten – Cilium braucht einen Moment für den neuen
Eintrag.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
k get svc echo-np -o jsonpath='{.spec.ports[0].nodePort} {.spec.externalTrafficPolicy}'Erwartet: 30080 Local
ssh [email protected] curl -s -m3 http://172.16.0.228:30080/clientipErwartet: 172.16.0.123:<Port> –
die echte Client-IP.
k get svc echo-lbErwartet: EXTERNAL-IP
<pending> (kein LB-IPAM-Pool bis Tag 15).
k exec client -- dig +short echo-hl.tag06.svc.cluster.localErwartet: die zwei Pod-IPs von echo,
keine ClusterIP.
k exec client -- curl -s -m3 http://router/Erwartet: hallo vom router
Challenge
Stelle echo-lb auf
externalTrafficPolicy: Local und zeige vom
router aus, woran ein externer Load Balancer erkennt,
welche Nodes er ansprechen darf.
Hinweis: Bei Local vergibt Kubernetes
für LoadBalancer-Services ein zusätzliches Feld
spec.healthCheckNodePort.
Lösung
k patch svc echo-lb -p '{"spec":{"externalTrafficPolicy":"Local"}}'
HC=$(k get svc echo-lb -o jsonpath='{.spec.healthCheckNodePort}'); echo $HC
for n in 172.16.0.126 172.16.0.228 172.16.0.83; do
ssh [email protected] "curl -s -m3 -w ' %{http_code}' http://$n:$HC/"
echo " <- $n"
doneErwartet:
31601
{"service":{"namespace":"tag06","name":"echo-lb"},"localEndpoints":0}
503 <- 172.16.0.126
{"service":{"namespace":"tag06","name":"echo-lb"},"localEndpoints":1}
200 <- 172.16.0.228
{"service":{"namespace":"tag06","name":"echo-lb"},"localEndpoints":1}
200 <- 172.16.0.83
Cilium beantwortet den Health-Check-Port selbst (statt kube-proxy):
200 mit lokalen Backends, 503 ohne. Cloud-Load-Balancer prüfen genau
diesen Port und nehmen cp1 aus der Rotation. Ein
NodePort-Service bekommt das Feld nicht – echo-np hat es
nicht.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
Auf router den Testserver mit Strg+C beenden, dann:
rm -r ~/tag06
exitAuf cp1:
k delete namespace tag06
k config set-context --current --namespace=defaultClusterweit hat Tag 6 nichts verändert.
Prüfungstipp
k exposekennt--type,--port,--target-port,--cluster-ip=None, aber keinen festen NodePort und keine Policies – die setzt du mitk patchoder per$do-Datei.externalTrafficPolicywirkt nur auf NodePort/LoadBalancer,internalTrafficPolicynur auf Verkehr aus dem Cluster;Localohne lokales Backend heißt: keine Antwort.- Doku-Stellen: kubernetes.io „Service“, „Service Internal Traffic Policy“, „Create an External Load Balancer“ (Abschnitt „Preserving the client source IP“).
Enterprise-Notiz
externalTrafficPolicy: Localist üblich, wenn Backends die echte Client-IP brauchen (WAF, Rate-Limits, Audit) – Pods dann über die Nodes verteilen (Topology Spread).- Statt SNAT kann Cilium mit DSR (Direct Server Return) die Client-IP
auch bei
Clustererhalten; mehr in Tag 7. - Session Affinity nach Client-IP ist ein Notbehelf; zustandsbehaftete
Apps besser über Cookies am Gateway (Gateway API
sessionPersistence) oder geteilten Session-Speicher. - ExternalName nur für Ziele ohne TLS-Namensprüfung oder mit passendem SAN – sonst eine eigene Slice auf feste IPs oder ein Egress-Gateway (Tag 16).
- Manuell gepflegte EndpointSlices veralten leicht; in Produktion pflegt sie ein Controller oder eine ServiceEntry-ähnliche Lösung im Mesh.