Kubernetes on Hetzner Using Bare Metal Servers as Nodes

tutorials/kubernetes-on-hetzner-using-bare-metal-servers/01.de.md

@@ -0,0 +1,284 @@
+---
+SPDX-License-Identifier: MIT
+path: "/tutorials/kubernetes-on-hetzner-using-bare-metal-servers/de"
+slug: "kubernetes-on-hetzner-using-bare-metal-servers"
+date: "2025-01-17"
+title: "Kubernetes auf Hetzner: Bare-Metal-Server als Nodes effizient nutzen"
+short_description: "So nutzt du Hetzners Bare-Metal-Server, um Kubernetes-Cluster effizient mit der Cluster API zu erstellen und zu verwalten – maximale Leistung, minimale Kosten!"
+tags: ["Kubernetes", "Hetzner Cloud", "bare-metal", "dedicated", "Lang:YAML"]
+author: "Syself"
+author_link: "https://github.com/syself"
+author_img: "https://avatars.githubusercontent.com/u/61753714"
+author_description: "Company focused on managed Kubernetes on Hetzner"
+language: "de"
+available_languages: ["en", "de"]
+header_img: "header-4"
+cta: "cloud"
+---
+
+## 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)](https://github.com/syself/cluster-api-provider-hetzner) 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](https://docs.docker.com/engine/install/), um Container auszuführen
+- [Kind](https://kind.sigs.k8s.io/docs/user/quick-start#installation), um ein lokales Kubernetes-Cluster zu erstellen
+- [kubectl](https://kubernetes.io/docs/tasks/tools/#kubectl) und [clusterctl](https://cluster-api.sigs.k8s.io/user/quick-start#install-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:
+
+```shell
+# 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:
+
+```shell
+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:
+
+```shell
+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](https://cluster-api.sigs.k8s.io/user/concepts) und [CAPH](https://syself.com/docs/caph/reference/introduction) 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.
+
+```yaml
+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:
+
+```shell
+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:
+
+```shell
+# 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](https://syself.com/docs/caph/topics/baremetal/introduction#flavors-of-hetzner-baremetal).
+
+> **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:
+
+```shell
+# 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.
+
+```shell
+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`:
+
+```bash
+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:
+
+```yaml
+        - 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:
+
+```shell
+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:
+
+```shell
+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](https://github.com/syself/cluster-api-provider-hetzner) und der [Dokumentation](https://syself.com/docs/caph).
+
+## 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
+
+<!--
+
+Contributor's Certificate of Origin
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I have
+  the right to submit it under the license indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best of my
+  knowledge, is covered under an appropriate license and I have the
+  right under that license to submit that work with modifications,
+  whether created in whole or in part by me, under the same license
+  (unless I am permitted to submit under a different license), as
+  indicated in the file; or
+
+(c) The contribution was provided directly to me by some other person
+  who certified (a), (b) or (c) and I have not modified it.
+
+(d) I understand and agree that this project and the contribution are
+  public and that a record of the contribution (including all personal
+  information I submit with it, including my sign-off) is maintained
+  indefinitely and may be redistributed consistent with this project
+  or the license(s) involved.
+
+Signed-off-by: Lucas Rattz <[email protected]>
+
+-->