Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 9: Endpunkte und Verfügbarkeit

Ziel: Du liest EndpointSlices samt ihren Conditions, steuerst mit Readiness, publishNotReadyAddresses, preStop und trafficDistribution, welche Pods Verkehr bekommen, und prüfst es in Cilium nach. · Dauer: ca. 70 min · Voraussetzung: Tag 6

Briefing

  • CKNE: Service Networking and DNS (25 %) – Endpunkte entscheiden, ob ein Service überhaupt antwortet; der häufigste Grund für „Service geht nicht“.
  • Jeder Endpunkt hat drei Conditions: ready, serving, terminating. Cilium übersetzt sie in Backend-Zustände (active, maintenance, terminating).
  • Die Readiness-Probe des Backends (agnhost netexec) prüft test ! -e /tmp/down – so schaltest du Readiness per touch um.
 Pod Ready? ── kubelet ──> Pod-Status ──> EndpointSlice-Controller ──> EndpointSlice
                                                                         │
                                         Cilium-Agent (eBPF-Backends) <──┘

Drill 1: EndpointSlices lesen

mkdir -p ~/ckne/tag09 && cd ~/ckne/tag09
k create ns tag09
k config set-context --current --namespace=tag09
cat > web.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 2
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      terminationGracePeriodSeconds: 60
      containers:
      - name: web
        image: registry.k8s.io/e2e-test-images/agnhost:2.66.1
        args: ["netexec", "--http-port=8080", "--delay-shutdown=45"]
        ports:
        - containerPort: 8080
        readinessProbe:
          exec:
            command: ["sh", "-c", "test ! -e /tmp/down"]
          periodSeconds: 2
        lifecycle:
          preStop:
            sleep:
              seconds: 15
EOF
k apply -f web.yaml
k expose deployment web --port=80 --target-port=8080
k run client --image=nicolaka/netshoot:v0.16 -- sleep infinity
k rollout status deployment web
k get pods -o wide
k get endpointslices -l kubernetes.io/service-name=web -o yaml

Erwartet (gekürzt):

deployment "web" successfully rolled out
NAME                  READY   STATUS    ...   IP           NODE
client                1/1     Running   ...   10.0.2.186   worker2
web-565f96c64-l72c9   1/1     Running   ...   10.0.1.47    worker1
web-565f96c64-n2pjp   1/1     Running   ...   10.0.2.214   worker2
- addressType: IPv4
  endpoints:
  - addresses:
    - 10.0.1.47
    conditions:
      ready: true
      serving: true
      terminating: false
    nodeName: worker1
    targetRef:
      kind: Pod
      name: web-565f96c64-l72c9
  ...
  metadata:
    labels:
      endpointslice.kubernetes.io/managed-by: endpointslice-controller.k8s.io
      kubernetes.io/service-name: web
    name: web-9ts49
    ownerReferences:
    - kind: Service
      name: web
  ports:
  - name: ""
    port: 8080
    protocol: TCP

Die Slice gehört dem Service (ownerReferences) und findet ihn über das Label kubernetes.io/service-name. Der Port ist der Container-Port, nicht der Service-Port. Damit die drei Conditions in eine Zeile passen, legst du dir eine jsonpath-Vorlage an:

JP='{range .items[*].endpoints[*]}{.targetRef.name}{" r="}{.conditions.ready}'\
'{" s="}{.conditions.serving}{" t="}{.conditions.terminating}{"\n"}{end}'
k get endpointslices -l kubernetes.io/service-name=web -o jsonpath="$JP"

Erwartet:

web-565f96c64-l72c9 r=true s=true t=false
web-565f96c64-n2pjp r=true s=true t=false

Fortschritt speichern? Kostenlos registrieren

Drill 2: Readiness steuert die Endpunkte

P1=$(k get pod -l app=web -o jsonpath='{.items[0].metadata.name}')
k exec $P1 -- touch /tmp/down
sleep 8
k get pods -l app=web
k get endpointslices -l kubernetes.io/service-name=web -o jsonpath="$JP"
k get endpointslices -l kubernetes.io/service-name=web
for i in 1 2 3 4; do k exec client -- curl -s http://web/hostname; echo; done
CIP=$(k get svc web -o jsonpath='{.spec.clusterIP}')
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
  | grep -A1 "$CIP:"

Erwartet:

NAME                  READY   STATUS    RESTARTS   AGE
web-565f96c64-l72c9   0/1     Running   0          28s
web-565f96c64-n2pjp   1/1     Running   0          28s
web-565f96c64-l72c9 r=false s=false t=false
web-565f96c64-n2pjp r=true s=true t=false
NAME        ADDRESSTYPE   PORTS   ENDPOINTS              AGE
web-9ts49   IPv4          8080    10.0.1.47,10.0.2.214   29s
web-565f96c64-n2pjp
web-565f96c64-n2pjp
web-565f96c64-n2pjp
web-565f96c64-n2pjp
69   10.103.176.39:80/TCP      ClusterIP      1 => 10.0.1.47:8080/TCP (maintenance)
                                              2 => 10.0.2.214:8080/TCP (active)

Nach drei fehlgeschlagenen Proben (failureThreshold 3 × periodSeconds 2) ist der Pod 0/1, die Slice setzt ready und serving auf false, Cilium parkt das Backend als maintenance. Falle: Die Spalte ENDPOINTS von k get endpointslices zeigt alle Adressen, auch nicht bereite – nur die Conditions sagen die Wahrheit. Der Pod bleibt so, bis Drill 3 die Datei wieder entfernt.

Fortschritt speichern? Kostenlos registrieren

Drill 3: publishNotReadyAddresses

Manche Dienste (Datenbank-Cluster, etcd) müssen ihre Peers schon vor der Readiness finden. Zwei headless Services zum Vergleich:

k expose deployment web --name=web-hl --cluster-ip=None --port=8080
k expose deployment web --name=web-peers --cluster-ip=None --port=8080 \
  $do > web-peers.yaml
sed -i '/^  clusterIP: None/a\  publishNotReadyAddresses: true' web-peers.yaml
grep -A1 clusterIP web-peers.yaml
k apply -f web-peers.yaml
k exec client -- dig +short web-hl.tag09.svc.cluster.local
k exec client -- dig +short web-peers.tag09.svc.cluster.local
k get endpointslices -l kubernetes.io/service-name=web-peers -o jsonpath="$JP"

Erwartet:

service/web-hl exposed
  clusterIP: None
  publishNotReadyAddresses: true
service/web-peers created
10.0.2.214
10.0.1.47
10.0.2.214
web-565f96c64-n2pjp r=true s=true t=false
web-565f96c64-l72c9 r=true s=false t=false

web-hl liefert nur den bereiten Pod, web-peers beide. In der Slice steht dafür ready=true trotz serving=false – der Controller ignoriert die Readiness, wie k explain service.spec.publishNotReadyAddresses beschreibt. Jetzt den Pod wieder gesund machen:

k exec $P1 -- rm /tmp/down
sleep 4
k exec client -- dig +short web-hl.tag09.svc.cluster.local
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
  | grep -A1 "$CIP:"

Erwartet:

10.0.2.214
10.0.1.47
69   10.103.176.39:80/TCP      ClusterIP      1 => 10.0.1.47:8080/TCP (active)
                                              2 => 10.0.2.214:8080/TCP (active)

Fortschritt speichern? Kostenlos registrieren

Drill 4: Terminating-Endpunkte, preStop und Grace Period

Was passiert mit einem Pod, der gelöscht wird, während noch Verkehr kommt?

P1=$(k get pod -l app=web -o jsonpath='{.items[0].metadata.name}')
PIP=$(k get pod $P1 -o jsonpath='{.status.podIP}')
k delete pod $P1 --wait=false
sleep 3
k get pods -l app=web
k get endpointslices -l kubernetes.io/service-name=web -o jsonpath="$JP"
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
  | grep -A2 "$CIP:"
for i in 1 2 3 4; do k exec client -- curl -s http://web/hostname; echo; done
k exec client -- curl -s -m2 http://$PIP:8080/hostname; echo " <- direkt"

Erwartet:

pod "web-565f96c64-l72c9" deleted from tag09 namespace
NAME                  READY   STATUS        RESTARTS   AGE
web-565f96c64-dtw9w   1/1     Running       0          4s
web-565f96c64-l72c9   1/1     Terminating   0          69s
web-565f96c64-n2pjp   1/1     Running       0          69s
web-565f96c64-l72c9 r=false s=true t=true
web-565f96c64-n2pjp r=true s=true t=false
web-565f96c64-dtw9w r=true s=true t=false
69   10.103.176.39:80/TCP      ClusterIP      1 => 10.0.1.47:8080/TCP (terminating)
                                              2 => 10.0.1.120:8080/TCP (active)
                                              3 => 10.0.2.214:8080/TCP (active)
web-565f96c64-dtw9w
web-565f96c64-n2pjp
web-565f96c64-dtw9w
web-565f96c64-n2pjp
web-565f96c64-l72c9 <- direkt

Sofort beim Löschen wird der Endpunkt terminating und ready=false – neue Verbindungen gehen nur an die anderen Pods. serving=true heißt: Der Pod könnte noch antworten, und das tut er, wie der direkte Aufruf zeigt. Zeitlich: erst 15 s preStop.sleep, dann SIGTERM, das agnhost mit --delay-shutdown=45 noch 45 s überbrückt – zusammen genau die terminationGracePeriodSeconds: 60. In dieser Zeit haben Cilium-Agenten und typische externe Load Balancer den Endpunkt in aller Regel entfernt. Nach gut einer Minute:

k get pods -l app=web
k get endpointslices -l kubernetes.io/service-name=web -o jsonpath="$JP"

Erwartet:

NAME                  READY   STATUS    RESTARTS   AGE
web-565f96c64-dtw9w   1/1     Running   0          73s
web-565f96c64-n2pjp   1/1     Running   0          2m18s
web-565f96c64-n2pjp r=true s=true t=false
web-565f96c64-dtw9w r=true s=true t=false

Fortschritt speichern? Kostenlos registrieren

Drill 5: trafficDistribution und Zonen

k explain service.spec.trafficDistribution | sed -n '/DESCRIPTION/,$p'
k patch svc web -p '{"spec":{"trafficDistribution":"PreferBogus"}}'

Erwartet (gekürzt):

DESCRIPTION:
    TrafficDistribution offers a way to express preferences for how traffic is
    distributed to Service endpoints. ... If set
    to "PreferClose", implementations should prioritize endpoints that are in
    the same zone.
The Service "web" is invalid: spec.trafficDistribution: Unsupported value:
"PreferBogus": supported values: "PreferClose", "PreferSameZone", "PreferSameNode"

k explain nennt nur PreferClose; welche Werte 1.37 wirklich kennt, verrät die Validierung. Zonen kommen aus dem Node-Label topology.kubernetes.io/zone – im Labor setzt du sie selbst:

k label node worker1 topology.kubernetes.io/zone=zone-a
k label node worker2 topology.kubernetes.io/zone=zone-b
k get nodes -L topology.kubernetes.io/zone
k patch svc web -p '{"spec":{"trafficDistribution":"PreferSameZone"}}'
sleep 3
k get endpointslices -l kubernetes.io/service-name=web -o jsonpath=\
'{range .items[*].endpoints[*]}{.nodeName} {.zone} {.hints}{"\n"}{end}'
k patch svc web -p '{"spec":{"trafficDistribution":"PreferSameNode"}}'
sleep 3
k get endpointslices -l kubernetes.io/service-name=web -o jsonpath=\
'{range .items[*].endpoints[*]}{.nodeName} {.zone} {.hints}{"\n"}{end}'

Erwartet (gekürzt):

node/worker1 labeled
node/worker2 labeled
NAME      STATUS   ROLES           AGE   VERSION   ZONE
cp1       Ready    control-plane   53m   v1.37.2
worker1   Ready    <none>          47m   v1.37.2   zone-a
worker2   Ready    <none>          47m   v1.37.2   zone-b
service/web patched
worker2 zone-b {"forZones":[{"name":"zone-b"}]}
worker1 zone-a {"forZones":[{"name":"zone-a"}]}
service/web patched
worker2 zone-b {"forNodes":[{"name":"worker2"}],"forZones":[{"name":"zone-b"}]}
worker1 zone-a {"forNodes":[{"name":"worker1"}],"forZones":[{"name":"zone-a"}]}

Der Controller schreibt Hinweise (hints) in die Slice – mehr nicht. Ob sie wirken, entscheidet die Service-Implementierung. Der Client läuft auf worker2 (Zone b):

for i in 1 2 3 4 5 6; do k exec client -- curl -s http://web/hostname; echo; done
cilium config view | grep service-topology

Erwartet:

web-565f96c64-n2pjp
web-565f96c64-n2pjp
web-565f96c64-dtw9w
web-565f96c64-dtw9w
web-565f96c64-n2pjp
web-565f96c64-n2pjp
enable-service-topology                           false

Beide Zonen antworten: Cilium wertet Hints nur mit dem Helm-Wert loadBalancer.serviceTopology=true aus (Agent-Option enable-service-topology). Im Labor bleibt das aus – in der Prüfung gilt: erst prüfen, ob die Implementierung Hints beachtet, bevor du ein „falsches“ Routing suchst. PreferClose ist der alte Name und liefert inzwischen eine Warnung:

k patch svc web -p '{"spec":{"trafficDistribution":"PreferClose"}}'

Erwartet:

Warning: spec.trafficDistribution: "PreferClose" is deprecated; use "PreferSameZone"
service/web patched

Fortschritt speichern? Kostenlos registrieren

Drill 6: PodDisruptionBudget – Readiness zählt

Ein PDB schützt vor freiwilligen Unterbrechungen (Drain, Eviction) und zählt dabei nur bereite Pods – dieselbe Readiness, die die Endpunkte steuert.

k create pdb web --selector=app=web --min-available=1
k get pdb web
P1=$(k get pod -l app=web -o jsonpath='{.items[0].metadata.name}')
P2=$(k get pod -l app=web -o jsonpath='{.items[1].metadata.name}')
k exec $P1 -- touch /tmp/down
sleep 8
k get pdb web
cat > evict.json <<EOF
{"apiVersion":"policy/v1","kind":"Eviction","metadata":{"name":"$P2"}}
EOF
k create --raw /api/v1/namespaces/tag09/pods/$P2/eviction -f evict.json

Erwartet:

poddisruptionbudget.policy/web created
NAME   MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
web    1               N/A               1                     2s
NAME   MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
web    1               N/A               0                     11s
Error from server (TooManyRequests): Cannot evict pod as it would violate the pod's
disruption budget.

Genau diese Eviction schickt k drain für jeden Pod – ohne Node-Drain zu üben, siehst du hier, warum ein Drain hängt: Ein unbereiter Pod verbraucht das Budget. Pod wieder gesund machen, dann klappt es:

k exec $P1 -- rm /tmp/down
sleep 5
k get pdb web
k create --raw /api/v1/namespaces/tag09/pods/$P2/eviction -f evict.json; echo
k get pods -l app=web

Erwartet:

NAME   MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
web    1               N/A               1                     17s
{"kind":"Status","apiVersion":"v1","metadata":{},"status":"Success","code":201}
NAME                  READY   STATUS        RESTARTS   AGE
web-565f96c64-dtw9w   1/1     Running       0          2m10s
web-565f96c64-n2pjp   1/1     Terminating   0          3m15s
web-565f96c64-p2zj9   1/1     Running       0          3s

Der per Eviction entfernte Pod durchläuft dieselbe Terminating-Phase wie in Drill 4. Zur Größe: Eine EndpointSlice fasst standardmäßig höchstens 100 Endpunkte (kube-controller-manager --max-endpoints-per-slice); größere Services verteilen sich auf mehrere Slices – deshalb immer per Label kubernetes.io/service-name abfragen, nie über den Slice-Namen.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeige die Namen aller Pods, die in den Slices von web nicht ready sind. Zeitziel: 60 s
  2. Zeige, wie viele Unterbrechungen PDB web gerade erlaubt. Zeitziel: 20 s
  3. Lege einen headless Service db (Port 5432, Selector app=db) an, der auch nicht bereite Adressen veröffentlicht. Zeitziel: 60 s
  4. Zeige, wo der Default für Endpunkte pro Slice am kube-controller-manager überschrieben wäre. Zeitziel: 30 s

Lösung

k exec $P1 -- touch /tmp/down; sleep 8
k get endpointslices -l kubernetes.io/service-name=web -o jsonpath=\
'{.items[*].endpoints[?(@.conditions.ready==false)].targetRef.name}'; echo
k get pdb web -o jsonpath='{.status.disruptionsAllowed}'; echo
k create service clusterip db --clusterip=None --tcp=5432 $do > db.yaml
sed -i '/^  clusterIP: None/a\  publishNotReadyAddresses: true' db.yaml
k apply -f db.yaml
k get svc db -o jsonpath='{.spec.clusterIP} {.spec.publishNotReadyAddresses}'; echo
k -n kube-system get pod -l component=kube-controller-manager -o yaml \
  | grep -c max-endpoints-per-slice
k exec $P1 -- rm /tmp/down

Erwartet (mit dem per touch /tmp/down unbereiten Pod $P1):

web-565f96c64-dtw9w
0
service/db created
None true
0

0 Treffer beim letzten Befehl heißt: Flag nicht gesetzt, es gilt der Standard 100.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

k get endpointslices -l kubernetes.io/service-name=web -o jsonpath="$JP"

Erwartet: zwei Pods mit r=true s=true t=false.

k get svc web-peers -o jsonpath='{.spec.publishNotReadyAddresses}'

Erwartet: true

k get svc web -o jsonpath='{.spec.trafficDistribution}'

Erwartet: PreferClose

k get pdb web

Erwartet: ALLOWED DISRUPTIONS 1.

k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
  | grep -A1 "$(k get svc web -o jsonpath='{.spec.clusterIP}'):"

Erwartet: zwei Backends, beide (active).

Challenge

Starte einen Rollout von web, während der Client zwei Anfragen pro Sekunde schickt, und belege, dass keine einzige fehlschlägt.

Hinweis: k rollout restart kehrt sofort zurück – direkt danach die Antwortcodes mit curl -w '%{http_code}' sammeln und zählen.

Lösung

k rollout restart deployment web
k exec client -- sh -c 'for i in $(seq 60); do
  curl -s -o /dev/null -w "%{http_code}\n" -m1 http://web/hostname; sleep 0.5; done' \
  | sort | uniq -c
k rollout status deployment web
k get pods -l app=web

Erwartet:

deployment.apps/web restarted
     60 200
deployment "web" successfully rolled out
NAME                   READY   STATUS        RESTARTS   AGE
web-565f96c64-dtw9w    1/1     Terminating   0          3m11s
web-565f96c64-p2zj9    1/1     Terminating   0          64s
web-5b4dddcd9b-n7vbg   1/1     Running       0          30s
web-5b4dddcd9b-nzpx8   1/1     Running       0          34s

Neue Pods bekommen erst Verkehr, wenn sie ready sind; alte verlieren ihn sofort beim Terminating, laufen aber noch bis zu 60 s weiter. So überlebt auch eine Verbindung, die ein Load Balancer kurz vorher noch zum alten Pod geschickt hat.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

Die Zonen-Labels sind clusterweit und müssen weg:

k label node worker1 topology.kubernetes.io/zone-
k label node worker2 topology.kubernetes.io/zone-
k get nodes -L topology.kubernetes.io/zone
k delete namespace tag09
k config set-context --current --namespace=default

Erwartet: Spalte ZONE leer bei allen drei Nodes, namespace "tag09" deleted.

Prüfungstipp

  • „Service hat keine Endpunkte“: erst k get endpointslices -l kubernetes.io/service-name=… mit Conditions, dann Selector gegen Pod-Labels und targetPort gegen den Container-Port prüfen.
  • Die Spalte ENDPOINTS lügt bei unbereiten Pods – Conditions lesen oder in Cilium cilium-dbg service list (maintenance, terminating).
  • Doku-Stellen: kubernetes.io „EndpointSlices“, „Traffic Distribution“ (Abschnitt im Service-Artikel) und „Specifying a Disruption Budget for your Application“.

Enterprise-Notiz

  • Readiness-Proben prüfen nur, was der Pod selbst kann – keine Abhängigkeiten wie die Datenbank, sonst fallen bei deren Ausfall alle Endpunkte gleichzeitig weg.
  • preStop-Pause plus Grace Period sind Pflicht hinter externen Load Balancern, die Ziele erst nach Sekunden austragen (Cloud-LBs, Ingress-Controller außerhalb).
  • trafficDistribution: PreferSameZone spart in Clouds Kosten für zonenübergreifenden Verkehr – mit Cilium erst nach loadBalancer.serviceTopology=true und mit genügend Replikas pro Zone.
  • PDBs gehören zu jedem replizierten Dienst; minAvailable gleich Replikazahl blockiert jedes Node-Update.
  • Sehr große Services (Tausende Endpunkte) erzeugen viele Slices und viel Watch-Verkehr – ein Grund, Endpunktzahlen und API-Server-Last zu überwachen.