OKD-Cluster auf Hetzner

01 Realitaets-Check – bevor du anfaengst

Wenn das alles ok ist: Hetzner-Konto anlegen, ein Projekt erstellen, unter Security → API Tokens einen Token mit Read & Write erzeugen und sofort kopieren.

02 Voraussetzung: Server-Basis

Konto, API-Token, hcloud CLI, SSH-Key – einmalig, in einer eigenen Anleitung.

03 SSH-Key: der .pub-Inhalt

Der SSH-Key liegt schon bei Hetzner (Server-Basis). OKD braucht zusätzlich den Inhalt des öffentlichen Schlüssels – er kommt in die install-config (fuer den core-User auf FCOS).

Get-Content $env:USERPROFILE\.ssh\id_ed25519.pub    # Inhalt merken (fuer Schritt 6)

04 Privates Netz & Load Balancer

Die Nodes reden ueber ein privates Netz miteinander (etcd, API). Ein Hetzner Load Balancer ist der einzige oeffentliche Einstieg und verteilt auf die Control-Plane-Nodes.

hcloud network create --name okd-net --ip-range 10.128.0.0/16
hcloud network add-subnet okd-net --network-zone eu-central --type cloud --ip-range 10.128.0.0/24

hcloud load-balancer create --name okd-lb --type lb11 --location nbg1 --network-zone eu-central
hcloud load-balancer attach-to-network okd-lb --network okd-net

# Dienste: API, Machine-Config, Ingress
hcloud load-balancer add-service okd-lb --protocol tcp --listen-port 6443  --destination-port 6443
hcloud load-balancer add-service okd-lb --protocol tcp --listen-port 22623 --destination-port 22623
hcloud load-balancer add-service okd-lb --protocol tcp --listen-port 80    --destination-port 80
hcloud load-balancer add-service okd-lb --protocol tcp --listen-port 443   --destination-port 443

hcloud load-balancer describe okd-lb -o 'format={{.PublicNet.IPv4.IP}}'   # -> oben ins Feld "LoadBalancer-IP"

Die LB-Targets (die Nodes) haengen wir in Schritt 8 an, sobald sie existieren. lb11 reicht fuer ein Lab. Traffic ist bei Hetzner-LBs inklusive.

05 DNS ohne eigenen Server: nip.io

OpenShift verlangt, dass api.<cluster>.<domain> und *.apps.<cluster>.<domain> aufloesen. nip.io loest jede Subdomain von <ip>.nip.io auf genau diese IP (Internet Protocol) auf – also zeigt automatisch alles auf den Load Balancer.

Fuer echten Betrieb spaeter eine richtige Domain nehmen – z. B. seb4u.com, das schon als Full-Zone bei Cloudflare liegt (siehe Domain zu Cloudflare umziehen). Dort in der bestehenden Zone api.okd als A-Record + *.apps.okd als Wildcard-A-Record auf die LB-IP setzen. Beide Records „DNS only“ (grau) – ein proxied Wildcard braucht Cloudflare Enterprise, und der OKD-Router macht TLS (Transport Layer Security) selbst.

06 Bastion + install-config.yaml

Eine kleine Wegwerf-VM erzeugt die Ignition-Dateien und stellt sie den Nodes bereit.

hcloud server create --name okd-bastion --type cpx22 --image ubuntu-24.04 `
  --ssh-key laptop --network okd-net
$bastion = (hcloud server ip okd-bastion).Trim()
ssh root@$bastion

OKD=$(curl -s https://api.github.com/repos/okd-project/okd/releases/latest | grep -oP '"tag_name": "\K[^"]+')
cd /root
curl -L "https://github.com/okd-project/okd/releases/download/$OKD/openshift-install-linux-$OKD.tar.gz" | tar xz
curl -L "https://github.com/okd-project/okd/releases/download/$OKD/openshift-client-linux-$OKD.tar.gz"  | tar xz
mv oc kubectl openshift-install /usr/local/bin/
mkdir -p /root/okd && cd /root/okd

apiVersion: v1
baseDomain: <lb-ip>.nip.io
metadata:
  name: lab
controlPlane:
  name: master
  replicas: 3
compute:
- name: worker
  replicas: 0
networking:
  networkType: OVNKubernetes
  machineNetwork:
  - cidr: 10.128.0.0/24
  clusterNetwork:
  - cidr: 10.132.0.0/14
    hostPrefix: 23
  serviceNetwork:
  - 172.30.0.0/16
platform:
  none: {}
pullSecret: '{"auths":{"fake":{"auth":"aWQ6cGFzcwo="}}}'
sshKey: 'ssh-ed25519 AAAA... (Inhalt deiner id_ed25519.pub)'

07 Manifeste & Ignition erzeugen

Aus der install-config werden die Boot-Konfigurationen. Vorher sichern – openshift-install verbraucht die Datei.

cd /root/okd
cp install-config.yaml install-config.yaml.bak

# Control-Plane schedulebar machen (kompakter Cluster):
openshift-install create manifests
sed -i 's/mastersSchedulable: false/mastersSchedulable: true/' manifests/cluster-scheduler-02-config.yml

openshift-install create ignition-configs
python3 -m http.server 8080 &      # serviert bootstrap.ign / master.ign

# FCOS-Image-URL passend zum Installer:
openshift-install coreos print-stream-json | grep -oP 'https://[^"]+qemu[^"]+x86_64[^"]+\.xz' | head -1

08 Nodes erstellen & FCOS schreiben

1 Bootstrap + 3 Master. Jede VM (virtuelle Maschine) startet im Rescue-Modus, coreos-installer schreibt Fedora CoreOS mit der passenden Ignition auf die Platte, dann Neustart ins fertige System.

# Beispiel: bootstrap (dann master-0/1/2 mit --type ccx33 und passender .ign)
hcloud server create --name okd-bootstrap --type cpx42 --image ubuntu-24.04 `
  --ssh-key laptop --network okd-net --start-after-create=false
hcloud server enable-rescue okd-bootstrap --ssh-key laptop
hcloud server poweron okd-bootstrap
$n = (hcloud server ip okd-bootstrap).Trim()

FCOS_URL="https://.../fedora-coreos-...-metal.x86_64.raw.xz"   # aus Schritt 7
BASTION_PRIV=10.128.0.2                                        # private IP der Bastion

podman run --privileged --rm --pull=always -v /dev:/dev -v /run/udev:/run/udev \
  quay.io/coreos/coreos-installer:release install /dev/sda \
  --image-url "$FCOS_URL" --insecure \
  --ignition-url "http://$BASTION_PRIV:8080/bootstrap.ign" --insecure-ignition

reboot

hcloud load-balancer add-target okd-lb --server okd-bootstrap --use-private-ip
# spaeter fuer master-0/1/2 dasselbe; Bootstrap nach Schritt 9 wieder entfernen

09 Bootstrap abwarten

cd /root/okd
openshift-install wait-for bootstrap-complete --log-level=info
# ~15-25 Min. Wenn "It is now safe to remove the bootstrap resources":

hcloud load-balancer remove-target okd-lb --server okd-bootstrap
hcloud server delete okd-bootstrap

10 Installation abschliessen & oc login

openshift-install wait-for install-complete
# druckt am Ende Console-URL und das kubeadmin-Passwort
cat /root/okd/auth/kubeadmin-password

scp root@$bastion:/root/okd/auth/kubeconfig $env:USERPROFILE\.kube\okd-hetzner.yaml
$env:KUBECONFIG = "$env:USERPROFILE\.kube\okd-hetzner.yaml"
oc get nodes
oc get clusteroperators        # alles "Available=True"?

# Bastion wird nicht mehr gebraucht:
hcloud server delete okd-bastion

11 Projekt, Route, Storage

oc new-project demo
oc new-app --image=docker.io/library/nginx --name=web
oc expose deployment/web --port=80
oc expose service/web        # Route auf web-demo.apps.lab.<lb-ip>.nip.io
oc get route

+ Worker hinzufuegen

Mehr Kapazitaet, ohne die Control-Plane zu belasten.

# neue VM, Rescue, coreos-installer mit worker.ign (von der Bastion – oder .ign vorher sichern!)
hcloud server create --name okd-worker-1 --type ccx33 --image ubuntu-24.04 `
  --ssh-key laptop --network okd-net --start-after-create=false
# ... Rescue + coreos-installer --ignition-url .../worker.ign + reboot

oc get csr -o name | ForEach-Object { oc adm certificate approve ($_ -replace 'certificatesigningrequest.certificates.k8s.io/','') }
oc get nodes        # der neue Worker erscheint nach 1-2 Min als Ready

Die worker.ign zeigt auf den Machine-Config-Server (:22623 ueber den LB) – die muss also erreichbar bleiben. worker.ign aus Schritt 7 vorher wegsichern, da die Bastion geloescht wurde.

+ Kosten: abreissen & neu aufbauen

Einen laufenden Cluster kann man nicht „pausieren“ – die 3 Server kosten durchgehend. Realistischer Spar-Weg: komplett loeschen, bei Bedarf in ~45 Min neu installieren (Schritte 6–10). Das Skript raeumt alles ab.

Richtwerte 2026 (CCX33 grob, aktuell: hcloud server-type describe CCX33). .\scripts\cluster.ps1 down loescht Server, LB und Netz – alle Uhren stoppen sofort. Ein vergessenes Wochenende (Fr–Mo) sind ~40 €. Deshalb ist das naechtliche Auto-Teardown hier der wichtigste Schutz.

.\scripts\cluster.ps1 status   # was laeuft, ~Kosten
.\scripts\cluster.ps1 down     # alle okd-* Server + LB + Netz loeschen

#Requires -Version 5.1
param([ValidateSet('down','status')][string]$Action = 'status')
# Kein globales 'Stop': hcloud und ssh schreiben Hinweise ("Server not found",
# Fortschritt) nach stderr - PowerShell 5.1 wertet das unter 'Stop' als Abbruch.
$ErrorActionPreference = 'Continue'
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12

$Prefix = 'okd-'
# Stundensaetze (EUR): aus scripts/rates.psd1 - eine Quelle wie cloud.ps1 / snapshot.ps1.
$RatesFile = Join-Path $PSScriptRoot 'rates.psd1'
$Rate = if (Test-Path $RatesFile) { Import-PowerShellDataFile $RatesFile }
        else { @{ cpx22 = 0.0267; cpx42 = 0.0952; cpx52 = 0.1377   # Fallback (Stand nach 15.06.2026)
                  ccx13 = 0.0589; ccx23 = 0.1178; ccx33 = 0.1897 } }

function Cluster-Servers {
  hcloud server list -o json | ConvertFrom-Json | Where-Object { $_.name -like "$Prefix*" }
}

function Show-Status {
  $srv = Cluster-Servers
  if (-not $srv) { Write-Host 'AUS - keine okd-* Server.' -ForegroundColor Green; return }
  $sum = 0.0
  foreach ($s in $srv) {
    $age = (Get-Date).ToUniversalTime() - ([datetime]$s.created).ToUniversalTime()
    $r = $Rate[$s.server_type.name]; if ($r) { $sum += $age.TotalHours * $r }
    Write-Host ("  {0,-16} {1,-8} seit {2:0.0} h" -f $s.name, $s.server_type.name, $age.TotalHours)
  }
  $lb = hcloud load-balancer list -o json | ConvertFrom-Json | Where-Object { $_.name -like "$Prefix*" }
  Write-Host ("`n{0} Server + {1} LB   ~{2:N2} EUR bisher (nur Server)" -f $srv.Count, $lb.Count, $sum) -ForegroundColor Yellow
}

function Invoke-Down {
  Cluster-Servers | ForEach-Object { Write-Host "delete $($_.name)"; hcloud server delete $_.name | Out-Null }
  hcloud load-balancer list -o json | ConvertFrom-Json | Where-Object { $_.name -like "$Prefix*" } |
    ForEach-Object { hcloud load-balancer delete $_.name | Out-Null }
  hcloud network list -o json | ConvertFrom-Json | Where-Object { $_.name -like "$Prefix*" } |
    ForEach-Object { hcloud network delete $_.name | Out-Null }
  [Environment]::SetEnvironmentVariable('KUBECONFIG', $null, 'User')
  Write-Host "`nAlles abgerissen. Kosten gestoppt." -ForegroundColor Green
}

switch ($Action) { 'down' { Invoke-Down } 'status' { Show-Status } }

.\scripts\install-autodown.ps1 -For cluster   # legt die Aufgabe "OKD Auto-Teardown" an

+ Absicherung

• Nodes ohne oeffentlichen Zugang: nach der Installation die Public-IPs der Master entfernen (hcloud server …) – Egress dann ueber ein NAT-Gateway oder Hetzners --without-ipv4 + IPv6 (Internet Protocol Version 6). Zugang nur noch ueber den LB und die Bastion.
• LB-Firewall: 6443 und die Console (443) auf deine IP beschraenken, solange nichts oeffentlich sein muss (Hetzner-LB unterstuetzt keine Source-IP-Filter – dafuer eine Cloud-Firewall vor die Nodes, oder haproxy statt LB).
• kubeadmin abschaffen: nach dem ersten echten OAuth-IdP (htpasswd, GitHub, …) den kubeadmin-Secret loeschen.
• Updates: oc adm upgrade – OKD zieht neue Releases aus dem eigenen Update-Graphen.
• etcd-Backup: oc debug node/… → /usr/local/bin/cluster-backup.sh regelmaessig laufen lassen.

+ Kill-Switch

Anders als bei den Ein-Node-Anleitungen gibt es kein Snapshot-und-zurueck: ein Cluster mit geaenderten Node-IPs ist kaputt. Der Kill-Switch hier ist deshalb komplett abreissen (Skript in Schritt 13) plus naechtliches Auto-Teardown. Neu aufbauen = Schritte 6–10, ~45 Minuten.

+ Andere Wege zu echtem OpenShift

Managed OpenShift – jemand betreibt die Control-Plane

Reihenfolge der Anleitungen nach Aufwand: Podman/Docker → k3s → OKD Single-Node → dieser OKD-Cluster. Fang klein an.