AI-Power im Homelab: Dein GPU-Knoten mit Proxmox & Docker

Servus, Home Lab-Enthusiasten und Admins!

Die Nachricht von Nvidias Kyber-Rack und den Rubin Ultra-Boards hat bei mir sofort das Herz eines jeden Hardware-Fans höherschlagen lassen. Eine Serverplattform, die bis zu 144 KI-Beschleuniger ohne Kabel in einem System vereint – das ist schon eine Ansage! Diese Dichte, diese Performance und vor allem die Vorstellung von einem optimierten, kabel-losen Design zeigen, wohin die Reise im High-Performance-Computing geht. Für uns im Home Lab mag ein Kyber-Rack noch in weiter Ferne liegen, aber die Idee dahinter – maximale Rechenleistung für KI-Workloads auf engstem Raum – ist absolut übertragbar auf unsere eigenen Projekte.

Genau das ist der Punkt, an dem ich ansetzen möchte. Wenn Nvidia uns zeigt, was im Großen möglich ist, können wir uns davon inspirieren lassen, um im Kleinen, in unserem Home Lab, ähnliche Prinzipien zu verfolgen. Wir wollen keine 144 KI-Beschleuniger, aber vielleicht eine oder zwei GPUs, die wir optimal für unsere eigenen AI-Experimente nutzen können. Denk an lokale LLMs, Stable Diffusion, AI-basierte Bild- oder Videoverarbeitung, oder vielleicht sogar das Training kleinerer Modelle. Dafür brauchen wir einen soliden Unterbau, und genau den werden wir heute gemeinsam aufsetzen.

In diesem Guide zeige ich dir, wie du einen GPU-beschleunigten Compute-Knoten in deinem Home Lab einrichtest. Wir nutzen Proxmox VE als Hypervisor, um unsere Hardware optimal zu virtualisieren, und Docker, um unsere AI-Workloads isoliert und effizient zu betreiben. Der Fokus liegt dabei auf dem GPU-Passthrough, einer Technik, die es uns ermöglicht, eine dedizierte Grafikkarte direkt an eine virtuelle Maschine durchzureichen – quasi so, als wäre sie nativ in der VM verbaut. Das ist der Schlüssel zu echter AI-Power im virtuellen Umfeld.

Warum ein eigener AI-Compute-Knoten im Homelab?

Die Gründe sind vielfältig, aber die wichtigsten sind für mich:

Datenschutz und Kontrolle: Du möchtest deine privaten Daten nicht an externe AI-Dienste schicken? Dann ist ein lokaler AI-Knoten die Lösung.
Kostenersparnis: Langfristig können die Kosten für Cloud-basierte AI-Dienste ins Geld gehen. Mit eigener Hardware hast du die volle Kostenkontrolle.
Lernkurve: Es gibt nichts Besseres, als selbst Hand anzulegen, um die zugrundeliegende Technologie zu verstehen. Von Proxmox über Docker bis hin zu den AI-Frameworks – du lernst unglaublich viel.
Flexibilität: Du bist nicht an die APIs oder Modelle eines Anbieters gebunden. Experimentiere mit allem, was Open Source ist.
Unabhängigkeit: Keine Internetverbindung? Kein Problem. Deine AI läuft trotzdem weiter.

Voraussetzungen

Bevor wir loslegen, lass uns sicherstellen, dass du die notwendige Basis hast. In meiner Erfahrung scheitern Projekte oft schon an den grundlegenden Voraussetzungen.

Proxmox VE Server: Ein laufender Proxmox VE Server (mind. Version 7.x, besser 8.x) mit ausreichend Ressourcen.
Hardware mit GPU: Ein physischer Host mit einer dedizierten Nvidia GPU, die du durchreichen möchtest. Wichtig: Prüfe, ob deine CPU und dein Mainboard IOMMU (Input/Output Memory Management Unit) unterstützen und im BIOS aktiviert ist. Das ist absolut entscheidend für GPU-Passthrough. Intel VT-d oder AMD-Vi sind die Schlagworte, nach denen du im BIOS suchen solltest.
Genug RAM und CPU-Kerne: Die virtuelle Maschine, die wir erstellen, sollte mindestens 8 GB RAM und 4-8 CPU-Kerne zugewiesen bekommen, je nach geplantem AI-Workload. Mehr ist hier immer besser.
Speicherplatz: Genug schneller Speicherplatz (SSD/NVMe) für die VM und deine AI-Modelle.
Netzwerk: Eine stabile Netzwerkverbindung für deinen Proxmox Host und die VM.
Grundkenntnisse: Vertrautheit mit der Linux-Kommandozeile und Proxmox VE.

Schritt 1: Die Basis – Proxmox VE und deine VM vorbereiten

Der erste und oft kniffligste Schritt ist, Proxmox für das GPU-Passthrough vorzubereiten und die virtuelle Maschine korrekt zu konfigurieren.

1.1 IOMMU im BIOS aktivieren

Starte deinen Proxmox Host neu und gehe ins BIOS/UEFI. Suche nach Einstellungen wie "Intel VT-d", "AMD-Vi", "IOMMU" oder "Virtualization Technology" und aktiviere sie. Ohne das geht es nicht weiter!

1.2 Proxmox Host für Passthrough konfigurieren

Melde dich per SSH auf deinem Proxmox Host an. Wir müssen dem Kernel mitteilen, dass er die IOMMU-Funktionalität nutzen soll und die GPU für Passthrough reservieren soll.

Bearbeite die GRUB-Konfiguration:

sudo nano /etc/default/grub

Finde die Zeile, die mit GRUB_CMDLINE_LINUX_DEFAULT beginnt, und füge Parameter hinzu. Für Intel-CPUs: intel_iommu=on. Für AMD-CPUs: amd_iommu=on. Wenn du Probleme mit der Gruppierung hast, kann pcie_acs_override=downstream,multifunction helfen (Vorsicht, kann Sicherheitsrisiken bergen und sollte nur bei Bedarf verwendet werden!).

Beispiel für Intel:

GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on iommu=pt"

Nach der Änderung musst du GRUB aktualisieren und den Server neu starten:

sudo update-grub
sudo reboot

Nach dem Neustart prüfen wir, ob IOMMU aktiv ist:

dmesg | grep -e DMAR -e IOMMU
find /sys/kernel/iommu_groups/ -type l

Du solltest Ausgaben sehen, die bestätigen, dass IOMMU aktiv ist und deine Geräte in IOMMU-Gruppen organisiert sind. Wichtig zu wissen: Deine GPU muss in einer eigenen IOMMU-Gruppe sein oder in einer Gruppe mit Geräten, die du ebenfalls durchreichen möchtest. Ist sie in einer Gruppe mit kritischen Systemgeräten, wird Passthrough schwierig oder unmöglich.

Nun müssen wir die Module laden, die für Passthrough benötigt werden, und die GPU-Treiber des Hosts (nouveau für Nvidia) auf die Blacklist setzen, damit Proxmox selbst die GPU nicht beansprucht:

sudo nano /etc/modules

Füge folgende Zeilen hinzu:

vfio
vfio_iommu_type1
vfio_pci
vfio_virqfd

Erstelle eine Blacklist-Datei für die Host-Treiber:

sudo nano /etc/modprobe.d/blacklist.conf

Füge diese Zeilen hinzu:

blacklist nouveau
blacklist nvidia
blacklist radeon
blacklist amdgpu

Und eine weitere Datei, um die VFIO-Module zu erzwingen und die PCI-IDs deiner GPU zu binden:

sudo nano /etc/modprobe.d/vfio.conf

Um die PCI-ID deiner GPU zu finden:

lspci -nnk | grep -i vga -A3

Du suchst nach der Zeile mit deiner Nvidia GPU, z.B. 10de:1f08 (dies ist ein Beispiel, deine ID wird anders sein!). Oft hat die GPU auch einen Audio-Controller, der durchgereicht werden muss (z.B. 10de:10f9). Beide IDs müssen angegeben werden.

options vfio-pci ids=10de:1f08,10de:10f9 disable_vga=1

Ersetze 10de:1f08,10de:10f9 durch deine tatsächlichen IDs. disable_vga=1 ist wichtig, wenn die GPU auch als Boot-GPU genutzt wird, um Konflikte zu vermeiden.

Aktualisiere die Initramfs und starte erneut:

sudo update-initramfs -u -k all
sudo reboot

1.3 Virtuelle Maschine erstellen und GPU durchreichen

Erstelle eine neue VM im Proxmox Webinterface (z.B. Ubuntu Server 22.04 LTS). Wichtig:

CPU: Wähle "host" als CPU-Typ für maximale Kompatibilität und Performance.
BIOS: UEFI (OVMF) ist oft besser für Passthrough.
Maschinentyp: Q35.
Grafikkarte: Wähle "None" oder "Standard VGA" (wenn du headless arbeitest).
PCI-Express: Aktiviere "PCI-Express" für die GPU.

Nachdem die VM erstellt ist, aber bevor du sie das erste Mal startest, füge die PCI-Geräte hinzu. Gehe im Proxmox Webinterface zur VM -> Hardware -> Hinzufügen -> PCI Gerät. Wähle deine Nvidia GPU und den dazugehörigen Audio-Controller aus. Aktiviere "Primäre GPU" und "Alle PCI-Funktionen".

Alternativ kannst du die VM-Konfigurationsdatei direkt bearbeiten (ersetze 100 mit deiner VM-ID):

sudo nano /etc/pve/qemu-server/100.conf

Füge eine Zeile für jedes PCI-Gerät hinzu (ersetze die IDs mit deinen):

args: -cpu 'host,+kvm_pv_unhalt,+kvm_pv_eoi,hv_tlbflush,hv_relaxed,hv_spinlocks=0x1fff,hv_vapic,hv_time,l3-cache=on,hv_vendor_id=NV43FIX'
cpu: host
hostpci0: 0000:01:00.0,pcie=1,x-vga=1 # Beispiel für die GPU
hostpci1: 0000:01:00.1,pcie=1      # Beispiel für den Audio-Controller der GPU
machine: q35
vga: none # Oder serial0, wenn du nur SSH nutzt und keine grafische Ausgabe brauchst

Die PCI-IDs (z.B. 0000:01:00.0) findest du mit lspci -nn auf dem Proxmox Host. Achte darauf, dass sie mit den IDs übereinstimmen, die du in vfio.conf verwendet hast.

Schritt 2: GPU-Treiber und Docker auf der VM installieren

Starte deine VM. Melde dich per SSH an und aktualisiere das System:

sudo apt update && sudo apt upgrade -y

2.1 Nvidia GPU-Treiber installieren

Dies ist ein kritischer Schritt. Die Installation der Nvidia-Treiber in der VM ist fast identisch mit der auf einem physischen Linux-System.

Zuerst fügen wir das Nvidia-Repository hinzu:

sudo apt install software-properties-common -y
sudo add-apt-repository ppa:graphics-drivers/ppa -y
sudo apt update

Dann installieren wir den empfohlenen Treiber. Finde den empfohlenen Treiber mit ubuntu-drivers devices. Nehmen wir an, es ist nvidia-driver-535:

sudo apt install nvidia-driver-535 -y
sudo reboot

Nach dem Neustart kannst du mit nvidia-smi prüfen, ob der Treiber korrekt installiert wurde und die GPU erkannt wird. Du solltest detaillierte Informationen über deine Grafikkarte sehen.

2.2 Docker installieren

Nun installieren wir Docker Engine. Ich gehe hier den offiziellen Weg über das Docker-Repository, da dieser am zuverlässigsten ist.

# Docker-Repository einrichten
sudo apt install ca-certificates curl gnupg -y
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update

# Docker installieren
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

# User zur Docker-Gruppe hinzufügen (optional, aber bequem)
sudo usermod -aG docker $USER
newgrp docker # Oder einfach ab- und wieder anmelden

Teste die Docker-Installation:

docker run hello-world

2.3 Nvidia Container Toolkit installieren

Damit Docker die GPU in Containern nutzen kann, brauchen wir das Nvidia Container Toolkit. Es stellt die notwendige Runtime und die Bibliotheken bereit.

# Nvidia Container Toolkit Repository einrichten
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
  && curl -s -L https://nvidia.github.io/libnvidia-container/ubuntu22.04/libnvidia-container.list | \
    sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
    sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt update
sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

Teste, ob die GPU in einem Docker-Container verfügbar ist:

docker run --rm --gpus all nvidia/cuda:12.2.2-base-ubuntu22.04 nvidia-smi

Wenn du hier eine Ausgabe ähnlich der von nvidia-smi siehst, die du direkt auf der VM ausgeführt hast, dann herzlichen Glückwunsch! Deine GPU ist erfolgreich in Docker-Containern verfügbar.

Schritt 3: Dein erster AI-Container – Stable Diffusion als Beispiel

Jetzt, wo alles vorbereitet ist, können wir unseren ersten AI-Workload starten. Ich nehme Stable Diffusion als Beispiel, da es sehr populär ist und die GPU-Beschleunigung hervorragend demonstriert. Es gibt verschiedene Docker-Images dafür, wir nehmen hier ein gängiges.

Dieses Beispiel nutzt das stable-diffusion-webui-docker Projekt, das die beliebte Automatic1111 WebUI in einem Container bereitstellt.

Zuerst klonen wir das Repository und wechseln in das Verzeichnis:

git clone https://github.com/AbdBarho/stable-diffusion-webui-docker.git
cd stable-diffusion-webui-docker

Dann passen wir die docker-compose.yaml an, um sicherzustellen, dass die GPU genutzt wird. Normalerweise ist das schon voreingestellt, aber es schadet nicht, zu prüfen.

Starte den Dienst. Beim ersten Start werden die Docker-Images heruntergeladen und die AI-Modelle initialisiert, was eine Weile dauern kann:

docker compose --profile auto up --build -d

Sobald der Container läuft (prüfe mit docker ps), kannst du die WebUI im Browser aufrufen. Die Standard-Ports sind oft 7860 oder 7861. Also öffne in deinem Browser http://<IP_DEINER_VM>:7860 (ersetze <IP_DEINER_VM> durch die tatsächliche IP-Adresse deiner VM).

Du kannst währenddessen mit nvidia-smi auf der VM beobachten, wie deine GPU ausgelastet wird, wenn du Bilder generierst. Das ist der Moment, in dem die Kyber-Rack-Vision im Kleinen Realität wird!

Netzwerk-Optimierung für AI-Workloads (Kurz)

Auch wenn wir hier "nur" eine GPU durchreichen, ist Netzwerk immer ein Thema. Gerade bei größeren Modellen, die du eventuell von einem NAS oder externen Quellen lädst, oder wenn du später ein Kubernetes-Cluster mit mehreren AI-Knoten aufbauen möchtest, wird die Netzwerkbandbreite wichtig.

Mein Tipp: Wenn dein Proxmox Host mehrere Netzwerkkarten hat, nutze Link Aggregation (Bonding) für Redundanz und erhöhte Bandbreite. Für wirklich anspruchsvolle Szenarien solltest du über 10G- oder sogar 25G-Ethernet nachdenken. Für einen einzelnen AI-Knoten im Home Lab ist das oft Overkill, aber es ist gut, die Optionen zu kennen.

Häufige Fehler und Lösungen

Wer das zum ersten Mal einrichtet, stolpert oft über ähnliche Probleme. Hier sind ein paar typische Fehler und deren Fixes:

1. GPU Passthrough funktioniert nicht / VM startet nicht

Problem: Die VM startet nicht oder die GPU wird nicht erkannt.
Lösung:
- IOMMU-Gruppen prüfen: Das ist der häufigste Fall. Ist deine GPU in einer IOMMU-Gruppe mit anderen Geräten, die nicht durchgereicht werden können oder sollen? Prüfe mit find /sys/kernel/iommu_groups/ -type l auf dem Proxmox Host. Wenn die GPU nicht isoliert ist, kann pcie_acs_override im GRUB helfen (siehe oben), ist aber keine garantierte Lösung und kann die Sicherheit beeinträchtigen.
- BIOS-Einstellungen: Überprüfe nochmals, ob VT-d/AMD-Vi/IOMMU im BIOS wirklich aktiviert ist.
- PCI-IDs in vfio.conf: Sind die PCI-IDs in /etc/modprobe.d/vfio.conf korrekt und stimmen sie mit lspci -nnk überein? Hast du sowohl die Grafik- als auch die Audio-ID der GPU angegeben?
- disable_vga=1: Wenn die GPU die primäre Boot-GPU deines Hosts ist, kann es zu Problemen kommen. disable_vga=1 in der vfio.conf und x-vga=1 in der VM-Config sind wichtig.
- vga: none in VM-Config: Stelle sicher, dass die VM keine virtuelle VGA-Karte zugewiesen bekommt, wenn du die echte GPU durchreichst.

2. Nvidia Container Toolkit / Docker Probleme

Problem: docker run --gpus all ... funktioniert nicht, oder Container können die GPU nicht sehen.
Lösung:
- Nvidia Treiber in VM: Sind die Nvidia-Treiber in der VM korrekt installiert und funktioniert nvidia-smi direkt in der VM? Ohne funktionierende Treiber keine GPU in Docker.
- Nvidia Container Toolkit installiert: Hast du nvidia-container-toolkit installiert und sudo nvidia-ctk runtime configure --runtime=docker ausgeführt?
- Docker-Dienst neu gestartet: Nach der Installation des Toolkits muss Docker neu gestartet werden: sudo systemctl restart docker.
- Falsches Docker Image: Nutzt du ein Docker-Image, das überhaupt GPU-Unterstützung mitbringt? Viele AI-Images basieren auf Nvidia CUDA-Images, aber nicht alle.

3. Performance-Probleme oder Instabilität

Problem: Die AI-Workloads laufen langsam oder die VM stürzt ab.
Lösung:
- VM-Ressourcen: Hast du der VM genügend CPU-Kerne und RAM zugewiesen? AI-Workloads sind sehr ressourcenhungrig.
- CPU-Typ: Nutze cpu: host in der VM-Konfiguration für maximale Performance und Zugriff auf alle CPU-Features.
- Kernel-Updates: Manchmal können Kernel-Updates auf dem Proxmox Host zu Problemen mit Passthrough führen. Prüfe die Proxmox-Foren.
- GPU-Temperatur: Überwache die Temperatur deiner GPU. Hohe Temperaturen können zu Throttling und Instabilität führen. Sorge für ausreichende Kühlung im Server.

Fazit & Nächste Schritte

Glückwunsch! Du hast nun einen leistungsstarken AI-Compute-Knoten in deinem Home Lab aufgebaut, inspiriert von Nvidias Vision für das Kyber-Rack. Du siehst, auch ohne ein millionenschweres Budget können wir uns die Prinzipien von hoher Dichte und dedizierter Rechenleistung für unsere eigenen Projekte zunutze machen. Das Wissen um GPU-Passthrough und Docker ist Gold wert und öffnet dir Türen zu unzähligen weiteren Projekten.

Was sind die nächsten Schritte? Für mich wäre das:

Kubernetes (k3s/k8s): Wenn du planst, mehr als einen AI-Knoten zu betreiben oder deine Workloads noch feiner zu orchestrieren, ist der Schritt zu einem Kubernetes-Cluster mit Nvidia-Device-Plugins der nächste logische Schritt.
Monitoring: Richte Prometheus und Grafana ein, um die Auslastung deiner GPUs, CPUs und des Speichers zu überwachen. So siehst du genau, wo Engpässe entstehen.
Weitere AI-Anwendungen: Experimentiere mit anderen lokalen LLMs (z.B. Llama.cpp), AI-Upscaling für Medien oder sogar dem Training eigener kleiner Modelle.
Automatisierung: Nutze Ansible, um die Einrichtung weiterer VMs oder die Bereitstellung von AI-Containern zu automatisieren.

Das Home Lab ist ein ständiger Lernprozess, und jedes gelöste Problem ist ein Sieg. Teile deine Erfahrungen und deine Setups in der smoth.me Community. Ich bin gespannt, was du als Nächstes baust!