PKR-Lab

20020 - Cluster Power Manager: Worker per Wake-on-LAN dazuschalten

Quelle: pkr-lab/pkr-lab-docs/capulus/capulus-ansible/2-betrieb-hardware/20020-cluster-power-manager.md

Cluster Power Manager: Worker per Wake-on-LAN dazuschalten

ControlPlane-0 (Homeserver, 192.168.178.94) und ControlPlane-1
(192.168.178.95) laufen dauerhaft und sind nicht Teil dieses Features:
Beide sind etcd-Mitglieder, ein Poweroff würde die API mitnehmen
(400a0).
worker-1 (192.168.178.96) soll dagegen nur dann laufen, wenn er
tatsächlich gebraucht wird
: Wird die Last auf dem Homeserver zu
groß, weckt der Homeserver ihn per Wake-on-LAN (WoL). Geht die Last wieder
zurück, schaltet der Homeserver ihn wieder ab. Die Logik verarbeitet eine
Liste von Workern (jeder weitere Eintrag wartet um die Stage-2-Zeit länger),
heute steht dort nur worker-1.

Ergänzt thermal_watchdog/resource_watchdog, die jeden Node
bei eigener Übertemperatur/Überlast selbst herunterfahren — dieses
Feature steuert stattdessen die anderen Nodes basierend auf der Last
des Homeservers.


Architektur

┌─────────────────────── homeserver (Control-Plane, immer an) ───────────────────────┐
│                                                                                       │
│  cluster-power-manager.service                                                      │
│  ├─ pollt lokale CPU/RAM (kein Prometheus/k8s in der Messkette,                      │
│  │  gleiches Prinzip wie resource_watchdog)                                         │
│  │                                                                                   │
│  ├─ Last sustained hoch  ──▶ wakeonlan worker-1-MAC ──▶ warten auf Ready            │
│  │                            (weitere Worker in der Liste: nach Stage-2-Zeit)       │
│  │                                                                                   │
│  └─ Last sustained niedrig ──▶ kubectl cordon+drain ──▶ ssh poweroff                │
│                                 (zuletzt geweckter Worker zuerst)                    │
└───────────────────────────────────────────────────────────────────────────────────────┘
              │ Magic Packet (UDP, Broadcast)      │ SSH (forced command: nur poweroff)
              ▼                                     ▼
┌─────────────────────┐                   ┌─────────────────────┐
│ weiterer Worker      │                   │ worker-1 (.96)       │
│ wake_on_lan-Rolle:   │                   │ wake_on_lan-Rolle:   │
│ ethtool wol g beim   │                   │ ethtool wol g beim   │
│ Boot (NIC muss WoL   │                   │ Boot                 │
│ auch im BIOS an      │                   │                       │
│ haben)               │                   │                       │
└─────────────────────┘                   └─────────────────────┘

Warum kein Prometheus/VictoriaMetrics in der Entscheidung? Gleicher
Grund wie bei thermal_watchdog/resource_watchdog: Die Skalierungslogik
soll auch funktionieren, wenn der Monitoring-Stack selbst gerade unter
der hohen Last leidet oder auf einem der Worker läuft. Stattdessen liest
das Skript /proc/stat//proc/meminfo direkt und prüft die
Worker-Erreichbarkeit per ICMP-Ping.

Warum ein eigener SSH-Key statt des Semaphore-Keys? Semaphores Key
läuft aus einem Pod im Cluster heraus und kann beliebige Playbooks
ausführen. Der hier generierte Key liegt auf dem nackten Homeserver-Host
und ist auf den Workern per authorized_keys-command=-Option fest
auf sudo poweroff beschränkt
— selbst wenn der private Schlüssel
abfließen sollte, kann damit nichts anderes ausgeführt werden.


Beteiligte Rollen

Rolle Läuft auf Zweck
wake_on_lan controlplane-1, worker-1 Aktiviert WoL (ethtool wol g) persistent bei jedem Boot
cluster_power_manager homeserver Erzeugt den Shutdown-SSH-Key, deployt den Watchdog (cluster-power-manager.service)
cluster_power_manager_target worker-1 Autorisiert den Public Key des Homeservers, beschränkt auf poweroff. Auf controlplane-1 mit cluster_power_manager_target_enabled: false nur zum Entfernen von Schlüssel und sudoers-Freigabe
power_agent homeserver HTTP-Gegenstück für manuelle Wake-/Shutdown-Taps aus der iOS-App (siehe capulus-core/3-apps-workloads/300d0-carplay-api.md) — nutzt denselben SSH-Key, dieselbe woke_at-Buchführung und dieselbe Worker-Liste wie oben weiter, damit sich App-Taps und dieser automatische Last-Watchdog nicht widersprechen. Läuft direkt nach cluster_power_manager in site.yml.

Reihenfolge beim erstmaligen Rollout wichtig: make install (site.yml,
erzeugt den SSH-Key auf homeserver) vor make controlplane-1 /
make worker-1 (lesen den Public Key per delegate_to vom Homeserver).


Voraussetzungen

  1. WoL im BIOS/UEFI aktivieren — auf worker-1 (und für den Neustart nach Stromausfall auf controlplane-1) einmalig
    manuell (Bezeichnung je nach Hersteller z.B. "Power On by PCI-E",
    "Wake on LAN", "Resume by PME#"). Ansible kann das nicht setzen, nur
    den OS-seitigen Teil (ethtool -s <iface> wol g).
  2. MAC-Adressen eintragen — auf jedem Worker per
    ip link show ermitteln und in
    capulus-ansible/host_vars/worker-1/vars.yml den
    Platzhalter wake_on_lan_mac_address ersetzen. Ohne echte MAC kann
    cluster_power_manager diesen Worker nicht wecken — der Rollout
    warnt darauf hin, bricht aber nicht ab.
  3. Homeserver und worker-1 im selben L2-Segment
    (192.168.178.0/24) — WoL-Magic-Packets sind UDP-Broadcasts und
    werden von den meisten Routern/Switches nicht zwischen Subnetzen
    weitergeleitet.

Deployment

make install     # site.yml: k3s-Server + cluster_power_manager (SSH-Key)
make worker-1    # wake_on_lan + cluster_power_manager_target auf worker-1
make controlplane-1    # wake_on_lan; entfernt den Shutdown-Schlüssel (cluster_power_manager_target_enabled: false)

Nur den Power-Manager auf dem Homeserver neu deployen (z.B. nach
Schwellwert-Änderung in group_vars/all.yml):

make cluster-power-manager

Schwellwerte & Hysterese

Defaults in
capulus-ansible/roles/cluster_power_manager/defaults/main.yml,
überschreibbar in capulus-ansible/group_vars/all.yml:

Variable Default Bedeutung
cluster_power_manager_cpu_scale_up_threshold 60% CPU-Schwelle zum Hochskalieren
cluster_power_manager_ram_scale_up_threshold 60% RAM-Schwelle zum Hochskalieren
cluster_power_manager_scale_up_sustain_seconds 60s Wie lange sustained hoch, bevor der erste Worker (worker-1) geweckt wird
cluster_power_manager_scale_up_sustain_seconds_stage2 200s Zusätzliche Zeit je weiterem Worker in der Liste (heute nicht genutzt)
cluster_power_manager_cpu_scale_down_threshold 30% CPU-Schwelle zum Herunterskalieren
cluster_power_manager_ram_scale_down_threshold 30% RAM-Schwelle zum Herunterskalieren
cluster_power_manager_scale_down_sustain_seconds 900s Wie lange sustained niedrig, bevor EIN Worker abgeschaltet wird
cluster_power_manager_min_uptime_seconds 300s Mindest-Laufzeit eines Workers nach dem Wecken, bevor er für Shutdown in Frage kommt
cluster_power_manager_unplanned_off_grace_seconds 600s Karenzzeit, nach der ein unerreichbarer, nicht cordoneter Worker cordoned wird

Bewusste Asymmetrie: Die Scale-down-Schwelle (30%) liegt deutlich
unter der Scale-up-Schwelle (60%), und die Sustain-Dauer zum Abschalten
(900s) ist länger als zum Aufwecken (60s/260s). Ohne diese Hysterese und die
Mindest-Laufzeit würde ein Worker direkt nach dem Aufwecken wieder
abgeschaltet werden, sobald die (durch ihn selbst mitverursachte)
Homeserver-Last kurzzeitig sinkt — klassisches Flapping. Pro
Scale-down-Sustain-Periode wird immer nur ein Worker abgeschaltet
(zuletzt geweckter zuerst), nicht beide gleichzeitig.

CPU oder RAM über Schwelle löst Hochskalieren aus; CPU und RAM
müssen für Herunterskalieren beide unter der (niedrigeren) Schwelle
liegen.


Testen ohne echten Shutdown

# Auf homeserver:
sudo systemctl edit --runtime cluster-power-manager
# In der sich öffnenden Datei:
[Service]
Environment=DRY_RUN=1
# Speichern, dann:
sudo systemctl restart cluster-power-manager
sudo journalctl -u cluster-power-manager -f

Mit DRY_RUN=1 protokolliert und benachrichtigt (ntfy) das Skript jeden
Wake-/Shutdown-Schritt, führt aber weder wakeonlan noch
kubectl cordon/drain noch den SSH-Poweroff tatsächlich aus. Der
systemctl edit --runtime-Drop-in verschwindet beim nächsten Boot
automatisch wieder.

Manueller WoL-Test unabhängig vom Watchdog:

# Von homeserver oder einem beliebigen Host im selben Subnetz:
wakeonlan <mac-adresse-worker-1>

Ungeplant ausgeschaltete Worker

Jeder geplante Shutdown (Power-Manager, nightly-worker-wake, power-agent) cordont den Worker vorher. Geht ein Worker
ohne cordon aus, etwa durch resource_watchdog oder thermal_watchdog (beide rufen nur systemctl poweroff auf),
den Stromtaster oder einen Absturz, steht er als „schedulable, NotReady“ im Cluster. Der Signalalarm Worker1Schlaeft
setzt aber cordoned voraus (Monitoring).
Ohne ihn feuern alle Folgealarme (DaemonSets, kubelet, Scrape-Ziele, entw-vm) dauerhaft und wiederholen sich alle 24 h.

Deshalb prüft der Dienst in jedem Durchlauf jeden Worker per Ping. Ist einer länger als
cluster_power_manager_unplanned_off_grace_seconds nicht erreichbar und nicht cordoned, cordont er ihn, löscht
woke_at und schickt einmal „Worker unerwartet aus“ per ntfy. worker-1Down meldet den Ausfall also einmal, danach
greift die Unterdrückung. Die Unerreichbarkeit merkt sich der Dienst in <state_dir>/<name>.unreachable_since.

Anlass am 2026-11-16: worker-1 ging am Vorabend um 20:34 nach einem Ansible-Lauf (cordon, Reboot, uncordon) ohne
cordon aus. Bis zum manuellen kubectl cordon kamen rund 20 Folgealarme in Mattermost an.

Fehlerbehebung

Worker wacht nach wakeonlan nicht auf:

Worker wird nicht automatisch heruntergefahren:

# Auf homeserver:
sudo journalctl -u cluster-power-manager -n 100
# Manueller Test des SSH-Pfads (sollte NUR poweroff ausführen können):
sudo ssh -i /etc/cluster-power-manager/id_ed25519 [email protected] whoami
# -> führt trotz "whoami" den forced command (sudo poweroff) aus,
#    das ist beabsichtigt (siehe cluster_power_manager_target)

Falls die SSH-Verbindung mit Permission denied fehlschlägt: Lief
make controlplane-1/make worker-1 nach make install? Der Public Key
muss zuerst auf homeserver existieren, bevor er auf den Workern
autorisiert werden kann.

Ständiges Auf-/Abschalten (Flapping):

cluster_power_manager_scale_down_sustain_seconds und
cluster_power_manager_min_uptime_seconds erhöhen (siehe
Schwellwerte) — deutet meist darauf hin,
dass die Scale-up/down-Schwellen zu dicht beieinander liegen oder die
typische Lastspitze kürzer ist als die konfigurierte Sustain-Dauer.


Mehrschichtiger RAM-Schutz

Der Homeserver ist aktuell der einzige durchgehend laufende Node, und
mehrere Apps skalieren per HPA hoch (siehe
b0040-hpa-autoscaling.md) —
wegen podAffinity bei RWO-Storage landen neue Replicas dabei zwingend
auf demselben Node wie die bereits laufenden (z. B. Immich, siehe
300c0-immich.md). Skalierung hilft
also gegen viele parallele Anfragen, kann aber im Zweifel selbst den
RAM-Druck auf dem Homeserver erhöhen, statt ihn zu verteilen. Cluster
Power Manager weckt zwar zusätzliche Worker bei hoher Homeserver-Last,
verschiebt aber keine bereits laufenden, affinity-gebundenen Pods dorthin.

Gegen einen daraus resultierenden RAM-Engpass greifen vier Schichten,
von früh/sanft bis spät/hart:

  1. VMRule/Alertmanager-Warnung (RAM ≥ 70% / CPU ≥ 80%, 2 Minuten,
    vmrule-resources.yaml)
    — kein Eingriff (Push nur bei critical über ntfy). Läuft im Cluster und kann daher
    selbst betroffen sein, wenn genau der Ressourcendruck, vor dem sie
    warnen soll, den Monitoring-Stack mit ausbremst.
  2. resource_watchdog-Frühwarnung (RAM ≥ 80% / CPU ≥ 85%, 60s,
    capulus-ansible/roles/resource_watchdog) —
    läuft dependency-frei direkt auf dem Host (kein Prometheus/k8s in der
    Messkette) und schickt eine einmalige ntfy-Warnung, auch wenn Schicht 1
    gerade selbst ausfällt. Ebenfalls kein Eingriff, reine Vorwarnung vor
    dem automatischen Shutdown.
  3. Kubelet-Eviction (verfügbarer RAM < 15%, eviction-hard +
    system-reserved/kube-reserved in capulus-ansible/group_vars/all.yml →
    k3s_kubelet_*) — der Kubelet evakuiert/killt gezielt einzelne Pods
    (typischerweise den größten Speicherverbraucher), bevor der gesamte
    Node gefährdet ist, und reserviert RAM für OS/kubelet/containerd/sshd/
    tailscaled, damit Pod-Speicherdruck nicht diese Systemdienste trifft.
    Wirkt erst nach sudo systemctl restart k3s (bzw. k3s-agent) auf dem
    jeweiligen Node.
  4. resource_watchdog-Shutdown (RAM/CPU ≥ 90%, 300s sustained,
    capulus-ansible/roles/resource_watchdog) —
    letzte Instanz, wenn Schicht 3 die Last nicht mehr abfangen konnte:
    fährt den kompletten Node herunter. Erreichbar dann nur noch über
    physischen Zugriff, NICHT mehr über Tailscale (Poweroff, kein Hang).
    Auf den k3s-Servern (controlplane-0/-1) ist diese Schicht ein reiner
    Alarm: resource_watchdog_action: notify schickt nur eine ntfy-Meldung
    und lässt den Host laufen, weil ein Poweroff ein etcd-Mitglied und damit
    bei zwei Mitgliedern die API mitnähme. thermal_watchdog (Hardware-Schutz)
    schaltet weiterhin ab.

Schicht 2 und 3 wurden ergänzt, nachdem ein reiner Shutdown ohne
Vorwarnung (Schicht 1 + 4 allein) dazu führte, dass der Homeserver ohne
erkennbaren Grund "einfach weg" war, obwohl er nur sauber heruntergefahren
hatte.

Nachtrag 2026-09-02: Der Vorfall, der diese vier Schichten ausgelöst
hat, stellte sich bei der Log-Analyse als kein RAM/CPU-Problem heraus,
sondern als physischer Link-Verlust auf eno1 (Realtek r8169,
journalctl: Lost carrier / Link is Down um 13:29:47, danach keine
Erholung mehr bis zum nächsten harten Reset). ethtool --show-eee eno1
zeigte "EEE status: enabled - active" bei 1Gbps — eine bekannte
Schwachstelle mancher Realtek-NICs. Fix:
capulus-ansible/roles/disable_eee
deaktiviert Energy Efficient Ethernet persistent beim Boot (analog zum
enable-wol.service-Muster in
capulus-ansible/roles/wake_on_lan) — eigene
Rolle statt Teil von common, damit auch worker-0/worker-1 (die
common nicht durchlaufen) denselben Schutz bekommen, falls sie
dieselbe NIC-Generation verbaut haben. Die vier Schichten oben bleiben
trotzdem sinnvoll — sie schützen vor echtem Ressourcendruck, unabhängig
von dieser konkreten Ursache.

Nachtrag 2026-09-20: Der EEE-Dienst war auf dem homeserver seit dem
Bridge-Umbau (br0, siehe
40080) wirkungslos:
disable_eee_interface nahm das Default-Route-Interface (jetzt br0,
ethtool --set-eee br0 schlägt fehl, Dienst failed), auf der physischen
NIC (enp4s0, früher eno1) war EEE weiter "enabled - active". Auf Hosts
mit Bridge muss disable_eee_interface in den host_vars auf die
physische NIC zeigen (libvirt_host_bridge_interface). Prüfen:
systemctl is-active disable-eee.service und
ethtool --show-eee <NIC> (muss "disabled" zeigen).