Warum ist Kubernetes in der Cloud-Native-Welt so wichtig ist?
Kubernetes (K8s) ist das Betriebssystem der modernen Cloud. Es orchestriert deine Container, automatisiert Deployments, skaliert deine Anwendungen bei Bedarf – und sorgt dafür, dass alles stabil läuft, selbst wenn einzelne Teile ausfallen.

In einer Welt, in der Software ständig schneller, verteilter und dynamischer wird, bietet Kubernetes genau das, was du brauchst: Selbstheilung, Skalierbarkeit, Portabilität – und das Ganze plattformunabhängig, ob in der Cloud oder On-Premises.

Cloud-Native bedeutet: flexibel, robust, automatisiert – und Kubernetes ist das Fundament dafür. Es macht dich unabhängig von Cloud-Anbietern, gibt dir die volle Kontrolle über deine Infrastruktur und öffnet die Tür zu einem riesigen Ökosystem moderner Tools wie Prometheus, Helm oder GitOps.

Jetzt geht loos!

1. Voraussetzungen

1. Drei Ubuntu-Server (VMs oder physisch) mit Ubuntu Server und Root-Rechten
2. SSH-Zugang zu allen Hosts (Passwort oder SSH-Key)
3. Lokaler Rechner mit installiertem Git

1.2. Ubuntu Server mit SSH-Server einrichten

1.2.1 Voraussetzungen

• Ubuntu 20.04, 22.04 oder neuer (Server oder Desktop)
• Root-Zugang oder ein Benutzer mit sudo-Rechten

1.2.2 OpenSSH-Server installieren

sudo apt update

sudo apt install openssh-server -y

1.2.3 Überprüfen, ob der SSH-Dienst läuft

sudo systemctl status ssh

Du solltest eine Ausgabe sehen wie:

● ssh.service - OpenBSD Secure Shell server

   Active: active (running)

Falls nicht:

sudo systemctl enable --now ssh

1.2.4 IP-Adresse des Servers ermitteln

Damit du dich später verbinden kannst:

ip a

Oder:

hostname -I

Notiere dir die IP-Adresse des Netzwerkschnittstelle z. B. 192.168.1.100

1.2.5 SSH-Server sicher konfigurieren (optional, aber empfohlen)

Die Konfigurationsdatei liegt unter:

sudo nano /etc/ssh/sshd_config

Hier ein sicherer Basissatz an Einstellungen:

PermitRootLogin no

PasswordAuthentication no

PermitEmptyPasswords no

ChallengeResponseAuthentication no

UsePAM yes

X11Forwarding no

AllowUsers andrej

💡 Wichtig: Nur PasswordAuthentication no setzen, wenn Public-Key-Login funktioniert, sonst sperrst du dich aus.

Änderungen übernehmen:

sudo systemctl reload ssh

1.2.6 Firewall konfigurieren (UFW – falls aktiv)

sudo ufw allow OpenSSH

sudo ufw enable

🔒 Das erlaubt eingehende Verbindungen auf Port 22 (Standard für SSH).

1.2.7 Verbindung testen

Auf deinem lokalen Rechner (Linux, macOS oder Git-Bash / PuTTY unter Windows):

ssh kubernete@192.168.1.100

Wenn alles richtig eingerichtet ist, solltest du direkt verbunden werden – entweder über Passwort oder über den SSH-Key.

1.2.8 Bonus: Port ändern (für Sicherheit durch Verschleierung)

Ändere in /etc/ssh/sshd_config:

Port 2222

Dann:

sudo ufw allow 2222/tcp

sudo systemctl restart ssh

Und künftig so verbinden:

ssh -p 2222 andrej@192.168.1.100

1.2.9 Tipps zur Sicherheit

1.3. Repository klonen und Umgebung vorbereiten

Bevor wir mit der Installation beginnen können, müssen wir das K3Nova-Repository klonen. Dieses enthält die vorkompilierte Binary sowie alle notwendigen Konfigurationsdateien, die für die Einrichtung des Clusters erforderlich sind.

Führe dazu die folgenden Befehle aus:

# Klone das k3s_installation-Repository

git clone https://github.com/AndrejSchefer/K3Nova.git

cd K3Nova

Im Verzeichnis K3Nova findest du:

• die K3Nova-Binaries, mit der du die Cluster-Installation über die Kommandozeile steuern kannst.
• Die vorbereitete Konfigurationsdateien (z. B. config/k3nova-config.json.tpl), mit denen du das Setup deines Clusters individuell anpassen kannst

1.4. Konfiguration anpassen

Erstelle aus der Vorlage config/k3nova-config.json.tpl eine Datei config/k3nove-config.json und trage die Zugangsdaten für einen Master und zwei Worker ein. Beispiel:

{
  "masters": [
    {
      "ip": "192.168.56.10",        # Master node IP address
      "ssh_user": "ubuntu",         # SSH user for master
      "ssh_pass": "yourpassword",    # SSH password for master
      "cluster_init": false
    }
  ],
  "workers": [
    {
      "ip": "192.168.56.11",         # Worker node 1 IP address
      "ssh_user": "ubuntu",          # SSH user for worker
      "ssh_pass": "yourpassword",    # SSH password for worker
      "cluster_init": false
    },
    {
      "ip": "192.168.56.12",        # Worker node 2 IP address
      "ssh_user": "ubuntu",         # SSH user for worker
      "ssh_pass": "yourpassword",    # SSH password for worker
      "cluster_init": false
    }
  ],
  "k3s_token_file": "master-node-token",  # Path to token file
  "docker_registry": {
    "url": "registry.local",
    "pvc_storagy_capacity": "10Gi",
    "pass": "123456",
    "user": "registry",
    "local": true
  },
  "redis": {
    "url": "redis.local",
    "pvc_storage_capacity": "10Gi",
    "pass": "123456",
    "user": "registry",
    "image": "redis:8.0.2",
    "local": true
  },
  "nfs": {
    "network_CIDR": "192.168.179.0/24",
    "nfs_server": "192.168.179.12",
    "nfs_user": "kubernetes",
    "nfs_pass": "123456",
    "server": "10.0.0.10",
    "export": "/mnt/k3s-nfs-localstorage",
    "capacity": "100Gi"
    },
    "email": "public@andrejschefer.de",
    "domain": "igneos.cloud",
    "cluster_issuer_name": "letsencrypt-prod"
}

2. Installiere eine Control-Plane und zwei worker

Nachdem du das Repository erfolgreich geklont hast, kannst du nun die K3Nova-Binary für dein Betriebssystem ausführbar machen und starten. Im folgenden Beispiel zeigen wir, wie du die Linux-Version (k3nova-linux-amd64) einrichtest:

# Am Beispiel Linux

mv k3nova-linux-amd64 k3nova 

chmod +x k3nova

./k3nova

• Zuerst wird die heruntergeladene Binary umbenannt, um sie einfacher per Befehl auszuführen (mv).
• Anschließend wird die Datei mit chmod +x ausführbar gemacht.
• Mit ./k3nova startest du das Tool direkt im Terminal.

Nach dem Start führt dich K3Nova interaktiv oder konfigurationsbasiert durch die Clusterinstallation. Stelle sicher, dass die zugehörige config/k3nova-config.json im selben Verzeichnis liegt – sie definiert, wie der Cluster aufgebaut werden soll (z. B. Control Planes, Worker, NFS, Registry, Monitoring etc.).

2.1 Installiere K3s Master (Control Plane)

2.1.1 Manuelle Installation der K3s Control Plane (Single-Node)

Auf dem ersten Master-Node (192.168.56.10) installieren wir K3s in der Rolle einer eigenständigen Control Plane. Dafür verwenden wir das offizielle Installationsskript von K3s und geben dabei gezielt Parameter mit, um die Sicherheit und Nutzbarkeit der Umgebung zu erhöhen:

curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="--write-kubeconfig-mode=644 --secrets-encryption" sh -s - server    

Wichtige Parameter im obigen Befehl:

• --write-kubeconfig-mode=644 erlaubt nicht-root Nutzern auf dem Master, die erzeugte kubeconfig (/etc/rancher/k3s/k3s.yaml) zu lesen. So können Sie später als normaler Benutzer mit kubectl arbeiten, ohne Root-Rechte.
• --secrets-encryption aktiviert die Verschlüsselung von Kubernetes-Secrets (in etcd/SQLite) auf dem Server. k3s generiert dabei automatisch einen AES-Schlüssel und ein Encryption-Config, das dem API-Server übergeben wird (Secrets Encryption | K3s). Diese Einstellung sorgt dafür, dass vertrauliche Daten (Secrets) auch im etcd-Storage verschlüsselt vorliegen.

2.1.2 Alternative: K3s-Master-Installation mit dem K3Nova

Anstatt die K3s-Control-Plane manuell mit dem offiziellen Skript zu installieren, kann die Einrichtung auch vollständig automatisiert über das CLI-Tool K3Nova erfolgen. Dieses Tool wurde entwickelt, um sowohl einfache als auch hochverfügbare K3s-Cluster schnell, reproduzierbar und sicher zu installieren.

Um einen K3s Master-Node auf 192.168.56.10 zu installieren und gleichzeitig die kube-config auf Ihrem lokalen Rechner (/home/user/.kube/config) für den sofortigen kubectl-Zugriff einzurichten, wähle bitte den Menüpunkt „Install Kubernetes Master“ in K3Nova. Der K3Nova führt automatisch die Befehle aus die du manuell oben ausgeführt hast

2.1.2.1 Installationsablauf

Nach dem Start des Installers mit:

./K3Nova

öffnet sich ein interaktives Terminalmenü. Dort kannst du auswählen, ob du:

• einen einzelnen Master installieren möchtest
• einen vollständigen Cluster mit Master-, Worker-, Monitoring-, Registry- und Storage-Komponenten aufsetzen willst
• oder ein hochverfügbares K3s-Cluster mit mehreren Control-Plane-Knoten konfigurieren möcht est

Sobald du im Tool die Option „Install Kubernetes Master“ auswählst, startet K3Nova automatisch den Installationsprozess. Dabei wird eine sichere SSH-Verbindung zum Zielserver aufgebaut, über die alle erforderlichen Befehle remote ausgeführt werden.

Im Hintergrund verwendet K3Nova nahezu denselben Befehl wie bei einer manuellen K3s-Installation – mit einem entscheidenden Unterschied: Statt des standardmäßig mitgelieferten Traefik-Ingress-Controllers richtet K3Nova eine erweiterte Traefik-Variante ein, die sowohl TCP- als auch UDP-Ingress unterstützt. Aus diesem Grund wird Traefik zunächst über den Parameter --disable=traefik deaktiviert:

curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="--write-kubeconfig-mode=644 --secrets-encryption --disable=traefik" sh -s - server

Diese Konfiguration sorgt dafür, dass die erzeugte kubeconfig für nicht-root-Nutzer lesbar ist und dass Secrets im Cluster verschlüsselt gespeichert werden.

2.1.2.2 Was bedeutet „Advanced Traefik“ in K3Nova?

Standardmäßig installiert K3s beim Setup automatisch eine einfache Traefik-Konfiguration als Ingress-Controller. Diese reicht für viele Webanwendungen aus, ist jedoch auf HTTP(S)-Ingress beschränkt. Sobald man Dienste wie Redis, PostgreSQL, MQTT oder andere Protokolle auf TCP/UDP-Basis absichern oder veröffentlichen möchte, stößt diese Standardinstallation an ihre Grenzen.

K3Nova geht hier bewusst einen Schritt weiter – und setzt auf eine erweiterte („advanced“) Traefik-Installation, die folgende Vorteile bietet:

~/.kube/config

kubectl get nodes

# Auf dem Master Node (192.168.56.10): Token auslesen
cat /var/lib/rancher/k3s/server/node-token
# Beispielausgabe (nicht real verwenden):
K1066b9f4e97c2e87ea47d6facf56e76828e62198e1f908d58e29cce355956f9c::server:37c672b9c9d3f9f4dce7f297bef856d1

# Auf dem Worker-Node ausführen (Master-IP und Token einsetzen):
curl -sfL https://get.k3s.io | K3S_URL="https://<MASTER_IP>:6443" K3S_TOKEN="<TOKEN>" sh -s - agent

# Zurück auf dem Master (mit gesetztem KUBECONFIG):

kubectl get nodes -o wide

curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="server --cluster-init --write-kubeconfig-mode=644 --secrets-encryption" sh -

sudo cat /var/lib/rancher/k3s/server/token

curl -sfL https://get.k3s.io | INSTALL_K3S_EXEC="server \
  --server https://192.168.56.10:6443 \
  --token <TOKEN> \
  --write-kubeconfig-mode=644 \
  --secrets-encryption" sh -

kubectl get nodes

{
  "control_planes": [
    {
        "ip": "192.168.179.10",
        "ssh_user": "kubernetes",
        "ssh_pass": "123456",
        cluster_init": true          # set true for insta
    },
    {
        "ip": "192.168.179.11",
        "ssh_user": "kubernetes",
        "ssh_pass": "123456",
        "cluster_init": false
    },
    {
        "ip": "192.168.179.14",
        "ssh_user": "kubernetes",
        "ssh_pass": "123456",
        "cluster_init": false
    }
],
  "workers": [
    {
      "ip": "192.168.56.11",        
      "ssh_user": "kubernetes",         
      "ssh_pass": "123456",
      "cluster_init": false
    },
    {
      "ip": "192.168.56.12",       
      "ssh_user": "ubuntu",        
      "ssh_pass": "yourpassword",  
      "cluster_init": false
    }
  ],
}

kubectl get nodes