Hetzner Kubernetes Cluster erstellen: K3s Setup

TL;DR

K3s auf Hetzner Cloud ist die guenstigste Option fuer produktive Kubernetes-Cluster in Deutschland. Drei CX22-Server reichen fuer den Start. Mit Hetzner CCM und CSI bekommt ihr LoadBalancer und Persistent Volumes nativ. Gesamtkosten: unter 30 Euro pro Monat.

Warum Hetzner Cloud fuer Kubernetes

Hetzner betreibt Rechenzentren in Falkenstein, Nuernberg und Helsinki. Die Preise liegen 60-80% unter AWS und Azure. Fuer Teams, die DSGVO-konforme Infrastruktur in Deutschland brauchen, ohne Managed-Kubernetes-Aufpreis, ist Hetzner plus K3s eine solide Kombination.

Ein Vergleich der guenstigsten Optionen:

Anbieter	3-Node-Cluster (2 vCPU, 4 GB)	LoadBalancer	Volumes (20 GB)
Hetzner Cloud	3 x 3,99 EUR = 11,97 EUR	5,49 EUR	0,96 EUR
AWS EKS	3 x ~35 EUR + 73 EUR Control Plane	~18 EUR	~2,40 EUR
DOKS (DigitalOcean)	3 x ~24 EUR (kostenlose Control Plane)	~12 EUR	~2,00 EUR

K3s statt Vanilla-Kubernetes, weil: kein etcd-Cluster noetig (SQLite oder embedded etcd), ein Binary statt dutzende Komponenten, ~512 MB RAM fuer die Control Plane.

Voraussetzungen

Hetzner Cloud Account mit API-Token
SSH-Key im Hetzner-Projekt hinterlegt
hcloud CLI installiert
Lokaler Rechner mit kubectl

# hcloud CLI installieren (macOS)
brew install hcloud

# Kontext erstellen
hcloud context create k8s-projekt
# API-Token eingeben wenn gefragt

# SSH-Key hochladen (falls noch nicht geschehen)
hcloud ssh-key create --name mein-key --public-key-from-file ~/.ssh/id_ed25519.pub

Server erstellen

Drei Server genuegen: ein Control-Plane-Node, zwei Worker. Fuer produktive Setups mit HA empfehle ich drei Control-Plane-Nodes -- K3s unterstuetzt das mit embedded etcd.

# Netzwerk erstellen
hcloud network create --name k8s-net --ip-range 10.0.0.0/16
hcloud network add-subnet k8s-net --type cloud --network-zone eu-central --ip-range 10.0.1.0/24

# Control-Plane-Node
hcloud server create \
  --name k3s-master-1 \
  --type cx22 \
  --image ubuntu-24.04 \
  --location fsn1 \
  --ssh-key mein-key \
  --network k8s-net

# Worker Nodes
for i in 1 2; do
  hcloud server create \
    --name k3s-worker-${i} \
    --type cx22 \
    --image ubuntu-24.04 \
    --location fsn1 \
    --ssh-key mein-key \
    --network k8s-net
done

Notiert euch die oeffentlichen IPs:

hcloud server list -o columns=name,ipv4,status

Firewall konfigurieren

Hetzner-Firewalls arbeiten auf Netzwerkebene. Definiert Regeln, bevor ihr K3s installiert.

hcloud firewall create --name k8s-firewall

# SSH (einschraenken auf eure IP)
hcloud firewall add-rule k8s-firewall \
  --direction in --protocol tcp --port 22 \
  --source-ips "EURE_IP/32" --description "SSH"

# Kubernetes API
hcloud firewall add-rule k8s-firewall \
  --direction in --protocol tcp --port 6443 \
  --source-ips "EURE_IP/32" --description "K8s API"

# NodePort Range (optional)
hcloud firewall add-rule k8s-firewall \
  --direction in --protocol tcp --port 30000-32767 \
  --source-ips "0.0.0.0/0" --description "NodePorts"

# Flannel VXLAN (nur intern zwischen Nodes)
hcloud firewall add-rule k8s-firewall \
  --direction in --protocol udp --port 8472 \
  --source-ips "10.0.0.0/16" --description "VXLAN"

# Kubelet Metrics
hcloud firewall add-rule k8s-firewall \
  --direction in --protocol tcp --port 10250 \
  --source-ips "10.0.0.0/16" --description "Kubelet"

# Firewall an Server haengen
hcloud firewall apply-to-resource k8s-firewall \
  --type server --server k3s-master-1
hcloud firewall apply-to-resource k8s-firewall \
  --type server --server k3s-worker-1
hcloud firewall apply-to-resource k8s-firewall \
  --type server --server k3s-worker-2

K3s installieren

SSH auf den Master-Node und K3s starten. Wichtig: --disable servicelb weil wir den Hetzner LoadBalancer nutzen. --disable traefik falls ihr Ingress-NGINX oder einen anderen Controller bevorzugt.

# Auf k3s-master-1
ssh root@MASTER_IP

# K3s Server installieren
curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="\
  server \
  --disable servicelb \
  --disable traefik \
  --flannel-iface ens10 \
  --node-ip 10.0.1.2 \
  --advertise-address 10.0.1.2 \
  --tls-san MASTER_PUBLIC_IP \
  --tls-san 10.0.1.2 \
  --kubelet-arg cloud-provider=external \
  --write-kubeconfig-mode 644" sh -

# Token auslesen
cat /var/lib/rancher/k3s/server/node-token

--flannel-iface ens10 ist das Hetzner-interne Netzwerk-Interface. Damit laeuft der gesamte Cluster-Traffic ueber das private Netzwerk.

Worker hinzufuegen:

# Auf jedem Worker-Node
ssh root@WORKER_IP

curl -sfL https://get.k3s.io | K3S_URL="https://10.0.1.2:6443" \
  K3S_TOKEN="TOKEN_VOM_MASTER" \
  INSTALL_K3S_EXEC="\
  --flannel-iface ens10 \
  --node-ip 10.0.1.X \
  --kubelet-arg cloud-provider=external" sh -

Kubeconfig lokal einrichten:

# Kubeconfig vom Master kopieren
scp root@MASTER_PUBLIC_IP:/etc/rancher/k3s/k3s.yaml ~/.kube/hetzner-k3s.yaml

# Server-Adresse anpassen
sed -i '' "s/127.0.0.1/MASTER_PUBLIC_IP/" ~/.kube/hetzner-k3s.yaml

export KUBECONFIG=~/.kube/hetzner-k3s.yaml
kubectl get nodes

Hetzner Cloud Controller Manager (CCM)

Der CCM integriert Kubernetes mit Hetzner: LoadBalancer-Services provisionieren automatisch Hetzner Load Balancer, Node-Informationen (Region, Typ) werden als Labels gesetzt, geloeschte Server werden als Nodes entfernt.

# Secret mit Hetzner API-Token und Netzwerk
kubectl -n kube-system create secret generic hcloud \
  --from-literal=token=EUER_HCLOUD_TOKEN \
  --from-literal=network=k8s-net

# CCM deployen
kubectl apply -f https://github.com/hetznercloud/hcloud-cloud-controller-manager/releases/latest/download/ccm-networks.yaml

# Pruefen
kubectl -n kube-system get pods -l app=hcloud-cloud-controller-manager

Hetzner CSI Driver

Fuer Persistent Volumes braucht ihr den CSI Driver. Der erstellt automatisch Hetzner Volumes und haengt sie an Nodes.

kubectl apply -f https://raw.githubusercontent.com/hetznercloud/csi-driver/main/deploy/kubernetes/hcloud-csi.yml

# StorageClass pruefen
kubectl get storageclass
# NAME                 PROVISIONER          RECLAIMPOLICY
# hcloud-volumes       csi.hetzner.cloud    Delete

Test mit einem PVC:

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: test-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  storageClassName: hcloud-volumes
EOF

kubectl get pvc test-pvc
# STATUS: Bound -> funktioniert
kubectl delete pvc test-pvc

Erster Workload mit LoadBalancer

Jetzt testen wir die komplette Kette: Deployment, Service mit Hetzner LoadBalancer.

cat <<EOF | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-demo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx-demo
  template:
    metadata:
      labels:
        app: nginx-demo
    spec:
      containers:
      - name: nginx
        image: nginx:1.27-alpine
        ports:
        - containerPort: 80
        resources:
          requests:
            cpu: 50m
            memory: 64Mi
          limits:
            cpu: 100m
            memory: 128Mi
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-demo
  annotations:
    load-balancer.hetzner.cloud/location: fsn1
    load-balancer.hetzner.cloud/use-private-ip: "true"
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 80
  selector:
    app: nginx-demo
EOF

# Warten bis External-IP zugewiesen
kubectl get svc nginx-demo -w

Nach 30-60 Sekunden bekommt der Service eine oeffentliche IP. In der Hetzner Console seht ihr den erstellten Load Balancer.

Ingress-Controller nachruesten

Fuer mehrere Domains auf einem LoadBalancer:

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm install ingress-nginx ingress-nginx/ingress-nginx \
  --namespace ingress-nginx --create-namespace \
  --set controller.service.annotations."load-balancer\.hetzner\.cloud/location"=fsn1 \
  --set controller.service.annotations."load-balancer\.hetzner\.cloud/use-private-ip"="true"

Produktions-Checkliste

Bevor ihr echte Workloads drauf laufen lasst:

Backups: K3s-Snapshots mit k3s etcd-snapshot save (bei embedded etcd) oder SQLite-Backup per Cronjob
Monitoring: kube-prometheus-stack via Helm -- Hetzner-Metriken ueber Node-Exporter
Cert-Manager: Let's Encrypt Zertifikate automatisch per cert-manager
Updates: K3s-Updates ueber system-upgrade-controller automatisieren
Node-Redundanz: Mindestens 3 Control-Plane-Nodes fuer HA
Netzwerk-Policies: Standard-Deny-All als Baseline setzen

Typische Fehler und Loesungen

Nodes zeigen "NotReady": Meistens liegt es an --flannel-iface. Prueft mit ip a welches Interface das private Netzwerk hat. Bei neueren Hetzner-Images kann es enp7s0 statt ens10 sein.

LoadBalancer bleibt auf "Pending": CCM-Logs pruefen mit kubectl -n kube-system logs -l app=hcloud-cloud-controller-manager. Haeufigste Ursache: falscher API-Token oder Netzwerk-Name im Secret.

Volumes mounten nicht: CSI-Driver braucht das gleiche Secret wie der CCM. Prueft ob hcloud Secret in kube-system existiert und der Token stimmt.

FAQ

Lohnt sich Hetzner Kubernetes fuer Produktion?

Ja, wenn euer Team K3s administrieren kann. Die Server sind stabil, das Netzwerk schnell, und der Preis unschlagbar. Fuer Teams ohne Kubernetes-Erfahrung ist ein Managed Service (DOKS, GKE) die sicherere Wahl.

Wie viele Nodes brauche ich?

Ein Control-Plane-Node plus zwei Worker reichen zum Start. Fuer HA: drei Control-Plane-Nodes mit embedded etcd. K3s skaliert problemlos auf 50+ Nodes.

Kann ich Hetzner Robot (Dedicated) statt Cloud nutzen?

Ja, K3s laeuft auch auf Dedicated Servern. Ihr verliert aber CCM-Integration (kein automatischer LoadBalancer) und muesstet Networking (z.B. via WireGuard) selbst konfigurieren.

Wie aktualisiere ich K3s auf Hetzner?

Am besten mit dem system-upgrade-controller. Der rollt Updates Node fuer Node aus. Alternativ: manuell per curl -sfL https://get.k3s.io | sh - auf jedem Node, Master zuerst.

Was kostet ein produktives Setup realistisch?

Drei CX22 (11,97 EUR), ein Load Balancer (5,49 EUR), drei Volumes 20 GB (2,88 EUR) und Snapshots (ca. 2 EUR): rund 22 EUR pro Monat. Deutlich unter 100 EUR fuer ein vollstaendiges Setup mit Monitoring.

Wer Kubernetes auf Hetzner aufsetzen will, ohne Wochen in Konfiguration zu versenken: Schreibt mir. Ich helfe bei der Planung und Umsetzung -- von der ersten VM bis zum produktiven Cluster.

Weiterführende Artikel:

Hetzner Kubernetes Cluster erstellen: K3s Setup Guide