Tag 13: Multicluster – Failover und föderierte Dienste
Ziel: Du verteilst Verkehr gezielt auf lokale und entfernte Instanzen, lässt einen Cluster ausfallen und misst, was der Client davon merkt – mit Gateway und mit einem föderierten Dienst. · Dauer: ca. 90 min · Voraussetzung: Tag 12
Briefing
- Ein gespiegelter Service ist ein normaler Service. Du kannst ihn per HTTPRoute mit Gewichten neben den lokalen stellen – Traffic Shifting über Clustergrenzen.
- Der Controller prüft das Gateway alle 3 s. Fällt es aus, leert er die Endpunkte des Spiegels. Schneller ist der Proxy des Clients: Er meidet das tote Gateway schon nach rund 3 s von selbst.
- Ein föderierter Dienst
(
<name>-federated) fasst gleichnamige Services aus mehreren Clustern zu einem zusammen. Der Proxy verteilt direkt auf alle Pods. - Föderiert heißt Pod-zu-Pod, ohne Gateway. Die Pod-Netze müssen sich erreichen.
- Die alte Failover-Extension (TrafficSplit) ist veraltet. Föderierte Dienste ersetzen sie.
ost west
last ─> echo-federated ─┬─> echo-ost │
└──── direkt ────────┴─> echo-west (10.42.0.0/16)
Drill 1: Zwei Instanzen, ein Name
In beiden Clustern läuft echo im Namespace
tag13. Die Deployments heißen echo-ost und
echo-west, damit du am Pod-Namen siehst, wer geantwortet
hat:
mkdir -p ~/linkerd/tag13 && cd ~/linkerd/tag13
WEST=172.16.0.182
cat > echo.yaml <<'EOF'
apiVersion: v1
kind: Namespace
metadata:
name: tag13
annotations: {linkerd.io/inject: enabled}
---
apiVersion: v1
kind: ServiceAccount
metadata: {name: echo, namespace: tag13}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: echo-CLUSTER, namespace: tag13}
spec:
replicas: 1
selector: {matchLabels: {app: echo}}
template:
metadata: {labels: {app: echo}}
spec:
serviceAccountName: echo
containers:
- name: echo
image: ghcr.io/mccutchen/go-httpbin:2.26.0
env: [{name: USE_REAL_HOSTNAME, value: "true"}]
ports: [{containerPort: 8080, name: http}]
readinessProbe:
httpGet: {path: /status/200, port: http}
---
apiVersion: v1
kind: Service
metadata: {name: echo, namespace: tag13}
spec:
selector: {app: echo}
ports: [{port: 80, targetPort: http, name: http}]
EOF
for c in ost west; do
sed "s/CLUSTER/$c/" echo.yaml | kubectl --context $c apply -f -
done
kubectl --context west -n tag13 label service echo mirror.linkerd.io/exported=trueDie Reihenfolge stimmt: Der Namespace in ost existiert,
bevor west exportiert. Der Lastgenerator schreibt pro
Aufruf nur, wer geantwortet hat. Das Ziel steht in ZIEL,
damit du es später umstellen kannst:
cat > last.yaml <<'EOF'
apiVersion: v1
kind: ServiceAccount
metadata: {name: last, namespace: tag13}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: last, namespace: tag13}
spec:
replicas: 1
selector: {matchLabels: {app: last}}
template:
metadata: {labels: {app: last}}
spec:
serviceAccountName: last
containers:
- name: last
image: docker.io/curlimages/curl:8.23.0
env: [{name: ZIEL, value: echo}]
command: [sh, -c]
args:
- |
while true; do
r=$(curl -s -m 2 http://$ZIEL/hostname | grep -o "echo-[a-z]*")
echo "$(date +%T) ${r:-fehler}"
sleep 0.5
done
EOF
kubectl --context ost apply -f last.yaml
kubectl --context ost -n tag13 rollout status deploy/last
kubectl --context ost -n tag13 get svcErwartet:
deployment "last" successfully rolled out
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
echo ClusterIP 10.108.151.187 <none> 80/TCP 11s
echo-west ClusterIP 10.100.226.150 <none> 80/TCP 9s
sleep 30
kubectl --context ost -n tag13 logs deploy/last -c last --since=30s \
| awk '{print $2}' | sort | uniq -cErwartet (Zahlen schwanken):
45 echo-ost
Die Baseline: Alles bleibt lokal. Ein Spiegel allein lenkt keinen Verkehr um.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Verkehr über die Grenze verteilen
Eine HTTPRoute hängt sich an den Service echo und
verteilt auf echo und den Spiegel:
cat > route.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: {name: echo, namespace: tag13}
spec:
parentRefs:
- {group: core, kind: Service, name: echo, port: 80}
rules:
- backendRefs:
- {name: echo, port: 80, weight: 50}
- {name: echo-west, port: 80, weight: 50}
EOF
kubectl --context ost apply -f route.yaml
sleep 58
kubectl --context ost -n tag13 logs deploy/last -c last --since=55s \
| awk '{print $2}' | sort | uniq -c
linkerd --context ost viz stat -n tag13 deploy/last --to svc/echo-westErwartet (Zahlen schwanken):
39 echo-ost
52 echo-west
NAME MESHED SUCCESS RPS LATENCY_P50 LATENCY_P95 LATENCY_P99 TCP_CONN
last 1/1 100.00% 0.9rps 5ms 10ms 10ms 1
Traffic Shifting wie im eigenen Cluster, nur liegt ein Backend woanders. So schiebst du Verkehr schrittweise in einen neuen Cluster, etwa bei einer Migration.
Fortschritt speichern? Kostenlos registrieren
Drill 3: west fällt aus – Gateway-Modus
Du nimmst das Gateway in west weg. Die Pods dort laufen
weiter, sind aber nicht mehr erreichbar:
kubectl --context west -n linkerd-multicluster scale deploy/linkerd-gateway --replicas=0
date +%T
sleep 20
linkerd --context ost multicluster gateways
kubectl --context ost -n tag13 get endpoints echo-westErwartet (gekürzt):
21:59:39
CLUSTER ALIVE NUM_SVC LATENCY
west False 1 -
NAME ENDPOINTS AGE
echo-west 5m44s
Nach drei fehlgeschlagenen Proben leert der Controller die Endpunkte
des Spiegels. Was hat last gesehen? Setz statt 21:59:39
deine Uhrzeit aus date ein:
kubectl --context ost -n tag13 logs deploy/last -c last --since=60s \
| awk '$1>="21:59:39" && $1<="21:59:47"'Erwartet (gekürzt):
21:59:39 echo-west
21:59:40 echo-ost
21:59:41 echo-ost
21:59:43 fehler
21:59:44 echo-ost
21:59:45 echo-ost
21:59:47 echo-ost
Ein Fehler, zwei Sekunden Stillstand (curl -m 2) –
danach geht alles nach ost, obwohl die Route weiter 50 zu
50 sagt. Waren das die leeren Endpunkte? Die Uhrzeiten im Log des Proxys
von last sagen etwas anderes:
kubectl --context ost -n tag13 logs deploy/last -c linkerd-proxy --since=60s \
--timestamps | grep -E 'closed|failfast|Removing' | sed -E 's/^.{11}(.{8}).*: /\1 /'Erwartet:
21:59:41 Service failed error=channel closed
21:59:44 Unavailable; entering failfast timeout=3.0
21:59:48 Removing endpoint addr=172.16.0.182:4143
Die Reihenfolge erklärt die Erholung. Um 21:59:41 schließt das
Gateway die Verbindung, Neuverbindungen laufen ins Leere. Nach 3 s ohne
erreichbaren Endpunkt schaltet der Proxy das Backend
echo-west auf failfast: Die wartende
Anfrage scheitert (das eine fehler), und die Route verteilt
nur noch auf Backends, die bereit sind. Die Endpunkte leert der
Controller erst um 21:59:48, rund 9 s nach dem Ausfall (3 Proben × 3 s).
Das räumt nur noch auf – gerettet hat den Verkehr schon der Proxy
selbst. Zurück:
kubectl --context west -n linkerd-multicluster scale deploy/linkerd-gateway --replicas=1
date +%T
sleep 50
linkerd --context ost multicluster gateways
kubectl --context ost -n tag13 logs deploy/last -c last --since=60s \
| grep -m1 echo-westErwartet:
22:00:20
CLUSTER ALIVE NUM_SVC LATENCY
west True 1 8ms
22:00:42 echo-west
Gut 20 Sekunden, obwohl der Gateway-Pod nach rund 6 s bereit ist. Die Proben des Controllers laufen über seinen eigenen Proxy, und der hat sich die tote Adresse gemerkt:
kubectl --context ost -n linkerd-multicluster logs deploy/controller-west \
-c linkerd-proxy --since=3m --timestamps \
| grep -E 'Failed to connect|exited failfast' | sed -E 's/^.{11}(.{8}).*: /\1 /'Erwartet (gekürzt):
21:59:43 Failed to connect error=connect timed out after 1s
21:59:44 Failed to connect error=connect timed out after 1s
21:59:45 Failed to connect error=connect timed out after 1s
21:59:47 Failed to connect error=connect timed out after 1s
21:59:50 Failed to connect error=connect timed out after 1s
21:59:54 Failed to connect error=connect timed out after 1s
22:00:01 Failed to connect error=connect timed out after 1s
22:00:15 Failed to connect error=connect timed out after 1s
22:00:41 Available; exited failfast elapsed=59.295263099
Die Abstände wachsen: 1, 2, 3, 4, 7, 14, 26 Sekunden (Backoff). Erst
der Versuch um 22:00:41 trifft das Gateway, dann ist die Probe grün und
der Endpunkt kommt zurück. Je länger west weg war, desto
länger dauert die Rückkehr – im Test nach gut zwei Minuten Ausfall gut
40 s, der Abstand wächst bis auf 60 s.
Fortschritt speichern? Kostenlos registrieren
Drill 4: ost fällt aus
Jetzt die Gegenrichtung, bei weiter 50 zu 50:
kubectl --context ost -n tag13 scale deploy/echo-ost --replicas=0
sleep 58
kubectl --context ost -n tag13 logs deploy/last -c last --since=55s \
| awk '{print $2}' | sort | uniq -cErwartet:
84 echo-west
Kein einziger Fehler – west übernimmt. Aber Vorsicht mit
dem Gewicht 0:
kubectl --context ost -n tag13 patch httproute echo --type=json \
-p '[{"op":"replace","path":"/spec/rules/0/backendRefs/1/weight","value":0}]'
sleep 40
kubectl --context ost -n tag13 logs deploy/last -c last --since=30s \
| awk '{print $2}' | sort | uniq -c
kubectl --context ost -n tag13 exec deploy/last -c last -- \
curl -s -o /dev/null -w '%{http_code}\n' -m 3 http://echo/hostnameErwartet:
48 fehler
503
Gewicht 0 heißt „nie“, auch wenn sonst nichts mehr da ist. Für eine Reserve, die nur im Notfall einspringt, sind Gewichte das falsche Werkzeug. Zurück auf den Ausgangszustand:
kubectl --context ost -n tag13 scale deploy/echo-ost --replicas=1
kubectl --context ost -n tag13 rollout status deploy/echo-ost
kubectl --context ost delete -f route.yamlFortschritt speichern? Kostenlos registrieren
Drill 5: Ein flaches Netz
Föderierte Dienste sprechen Pods im anderen Cluster direkt an. Heute geht das nicht:
kubectl --context ost -n tag13 run ohne --image=docker.io/curlimages/curl:8.23.0 \
--restart=Never --annotations=linkerd.io/inject=disabled --command -- sleep 3600
kubectl --context ost -n tag13 wait --for=condition=Ready pod/ohne
P=$(kubectl --context west -n tag13 get pod -l app=echo \
-o jsonpath='{.items[0].status.podIP}')
echo $P
kubectl --context ost -n tag13 exec ohne -- \
curl -s -m 3 -o /dev/null -w '%{http_code}\n' http://$P:8080/hostnameErwartet:
10.42.0.21
000
command terminated with exit code 28
Die Nodes in ost kennen 10.42.0.0/16 nicht. Eine
statische Route auf jedem Node reicht für das Labor. Cilium maskiert
ausgehenden Verkehr auf die Node-IP, deshalb braucht west
keine Route zurück:
sudo ip route add 10.42.0.0/16 via $WEST
for w in 172.16.0.228 172.16.0.83; do
ssh ubuntu@$w sudo ip route add 10.42.0.0/16 via $WEST
done
ip route get $P
kubectl --context ost -n tag13 exec ohne -- \
curl -s -m 3 -o /dev/null -w '%{http_code}\n' http://$P:8080/hostnameErwartet:
10.42.0.21 via 172.16.0.182 dev eth0 src 172.16.0.126 uid 1000
cache
200
Die Routen sind nicht dauerhaft und nach einem Neustart weg. Das ist hier gewollt.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Ein föderierter Dienst
Das Label mirror.linkerd.io/federated=member kommt an
den Service in beiden Clustern:
for c in ost west; do
kubectl --context $c -n tag13 label service echo mirror.linkerd.io/federated=member
done
sleep 10
kubectl --context ost -n tag13 get svc
linkerd --context ost diagnostics endpoints echo-federated.tag13.svc.cluster.local:80Erwartet:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
echo ClusterIP 10.108.151.187 <none> 80/TCP 7m13s
echo-federated ClusterIP 10.103.75.249 <none> 80/TCP 11s
echo-west ClusterIP 10.100.226.150 <none> 80/TCP 7m11s
NAMESPACE IP PORT POD SERVICE
tag13 10.0.1.144 8080 echo-ost-555d67ccf8-6hz89 echo.tag13
tag13 10.42.0.21 8080 echo-west-555d67ccf8-c7pcc echo.tag13
Ein Service, zwei Pods aus zwei Clustern, beide mit
Pod-IP – kein Gateway. Das funktioniert mit dem
bestehenden Link aus Tag 12. Jetzt last umstellen:
kubectl --context ost -n tag13 set env deploy/last ZIEL=echo-federated
kubectl --context ost -n tag13 rollout status deploy/last
sleep 58
kubectl --context ost -n tag13 logs deploy/last -c last --since=55s \
| awk '{print $2}' | sort | uniq -cErwartet (Zahlen schwanken):
31 echo-ost
54 echo-west
Keine Route, keine Gewichte – der Proxy verteilt nach Latenz auf alle
Endpunkte. Und wer kommt jetzt in west an?
linkerd --context west diagnostics proxy-metrics -n tag13 deploy/echo-west \
| grep '^tcp_open_total{direction="inbound",peer="src"' \
| grep -oE '(target_port|client_id|no_tls_reason)="[^"]*"|[0-9]+$' | paste - - -Erwartet (gekürzt):
target_port="8080" client_id="last.tag13.serviceaccount.identity.linkerd.cluster.l…" 1
target_port="8080" client_id="linkerd-gateway.linkerd-multicluster.serviceaccou…" 4
target_port="8080" no_tls_reason="no_tls_from_remote" 52
Über den föderierten Dienst sieht echo-west den echten
Client last statt des Gateways (das waren die Aufrufe aus
Drill 2). Ohne TLS kommen nur die Probes des kubelet und dein Test aus
Drill 5.
Fortschritt speichern? Kostenlos registrieren
Drill 7: west fällt hart aus
Diesmal nicht nur das Gateway: Du hältst ganz k3s an, samt API und
Pods. k3s-killall.sh beendet alle Container, lässt andere
Dienste auf der VM aber laufen:
date +%T
ssh ubuntu@$WEST sudo k3s-killall.sh > /dev/null 2>&1
sleep 50
kubectl --context ost -n tag13 logs deploy/last -c last --since=55s \
| awk '{print $2}' | sort | uniq -c
linkerd --context ost multicluster gateways
linkerd --context ost diagnostics endpoints echo-federated.tag13.svc.cluster.local:80Erwartet:
16:31:33
75 echo-ost
5 echo-west
CLUSTER ALIVE NUM_SVC LATENCY
west False 1 -
NAMESPACE IP PORT POD SERVICE
tag13 10.0.1.144 8080 echo-ost-555d67ccf8-6hz89 echo.tag13
tag13 10.42.0.21 8080 echo-west-555d67ccf8-c7pcc echo.tag13
Kein einziges fehler. Spannend: Der tote Endpunkt steht
noch in der Liste, denn die API von west antwortet nicht
mehr und niemand kann ihn austragen. Der Proxy merkt es selbst:
kubectl --context ost -n tag13 logs deploy/last -c linkerd-proxy --since=60s \
| grep -o 'endpoint{addr=[0-9.:]*}: linkerd_reconnect: .*' | tail -2Erwartet (gekürzt):
endpoint{addr=10.42.0.21:8080}: linkerd_reconnect: Failed to connect error=connect …
endpoint{addr=10.42.0.21:8080}: linkerd_reconnect: Failed to connect error=connect …
Ein Endpunkt, zu dem keine Verbindung aufgeht, bekommt keine
Anfragen. Der Proxy versucht es im Hintergrund mit wachsendem Abstand
weiter. Jetzt west zurückholen:
date +%T
ssh ubuntu@$WEST sudo systemctl start k3s
kubectl --context west wait --for=condition=Ready node/west --timeout=120s
kubectl --context west -n tag13 get pod -o wideErwartet (gekürzt):
16:33:07
node/west condition met
NAME READY STATUS RESTARTS AGE IP ...
echo-west-555d67ccf8-c7pcc 2/2 Running 2 (101s ago) 11m 10.42.0.10 ...
Der Pod hat eine neue IP. Bis ost sie
kennt und Verkehr schickt, vergeht Zeit:
sleep 120
kubectl --context ost -n tag13 logs deploy/last -c last --since=300s \
| awk '$1>"16:33:00" && $2=="echo-west"' | head -1Erwartet:
16:35:16 echo-west
Gut zwei Minuten nach dem Start von k3s: API hoch, Pods neu, Watch
des Destination-Controllers neu verbunden. Über den ganzen Ausfall
hinweg gab es keinen Fehler – aber auch zwei Minuten lang keinen Verkehr
nach west.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeig, aus welchem entfernten Cluster
echo-federatedMitglieder hat. Zeitziel: 30 s - Zeig die Endpunkte von
echo-federated. Zeitziel: 20 s - Zeig, warum ein Client ohne Proxy
echo-federatednicht nutzen kann. Zeitziel: 45 s - Zeig die Proxy-Warnungen von
lastzu nicht erreichbaren Endpunkten. Zeitziel: 30 s
Lösung
kubectl --context ost -n tag13 get svc echo-federated \
-o jsonpath='{.metadata.annotations.multicluster\.linkerd\.io/remote-discovery}'
linkerd --context ost diagnostics endpoints echo-federated.tag13.svc.cluster.local:80
kubectl --context ost -n tag13 get endpointslices \
-l kubernetes.io/service-name=echo-federated
kubectl --context ost -n tag13 exec ohne -- \
curl -s -m 3 -o /dev/null -w '%{http_code}\n' http://echo-federated/hostname
kubectl --context ost -n tag13 logs deploy/last -c linkerd-proxy | grep reconnectErwartet (gekürzt):
echo@west
...
No resources found in tag13 namespace.
000
command terminated with exit code 7
echo-federated hat keinen Selector und keine
EndpointSlices. Nur Linkerds Destination-Controller kennt die Mitglieder
– ohne Proxy kein Ziel.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
linkerd --context ost diagnostics endpoints echo-federated.tag13.svc.cluster.local:80Erwartet: zwei Zeilen, eine mit 10.0.x.x
(echo-ost), eine mit 10.42.x.x
(echo-west).
kubectl --context ost -n tag13 logs deploy/last -c last --since=30s \
| awk '{print $2}' | sort | uniq -cErwartet: Zeilen für echo-ost und
echo-west, keine für fehler.
linkerd --context ost multicluster check 2>&1 | tail -1Erwartet:
Status check results are √
Challenge
Mach aus dem Spiegel echo-west einen Spiegel
ohne Gateway: Er soll direkt auf den Pod in
west zeigen, weiterhin unter dem Namen
echo-west.
Hinweis: Der Link kennt neben
exported=true einen zweiten Wert für das Export-Label.
Lösung
kubectl --context west -n tag13 label service echo \
mirror.linkerd.io/exported=remote-discovery --overwrite
sleep 10
kubectl --context ost -n tag13 get svc echo-west \
-o jsonpath='{.metadata.labels.multicluster\.linkerd\.io/remote-discovery}{"\n"}'
linkerd --context ost diagnostics endpoints echo-west.tag13.svc.cluster.local:80
kubectl --context ost -n tag13 exec deploy/last -c last -- \
curl -s http://echo-west/hostnameErwartet (gekürzt):
west
NAMESPACE IP PORT POD SERVICE
tag13 10.42.0.10 8080 echo-west-555d67ccf8-c7pcc echo.tag13
{
"hostname": "echo-west-555d67ccf8-c7pcc"
}
Der Link aus Tag 12 enthält schon
remoteDiscoverySelector
(mirror.linkerd.io/exported=remote-discovery). Der Spiegel
bleibt, zeigt aber auf die Pod-IP. Wie beim föderierten Dienst braucht
das ein flaches Netz.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
Erst die Exporte, dann der Link. Seit Linkerd 2.18 gibt es kein
multicluster unlink mehr, du entfernst die Teile
einzeln:
kubectl --context ost -n tag13 delete pod ohne
kubectl --context west -n tag13 label service echo \
mirror.linkerd.io/exported- mirror.linkerd.io/federated-
kubectl --context ost -n tag13 label service echo mirror.linkerd.io/federated-
kubectl --context ost get svc -A -l mirror.linkerd.io/mirrored-service=true
kubectl --context ost -n linkerd-multicluster delete link west
linkerd --context ost multicluster install -f ../tag12/mc-ost-gw.yaml \
| kubectl --context ost delete -l mirror.linkerd.io/cluster-name=west -f -
kubectl --context ost -n linkerd-multicluster delete secret cluster-credentials-west
kubectl --context ost -n linkerd delete secret cluster-credentials-westErwartet (gekürzt):
No resources found
link.multicluster.linkerd.io "west" deleted from linkerd-multicluster namespace
deployment.apps "controller-west" deleted from linkerd-multicluster namespace
service "probe-west" deleted from linkerd-multicluster namespace
...
Dann Routen und Namespaces:
sudo ip route del 10.42.0.0/16 via $WEST
for w in 172.16.0.228 172.16.0.83; do
ssh ubuntu@$w sudo ip route del 10.42.0.0/16 via $WEST
done
for c in ost west; do kubectl --context $c delete namespace tag13; done
linkerd --context ost multicluster check 2>&1 | tail -1
linkerd --context ost multicluster gatewaysErwartet:
Status check results are √
CLUSTER ALIVE NUM_SVC LATENCY
Die Extension bleibt auf beiden Clustern installiert,
west läuft weiter. Einen neuen Link legst du jederzeit
wieder an: Controller auf ost mit
../tag12/mc-ost-gw.yaml (Tag 12, Drill 5 und Challenge –
mit mc-ost-values.yaml verschwände das NodePort-Gateway),
dann link-gen wie in Drill 6.
Interview-Notiz
- Wie macht man Failover zwischen Clustern mit Linkerd? Föderierte Dienste: Der Proxy verteilt auf alle Pods aller Cluster und meidet Endpunkte, die nicht antworten. Die alte Failover-Extension mit TrafficSplit ist veraltet.
- Gateway oder Pod-zu-Pod? Gateway braucht nur eine erreichbare Adresse, kostet einen Hop und versteckt die Client-Identität. Pod-zu-Pod braucht geroutete, überschneidungsfreie Pod-Netze, behält aber die echte Identität.
- Was passiert, wenn ein ganzer Cluster weg ist? Seine Endpunkte bleiben bekannt, weil seine API nicht antwortet. Der Proxy kommt nicht durch und schickt nichts mehr hin.
Enterprise-Notiz
- Flache Netze kommen im Betrieb aus dem Netzwerk-Design (BGP, Cilium ClusterMesh, Cloud-VPC-Peering), nicht aus statischen Routen.
- Föderierte Dienste brauchen gemeshte Clients. Ingress-Controller und
Jobs ohne Proxy sehen
-federatedals leeren Service. - Gleiche Service-Namen in allen Clustern sind Pflicht für Föderation – Namenskonventionen vorher festlegen.
- Ausfälle regelmäßig üben (Game Days): Gateway weg, API weg, ganzer Cluster weg. Die Wiederkehr dauert länger als der Ausfall.
- Policies: Über das Gateway sieht der Server die Gateway-Identität, über Pod-zu-Pod den echten Client. Regeln für beide Wege schreiben.