Einen Kubernetes-Cluster im eigenen Homelab einrichten

Kubernetes im eigenen Homelab zu betreiben, ist eine hervorragende Möglichkeit, Container-Orchestrierung zu lernen, Anwendungen zu testen und produktionsreife Fähigkeiten aufzubauen. In diesem Leitfaden stellen wir einen K3s-Cluster auf Proxmox mit mehreren Nodes und Hochverfügbarkeit bereit.

Warum K3s?

K3s ist eine leichtgewichtige Kubernetes-Distribution, perfekt für Homelabs:

Leichtgewichtig: Verbraucht nur 512 MB RAM
Einfache Installation: Eine einzelne Binärdatei, keine komplexen Abhängigkeiten
Vollständiges Kubernetes: 100 % kompatibel mit Upstream-Kubernetes
Integrierte Features: Enthält Traefik, CoreDNS und lokalen Storage

Architekturübersicht

Wir erstellen einen 3-Node-Cluster:

1 Control-Plane-Node: Verwaltet den Cluster
2 Worker-Nodes: Führen Anwendungs-Workloads aus

┌─────────────────┐
│  Control Plane  │
│   192.168.1.10  │
└────────┬────────┘
         │
    ┌────┴────┐
    │         │
┌───▼───┐ ┌──▼────┐
│Worker1│ │Worker2│
│  .11  │ │  .12  │
└───────┘ └───────┘

Voraussetzungen

Proxmox VE installiert und konfiguriert
3 VMs oder LXC-Container (Ubuntu 22.04 empfohlen)
Mindestens 2 GB RAM pro Node (4 GB empfohlen)
2 CPU-Kerne pro Node
20 GB Storage pro Node

Die Nodes vorbereiten

VMs in Proxmox erstellen

Erstellen Sie für jeden Node eine VM mit:

# CPU: 2 cores
# RAM: 4GB
# Disk: 20GB
# Network: Bridge to vmbr0

Ubuntu Server installieren

Von der Ubuntu-Server-ISO booten
Den Installationsassistenten durchlaufen
OpenSSH-Server installieren
Das System aktualisieren:

sudo apt update && sudo apt upgrade -y

Statische IP-Adressen konfigurieren

Bearbeiten Sie /etc/netplan/00-installer-config.yaml:

network:
  version: 2
  ethernets:
    ens18:
      addresses:
        - 192.168.1.10/24  # Change for each node
      gateway4: 192.168.1.1
      nameservers:
        addresses: [192.168.1.1, 8.8.8.8]

Konfiguration anwenden:

sudo netplan apply

Swap deaktivieren

Kubernetes erfordert, dass Swap deaktiviert ist:

sudo swapoff -a
sudo sed -i '/ swap / s/^/#/' /etc/fstab

Hostnamen konfigurieren

Setzen Sie für jeden Node einen eindeutigen Hostnamen:

# Control plane
sudo hostnamectl set-hostname k3s-master

# Worker nodes
sudo hostnamectl set-hostname k3s-worker1
sudo hostnamectl set-hostname k3s-worker2

Aktualisieren Sie /etc/hosts auf allen Nodes:

192.168.1.10    k3s-master
192.168.1.11    k3s-worker1
192.168.1.12    k3s-worker2

K3s installieren

Control Plane installieren

Führen Sie auf dem Master-Node Folgendes aus:

curl -sfL https://get.k3s.io | sh -s - server \
  --write-kubeconfig-mode 644 \
  --disable traefik \
  --node-name k3s-master

Hinweis: Wir deaktivieren Traefik, um es später manuell mit benutzerdefinierter Konfiguration zu installieren.

Installation überprüfen:

sudo kubectl get nodes

Node-Token für die Worker abrufen:

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

Speichern Sie dieses Token; Sie benötigen es für die Worker-Nodes.

Worker-Nodes installieren

Führen Sie auf jedem Worker-Node Folgendes aus:

curl -sfL https://get.k3s.io | K3S_URL=https://192.168.1.10:6443 \
  K3S_TOKEN=YOUR_NODE_TOKEN \
  sh -s - agent \
  --node-name k3s-worker1  # Change for each node

Ersetzen Sie YOUR_NODE_TOKEN durch das Token vom Master-Node.

Cluster überprüfen

Auf dem Master-Node:

kubectl get nodes

Sie sollten alle drei Nodes im Zustand „Ready" sehen:

NAME          STATUS   ROLES                  AGE   VERSION
k3s-master    Ready    control-plane,master   5m    v1.27.3+k3s1
k3s-worker1   Ready    <none>                 2m    v1.27.3+k3s1
k3s-worker2   Ready    <none>                 2m    v1.27.3+k3s1

kubectl-Zugriff konfigurieren

Zugriff von der lokalen Maschine

Kopieren Sie die kubeconfig vom Master-Node:

# On master node
sudo cat /etc/rancher/k3s/k3s.yaml

Auf Ihrer lokalen Maschine:

mkdir -p ~/.kube
# Paste the content and update the server IP
nano ~/.kube/config

Ändern Sie server: https://127.0.0.1:6443 zu server: https://192.168.1.10:6443

Verbindung testen:

kubectl get nodes

Wichtige Komponenten installieren

Helm-Paketmanager

Installieren Sie Helm auf Ihrer lokalen Maschine:

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

MetalLB Load Balancer

Für Bare-Metal-LoadBalancer-Unterstützung:

kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.13.12/config/manifests/metallb-native.yaml

IP-Pool-Konfiguration erstellen:

# metallb-config.yaml
apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: default
  namespace: metallb-system
spec:
  addresses:
  - 192.168.1.200-192.168.1.250
---
apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: default
  namespace: metallb-system
spec:
  ipAddressPools:
  - default

Konfiguration anwenden:

kubectl apply -f metallb-config.yaml

Traefik Ingress Controller

Installieren Sie Traefik mit Helm:

helm repo add traefik https://traefik.github.io/charts
helm repo update

helm install traefik traefik/traefik \
  --namespace traefik \
  --create-namespace \
  --set service.type=LoadBalancer

Traefik-LoadBalancer-IP abrufen:

kubectl get svc -n traefik

Cert-Manager

Für automatische TLS-Zertifikate:

kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.13.3/cert-manager.yaml

Longhorn Storage

Verteilter Block-Storage für Kubernetes:

helm repo add longhorn https://charts.longhorn.io
helm repo update

helm install longhorn longhorn/longhorn \
  --namespace longhorn-system \
  --create-namespace

Zugriff auf die Longhorn-UI:

kubectl -n longhorn-system port-forward svc/longhorn-frontend 8080:80

Besuchen Sie http://localhost:8080

Eine Testanwendung bereitstellen

Erstellen Sie ein Test-Deployment:

# nginx-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-demo
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: LoadBalancer
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80

Bereitstellen:

kubectl apply -f nginx-deployment.yaml
kubectl get svc nginx-service

Greifen Sie über die LoadBalancer-IP auf die Anwendung zu.

Monitoring mit Prometheus

kube-prometheus-stack installieren:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace

Zugriff auf Grafana:

kubectl port-forward -n monitoring svc/prometheus-grafana 3000:80

Standard-Zugangsdaten: admin / prom-operator

Best Practices

Resource Limits

Setzen Sie immer Resource Requests und Limits:

resources:
  requests:
    memory: "64Mi"
    cpu: "250m"
  limits:
    memory: "128Mi"
    cpu: "500m"

Namespace-Organisation

Verwenden Sie Namespaces, um Workloads zu organisieren:

kubectl create namespace production
kubectl create namespace development

Backup-Strategie

Regelmäßige Backups mit Velero:

helm repo add vmware-tanzu https://vmware-tanzu.github.io/helm-charts
helm install velero vmware-tanzu/velero \
  --namespace velero \
  --create-namespace

Troubleshooting

Pod startet nicht

kubectl describe pod POD_NAME
kubectl logs POD_NAME

Node nicht bereit

kubectl describe node NODE_NAME
sudo systemctl status k3s
sudo journalctl -u k3s -f

Netzwerkprobleme

kubectl get pods -n kube-system
kubectl logs -n kube-system COREDNS_POD

Nächste Schritte

GitOps mit ArgoCD implementieren
CI/CD-Pipelines einrichten
Horizontales Pod-Autoscaling konfigurieren
Network Policies implementieren
Service Mesh bereitstellen (Istio/Linkerd)

Fazit

Sie haben jetzt einen voll funktionsfähigen Kubernetes-Cluster in Ihrem Homelab am Laufen! Dieses Setup bietet eine solide Grundlage, um mit Cloud-native-Technologien zu lernen und zu experimentieren.

Newsletter abonnieren