Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 16: Hochverfügbare Control-Plane

Ziel: Drei Control-Planes mit gestapeltem etcd hinter einer virtuellen IP – und ein Cluster, der den Ausfall eines Nodes übersteht. · Dauer: ca. 90 min · Voraussetzung: Tag 13

Briefing

CKA: „Implement and configure a highly-available control plane” (Teil der 25 %).

                  VIP 172.16.0.245:6443  (kube-vip, ARP)
                 /            |              \
        cp1 .126         worker1 .228       worker2 .83
     API + etcd          API + etcd         API + etcd     <- "stacked etcd"
  • Alle Clients sprechen die VIP an, nie eine einzelne Node-IP.
  • etcd braucht eine Mehrheit (Quorum): Bei drei Mitgliedern darf eines ausfallen.
  • kube-vip läuft als Static Pod auf jeder Control-Plane und hält die VIP auf genau einem Node.

Heute baust du den Cluster neu. Alle Workloads und Add-ons gehen dabei verloren – Drill 7 installiert die wichtigsten wieder.

Drill 1: Den alten Cluster abbauen

Auf worker1, worker2 und zuletzt cp1:

sudo kubeadm reset -f
sudo rm -rf /etc/cni/net.d /var/lib/calico ~/.kube
sudo iptables -F
sudo iptables -t nat -F
sudo iptables -t mangle -F
sudo iptables -X
sudo systemctl reboot

Der Neustart entfernt die Calico-Netzwerkschnittstellen. Danach auf jeder VM:

sudo ls /etc/kubernetes/manifests | wc -l
ip -o link | grep -c -E 'cali|vxlan'

Erwartet: zweimal 0. containerd, kubeadm und kubelet bleiben installiert.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Die VIP vorbereiten

Prüfe zuerst, dass die Adresse frei ist:

ping -c2 -W1 172.16.0.245

Erwartet: 100% packet loss.

Auf cp1 das kube-vip-Manifest erzeugen – das Image bringt dafür einen Generator mit:

KV=v1.3.1
sudo ctr image pull ghcr.io/kube-vip/kube-vip:$KV
sudo mkdir -p /etc/kubernetes/manifests
sudo ctr run --rm --net-host ghcr.io/kube-vip/kube-vip:$KV vip /kube-vip manifest pod \
  --interface eth0 --address 172.16.0.245 --controlplane --arp --leaderElection \
  | sudo tee /etc/kubernetes/manifests/kube-vip.yaml >/dev/null
sudo grep -n -E 'image:|value: 172|admin.conf' /etc/kubernetes/manifests/kube-vip.yaml

Erwartet:

42:      value: 172.16.0.245
45:    image: ghcr.io/kube-vip/kube-vip:v1.3.1
57:    - mountPath: /etc/kubernetes/admin.conf
66:      path: /etc/kubernetes/admin.conf

Eine Falle beim ersten Node: admin.conf bekommt erst nach dem Start des API-Servers Rechte – kube-vip soll die VIP aber schon vorher bereitstellen. Für kubeadm init deshalb vorübergehend super-admin.conf:

sudo sed -i 's#\(path: /etc/kubernetes/\)admin.conf#\1super-admin.conf#' \
  /etc/kubernetes/manifests/kube-vip.yaml

Fortschritt speichern? Kostenlos registrieren

Drill 3: Die erste Control-Plane

sudo kubeadm init --kubernetes-version=v1.37.2 \
  --control-plane-endpoint=172.16.0.245:6443 --upload-certs \
  --pod-network-cidr=192.168.0.0/16 --apiserver-advertise-address=172.16.0.126

Erwartet (gekürzt):

You can now join any number of control-plane nodes running the following command on each
as root:

  kubeadm join 172.16.0.245:6443 --token e8f79e.2x4p86m4py4k91ba \
    --discovery-token-ca-cert-hash sha256:a0f7dc6016fe9fffd2de088f9eb2162cb1f936bec... \
    --control-plane --certificate-key 64441cac60641c6bf7c5e4e3676a04cbb2417210bde38e2...

Please note that the certificate-key gives access to cluster sensitive data, keep it
secret!

--control-plane-endpoint trägt die VIP in alle Zertifikate und kubeconfigs ein. --upload-certs legt die CA-Schlüssel verschlüsselt im Cluster ab, damit weitere Control-Planes sie mit dem certificate-key abholen können – zwei Stunden lang.

kube-vip wieder auf admin.conf umstellen, kubectl einrichten, Calico installieren:

sudo sed -i 's#\(path: /etc/kubernetes/\)super-admin.conf#\1admin.conf#' \
  /etc/kubernetes/manifests/kube-vip.yaml
mkdir -p ~/.kube
sudo cp /etc/kubernetes/admin.conf ~/.kube/config
sudo chown $(id -u):$(id -g) ~/.kube/config
k config view --minify -o jsonpath='{.clusters[0].cluster.server}{"\n"}'

Erwartet: https://172.16.0.245:6443

Der Wechsel startet kube-vip neu; für ein paar Sekunden meldet kubectl dann no route to host. Danach:

C=https://raw.githubusercontent.com/projectcalico/calico/v3.33.1/manifests
k create -f $C/operator-crds.yaml
k create -f $C/tigera-operator.yaml
k create -f $C/custom-resources.yaml
ip -o -4 addr show eth0

Erwartet (gekürzt):

2: eth0    inet 172.16.0.126/24 metric 100 brd 172.16.0.255 scope global dynamic eth0
...
2: eth0    inet 172.16.0.245/32 scope global deprecated eth0 ...

Die VIP liegt als zweite Adresse auf cp1.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Zwei weitere Control-Planes

Auf cp1 einen frischen Join-Befehl für Control-Planes bauen:

sudo kubeadm init phase upload-certs --upload-certs | tail -1
kubeadm token create --print-join-command

Die erste Ausgabe ist der certificate-key, die zweite der normale Join-Befehl. Auf worker1 zuerst kube-vip vorbereiten (wie in Drill 2, aber ohne super-admin), dann joinen:

KV=v1.3.1
sudo ctr image pull ghcr.io/kube-vip/kube-vip:$KV
sudo mkdir -p /etc/kubernetes/manifests
sudo ctr run --rm --net-host ghcr.io/kube-vip/kube-vip:$KV vip /kube-vip manifest pod \
  --interface eth0 --address 172.16.0.245 --controlplane --arp --leaderElection \
  | sudo tee /etc/kubernetes/manifests/kube-vip.yaml >/dev/null
sudo kubeadm join 172.16.0.245:6443 --token <TOKEN> \
  --discovery-token-ca-cert-hash sha256:<HASH> \
  --control-plane --certificate-key <KEY> --apiserver-advertise-address=172.16.0.228

Erwartet (gekürzt):

This node has joined the cluster and a new control plane instance was created:

Dasselbe auf worker2 mit --apiserver-advertise-address=172.16.0.83. Zurück auf cp1:

k wait --for=condition=Ready nodes --all --timeout=300s
k get nodes

Erwartet:

NAME      STATUS   ROLES           AGE     VERSION
cp1       Ready    control-plane   4m33s   v1.37.2
worker1   Ready    control-plane   110s    v1.37.2
worker2   Ready    control-plane   35s     v1.37.2

Fortschritt speichern? Kostenlos registrieren

Drill 5: etcd mit drei Mitgliedern

sudo etcdctl --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key member list -w table

Erwartet:

+------------------+---------+---------+---------------------------+--------------------
-------+
|        ID        | STATUS  |  NAME   |        PEER ADDRS         |       CLIENT ADDRS
|
+------------------+---------+---------+---------------------------+--------------------
-------+
| 1ff2278c0fd14cc3 | started |     cp1 | https://172.16.0.126:2380 |
https://172.16.0.126:2379 |
| 465cb3aab965445d | started | worker2 |  https://172.16.0.83:2380 | 
https://172.16.0.83:2379 |
| eda1c7a40b588aae | started | worker1 | https://172.16.0.228:2380 |
https://172.16.0.228:2379 |
+------------------+---------+---------+---------------------------+--------------------
-------+

(Spalte IS LEARNER gekürzt.) Damit auf allen drei Nodes auch Workloads laufen, die Control-Plane-Taints entfernen, und nachsehen, wer die VIP hält:

k taint nodes --all node-role.kubernetes.io/control-plane-
k get lease -n kube-system plndr-cp-lock -o jsonpath='{.spec.holderIdentity}{"\n"}'

Erwartet:

node/cp1 untainted
node/worker1 untainted
node/worker2 untainted
cp1

Fortschritt speichern? Kostenlos registrieren

Drill 6: Ausfall eines Nodes

kubectl auch auf worker1 einrichten – die kubeconfig zeigt dort ebenfalls auf die VIP:

mkdir -p ~/.kube
sudo cp /etc/kubernetes/admin.conf ~/.kube/config
sudo chown $(id -u):$(id -g) ~/.kube/config

Jetzt auf cp1 den Ausfall auslösen:

sudo systemctl reboot

Sofort danach auf worker1:

k get nodes
k get lease -n kube-system plndr-cp-lock -o jsonpath='{.spec.holderIdentity}{"\n"}'
k create deployment during-outage --image=nginx:1.29

Erwartet (gekürzt):

NAME      STATUS   ROLES           AGE     VERSION
cp1       Ready    control-plane   5m4s    v1.37.2
...
worker1
deployment.apps/during-outage created

Die VIP ist auf worker1 umgezogen, die API antwortet, Schreiben funktioniert – etcd hat mit zwei von drei Mitgliedern noch die Mehrheit. cp1 steht noch auf Ready, weil der Node-Controller etwa 40 Sekunden wartet. Nach dem Neustart kommt cp1 von selbst zurück:

k wait --for=condition=Ready node/cp1 --timeout=180s
k delete deployment during-outage

Und wenn zwei von drei ausfallen? Auf worker1 und worker2 etcd anhalten:

sudo mv /etc/kubernetes/manifests/etcd.yaml /root/

Auf cp1, nach etwa 30 Sekunden:

k get nodes --request-timeout=10s

Erwartet:

Unable to connect to the server: dial tcp 172.16.0.245:6443: connect: no route to host

Ohne Quorum kann kube-vip seinen Lease nicht erneuern und gibt die VIP auf; etcd selbst meldet Error: unhealthy cluster. Auf worker1 und worker2 zurück:

sudo mv /root/etcd.yaml /etc/kubernetes/manifests/

Nach etwa einer Minute antwortet der Cluster wieder.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Die Add-ons zurückholen

Der Neubau hat alles aus den Tagen 6–12 entfernt. Die Befehle kennst du – hier gebündelt. metrics-server (Tag 6):

M=https://github.com/kubernetes-sigs/metrics-server/releases/download/v0.9.1
k apply -f $M/components.yaml
k patch deployment metrics-server -n kube-system --type=json \
  -p='[{"op":"add","path":"/spec/template/spec/containers/0/args/-",
  "value":"--kubelet-insecure-tls"}]'

MetalLB mit Pool (Tag 7):

ML=https://raw.githubusercontent.com/metallb/metallb/v0.16.2/config/manifests
k apply -f $ML/metallb-native.yaml
k wait -n metallb-system --for=condition=Ready pod --all --timeout=180s
cat <<'EOF' | k apply -f -
apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: lab
  namespace: metallb-system
spec:
  addresses:
  - 172.16.0.242-172.16.0.244
---
apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: lab
  namespace: metallb-system
spec:
  ipAddressPools:
  - lab
EOF

NFS-CSI und Standard-StorageClass (Tag 10; der NFS-Server auf cp1 läuft noch):

helm install csi-driver-nfs csi-driver-nfs/csi-driver-nfs -n kube-system \
  --version 4.13.6
cat <<'EOF' | k apply -f -
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs
  annotations:
    storageclass.kubernetes.io/is-default-class: "true"
provisioner: nfs.csi.k8s.io
parameters:
  server: 172.16.0.126
  share: /srv/nfs/k8s
reclaimPolicy: Delete
volumeBindingMode: Immediate
allowVolumeExpansion: true
mountOptions:
- nfsvers=4.1
EOF

Gateway-API-CRDs und Traefik (Tag 8):

G=https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.7.0
k apply --server-side -f $G/standard-install.yaml
helm install traefik traefik/traefik --version 42.4.1 -n traefik --create-namespace \
  --set providers.kubernetesGateway.enabled=true --set gateway.enabled=false
k rollout status deployment traefik -n traefik
k get svc traefik -n traefik
k get sc

Erwartet (gekürzt):

deployment "traefik" successfully rolled out
NAME      TYPE           CLUSTER-IP      EXTERNAL-IP    PORT(S)
traefik   LoadBalancer   10.106.40.170   172.16.0.242   80:32671/TCP,443:30441/TCP
NAME            PROVISIONER      RECLAIMPOLICY   VOLUMEBINDINGMODE  
ALLOWVOLUMEEXPANSION
nfs (default)   nfs.csi.k8s.io   Delete          Immediate           true

cert-manager aus Tag 12 brauchst du nicht mehr.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Welcher Node ist etcd-Leader? Zeitziel: 45 s
  2. Wie viele etcd-Mitglieder dürfen bei fünf Control-Planes ausfallen? Zeitziel: 10 s
  3. Zeige die Adresse, unter der kubectl den Cluster anspricht. Zeitziel: 15 s

Lösung

E=https://172.16.0.126:2379,https://172.16.0.228:2379,https://172.16.0.83:2379
sudo etcdctl --endpoints=$E \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key endpoint status \
  | awk -F', ' '{print $1, $9}'
k config view --minify -o jsonpath='{.clusters[0].cluster.server}{"\n"}'

Erwartet:

https://172.16.0.126:2379 false
https://172.16.0.228:2379 false
https://172.16.0.83:2379 true
https://172.16.0.245:6443

Die neunte Spalte von endpoint status ist IS LEADER. Der Leader kann wechseln – nach dem Quorum-Test aus Drill 6 war es hier worker2.

Zu 2: zwei. Quorum ist (n / 2) + 1, abgerundet – bei fünf also drei.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

k get nodes -l node-role.kubernetes.io/control-plane --no-headers | wc -l

Erwartet: 3

k get pods -n kube-system -l component=etcd --no-headers | grep -c Running

Erwartet: 3

k get pods -n kube-system | grep -c kube-vip

Erwartet: 3 – kube-vip-Pods tragen keine Labels, deshalb hier per Name.

Challenge

Ein neuer Kollege soll eine vierte Control-Plane hinzufügen. Der certificate-key aus Drill 4 ist abgelaufen. Erzeuge einen vollständigen, frischen Join-Befehl für eine Control-Plane – ohne ihn auszuführen.

Hinweis: Zwei Befehle; der zweite kennt die Option --certificate-key.

Lösung

KEY=$(sudo kubeadm init phase upload-certs --upload-certs | tail -1)
kubeadm token create --print-join-command --certificate-key $KEY

Erwartet (gekürzt):

kubeadm join 172.16.0.245:6443 --token ... --discovery-token-ca-cert-hash sha256:...
--control-plane --certificate-key ...

Fortschritt speichern? Kostenlos registrieren

Prüfungstipp

  • In der Prüfung heißt die HA-Aufgabe oft „join this node as an additional control plane”. Entscheidend: --control-plane und --certificate-key.
  • kubeadm init phase upload-certs --upload-certs erzeugt einen neuen Schlüssel, wenn der alte (zwei Stunden) abgelaufen ist.
  • Quorum: bei 3 Mitgliedern 1 Ausfall, bei 5 Mitgliedern 2. Gerade Zahlen bringen nichts.

Enterprise-Notiz

  • Statt kube-vip oft ein externer Load Balancer (HAProxy + keepalived, F5, Cloud-LB) vor den API-Servern.
  • Control-Planes auf getrennte Hosts, Racks oder Zonen verteilen – drei VMs auf demselben Hypervisor sind keine Hochverfügbarkeit.
  • Großcluster trennen etcd von den API-Servern („external etcd”).