Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 12: Multicluster – zwei Cluster verbinden

Ziel: Ein zweiter Cluster west läuft mit demselben Trust Anchor, ein Dienst aus west erscheint in ost als normaler Service und der Verkehr geht per mTLS über die Clustergrenze. · Dauer: ca. 90 min · Voraussetzung: Tag 5

Briefing

  • Die Multicluster-Extension spiegelt Services: Ein Controller in ost liest die API von west und legt für jeden exportierten Service <name>-west an.
  • Im Gateway-Modus zeigt der Spiegel auf ein Gateway in west. Nur dessen Adresse muss von ost erreichbar sein, Pod-Netze nicht.
  • Ein Link ist gerichtet: ost liest west. Für die Gegenrichtung brauchst du einen zweiten Link.
  • Ohne gemeinsamen Trust Anchor keine Identität über Clustergrenzen. Deshalb kam er an Tag 5 aus einer eigenen CA.
 ost                                      west
 last ─> helper-west (Spiegel) ──mTLS──> linkerd-gateway ─> helper
          controller-west ───── liest API (6443) ─────┘

Drill 1: Den zweiten Cluster bauen

west ist eine eigene VM (im Test 172.16.0.182, 4 vCPU, 7 GB, Ubuntu 24.04). Ein k3s-Single-Node reicht. Prüf vorher, welche Ports belegt sind – im Test lief dort noch eine Datenbank auf 5432:

mkdir -p ~/linkerd/tag12 && cd ~/linkerd/tag12
WEST=172.16.0.182
ssh ubuntu@$WEST sudo ss -ltn

k3s braucht 6443 (API), 10250 (kubelet) und 8472/udp (Flannel). Das Gateway belegt später 4143 und 4191. Dann installieren, Version gepinnt:

ssh ubuntu@$WEST 'curl -sfL https://get.k3s.io | INSTALL_K3S_VERSION=v1.37.2+k3s1 \
  sh -s - server --node-name west --disable traefik \
  --cluster-cidr 10.42.0.0/16 --service-cidr 10.43.0.0/16'
ssh ubuntu@$WEST sudo k3s kubectl get nodes

Erwartet (gekürzt):

[INFO]  systemd: Enabling k3s unit
[INFO]  systemd: Starting k3s
NAME   STATUS   ROLES           AGE   VERSION
west   Ready    control-plane   30s   v1.37.2+k3s1

Das Skript erkennt die Architektur selbst. Traefik brauchst du nicht. Den eingebauten ServiceLB von k3s behältst du: Er gibt dem Gateway später eine LoadBalancer-Adresse, nämlich die IP der VM.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Netze ohne Überschneidung

Gespiegelte Services bekommen in ost eine eigene ClusterIP, das ist unkritisch. Ab Tag 13 sprechen Pods aber direkt mit Pods im anderen Cluster. Dann dürfen sich die Netze nicht überschneiden:

kubectl -n kube-system get configmap cilium-config \
  -o jsonpath='{.data.cluster-pool-ipv4-cidr}{"\n"}'
kubectl cluster-info dump | grep -m1 -o 'service-cluster-ip-range=[0-9./]*'

Erwartet:

10.0.0.0/16
service-cluster-ip-range=10.96.0.0/12
Cluster Pod-Netz Service-Netz
ost 10.0.0.0/16 (Cilium) 10.96.0.0/12
west 10.42.0.0/16 (Flannel) 10.43.0.0/16

Die k3s-Vorgaben passen hier. Im Installationsbefehl stehen sie trotzdem, damit sie dokumentiert sind. Später ändern geht nur mit Neuinstallation.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Zwei Kontexte

Die kubeconfig von k3s zeigt auf 127.0.0.1 und heißt überall default. Beides passt du an und führst sie mit deiner bestehenden zusammen:

ssh ubuntu@$WEST sudo cat /etc/rancher/k3s/k3s.yaml \
  | sed -e "s/127.0.0.1/$WEST/" -e 's/default/west/g' > west.kubeconfig
cp ~/.kube/config ~/.kube/config.vor-tag12.bak
KUBECONFIG=~/.kube/config:west.kubeconfig kubectl config view --flatten > config.neu
chmod 600 config.neu && mv config.neu ~/.kube/config
kubectl config get-contexts
kubectl --context west get nodes

Erwartet:

CURRENT   NAME   CLUSTER   AUTHINFO    NAMESPACE
*         ost    ost       ost-admin   default
          west   west      west
NAME   STATUS   ROLES           AGE   VERSION
west   Ready    control-plane   65s   v1.37.2+k3s1

Ab jetzt nennst du den Cluster immer mit: kubectl --context west, linkerd --context ost. Der aktuelle Kontext bleibt ost – Befehle ohne --context landen also wie bisher dort.

Tipp: Heißt dein Kontext für den ersten Cluster noch kubernetes-admin@kubernetes, benennst du ihn mit kubectl config rename-context in ost um.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Linkerd auf west mit gemeinsamem Anchor

Jeder Cluster bekommt einen eigenen Issuer, beide unterschrieben vom Trust Anchor aus Tag 5:

step certificate create identity.linkerd.cluster.local \
  west-issuer.crt west-issuer.key \
  --profile intermediate-ca --not-after 8760h --no-password --insecure \
  --ca ../tag05/ca.crt --ca-key ../tag05/ca.key
chmod 600 west-issuer.key
step certificate verify west-issuer.crt --roots ../tag05/ca.crt && echo verify-ok

Erwartet (gekürzt):

Your certificate has been saved in west-issuer.crt.
Your private key has been saved in west-issuer.key.
verify-ok
linkerd --context west check --pre 2>&1 | tail -1
linkerd --context west install --crds | kubectl --context west apply -f -
linkerd --context west install \
  --identity-trust-anchors-file ../tag05/ca.crt \
  --identity-issuer-certificate-file west-issuer.crt \
  --identity-issuer-key-file west-issuer.key > west-cp.yaml
kubectl --context west apply -f west-cp.yaml
kubectl --context west -n linkerd rollout status deploy --timeout=300s
linkerd --context west check 2>&1 | tail -1

Erwartet (gekürzt):

Status check results are √
...
deployment "linkerd-destination" successfully rolled out
deployment "linkerd-identity" successfully rolled out
deployment "linkerd-proxy-injector" successfully rolled out
Status check results are √

check --pre ist auf k3s sofort grün: k3s bringt die Gateway-API-CRDs (v1.6.3) selbst mit. Jetzt der wichtigste Vergleich des Tages:

for c in ost west; do
  echo -n "$c "
  kubectl --context $c -n linkerd get configmap linkerd-identity-trust-roots \
    -o jsonpath='{.data.ca-bundle\.crt}' | step certificate fingerprint -
done

Erwartet:

ost 8b44a80f0940a58823716aecd2aeac2895e43d94bd968826ec821389f65bab81
west 8b44a80f0940a58823716aecd2aeac2895e43d94bd968826ec821389f65bab81

Gleicher Fingerabdruck: Ein Proxy in ost vertraut einem Zertifikat aus west.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Die Extension auf beiden Seiten

west exportiert und braucht das Gateway:

linkerd --context west multicluster install > mc-west.yaml
kubectl --context west apply -f mc-west.yaml
kubectl --context west -n linkerd-multicluster rollout status deploy/linkerd-gateway
kubectl --context west -n linkerd-multicluster get svc linkerd-gateway

Erwartet:

deployment "linkerd-gateway" successfully rolled out
NAME              TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)    ...
linkerd-gateway   LoadBalancer   10.43.109.228   172.16.0.182   4143:30946/TCP,...

ServiceLB hat die IP der VM eingetragen (in den ersten Sekunden steht dort noch <pending>). ost liest nur und braucht heute kein Gateway, aber einen Controller für den Link west. Seit Linkerd 2.18 legst du ihn über die Werte der Extension an:

cat > mc-ost-values.yaml <<'EOF'
gateway:
  enabled: false
controllers:
- link:
    ref:
      name: west
EOF
linkerd --context ost multicluster install -f mc-ost-values.yaml > mc-ost.yaml
kubectl --context ost apply -f mc-ost.yaml
kubectl --context ost -n linkerd-multicluster get pods

Erwartet:

NAME                                            READY   STATUS     RESTARTS   AGE
controller-west-9b9b5d7df-2qkqp                 0/2     Init:1/2   0          5s
linkerd-local-service-mirror-759d5b44f8-88bjz   0/2     Init:1/2   0          5s

controller-west wartet auf seine Zugangsdaten. Die kommen mit dem Link.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Den Link erzeugen

link-gen läuft gegen den Cluster, der gelesen wird, und erzeugt Zugangsdaten plus die Link-Ressource. Angewendet wird sie im lesenden Cluster:

linkerd --context west multicluster link-gen --cluster-name west > link-west.yaml
grep -E '^kind:|gatewayAddress|gatewayPort|server:' link-west.yaml
kubectl --context ost apply -f link-west.yaml
kubectl --context ost -n linkerd-multicluster rollout status deploy/controller-west

Erwartet (gekürzt):

kind: Secret
kind: Secret
kind: Link
  gatewayAddress: 172.16.0.182
  gatewayPort: "4143"
secret/cluster-credentials-west created
secret/cluster-credentials-west created
link.multicluster.linkerd.io/west created
deployment "controller-west" successfully rolled out

linkerd multicluster link gibt es noch, ist aber als veraltet markiert. Die Secrets enthalten eine kubeconfig für west mit der API-Adresse aus deinem Kontext – die muss also auch von Pods in ost erreichbar sein. Sonst hilft --api-server-address.

linkerd --context ost multicluster check 2>/dev/null | tail -12
linkerd --context ost multicluster gateways

Erwartet (gekürzt):

√ clusters share trust anchors
    * west
...
√ probe services able to communicate with all gateway mirrors
    * west
...
Status check results are √
CLUSTER  ALIVE    NUM_SVC      LATENCY
west     True           0         39ms

clusters share trust anchors prüft genau das, was du in Drill 4 von Hand verglichen hast. NUM_SVC steht auf 0, bis du etwas exportierst. Die Warnung v1 Endpoints is deprecated während des Checks kommt von Kubernetes 1.37 und ist harmlos.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Einen Dienst exportieren

In west läuft eine Kopie von helper im Namespace tag12. USE_REAL_HOSTNAME lässt go-httpbin unter /hostname den Pod-Namen melden:

cat > helper.yaml <<'EOF'
apiVersion: v1
kind: Namespace
metadata:
  name: tag12
  annotations: {linkerd.io/inject: enabled}
---
apiVersion: v1
kind: ServiceAccount
metadata: {name: helper, namespace: tag12}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: helper, namespace: tag12}
spec:
  replicas: 2
  selector: {matchLabels: {app: helper}}
  template:
    metadata: {labels: {app: helper}}
    spec:
      serviceAccountName: helper
      containers:
      - name: helper
        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: helper, namespace: tag12}
spec:
  selector: {app: helper}
  ports: [{port: 80, targetPort: http, name: http}]
EOF
kubectl --context west apply -f helper.yaml
kubectl --context west -n tag12 rollout status deploy/helper

Achtung: Der Spiegel landet im gleichnamigen Namespace in ost, und den legt der Controller nicht an. Im Test lief der Export zuerst ins Leere: drei Fehlversuche im Log von controller-west, erst nach dem Anlegen des Namespace kam der Spiegel.

Also zuerst der Namespace in ost, dann das Label in west:

kubectl --context ost create namespace tag12
kubectl --context ost annotate namespace tag12 linkerd.io/inject=enabled
kubectl --context west -n tag12 label service helper mirror.linkerd.io/exported=true
kubectl --context ost -n tag12 get svc,endpoints

Erwartet (gekürzt):

NAME                  TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
service/helper-west   ClusterIP   10.110.88.111   <none>        80/TCP    21s
NAME                    ENDPOINTS           AGE
endpoints/helper-west   172.16.0.182:4143   26s

Der Spiegel hat keinen Selector. Sein einziger Endpunkt ist das Gateway. Jetzt ein Lastgenerator in ost, nach dem Muster von Tag 0:

cat > last.yaml <<'EOF'
apiVersion: v1
kind: ServiceAccount
metadata: {name: last, namespace: tag12}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: last, namespace: tag12}
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
        command: [sh, -c]
        args:
        - |
          while true; do
            for p in /get /unstable?failure_rate=0.3; do
              code=$(curl -s -o /dev/null -w "%{http_code}" -m 5 http://helper-west$p)
              echo "$(date +%T) ${p%%\?*} $code"
            done
            sleep 1
          done
EOF
kubectl --context ost apply -f last.yaml
kubectl --context ost -n tag12 rollout status deploy/last
kubectl --context ost -n tag12 exec deploy/last -c last -- \
  curl -s http://helper-west/hostname

Erwartet:

{
  "hostname": "helper-8687c947f6-wlj9h"
}

Ein Pod-Name aus west, aufgerufen über einen ganz normalen Service-Namen in ost.

Fortschritt speichern? Kostenlos registrieren

Drill 8: mTLS über die Grenze

Erst die Zahlen aus Sicht von ost:

sleep 60
kubectl --context ost -n tag12 logs deploy/last -c last --since=55s \
  | awk '{print $2, $3}' | sort | uniq -c
linkerd --context ost viz stat -n tag12 deploy/last --to svc/helper-west

Erwartet (Zahlen schwanken):

     46 /get 200
     33 /unstable 200
     14 /unstable 500
NAME   MESHED   SUCCESS      RPS   LATENCY_P50   LATENCY_P95   LATENCY_P99   TCP_CONN
last      1/1    83.17%   1.7rps           7ms          17ms          19ms          1

Gleiche Fehlerquote wie in notes, eine Latenz von wenigen Millisekunden für den Weg über das Gateway. Wer kommt in west an? Das Gateway zählt seine Clients:

linkerd --context west diagnostics proxy-metrics -n linkerd-multicluster \
  deploy/linkerd-gateway \
  | grep '^tcp_open_total{direction="inbound",peer="src"' \
  | grep -oE '(target_port|client_id|no_tls_reason)="[^"]*"|[0-9]+$' | paste - - -

Erwartet:

target_port="4143"  client_id="last.tag12.serviceaccount.identity.linkerd.cluster.l…"  1
target_port="4191"  client_id="controller-west.linkerd-multicluster.serviceaccou…"  1
target_port="4191"  no_tls_reason="no_tls_from_remote"  45

Port 4143 ist der Tunnel: last aus ost mit seiner vollen Identität. 4191 ist die Probe – einmal vom Controller in ost per mTLS, dazu die Klartext-Probes des kubelet. Und ein Client ohne Proxy?

kubectl --context ost -n tag12 run ohne --image=docker.io/curlimages/curl:8.23.0 \
  --restart=Never --annotations=linkerd.io/inject=disabled --command -- sleep 3600
kubectl --context ost -n tag12 wait --for=condition=Ready pod/ohne
kubectl --context ost -n tag12 exec ohne -- curl -sv -m 5 http://helper-west/get \
  2>&1 | tail -2

Erwartet:

* Empty reply from server
command terminated with exit code 52

Das Gateway nimmt nur mTLS aus dem Mesh an. Ein offener Port ins Nachbarnetz ist es nicht.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig alle gespiegelten Services in ost. Zeitziel: 20 s
  2. Zeig die Gateway-Adresse aus dem Link. Zeitziel: 30 s
  3. Beende den Export von helper und exportiere ihn danach wieder. Zeitziel: 45 s
  4. Zeig, mit welcher Identität helper in west angesprochen wird. Zeitziel: 60 s

Lösung

kubectl --context ost get svc -A -l mirror.linkerd.io/mirrored-service=true
kubectl --context ost -n linkerd-multicluster get link west \
  -o jsonpath='{.spec.gatewayAddress}:{.spec.gatewayPort}{"\n"}'
kubectl --context west -n tag12 label service helper mirror.linkerd.io/exported-
kubectl --context ost -n tag12 get svc
kubectl --context west -n tag12 label service helper mirror.linkerd.io/exported=true
kubectl --context ost -n tag12 get svc
linkerd --context west diagnostics proxy-metrics -n tag12 deploy/helper \
  | grep '^tcp_open_total{direction="inbound",peer="src"' \
  | grep -oE '(target_port|client_id)="[^"]*"|[0-9]+$' | paste - - -

Erwartet (gekürzt):

NAMESPACE   NAME          TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
tag12       helper-west   ClusterIP   10.110.88.111   <none>        80/TCP    7m36s
172.16.0.182:4143
...
helper-west   ClusterIP   10.108.196.97    <none>        80/TCP    5s
...
target_port="8080"  client_id="linkerd-gateway.linkerd-multicluster.serviceaccount…"

Zwei Dinge fallen auf: Nach dem neuen Export hat helper-west eine neue ClusterIP, und last hatte in der Zwischenzeit einige Fehler mit Code 000. Und helper sieht nur das Gateway, nicht last – Policies in west müssen deshalb das Gateway erlauben.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

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

Erwartet:

Status check results are √
linkerd --context ost multicluster gateways

Erwartet:

CLUSTER  ALIVE    NUM_SVC      LATENCY
west     True           1         18ms
kubectl --context ost -n tag12 exec deploy/last -c last -- \
  curl -s -o /dev/null -w '%{http_code}\n' http://helper-west/get

Erwartet: 200

kubectl --context ost -n notes get pods

Erwartet: alle Pods 2/2 Running – die App in ost hat von alldem nichts gemerkt.

Challenge

Dreh die Richtung um: west soll einen helper aus ost als helper-ost sehen. Auf ost gibt es keine LoadBalancer-Adressen, das Gateway muss also als NodePort laufen.

Hinweis: link-gen braucht dann Adressen und Port von Hand – und der Controller in west muss den Probe-Port kennen, bevor du den Link anwendest.

Lösung

kubectl --context ost get ciliumloadbalancerippools
cat > mc-ost-gw.yaml <<'EOF'
gateway:
  enabled: true
  serviceType: NodePort
controllers:
- link:
    ref:
      name: west
EOF
linkerd --context ost multicluster install -f mc-ost-gw.yaml \
  | kubectl --context ost apply -f -
kubectl --context ost -n linkerd-multicluster rollout status deploy/linkerd-gateway
GW=$(kubectl --context ost -n linkerd-multicluster get svc linkerd-gateway \
  -o jsonpath='{.spec.ports[?(@.name=="mc-gateway")].nodePort}')
PROBE=$(kubectl --context ost -n linkerd-multicluster get svc linkerd-gateway \
  -o jsonpath='{.spec.ports[?(@.name=="mc-probe")].nodePort}')
echo $GW $PROBE

Erwartet:

No resources found
deployment "linkerd-gateway" successfully rolled out
30839 30980

Keine IP-Pools, also NodePort. Ohne --gateway-addresses bricht link-gen mit gateway linkerd-gateway.linkerd-multicluster has no ingress addresses ab.

cat > mc-west-values.yaml <<EOF
controllers:
- link:
    ref:
      name: ost
  gateway:
    probe:
      port: $PROBE
EOF
linkerd --context west multicluster install -f mc-west-values.yaml \
  | kubectl --context west apply -f -
linkerd --context ost multicluster link-gen --cluster-name ost \
  --gateway-addresses 172.16.0.126,172.16.0.228,172.16.0.83 --gateway-port $GW \
  | kubectl --context west apply -f -
kubectl --context ost apply -f helper.yaml
kubectl --context ost -n tag12 rollout status deploy/helper
kubectl --context ost -n tag12 label service helper mirror.linkerd.io/exported=true
kubectl --context west -n linkerd-multicluster rollout status deploy/controller-ost
linkerd --context west multicluster gateways
kubectl --context west -n tag12 run c --image=docker.io/curlimages/curl:8.23.0 \
  --command -- sleep 3600
kubectl --context west -n tag12 wait --for=condition=Ready pod/c
kubectl --context west -n tag12 exec c -c c -- curl -s http://helper-ost/hostname

Erwartet (gekürzt, helper-ost kommt nach etwa 40 s):

CLUSTER  ALIVE    NUM_SVC      LATENCY
ost      True           1         26ms
{
  "hostname": "helper-8687c947f6-8l2p4"
}

Der Fallstrick liegt beim Probe-Port: link-gen trägt den NodePort der Probe (30980) richtig in den Link ein. Der Probe-Service in west nimmt seinen Port aber aus den Werten der Extension, Vorgabe 4191. Passen beide nicht zusammen, bleibt ALIVE auf False und das Log von controller-ost zeigt connection reset by peer. Korrigierst du den Port erst nachträglich, musst du controller-ost zusätzlich neu starten.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

Der Link ost → west bleibt für Tag 13. Die Gegenrichtung aus der Challenge und die Namespaces kommen weg:

kubectl --context west -n linkerd-multicluster delete link ost
linkerd --context west multicluster install -f mc-west-values.yaml \
  | kubectl --context west delete -l mirror.linkerd.io/cluster-name=ost -f -
kubectl --context west -n linkerd-multicluster delete secret cluster-credentials-ost
kubectl --context west -n linkerd delete secret cluster-credentials-ost
kubectl --context west delete namespace tag12
kubectl --context ost delete namespace tag12
linkerd --context ost multicluster check 2>&1 | tail -1

Das Gateway in ost (NodePort) darf bleiben.

Interview-Notiz

  • Was braucht Linkerd-Multicluster? Einen gemeinsamen Trust Anchor, Zugriff des lesenden Clusters auf die API des anderen und im Gateway-Modus eine erreichbare Gateway-Adresse – keine gerouteten Pod-Netze.
  • In welche Richtung wirkt ein Link? Der Cluster, in dem der Link liegt, liest den anderen und spiegelt dessen Services. Gegenrichtung = zweiter Link.
  • Wie sicher ist das Gateway? Es nimmt nur mTLS von Proxys mit gültiger Identität aus demselben Trust Anchor an. Die Identität enthält aber keinen Clusternamen: last.tag12 aus ost sieht genauso aus wie ein last.tag12 in west.

Enterprise-Notiz

  • Trust Anchor zentral (eigene PKI, Vault) und pro Cluster ein eigener Issuer, wie hier. Nachträglich auf einen gemeinsamen Anchor umzustellen heißt Rotation aller Cluster.
  • Der Link enthält eine kubeconfig mit Leserechten auf Services – wie ein Geheimnis behandeln, pro Gegenstelle eigene Zugangsdaten (linkerd multicluster allow).
  • Gateways hinter einen echten LoadBalancer mit fester Adresse; NodePorts auf allen Nodes sind fürs Labor gut, im Betrieb ein bewegliches Ziel.
  • Pod- und Service-Netze clusterübergreifend planen, auch wenn heute nur der Gateway-Modus läuft. Flache Netze (Tag 13) lassen sich sonst nicht nachrüsten.
  • Namespaces im lesenden Cluster vorab anlegen, am besten per GitOps zusammen mit dem Export.