Zum Inhalt springen
Trainingslager IT-Trainingslager

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, externalTrafficPolicy und internalTrafficPolicy gehö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: /hostname nennt den Pod, /clientip die 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; done

Erwartet (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-np

Erwartet (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 ciliumloadbalancerippools

Erwartet:

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; echo

Erwartet: 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 -1

Erwartet:

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_affinity

Erwartet:

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
exit

Erwartet:

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/hostname

Erwartet:

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 8000

Zurü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

  1. Lege für deployment/echo einen NodePort-Service web an, Port 80 → 8080, NodePort fest 31000. Zeitziel: 60 s
  2. Begrenze die Session Affinity von Service echo auf 60 Sekunden. Zeitziel: 30 s
  3. Zeige Pod-IP, Pod-Name und Node jedes Endpunkts von echo in einer Zeile. Zeitziel: 60 s
  4. Zeige für alle Services in tag06 Typ, externalTrafficPolicy und internalTrafficPolicy. 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.internalTrafficPolicy

Erwartet (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/clientip

Erwartet: 172.16.0.123:<Port> – die echte Client-IP.

k get svc echo-lb

Erwartet: EXTERNAL-IP <pending> (kein LB-IPAM-Pool bis Tag 15).

k exec client -- dig +short echo-hl.tag06.svc.cluster.local

Erwartet: 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"
done

Erwartet:

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
exit

Auf cp1:

k delete namespace tag06
k config set-context --current --namespace=default

Clusterweit hat Tag 6 nichts verändert.

Prüfungstipp

  • k expose kennt --type, --port, --target-port, --cluster-ip=None, aber keinen festen NodePort und keine Policies – die setzt du mit k patch oder per $do-Datei.
  • externalTrafficPolicy wirkt nur auf NodePort/LoadBalancer, internalTrafficPolicy nur auf Verkehr aus dem Cluster; Local ohne 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: Local ist ü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 Cluster erhalten; 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.