Zum Inhalt springen
Trainingslager IT-Trainingslager

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=true

Die 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 svc

Erwartet:

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 -c

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

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

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

Erwartet:

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 -c

Erwartet:

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

Erwartet:

     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.yaml

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

Erwartet:

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

Erwartet:

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:80

Erwartet:

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 -c

Erwartet (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:80

Erwartet:

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 -2

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

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

Erwartet:

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

  1. Zeig, aus welchem entfernten Cluster echo-federated Mitglieder hat. Zeitziel: 30 s
  2. Zeig die Endpunkte von echo-federated. Zeitziel: 20 s
  3. Zeig, warum ein Client ohne Proxy echo-federated nicht nutzen kann. Zeitziel: 45 s
  4. Zeig die Proxy-Warnungen von last zu 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 reconnect

Erwartet (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:80

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

Erwartet: Zeilen für echo-ost und echo-west, keine für fehler.

linkerd --context ost multicluster check 2>&1 | tail -1

Erwartet:

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

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

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

Erwartet:

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 -federated als 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.