Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 8: RKE2 HA mit Ansible

Ziel: Drei RKE2-Server und drei Agents bilden einen HA-Cluster hinter der API-VIP 10.10.20.10, mit Cilium als CNI, und du upgradest ihn per system-upgrade-controller. · Dauer: ca. 120 min · Voraussetzung: Tag 7

Briefing

  • RKE2 v1.36.4+rke2r1 wird installiert, in Drill 7 geht es per Plan auf v1.36.5+rke2r1 (Stable-Channel, Oktober 2026).
  • Rolle rke2_server: Installation, config.yaml, Cilium-HelmChartConfig und kube-vip als Manifest. Rolle rke2_agent nutzt dieselben Install-Tasks.
  • Join-Reihenfolge: rke2-cp-1 initialisiert etcd, cp-2/cp-3 joinen einzeln über die VIP (Port 9345), dann die Agents.
  • kube-vip (DaemonSet, ARP, Leader Election) hält die VIP auf genau einem Server. Cilium ersetzt kube-proxy und kann damit an Tag 9 L2-Announcements.
  • Seit v1.36 ist Traefik der RKE2-Default-Ingress. ingress-nginx ist upstream seit März 2026 eingestellt und ab v1.37 für neue Cluster nicht mehr verfügbar. Deshalb ingress-controller: traefik.
             VIP 10.10.20.10 (kube-vip, ARP)  rke2.lab.internal
          :6443 API  /  :9345 Supervisor (join)
     ┌──────────────┬──────────────┬──────────────┐
  rke2-cp-1 .11  rke2-cp-2 .12  rke2-cp-3 .13      etcd + CP
     └──────┬───────┴──────┬───────┴──────┬───────┘
         rke2-wk-1 .21  rke2-wk-2 .22  rke2-gpu-1 .31   Agents

Drill 1: Projekt, Inventory, Variablen

Das Inventory kommt aus Tag 7. Dazu Konfiguration und gemeinsame Variablen:

cd ~/ki-lab/code/infra-rke2
mkdir -p group_vars upgrade roles/rke2_server/{defaults,tasks,templates,handlers} \
  roles/rke2_agent/{tasks,templates,handlers}
cat > ansible.cfg <<'EOF'
[defaults]
inventory = inventory.yaml
roles_path = roles
host_key_checking = False
interpreter_python = auto_silent
forks = 10

[ssh_connection]
pipelining = True
EOF
cat > group_vars/all.yml <<'EOF'
---
rke2_version: v1.36.4+rke2r1   # Tag 8 Drill 7: Upgrade auf v1.36.5
# Lab-Wert! In echt: export RKE2_TOKEN=$(openssl rand -hex 32)
rke2_token: >-
  {{ lookup('ansible.builtin.env', 'RKE2_TOKEN')
     | default('rke2-lab-token-1234', true) }}
rke2_vip: 10.10.20.10
rke2_vip_hostname: rke2.lab.internal
rke2_vip_interface: eth0
rke2_first_server: "{{ groups['rke2_servers'][0] }}"
# Server nur für Control-Plane-Pods (CriticalAddonsOnly)
rke2_server_taint: true
kube_vip_version: v1.2.4
kubeconfig_local: "~/ki-lab/rke2.yaml"
kubeconfig_context: rke2-lab
EOF
export RKE2_TOKEN=$(openssl rand -hex 32)
echo "export RKE2_TOKEN=$RKE2_TOKEN" > ~/ki-lab/rke2-token.env
chmod 600 ~/ki-lab/rke2-token.env
ansible-inventory --graph

Erwartet:

@all:
  |--@ungrouped:
  |--@gpu_nodes:
  |  |--rke2-gpu-1
  |--@rke2_agents:
  |  |--rke2-gpu-1
  |  |--rke2-wk-1
  |  |--rke2-wk-2
  |--@rke2_servers:
  |  |--rke2-cp-1
  |  |--rke2-cp-2
  |  |--rke2-cp-3

Warum ein Token aus der Umgebung? Der Cluster-Token ist das Join-Geheimnis und schützt zusätzlich die etcd-Bootstrap-Daten. rke2-lab-token-1234 ist nur der Lab-Fallback, falls RKE2_TOKEN fehlt.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Rolle rke2_server – Installation

cat > roles/rke2_server/defaults/main.yml <<'EOF'
---
rke2_server_install_type: server
rke2_server_manifest_dir: /var/lib/rancher/rke2/server/manifests
rke2_server_kubectl: >-
  /var/lib/rancher/rke2/bin/kubectl --kubeconfig /etc/rancher/rke2/rke2.yaml
rke2_server_cilium_qps: 30
rke2_server_cilium_burst: 50
EOF
cat > roles/rke2_server/tasks/install.yml <<'EOF'
---
- name: Installationsskript laden
  ansible.builtin.get_url:
    url: https://get.rke2.io
    dest: /root/rke2-install.sh
    mode: "0700"

- name: RKE2 installieren ({{ rke2_server_install_type }})
  ansible.builtin.command: /root/rke2-install.sh
  environment:
    INSTALL_RKE2_VERSION: "{{ rke2_version }}"
    INSTALL_RKE2_TYPE: "{{ rke2_server_install_type }}"
  args:
    creates: /usr/local/bin/rke2

- name: Konfigurationsverzeichnis anlegen
  ansible.builtin.file:
    path: /etc/rancher/rke2
    state: directory
    mode: "0755"
EOF

creates: macht die Installation idempotent. Upgrades laufen nicht über dieses Skript, sondern über den system-upgrade-controller (Drill 7).

Fortschritt speichern? Kostenlos registrieren

Drill 3: config.yaml und Cilium

cat > roles/rke2_server/templates/config.yaml.j2 <<'EOF'
# {{ ansible_managed }}
token: {{ rke2_token }}
{% if inventory_hostname != rke2_first_server %}
server: https://{{ rke2_vip }}:9345
{% endif %}
node-ip: {{ ansible_host }}
tls-san:
  - {{ rke2_vip }}
  - {{ rke2_vip_hostname }}
cni: cilium
disable-kube-proxy: true
ingress-controller: traefik
write-kubeconfig-mode: "0600"
etcd-snapshot-schedule-cron: "0 */6 * * *"
etcd-snapshot-retention: 12
{% if rke2_server_taint %}
node-taint:
  - "CriticalAddonsOnly=true:NoExecute"
{% endif %}
EOF
cat > roles/rke2_server/templates/rke2-cilium-config.yaml.j2 <<'EOF'
# {{ ansible_managed }}
apiVersion: helm.cattle.io/v1
kind: HelmChartConfig
metadata:
  name: rke2-cilium
  namespace: kube-system
spec:
  valuesContent: |-
    kubeProxyReplacement: true
    k8sServiceHost: "localhost"
    k8sServicePort: "6443"
    l2announcements:
      enabled: true
    externalIPs:
      enabled: true
    k8sClientRateLimit:
      qps: {{ rke2_server_cilium_qps }}
      burst: {{ rke2_server_cilium_burst }}
    devices: {{ rke2_vip_interface }}
    operator:
      replicas: 1
EOF

Warum so?

  • tls-san: Das API-Zertifikat muss VIP und Hostname enthalten, sonst scheitert kubectl über rke2.lab.internal.
  • Nur rke2-cp-1 hat kein server: – er initialisiert etcd. Alle anderen joinen über die VIP.
  • node-taint CriticalAddonsOnly: Workloads (vLLM, LiteLLM, Longhorn) bleiben auf den Agents, die 8-GB-Server tragen nur etcd und Control Plane.
  • Cilium: kubeProxyReplacement mit k8sServiceHost: localhost (RKE2-Doku). L2-Announcements brauchen den kube-proxy-Ersatz und ein höheres Client-Rate-Limit, weil jeder Node Leases erneuert. Den Pool selbst legst du an Tag 9 an.

Fortschritt speichern? Kostenlos registrieren

Drill 4: kube-vip für die API-VIP

kube-vip läuft als DaemonSet auf allen Servern (hostNetwork). Der Leader setzt per ARP 10.10.20.10 auf eth0. RKE2 wendet alles in server/manifests/ automatisch an – kein kubectl apply nötig, also klappt es schon beim ersten Server.

cat > roles/rke2_server/templates/kube-vip.yaml.j2 <<'EOF'
# {{ ansible_managed }}
apiVersion: v1
kind: ServiceAccount
metadata:
  name: kube-vip
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: system:kube-vip-role
rules:
  - apiGroups: [""]
    resources: ["services/status"]
    verbs: ["update"]
  - apiGroups: [""]
    resources: ["services", "endpoints"]
    verbs: ["list", "get", "watch", "update"]
  - apiGroups: [""]
    resources: ["nodes"]
    verbs: ["list", "get", "watch", "update", "patch"]
  - apiGroups: ["coordination.k8s.io"]
    resources: ["leases"]
    verbs: ["list", "get", "watch", "update", "create"]
  - apiGroups: ["discovery.k8s.io"]
    resources: ["endpointslices"]
    verbs: ["list", "get", "watch", "update"]
  - apiGroups: [""]
    resources: ["pods"]
    verbs: ["list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: system:kube-vip-binding
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:kube-vip-role
subjects:
  - kind: ServiceAccount
    name: kube-vip
    namespace: kube-system
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: kube-vip-ds
  namespace: kube-system
spec:
  selector:
    matchLabels:
      name: kube-vip-ds
  template:
    metadata:
      labels:
        name: kube-vip-ds
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
              - matchExpressions:
                  - key: node-role.kubernetes.io/control-plane
                    operator: Exists
      containers:
        - name: kube-vip
          image: ghcr.io/kube-vip/kube-vip:{{ kube_vip_version }}
          args: ["manager"]
          env:
            - {name: vip_arp, value: "true"}
            - {name: port, value: "6443"}
            - {name: vip_interface, value: "{{ rke2_vip_interface }}"}
            - {name: vip_subnet, value: "32"}
            - {name: cp_enable, value: "true"}
            - {name: cp_namespace, value: kube-system}
            - {name: svc_enable, value: "false"}
            - {name: vip_leaderelection, value: "true"}
            - {name: vip_leaseduration, value: "5"}
            - {name: vip_renewdeadline, value: "3"}
            - {name: vip_retryperiod, value: "1"}
            - {name: address, value: "{{ rke2_vip }}"}
          securityContext:
            capabilities:
              add: ["NET_ADMIN", "NET_RAW", "SYS_TIME"]
      hostNetwork: true
      serviceAccountName: kube-vip
      tolerations:
        - {effect: NoSchedule, operator: Exists}
        - {effect: NoExecute, operator: Exists}
EOF

RBAC und Umgebungsvariablen entsprechen dem von kube-vip manifest daemonset --controlplane --arp --leaderElection erzeugten Manifest (kube-vip-Doku). svc_enable: "false", weil Services an Tag 9 Cilium übernimmt – zwei ARP-Sprecher für dieselben IPs wären ein Fehler.

Tipp: Warum kein Static Pod? Der Static-Pod-Weg braucht eine Admin-Kubeconfig auf dem Host, die es auf joinenden RKE2-Servern vor dem Start noch nicht gibt. Das DaemonSet nutzt seinen ServiceAccount.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Tasks, Handler und die Agent-Rolle

cat > roles/rke2_server/tasks/main.yml <<'EOF'
---
- name: RKE2 installieren
  ansible.builtin.include_tasks: install.yml

- name: Manifest-Verzeichnis anlegen
  ansible.builtin.file:
    path: "{{ rke2_server_manifest_dir }}"
    state: directory
    mode: "0755"

- name: Cilium-HelmChartConfig und kube-vip ablegen
  ansible.builtin.template:
    src: "{{ item }}.j2"
    dest: "{{ rke2_server_manifest_dir }}/{{ item }}"
    mode: "0600"
  loop:
    - rke2-cilium-config.yaml
    - kube-vip.yaml

- name: Server-config.yaml schreiben
  ansible.builtin.template:
    src: config.yaml.j2
    dest: "/etc/rancher/rke2/config.yaml"
    mode: "0600"
  notify: Restart rke2-server

- name: Rke2-server starten
  ansible.builtin.systemd_service:
    name: rke2-server
    enabled: true
    state: started

- name: Warten bis der Node Ready ist
  ansible.builtin.command: >-
    {{ rke2_server_kubectl }} wait --for=condition=Ready
    node/{{ inventory_hostname }} --timeout=30s
  register: rke2_server_node_ready
  until: rke2_server_node_ready.rc == 0
  retries: 40
  delay: 15
  changed_when: false

- name: API-Server über die VIP erreichbar
  ansible.builtin.wait_for:
    host: "{{ rke2_vip }}"
    port: 6443
    timeout: 300
EOF
cat > roles/rke2_server/handlers/main.yml <<'EOF'
---
- name: Restart rke2-server
  ansible.builtin.systemd_service:
    name: rke2-server
    state: restarted
EOF
cat > roles/rke2_agent/tasks/main.yml <<'EOF'
---
- name: RKE2 installieren (Tasks aus rke2_server)
  ansible.builtin.include_role:
    name: rke2_server
    tasks_from: install.yml
  vars:
    rke2_server_install_type: agent

- name: Agent-config.yaml schreiben
  ansible.builtin.template:
    src: config.yaml.j2
    dest: /etc/rancher/rke2/config.yaml
    mode: "0600"
  notify: Restart rke2-agent

- name: Rke2-agent starten
  ansible.builtin.systemd_service:
    name: rke2-agent
    enabled: true
    state: started
EOF
cat > roles/rke2_agent/handlers/main.yml <<'EOF'
---
- name: Restart rke2-agent
  ansible.builtin.systemd_service:
    name: rke2-agent
    state: restarted
EOF
cat > roles/rke2_agent/templates/config.yaml.j2 <<'EOF'
# {{ ansible_managed }}
server: https://{{ rke2_vip }}:9345
token: {{ rke2_token }}
node-ip: {{ ansible_host }}
EOF

Ein Server gilt erst als fertig, wenn er Ready ist und die VIP antwortet. So joint cp-2 nie gegen eine VIP, die noch niemand hält. Die Agent-Rolle braucht keine Manifeste: Agents bekommen alles vom Server.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Join-Reihenfolge und Kubeconfig

cat > site.yml <<'EOF'
---
- name: Ersten RKE2-Server initialisieren
  hosts: rke2_servers[0]
  become: true
  roles:
    - rke2_server

- name: Weitere Server einzeln joinen
  hosts: rke2_servers[1:]
  become: true
  serial: 1
  roles:
    - rke2_server

- name: Agents joinen
  hosts: rke2_agents
  become: true
  serial: 2
  roles:
    - rke2_agent

- name: Kubeconfig auf den Laptop holen
  hosts: rke2_servers[0]
  become: true
  tasks:
    - name: Kubeconfig lesen
      ansible.builtin.slurp:
        src: /etc/rancher/rke2/rke2.yaml
      register: rke2_kubeconfig

    - name: Kubeconfig lokal schreiben (VIP-Hostname, Kontext rke2-lab)
      become: false
      delegate_to: localhost
      ansible.builtin.copy:
        dest: "{{ kubeconfig_local }}"
        mode: "0600"
        content: >-
          {{ rke2_kubeconfig.content | b64decode
             | replace('https://127.0.0.1:6443',
                       'https://' ~ rke2_vip_hostname ~ ':6443')
             | regex_replace('(?m): default$', ': ' ~ kubeconfig_context) }}
EOF
ansible-playbook --syntax-check site.yml
ansible-lint

Erwartet:

playbook: site.yml

Passed: 0 failure(s), 0 warning(s) in 23 files processed of 24 encountered.
Last profile that met the validation criteria was 'production'.

Die Plays bilden die Join-Reihenfolge ab: erst rke2_servers[0], dann die restlichen Server mit serial: 1 (etcd verträgt nur ein neues Mitglied gleichzeitig), dann Agents. Der letzte Play holt die Kubeconfig, ersetzt 127.0.0.1 durch die VIP und benennt default in rke2-lab um.

grep -q rke2.lab.internal /etc/hosts || \
  echo "10.10.20.10 rke2.lab.internal" | sudo tee -a /etc/hosts
source ~/ki-lab/rke2-token.env
ansible-playbook site.yml

Erwartet (gekürzt, nicht live getestet, ca. 15–20 min):

TASK [rke2_server : Warten bis der Node Ready ist] *****************
FAILED - RETRYING: [rke2-cp-1]: Warten bis der Node Ready ist (40 retries left).
ok: [rke2-cp-1]
...
PLAY RECAP *********************************************************
rke2-cp-1    : ok=14   changed=6    unreachable=0    failed=0
rke2-cp-2    : ok=10   changed=5    unreachable=0    failed=0
rke2-cp-3    : ok=10   changed=5    unreachable=0    failed=0
rke2-gpu-1   : ok=6    changed=4    unreachable=0    failed=0
rke2-wk-1    : ok=6    changed=4    unreachable=0    failed=0
rke2-wk-2    : ok=6    changed=4    unreachable=0    failed=0
export KUBECONFIG=~/ki-lab/rke2.yaml
kubectl config current-context
kubectl get nodes -o wide | awk '{print $1, $2, $3, $5, $6}' | column -t

Erwartet (gekürzt, nicht live getestet):

rke2-lab
NAME        STATUS  ROLES                      VERSION         INTERNAL-IP
rke2-cp-1   Ready   control-plane,etcd,master  v1.36.4+rke2r1  10.10.20.11
rke2-cp-2   Ready   control-plane,etcd,master  v1.36.4+rke2r1  10.10.20.12
rke2-cp-3   Ready   control-plane,etcd,master  v1.36.4+rke2r1  10.10.20.13
rke2-gpu-1  Ready   <none>                     v1.36.4+rke2r1  10.10.20.31
rke2-wk-1   Ready   <none>                     v1.36.4+rke2r1  10.10.20.21
rke2-wk-2   Ready   <none>                     v1.36.4+rke2r1  10.10.20.22

Wer hält die VIP, und läuft Cilium ohne kube-proxy?

kubectl -n kube-system get lease plndr-cp-lock \
  -o jsonpath='{.spec.holderIdentity}{"\n"}'
kubectl -n kube-system get ds kube-vip-ds cilium
kubectl -n kube-system get pods -l component=kube-proxy --no-headers | wc -l
kubectl -n kube-system exec ds/cilium -c cilium-agent -- \
  cilium-dbg status | grep -E 'KubeProxyReplacement|Cluster health'

Erwartet (gekürzt, nicht live getestet):

rke2-cp-1
NAME          DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE
kube-vip-ds   3         3         3       3            3
cilium        6         6         6       6            6
0
KubeProxyReplacement:    True   [eth0   10.10.20.21 (Direct Routing)]
Cluster health:          6/6 reachable   (2026-10-09T18:12:03Z)

Fortschritt speichern? Kostenlos registrieren

Drill 7: Upgrade mit dem system-upgrade-controller

Der Controller führt pro Node einen Job mit dem Image rancher/rke2-upgrade aus: cordon, Binary tauschen, Dienst neu starten. Server immer vor Agents – das erledigt der prepare-Schritt im Agent-Plan.

SUC=https://github.com/rancher/system-upgrade-controller/releases/download/v0.20.2
kubectl apply -f $SUC/crd.yaml -f $SUC/system-upgrade-controller.yaml
kubectl -n system-upgrade rollout status deploy/system-upgrade-controller
cat > upgrade/plans.yaml <<'EOF'
apiVersion: upgrade.cattle.io/v1
kind: Plan
metadata:
  name: server-plan
  namespace: system-upgrade
spec:
  concurrency: 1
  cordon: true
  nodeSelector:
    matchExpressions:
      - key: node-role.kubernetes.io/control-plane
        operator: In
        values: ["true"]
  tolerations:
    - key: CriticalAddonsOnly
      operator: Exists
  serviceAccountName: system-upgrade
  upgrade:
    image: rancher/rke2-upgrade
  version: v1.36.5+rke2r1
---
apiVersion: upgrade.cattle.io/v1
kind: Plan
metadata:
  name: agent-plan
  namespace: system-upgrade
spec:
  concurrency: 1
  cordon: true
  nodeSelector:
    matchExpressions:
      - key: node-role.kubernetes.io/control-plane
        operator: DoesNotExist
  prepare:
    image: rancher/rke2-upgrade
    args: ["prepare", "server-plan"]
  serviceAccountName: system-upgrade
  upgrade:
    image: rancher/rke2-upgrade
  version: v1.36.5+rke2r1
EOF
kubectl apply -f upgrade/plans.yaml

Erwartet (gekürzt, nicht live getestet):

deployment "system-upgrade-controller" successfully rolled out
plan.upgrade.cattle.io/server-plan created
plan.upgrade.cattle.io/agent-plan created

version statt channel: Im Lab willst du entscheiden, wann ein Upgrade läuft. Mit channel: https://update.rke2.io/v1-release/channels/stable zieht der Cluster jede neue Stable-Version selbst. Die tolerations braucht der Server-Plan wegen des CriticalAddonsOnly-Taints.

kubectl -n system-upgrade get plans -o wide
kubectl get nodes -w   # nach ca. 15 min mit Strg+C beenden

Erwartet (gekürzt, nicht live getestet):

NAME          IMAGE                 CHANNEL   VERSION          COMPLETE
server-plan   rancher/rke2-upgrade            v1.36.5+rke2r1   False
agent-plan    rancher/rke2-upgrade            v1.36.5+rke2r1   False
rke2-cp-1    Ready,SchedulingDisabled   control-plane,etcd,master   v1.36.4+rke2r1
rke2-cp-1    Ready                      control-plane,etcd,master   v1.36.5+rke2r1
...

Danach rke2_version in group_vars/all.yml auf v1.36.5+rke2r1 setzen, damit neue Nodes gleich mit der aktuellen Version joinen.

Achtung: Keine Minor-Version überspringen (1.36 → 1.38 geht nicht). Vor jedem Upgrade einen etcd-Snapshot ziehen: sudo rke2 etcd-snapshot save --name pre-upgrade auf rke2-cp-1.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

export KUBECONFIG=~/ki-lab/rke2.yaml
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
check "Kontext rke2-lab" '[ "$(kubectl config current-context)" = rke2-lab ]'
check "6 Nodes Ready" '[ "$(kubectl get nodes --no-headers \
  | awk "\$2==\"Ready\"" | wc -l)" -eq 6 ]'
check "3 etcd-Mitglieder" '[ "$(kubectl get nodes \
  -l node-role.kubernetes.io/etcd=true --no-headers | wc -l)" -eq 3 ]'
check "API ueber VIP" 'curl -sk --max-time 5 https://10.10.20.10:6443/livez'
check "kube-vip 3/3" '[ "$(kubectl -n kube-system get ds kube-vip-ds \
  -o jsonpath="{.status.numberReady}")" -eq 3 ]'
check "kein kube-proxy" '[ "$(kubectl -n kube-system get pods \
  -l component=kube-proxy --no-headers | wc -l)" -eq 0 ]'
check "IngressClass traefik" 'kubectl get ingressclass traefik'
check "Plans complete" '[ "$(kubectl -n system-upgrade get plans \
  -o jsonpath="{.items[*].status.conditions[?(@.type==\"Complete\")].status}")" \
  = "True True" ]'

Erwartet:

✔ Kontext rke2-lab
✔ 6 Nodes Ready
✔ 3 etcd-Mitglieder
✔ API ueber VIP
✔ kube-vip 3/3
✔ kein kube-proxy
✔ IngressClass traefik
✔ Plans complete

Challenge

Beweise, dass die VIP HA ist: Fahre den Server herunter, der gerade den Lease plndr-cp-lock hält, und zeige, dass kubectl über rke2.lab.internal nach wenigen Sekunden weiter funktioniert und ein anderer Server die VIP übernimmt. Starte ihn danach wieder.

Hinweis: Die VMID ergibt sich aus dem Namen (rke2-cp-2 → 212), qm shutdown läuft auf dem Proxmox-Host.

Lösung

H=$(kubectl -n kube-system get lease plndr-cp-lock \
  -o jsonpath='{.spec.holderIdentity}'); echo "VIP bei $H"
ssh [email protected] "qm shutdown 21${H##*-}"
for i in $(seq 1 12); do
  kubectl get --raw=/livez >/dev/null 2>&1 && echo "API ok nach $((i*5))s" && break
  sleep 5
done
kubectl -n kube-system get lease plndr-cp-lock -o jsonpath='{.spec.holderIdentity}'
ssh [email protected] "qm start 21${H##*-}"

Erwartet (gekürzt, nicht live getestet):

VIP bei rke2-cp-1
API ok nach 10s
rke2-cp-3

Mit zwei von drei etcd-Mitgliedern bleibt das Quorum erhalten. Fährst du zwei Server herunter, steht die API – genau deshalb drei.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • CIS: profile: cis in der Server- und Agent-config.yaml aktiviert die RKE2-Härtung (PSA restricted, NetworkPolicies, Audit-Log). Voraussetzung laut Doku: Benutzer etcd anlegen und rke2-cis-sysctl.conf nach /etc/sysctl.d/ kopieren – im Lab bewusst aus, weil GPU-Operator und Longhorn Ausnahmen brauchen.
  • Token und Secrets-Encryption: Cluster-Token aus Vault/OpenBao, secrets-encryption ist bei RKE2 Default – Key-Rotation (rke2 secrets-encrypt rotate-keys) in den Betriebsplan.
  • etcd-Snapshots zusätzlich nach S3 (etcd-s3: true + Bucket), Restore regelmäßig üben (Tag 15).
  • kube-vip im ARP-Modus braucht ein flaches L2-Netz. Über Rechenzentren hinweg: BGP-Modus oder ein externer Load Balancer (HAProxy/F5) vor Port 6443 und 9345.
  • Air-Gap: Tarballs und Images (rke2-images-*.tar.zst) statt get.rke2.io, Registry-Mirror in /etc/rancher/rke2/registries.yaml.