Blog Hetzner – Cluster Creation with KubeOne

Einleitung

In unserem letzten Artikel haben wir die Hetzner Cloud als günstige, aber leistungsfähige Alternative zu großen Hyperscalern vorgestellt. Jetzt gehen wir einen Schritt weiter und zeigen, wie sich auf dieser Basis ein produktionsreifes Kubernetes-Cluster aufsetzen lässt – und zwar mit KubeOne.

Der Fokus liegt dabei nicht auf einem vollautomatisierten Platform-as-a-Service-Angebot, sondern auf einem flexiblen Setup für Nutzer:innen, die ihre Infrastruktur bewusst selbst gestalten möchten – sei es aus Kostengründen, wegen regulatorischer Anforderungen oder schlicht zur Wahrung der eigenen Kontrolle.

Warum KubeOne?

Wer Kubernetes auf Bare Metal oder bei einem IaaS-Provider wie Hetzner betreiben möchte, steht schnell vor der Frage: Wie automatisiere ich den Aufbau und die Wartung meines Clusters, ohne gleich in die Komplexität von Cluster API, Rancher oder OpenShift einzutauchen?

KubeOne trifft hier einen praktischen Sweet Spot:

• Deklarativ: Cluster-Topologie und Konfiguration werden in YAML-Dateien definiert.
• Flexibel: Unterstützt verschiedenste Infrastrukturen, darunter auch vSphere, AWS – und eben Bare Metal bzw. Hetzner.
• Kubeadm-basiert: Baut auf dem offiziellen Kubernetes-Installer auf.
• Open Source & aktiv gepflegt: Entwickelt von Kubermatic, mit Fokus auf Transparenz und Wartbarkeit.

Vorgehen

Bevor es mit der eigentlichen Cluster-Erstellung losgehen kann, braucht es eine solide Grundlage – sowohl auf Seiten der Infrastruktur als auch bei den eingesetzten Tools. Für unsere Umgebung setzen wir auf dedizierte Root-Server von Hetzner, die durch garantierte Ressourcen und eine stabile Netzwerkanbindung überzeugen. Alternativ ließe sich das Setup auch mit Hetzners Cloud-Instanzen realisieren, für produktive Workloads bietet Bare Metal jedoch deutliche Vorteile.

Als Betriebssystem kommt eine gängige Linux-Distribution zum Einsatz – in unserem Fall Ubuntu –, da KubeOne auf kubeadm aufsetzt und somit auf die klassischen Kubernetes-Umgebungen ausgerichtet ist. Die Orchestrierung der Cluster-Komponenten übernimmt KubeOne, während Terraform für die Provisionierung der Infrastruktur zuständig ist. Besonders elegant lässt sich das mit dem offiziellen Hetzner Cloud Provider für Terraform lösen, wobei bei Root-Servern etwas mehr Handarbeit erforderlich ist.

Ein funktionierender SSH-Zugang zu den Maschinen sowie öffentlich erreichbare IP-Adressen (mindestens für die Control-Plane) sind ebenfalls Voraussetzung. Nur so kann KubeOne die Nodes initialisieren, konfigurieren und das Cluster vollständig aufsetzen. Eine gute Vorbereitung dieser Komponenten sorgt dafür, dass der eigentliche Clusteraufbau später reibungslos verläuft.

Schritt 1: Infrastruktur und lokale Vorbereitung

Bevor ihr euch an die eigentliche Infrastruktur wagt, müssen die Werkzeuge lokal installiert sein. Konkret braucht ihr:

• Terraform
• KubeOne (passend zur gewünschten Cluster-Version, z. B. v1.10.x)
• Einen funktionierenden SSH-Zugang zu Hetzner (für Root-Server über Robot, für Cloud-Instanzen über das Hetzner Cloud Console)

Unter macOS oder Linux lässt sich KubeOne z. B. so installieren:

curl -LO https://github.com/kubermatic/kubeone/releases/download/v1.10.3/kubeone_1.10.3_linux_amd64.tar.gz
tar -xzf kubeone_1.10.3_linux_amd64.tar.gz
sudo mv kubeone /usr/local/bin/

Terraform steht ebenfalls als Binärdatei zum Download bereit oder kann über brew (macOS/Linux) installiert werden:

brew install terraform

Schritt 2: Infrastruktur mit Terraform provisionieren

Für die Anbindung an Hetzner verwenden wir den offiziellen Terraform-Provider. Ein minimales Setup für drei Nodes könnte so aussehen:

provider "hcloud" {
  token = var.hcloud_token
}

resource "hcloud_server" "cp" {
  name        = "control-plane"
  server_type = "cpx31"
  image       = "ubuntu-22.04"
  location    = "nbg1"
  ssh_keys    = [hcloud_ssh_key.default.id]
}

resource "hcloud_server" "worker" {
  count       = 2
  name        = "worker-${count.index}"
  server_type = "cpx31"
  image       = "ubuntu-22.04"
  location    = "nbg1"
  ssh_keys    = [hcloud_ssh_key.default.id]
}

Anschließend:

terraform init
terraform apply
terraform output -json > terraform-output.json

Schritt 3: KubeOne-Konfiguration erstellen

Die Konfigurationsdatei kubeone.yaml ist das zentrale Element in jeder KubeOne-Installation. Sie beschreibt das Ziel-Cluster und legt fest, welche Hosts welche Rollen übernehmen, welche Kubernetes-Version installiert werden soll und welche Cloud-spezifischen Einstellungen zu berücksichtigen sind.

Ein einfaches Beispiel für ein Setup mit einer Control Plane und zwei Worker Nodes bei Hetzner könnte so aussehen:

apiVersion: kubeone.io/v1beta2
kind: KubeOneCluster
name: hetzner-cluster
versions:
  kubernetes: "1.29.2"
cloudProvider:
  hetzner: {}
controlPlane:
  hosts:
    - publicAddress: "203.0.113.10"
      sshUsername: "root"
workerNodes:
  - publicAddress: "203.0.113.11"
    sshUsername: "root"
  - publicAddress: "203.0.113.12"
    sshUsername: "root"

Was hier passiert, ist schnell erklärt:

• versions.kubernetes legt die gewünschte Kubernetes-Version fest. KubeOne sorgt dafür, dass diese Version konsistent auf allen Nodes installiert wird – inklusive Container Runtime, kubelet, kube-proxy und Co.

• Der Block cloudProvider aktiviert Hetzner-spezifische Einstellungen – etwa für das CSI-Volume-Plugin. Die Angabe {} genügt hier, da keine weiteren Parameter nötig sind.

• Unter controlPlane.hosts werden die Maschinen definiert, die später die zentralen Steuerungskomponenten von Kubernetes ausführen. Wichtig ist vor allem die öffentliche IP-Adresse (publicAddress) und der SSH-Nutzername, mit dem KubeOne sich verbindet.

• Der Abschnitt workerNodes funktioniert analog und listet die Maschinen auf, die später Workloads tragen – also Deployments, StatefulSets und Services.

Angaben wie ein abweichender SSH-Port, ein Private Key oder interne IPs ergänzen. Wer z. B. in einem privaten Netzwerk arbeitet, kann mit privateAddress dafür sorgen, dass der interne Traffic nicht über öffentliche IPs läuft.

Schritt 4: Cluster installieren

Sind die Infrastruktur und die Konfiguration einmal vorbereitet, übernimmt KubeOne den Rest. Mit nur einem Befehl wird das gesamte Cluster automatisiert aufgebaut:

kubeone install -m terraform-output.json -c kubeone.yaml

Der Parameter -m terraform-output.json verweist auf die zuvor exportierten Terraform-Ausgaben (z. B. mit terraform output -json > terraform-output.json), während -c kubeone.yaml die eben erstellte Clusterdefinition übergibt.

KubeOne verbindet sich nun via SSH mit den Hosts, prüft deren Zustand, installiert Container Runtime und Kubernetes-Komponenten per kubeadm, setzt das Netzwerk-Plugin auf und bringt das Cluster in einen funktionierenden Zustand – inkl. kubeconfig und Admin-Zugriff.

Im Erfolgsfall erhältst du am Ende Zugriff auf das Cluster über eine generierte kubeconfig-Datei – standardmäßig im lokalen Verzeichnis ~/.kubeone/.

Viel Spaß beim Ausprobieren

Wir hoffen, dieser erste Einblick in die Cluster-Erstellung mit KubeOne hat euch weitergeholfen – oder zumindest Lust gemacht, es selbst einmal auszuprobieren. Gerade in Kombination mit Hetzner ergibt sich eine spannende Mischung aus Performance, Kostenkontrolle und technischer Freiheit.

Falls ihr Fragen habt oder selbst Erfahrungen mit KubeOne auf Hetzner gesammelt habt, freuen wir uns über Feedback oder Kommentare. Und wie immer gilt: Wer nicht alles selbst bauen möchte, bekommt bei uns natürlich auch Unterstützung – von der ersten Beratung bis zum voll gemanagten Cluster.