software

Kubernetes zu Hause: Mini-K8s mit k3s

Kubernetes zu Hause mit k3s: Leichtgewichtiges K8s in 5 Minuten installieren. Praxis-Guide für Self-Hosting und Home-Lab.

von Ultrion Redaktion2026-08-075 Min Lesezeit
Werbung (AdSense — In-Article)


Kubernetes zu Hause: Mini-K8s mit k3s

Kubernetes gilt als komplex und ressourcenhungrig. k3s von Rancher ändert das: Ein leichtgewichtiges K8s, das auf einem Raspberry Pi läuft. Wir zeigen, wie Sie es zu Hause einsetzen.

Was ist k3s?

k3s ist eine Lightweight-Version von Kubernetes, entwickelt von Rancher (jetzt SUSE). Es ist:

  • Ein einzelnes Binary (~70 MB)

  • Volle K8s-Kompatibilität (CNCF-zertifiziert)

  • Ressourcenschonend (ab 512 MB RAM)

  • Einfach zu installieren (ein Befehl)

  • Ideal für Edge, IoT und Home-Lab
  • k3s vs k8s vs Docker Compose

    | Eigenschaft | Docker Compose | k3s | k8s (full) |
    |-------------|---------------|-----|------------|
    | Komplexität | Niedrig | Mittel | Hoch |
    | Ressourcen | Minimal | Gering (512 MB+) | Hoch (4+ GB) |
    | Multi-Node | ❌ | ✅ | ✅ |
    | Auto-Scaling | ❌ | ✅ | ✅ |
    | Self-Healing | Begrenzt | ✅ | ✅ |
    | Load Balancing | ❌ | ✅ (ServiceLB) | ✅ (Ingress) |
    | Storage | Volumes | CSI (Longhorn, etc.) | CSI |
    | Lernkurve | Flach | Mittel | Steil |
    | Use Case | Single-Node | Home-Lab / Edge | Production |

    Installation: k3s in 5 Minuten

    Schritt 1: Master Node installieren

    ``bash
    curl -sfL https://get.k3s.io | sh -
    `

    Das war's. k3s ist installiert und läuft.

    Schritt 2: Node-Status prüfen

    `bash
    sudo k3s kubectl get nodes
    `

    `
    NAME STATUS ROLES AGE VERSION
    ultrion-server Ready control-plane,master 1m v1.31.4+k3s1
    `

    Schritt 3: kubeconfig einrichten

    `bash
    mkdir -p ~/.kube
    sudo k3s kubectl config view --raw > ~/.kube/config
    chmod 600 ~/.kube/config
    `

    Jetzt können Sie kubectl ohne sudo nutzen.

    Schritt 4: Worker Node hinzufügen (optional)

    Auf einem zweiten Server:

    `bash

    Auf dem Master: Node-Token auslesen


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

    Auf dem Worker:


    curl -sfL https://get.k3s.io | K3S_URL=https://:6443 K3S_TOKEN= sh -
    `

    Erste Schritte mit k3s

    Einen Pod starten

    `bash
    kubectl run nginx --image=nginx:alpine --port=80
    `

    Den Pod freigeben (Service)

    `bash
    kubectl expose pod nginx --port=80 --type=LoadBalancer
    `

    Service-IP abrufen

    `bash
    kubectl get svc nginx
    `

    `
    NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
    nginx LoadBalancer 10.43.42.10 192.168.1.50 80:30567/TCP 10s
    `

    k3s weist automatisch eine externe IP zu (ServiceLB). Nginx ist unter http://192.168.1.50 erreichbar.

    Deployment mit YAML

    Statt einzelner Befehle: ein YAML-Manifest.

    `yaml

    nginx-deployment.yaml


    apiVersion: apps/v1
    kind: Deployment
    metadata:
    name: nginx
    spec:
    replicas: 2
    selector:
    matchLabels:
    app: nginx
    template:
    metadata:
    labels:
    app: nginx
    spec:
    containers:
    - name: nginx
    image: nginx:alpine
    ports:
    - containerPort: 80

    ---
    apiVersion: v1
    kind: Service
    metadata:
    name: nginx
    spec:
    type: LoadBalancer
    ports:
    - port: 80
    selector:
    app: nginx
    `

    `bash
    kubectl apply -f nginx-deployment.yaml
    `

    Praxis-Beispiel: Nextcloud auf k3s

    `yaml
    apiVersion: apps/v1
    kind: Deployment
    metadata:
    name: nextcloud
    spec:
    replicas: 1
    selector:
    matchLabels:
    app: nextcloud
    template:
    metadata:
    labels:
    app: nextcloud
    spec:
    containers:
    - name: nextcloud
    image: nextcloud:latest
    ports:
    - containerPort: 80
    volumeMounts:
    - name: data
    mountPath: /var/www/html
    env:
    - name: MYSQL_HOST
    value: "db"
    volumes:
    - name: data
    persistentVolumeClaim:
    claimName: nextcloud-pvc

    ---
    apiVersion: v1
    kind: Service
    metadata:
    name: nextcloud
    spec:
    type: LoadBalancer
    ports:
    - port: 8080
    targetPort: 80
    selector:
    app: nextcloud

    ---
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
    name: nextcloud-pvc
    spec:
    accessModes:
    - ReadWriteOnce
    storageClassName: local-path
    resources:
    requests:
    storage: 50Gi
    `

    Storage in k3s

    k3s bringt local-path-provisioner mit — automatische lokale Volumes ohne extra Setup.

    `yaml

    PVC anfordern


    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
    name: data-pvc
    spec:
    accessModes: [ReadWriteOnce]
    storageClassName: local-path
    resources:
    requests:
    storage: 100Gi
    `

    Für verteilten Storage: Longhorn (kostenlos, von Rancher) installieren.

    Ingress: Mehrere Services über eine IP

    Mit einem Ingress Controller (Traefik ist in k3s enthalten) können Sie mehrere Services über Domains routen:

    `yaml
    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
    name: my-ingress
    annotations:
    ingress.kubernetes.io/ssl-redirect: "true"
    spec:
    rules:
    - host: nextcloud.example.com
    http:
    paths:
    - path: /
    pathType: Prefix
    backend:
    service:
    name: nextcloud
    port:
    number: 80
    - host: jellyfin.example.com
    http:
    paths:
    - path: /
    pathType: Prefix
    backend:
    service:
    name: jellyfin
    port:
    number: 8096
    `

    Traefik in k3s ist automatisch aktiviert. SSL mit cert-manager + Let's Encrypt automatisieren.

    Helm: Der Paketmanager für K8s

    `bash

    Helm installieren


    curl https://baltocdn.com/helm/signing.asc | sudo apt-key add -
    echo "deb https://baltocdn.com/helm/stable/debian/ all main" | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list
    sudo apt update && sudo apt install helm

    Apps installieren (Beispiel: Jellyfin)


    helm repo add jetstack https://charts.jetstack.io
    helm install cert-manager jetstack/cert-manager --namespace cert-manager --create-namespace
    ``

    k3s vs Alternativen

    | Lösung | Ressourcen | Multi-Node | Schwierigkeit |
    |--------|-----------|------------|---------------|
    | k3s | 512 MB+ | ✅ | Mittel |
    | k0s | 512 MB+ | ✅ | Mittel |
    | MicroK8s | 1 GB+ | ✅ | Mittel |
    | Minikube | 2 GB+ | ❌ | Niedrig |
    | kind | 1 GB+ | ❌ | Mittel |
    | Docker Compose | 256 MB | ❌ | Niedrig |

    FAQ

    Brauche ich Kubernetes zu Hause?


    Wenn Sie 1-3 Services hosten: nein, Docker Compose reicht. Wenn Sie: Auto-Scaling, Self-Healing, Multi-Node-Cluster, Lernen für die Arbeit wollen: ja.

    Auf was für Hardware läuft k3s?


  • Minimum: Raspberry Pi 4 (4 GB)

  • Empfohlen: Intel N100 Mini-PC (8 GB RAM)

  • Komfortabel: Proxmox-VM mit 4+ Cores, 16+ GB RAM
  • Kann ich k3s mit Docker Compose kombinieren?


    Ja. Viele Heimanwender nutzen k3s für die K8s-Services und Docker Compose für einfache Dinge. Beides läuft parallel auf demselben Host.

    Was ist der Nachteil von k3s gegenüber vollem k8s?


    k3s entfernt einige Features, die im Home-Lab nicht nötig sind (Cloud-Provider-spezifische Code, Legacy-APIs). Für 99 % der Anwendungen ist k3s identisch mit k8s.

    Fazit

    k3s macht Kubernetes für Heimanwender zugänglich. Ein Befehl installiert es, 512 MB RAM reichen aus, Traefik und ServiceLB sind inklusive. Wenn Sie K8s lernen oder ein Home-Lab aufbauen wollen, ist k3s die beste Wahl. Für einfache Setups (1-3 Container) bleibt Docker Compose die einfachere Lösung. Aber wenn Sie mehr wollen — Auto-Healing, Multi-Node, Helm-Charts — ist k3s der logische nächste Schritt.

    Werbung (AdSense — In-Article Bottom)

    Verwandte Artikel