Kubernetes auf Hetzner: Bare-Metal-Server als Nodes effizient nutzen

Einführung

Möchtest du die Leistungsfähigkeit von Hetzners dedizierten Servern nutzen, um deine Infrastruktur zu erweitern? Dieses Tutorial zeigt dir Schritt für Schritt, wie du mit dem Cluster API Provider Hetzner (CAPH) ein Bare-Metal-Kubernetes-Cluster erstellst.

Dieser Artikel ist der zweite in einer Serie über die Verwaltung von Kubernetes auf Hetzner mit Cluster API (CAPI) und konzentriert sich auf die Nutzung dedizierter Server, auch bekannt als Bare-Metal-Server, die bis zu 40 % günstiger sein können als Hetzner-Cloud-Instanzen.

Der Cluster API Provider Hetzner (CAPH) ist ein Open-Source-Projekt (entwickelt von der Syself GmbH und der Community), das dir ermöglicht, die Funktionen der Cluster API zu nutzen, um hochverfügbare Kubernetes-Cluster auf Hetzner-Bare-Metal-Servern (Robot) und Hetzner-Cloud-Instanzen zu verwalten.

Mit dem Ansatz der Cluster API kannst du Kubernetes-Cluster skalierbar und deklarativ verwalten. Im Gegensatz zu herkömmlichen Infrastructure-as-Code-Tools wie Terraform oder Ansible bietet CAPI leistungsstarke Funktionen wie automatische Wiederherstellung bei Fehlern und intelligente Automatisierung von Updates. So kannst du deine Systeme einfach und zuverlässig am Laufen halten. Die Software überwacht kontinuierlich deine Infrastrukturressourcen und sorgt dafür, dass sie stets in einem gesunden Zustand bleiben – nicht nur, wenn eine Pipeline ausgelöst wird.

Das CAPH-Projekt hat im Oktober 2024 mit dem Release von Version 1.0 den allgemeinen Verfügbarkeitsstatus erreicht, nach vier Jahren Entwicklung und produktiver Nutzung durch Hunderte von Organisationen.

Dieses Tutorial führt dich durch den Prozess der Erstellung eines Bare-Metal-Kubernetes-Clusters mit CAPH. Wenn du den ersten Artikel bereits gelesen hast und ein funktionierendes Setup besitzt, kannst du diesen Abschnitt überspringen.

Warum Bare Metal?

Bare-Metal-Server bieten gegenüber virtuellen Maschinen mehrere Vorteile: eine höhere Rechenleistung, bis zu 40 % geringere Kosten im Vergleich zu ähnlichen VMs bei Hetzner, schnellere NVMe-Festplatten und eine bessere Kosteneffizienz für das Hosting von datenintensiven Workloads wie Datenbanken.

Da die Virtualisierungsebene entfällt, hast du direkten Zugriff auf die Hardware. Dies ermöglicht eine effizientere Ressourcennutzung und stellt sicher, dass du der einzige Nutzer dieser Maschine bist. Dadurch entfällt in einigen Fällen die Notwendigkeit von Confidential Computing.

Allerdings fehlen Hetzner-Bare-Metal-Servern die umfangreichen API-Integrationen von Cloud-VMs. Die Bereitstellung ist komplexer, und die Benutzeroberfläche weniger intuitiv.

Hier kommt CAPH ins Spiel — das Bare-Metal-Server durch Automatisierung sehr einfach mithilfe Kubernetes-Ressourcen bedienbar sind. So kannst du uneingeschränkt und ohne zusätzlichen Aufwand die Vorteile dieser Server nutzen.

Voraussetzungen

• Docker, um Container auszuführen
• Kind, um ein lokales Kubernetes-Cluster zu erstellen
• kubectl und clusterctl, um deine Cluster zu verwalten
• Ein Hetzner-Account mit Bare-Metal-Servern
• Ein SSH-Schlüssel

Schritt 1 - Hetzner-Account vorbereiten

Erstelle ein neues Projekt in der Hetzner Cloud Console, gehe zum Tab „Sicherheit“ und erstelle ein API-Token mit Lese- und Schreibzugriff. Notiere es dir.

Füge anschließend deinen öffentlichen SSH-Schlüssel zum Projekt hinzu. Notiere den Namen, den du dafür verwendet hast. Dieser wird später als Umgebungsvariable benötigt.

Damit CAPH die Bare-Metal-Server verwalten kann, musst du in der Hetzner Robot Console einen neuen Web-Service-Benutzer erstellen. Klicke dazu auf die Schaltfläche „Benutzer erstellen“. Die Benutzer-ID wird dir per E-Mail zugeschickt.

Schritt 2 - Management-Cluster erstellen

Ein Kubernetes-Cluster wird benötigt, um den Cluster-API- und CAPH-Stack auszuführen. Dieses sogenannte Management-Cluster verwaltet deine Kubernetes-Infrastruktur über Kubernetes-API-Objekte. Im Hintergrund kümmern sich die Controller um den gesamten Lebenszyklus der Maschinen und Infrastruktur.

Wir starten mit einem lokalen Kind-Cluster als temporärem Bootstrap-Cluster. Später können wir die Controller auf das neue Workload-Cluster in der Hetzner Cloud verschieben. Wenn du bereits ein laufendes Cluster hast, kannst du es stattdessen nutzen.

Erstelle ein lokales Kind-Cluster:

# Cluster mit Kind erstellen
kind create cluster --name caph-mgt-cluster

# Initialisierung
clusterctl init --core cluster-api --bootstrap kubeadm --control-plane kubeadm --infrastructure hetzner

Erstelle ein Secret mit den Zugangsdaten für die Provider-Integration, um mit den Hetzner-APIs (HCloud API und Robot API) zu kommunizieren. Außerdem wird der SSH-Schlüssel hinzugefügt, der von CAPH verwendet wird. Auch einige Informationen, welche für die Definition des Clusters wichtig sind, speichern wir in Variablen:

export HCLOUD_TOKEN="<DEIN-TOKEN>"
export HETZNER_ROBOT_USER="<DEIN-ROBOT-BENUTZER>"
export HETZNER_ROBOT_PASSWORD="<DEIN-ROBOT-PASSWORT>"
export SSH_KEY_NAME="<DEIN-SSH-SCHLÜSSEL-NAME>"
export HETZNER_SSH_PUB_PATH="<PFAD-ZU-DEINEM-SSH-PUBLIC-KEY>"
export HETZNER_SSH_PRIV_PATH="<PFAD-ZU-DEINEM-SSH-PRIVATE-KEY>"
export HCLOUD_CONTROL_PLANE_MACHINE_TYPE="" 
export HCLOUD_REGION="" 
export HCLOUD_WORKER_MACHINE_TYPE="" 
export KUBERNETES_VERSION="1.30.5"

Secrets anlegen:

kubectl create secret generic hetzner --from-literal=hcloud=$HCLOUD_TOKEN --from-literal=robot-user=$HETZNER_ROBOT_USER --from-literal=robot-password=$HETZNER_ROBOT_PASSWORD

kubectl create secret generic robot-ssh --from-literal=sshkey-name=$SSH_KEY_NAME \
        --from-file=ssh-privatekey=$HETZNER_SSH_PRIV_PATH \
        --from-file=ssh-publickey=$HETZNER_SSH_PUB_PATH

Falls bereits ein Secret existiert, kannst du es bearbeiten und die neuen Variablen hinzufügen.

Schritt 2.1 - Cluster API und CAPH-Ressourcen verstehen

Nachdem das Management-Cluster läuft, lohnt es sich, die von den Kubernetes-Operatoren verwalteten Ressourcen genauer anzusehen. Cluster API verwaltet die Infrastruktur ähnlich wie Kubernetes Container.

• MachineDeployment: Erstellt MachineSets, die für Maschinen zuständig sind.
• HCloudMachine: Für Cloud-VMs.
• HetznerBareMetalMachine: Für dedizierte Server.

Für Bare-Metal-Server benötigst du zusätzlich HetznerBareMetalHost-Objekte, mit denen ein Inventar der verfügbaren Maschinen erstellt wird.

Weitere Details findest du in der Cluster API und CAPH Dokumentation.

Schritt 3 - Server registrieren

Um Bare-Metal-Server zu nutzen, registrierst du sie als Hosts, die dann für Cluster verfügbar sind. Ein Beispiel für eine HetznerBareMetalHost-Ressource:

Ersetze spec.serverID mit der ID des Bare-Metal-Servers und spec.rootDeviceHints.wwn mit dem WWN der Festplatte.

apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
kind: HetznerBareMetalHost
metadata:
  name: baremetal-1
  annotations:
    capi.syself.com/wipe-disk: all
spec:
  description: Mein erster Bare-Metal-Server
  serverID: 1234567
  rootDeviceHints:
    wwn: eui.5367492f3d453310

Die Annotation dient dazu, die Festplatten deines Bare-Metal-Servers zu löschen. Das ist empfehlenswert, da die meisten Server von Hetzner standardmäßig mit aktiviertem RAID ausgeliefert werden, welches in diesem Guide nicht verwendet wird.

Falls du die WWN (World Wide Name) der Festplatte nicht kennst, kannst du den gesamten rootDeviceHints-Block weglassen. Die WWN kann später aus dem Status der Ressource abgerufen werden, sobald der Host zum Provisionieren ausgewählt wurde:

kubectl get hbmh baremetal-1 -o yaml | yq .spec.status.hardwareDetails.storage

Die WWN kann in verschiedenen Formaten vorliegen. Falls sie anders aussieht als im Beispiel, ist das kein Problem.

Schritt 4 - Workload-Cluster erstellen

Nachdem die Bare-Metal-Server registriert wurden, kannst du ein Cluster erstellen, das diese nutzt.

Führe den folgenden Befehl im Management-Cluster aus:

# Manifeste für ein Workload-Cluster generieren und anwenden
clusterctl generate cluster my-cluster --flavor hetzner-hcloud-control-planes | kubectl apply -f -

Dies generiert alle notwendigen Ressourcen für ein Cluster mit dem hetzner-hcloud-control-planes-Flavor und erstellt sie im Management-Cluster. Der genutzte Flavor verwendet virtuelle Maschinen für die Control Planes und Bare-Metal-Server für die Worker Nodes.

Ein Flavor ist ein Paket von Custom Resource Manifests mit voreingestellter Konfiguration. Es enthält Ressourcen wie MachineDeployments und zusätzliche Manifeste, z. B. für Bare-Metal-Nodes. Flavors dienen als Ausgangspunkte für die Cluster-Konfiguration in CAPH.

Eine vollständige Liste der verfügbaren Flavors findest du in der CAPH-Dokumentation.

Hinweis: Diese Flavors dienen nur Demonstrationszwecken. Für den produktiven Einsatz solltest du eine eigene Cluster-Konfiguration erstellen, die für deine Anforderungen optimiert ist. Beispielsweise könnten die Control Planes im gleichen Rechenzentrum wie die Bare-Metal-Instanzen gehostet werden, außerdem sollte Load Balancing eingerichtet werden.

Nach Anwendung der Ressourcen kannst du die kubeconfig des Workload-Clusters abrufen:

# Kubeconfig des neuen Clusters abrufen
clusterctl get kubeconfig my-cluster > hetzner-cluster-kubeconfig.yaml

Schritt 5 - Komponenten im Cluster installieren

Das neu erstellte Cluster benötigt einige grundlegende Komponenten, bevor es einsatzbereit ist. Dazu gehören:

• Container Network Interface (CNI): Zuständig für Netzwerkkapazitäten.
• Cloud Controller Manager (CCM): Ermöglicht die Nutzung von Hetzner-Ressourcen wie Load Balancern und die Initialisierung der Nodes.

export KUBECONFIG=hetzner-cluster-kubeconfig.yaml

# Hetzner CCM installieren
helm repo add syself https://charts.syself.com/
helm repo update syself
helm install ccm syself/ccm-hetzner -n kube-system

# Flannel CNI installieren - Du kannst auch ein anderes CNI wie Cilium verwenden
kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

In diesem Beispiel wurde Flannel verwendet, aber du kannst auch andere CNIs wie Cilium oder Calico einsetzen.

Bearbeite anschließend das Deployment hcloud-cloud-controller-manager:

kubectl edit deployment ccm-ccm-hetzner -n kube-system

Unter Linux wird die Datei standardmäßig über vim geöffnet. Wechsel mit i in den "Insert Mode". Füge die folgenden Einträge in den env-Abschnitt des Containers ein:

        - name: HCLOUD_TOKEN
          valueFrom:
            secretKeyRef:
              key: hcloud
              name: hetzner
        - name: ROBOT_USER
          valueFrom:
            secretKeyRef:
              key: robot-user
              name: hetzner
        - name: ROBOT_PASSWORD
          valueFrom:
            secretKeyRef:
              key: robot-password
              name: hetzner

Nachdem die Änderungen vorgenommen wurden kannst du mit esc den "Insert Mode" verlassen. Gib :wq ein, um die Änderungen zu speichern und den Editor zu beenden.

Nun bearbeite das Machine Deployment für die Bare-Metal-Maschinen:

kubectl edit machinedeployment my-cluster-md-1

Ändere das Feld spec.replicas auf 1. Warte ein paar Minuten, bis die Maschine dem Cluster beitritt.

Das war's! Du hast jetzt ein funktionierendes Cluster mit Hetzner Bare-Metal-Servern als Worker Nodes.

Falls du das Cluster löschen möchtest, kannst du den folgenden Befehl verwenden:

kubectl delete cluster my-cluster

Das Cluster und die Cloud-Instanzen der Control Planes werden gelöscht. Die Bare-Metal-Server werden vom Cluster getrennt, bleiben aber in deinem Account. Falls du nicht weiter dafür bezahlen möchtest, musst du die Server in der Hetzner Robot Console löschen.

Nächste Schritte

Eine bewährte Methode, um Bare Metal optimal zu nutzen, ist die Kombination mit virtuellen Maschinen in einem gemischten Setup mit Autoscaling. Bare-Metal-Server können die Grundlast bewältigen, während VMs bei Lastspitzen hochskaliert werden. Dazu benötigst du den Metrics Server.

Dieses Cluster wurde mit den Standard-Bootstrap- und Controlplane-Providern von kubeadm erstellt. Für produktive Umgebungen solltest du jedoch zusätzliche Ebenen hinzufügen und eigene Node-Images erstellen, da die Standardkonfiguration nur die Grundlagen abdeckt.

Andere Teile der Infrastruktur sollten ebenfalls konfiguriert werden, z. B. Load Balancing, Fehlertoleranz, Netzwerksicherheit (Firewall, Policies etc.) und Betriebssystem-Hardening. Falls du Storage planst, benötigst du außerdem ein CSI (Container Storage Interface).

Weitere Informationen zu den Funktionen von CAPH findest du im GitHub-Readme und der Dokumentation.

Ergebnis

Mit dem Cluster API Provider Hetzner kannst du Hetzner dedizierte Server als Nodes in deinen Kubernetes-Clustern mit automatisierter Bereitstellung nutzen. Dadurch erhältst du eine effizientere Infrastruktur, während du die Vorteile von Cloud-VMs beibehältst.

In diesem Tutorial hast du ein eigenes Kubernetes-Cluster auf Hetzner-Bare-Metal-Servern mit hoher Verfügbarkeit erstellt. Eine Beispielkonfiguration wurde verwendet, um den Prozess zu vereinfachen.

License: MIT