Warum verwendet Docker Model Runner die GPU nicht standardmäßig?

Der Docker Model Runner erfordert eine explizite GPU-Konfiguration, da er mit der CUDA-fähigen Version installiert werden muss. Im Gegensatz zu standardmäßigen docker run-Befehlen unterstützt docker model run keine –gpus-Flags. Daher muss die GPU-Unterstützung auf Ebene des Docker-Daemons und während der Installation des Runners konfiguriert werden.

Muss ich Docker Model Runner neu installieren, um die GPU zu aktivieren?

Ja, wenn Docker Model Runner bereits ohne GPU-Unterstützung installiert wurde, müssen Sie es mit docker model reinstall-runner –gpu cuda erneut installieren. Dies zieht die CUDA-fähige Version (docker/model-runner_latest-cuda) anstelle der CPU-eingeschränkten Version herunter.

Was ist, wenn nvidia-container-runtime sich an einem anderen Ort befindet?

Ermitteln Sie den Installationspfad des nvidia-container-runtime, und aktualisieren Sie anschließend den “path”-Wert in /etc/docker/daemon.json entsprechend. Der Pfad ist typischerweise /usr/bin/nvidia-container-runtime, kann aber je nach Installation variieren.

Wie kann ich überprüfen, ob die GPU genutzt wird?

Überprüfen Sie die Docker Model Runner-Protokolle mit „docker model logs | grep -i cuda“. Sie sollten Nachrichten wie „using device CUDA0“, „offloaded X/X layers to GPU“ und „CUDA0 model buffer size“ sehen. Sie können auch die GPU-Nutzung mit nvidia-smi überwachen, während ein Modell läuft.

Welche GPU-Backends werden unterstützt?

Docker Model Runner unterstützt mehrere GPU-Backends: cuda (NVIDIA CUDA), rocm (AMD ROCm), musa (Moore Threads MUSA), cann (Huawei CANN), auto (automatische Erkennung) und none (nur CPU). Verwenden Sie den –gpu-Flag während der Installation, um Ihr Backend anzugeben.

Wo passt Docker Model Runner mit GPU in das Landschaftsbild der LLM-Hosting-Technologien?

„Docker Model Runner ist eine lokale/ selbstgehostete Option. Unser Hauptleitfaden zur LLM-Hosting-Vergleichsstudie vergleicht ihn mit Ollama, vLLM, LocalAI und Cloud-Anbietern, einschließlich Kosten- und Infrastrukturkompromisse.“

Ist die GPU-Konfiguration mit Ollama einfacher als mit Docker Model Runner?

Ja. Ollama erkennt automatisch und nutzt GPUs ohne Daemon- oder Neuaninstallationsschritte. Der Docker Model Runner benötigt den Docker-Daemon, die NVIDIA-Runtime und eine CUDA-fähige Runner-Installation. Beides wird im LLM-Hosting-Leitfaden behandelt.

Hinzufügen von NVIDIA-GPU-Unterstützung zum Docker-Modell-Runner

GPU-Beschleunigung für Docker Model Runner mit NVIDIA CUDA-Unterstützung aktivieren

Docker Model Runner ist das offizielle Tool von Docker, um KI-Modelle lokal zu verwenden, aber GPU-Beschleunigung mit NVidia in Docker Model Runner erfordert eine spezifische Konfiguration.

Im Gegensatz zu Standard-docker run-Befehlen unterstützt docker model run keine --gpus- oder -e-Flags, weshalb die GPU-Unterstützung auf Ebene des Docker-Daemons und während der Installation des Runners konfiguriert werden muss.

Wenn Sie eine alternative Lösung zur LLM-Hosting-Unterstützung mit einfacherer GPU-Konfiguration suchen, erwägen Sie Ollama, die eine integrierte GPU-Unterstützung und eine einfachere Einrichtung bietet. Docker Model Runner bietet jedoch eine bessere Integration mit der Docker-Ökosystem und der OCI-Artifact-Verteilung. Für eine umfassendere Vergleichsübersicht zwischen Docker Model Runner und Ollama, vLLM, LocalAI und Cloud-Anbietern – einschließlich Kosten- und Infrastrukturkompromisse – siehe LLM-Hosting: Lokal, Selbstgehostet & Cloud-Infrastruktur Vergleich.

Docker Model Runner mit NVIDIA GPU-Unterstützung Dieses schöne Bild wurde von AI-Modell Flux 1 dev generiert.

Voraussetzungen

Bevor Sie die GPU-Unterstützung konfigurieren, stellen Sie sicher, dass Sie folgende Voraussetzungen erfüllen:

NVIDIA-GPU mit kompatiblen Treibern installiert. Für Hilfe bei der Auswahl der richtigen GPU für KI-Aufgaben siehe unseren Leitfaden zu Vergleich der NVidia-GPU-Spezifikationen für KI.
NVIDIA Container Toolkit installiert (siehe NVIDIA RTX-Unterstützung)
Docker Model Runner installiert (kann mit GPU-Unterstützung neu installiert werden)

Überprüfen Sie, ob Ihre GPU zugänglich ist:

nvidia-smi

Testen Sie die GPU-Zugriffsrechte von Docker:

docker run --rm --gpus all nvidia/cuda:12.2.2-base-ubi8 nvidia-smi

Für weitere Docker-Befehle und Konfigurationsoptionen siehe unsere Docker Cheatsheet.

Schritt 1: Konfigurieren Sie den Docker-Daemon für NVIDIA Runtime

Docker Model Runner erfordert, dass die NVIDIA-Runtime als Standard-Runtime im Docker-Daemon-Konfigurationsdatei festgelegt wird.

Finden Sie den Pfad zur NVIDIA Container Runtime

Zuerst finden Sie heraus, wo nvidia-container-runtime installiert ist:

which nvidia-container-runtime

Dies gibt typischerweise /usr/bin/nvidia-container-runtime aus. Notieren Sie diesen Pfad für den nächsten Schritt.

Konfigurieren Sie den Docker-Daemon

Erstellen Sie oder aktualisieren Sie /etc/docker/daemon.json, um NVIDIA als Standard-Runtime festzulegen:

sudo tee /etc/docker/daemon.json > /dev/null << 'EOF'
{
  "default-runtime": "nvidia",
  "runtimes": {
    "nvidia": {
      "path": "/usr/bin/nvidia-container-runtime",
      "runtimeArgs": []
    }
  }
}
EOF

Wichtig: Wenn which nvidia-container-runtime einen anderen Pfad zurückgibt, aktualisieren Sie den Wert "path" in der JSON-Konfiguration entsprechend.

Starten Sie den Docker-Service neu

Wenden Sie die Konfiguration an, indem Sie Docker neu starten:

sudo systemctl restart docker

Überprüfen Sie die Konfiguration

Bestätigen Sie, dass die NVIDIA-Unterstützung konfiguriert ist:

docker info | grep -i runtime

Im Ausgabeergebnis sollten Sie Default Runtime: nvidia sehen.

Schritt 2: Installieren Sie Docker Model Runner mit GPU-Unterstützung

Docker Model Runner muss mit expliziter GPU-Unterstützung installiert oder neu installiert werden. Der Runner-Container selbst muss die CUDA-fähige Version sein.

Stoppen Sie den aktuellen Runner (falls er läuft)

Wenn Docker Model Runner bereits installiert ist, stoppen Sie ihn zuerst:

docker model stop-runner

Installieren/Neuinstallieren mit CUDA-Unterstützung

Installieren oder neuinstallieren Sie Docker Model Runner mit CUDA-GPU-Unterstützung:

docker model reinstall-runner --gpu cuda

Dieser Befehl:

Lädt die CUDA-fähige Version (docker/model-runner:latest-cuda) anstelle der CPU-only-Version herunter
Konfiguriert den Runner-Container, um die NVIDIA-Unterstützung zu verwenden
Aktiviert die GPU-Beschleunigung für alle Modelle

Hinweis: Wenn Sie Docker Model Runner bereits ohne GPU-Unterstützung installiert haben, müssen Sie ihn mit dem Flag --gpu cuda neu installieren. Die Konfiguration des Docker-Daemons allein reicht nicht aus – der Runner-Container selbst muss die CUDA-fähige Version sein.

Verfügbare GPU-Backends

Docker Model Runner unterstützt mehrere GPU-Backends:

cuda - NVIDIA CUDA (am häufigsten für NVIDIA-GPUs)
rocm - AMD ROCm (für AMD-GPUs)
musa - Moore Threads MUSA
cann - Huawei CANN
auto - Automatische Erkennung (Standard, kann nicht korrekt funktionieren)
none - Nur CPU

Für NVIDIA-GPUs verwenden Sie immer --gpu cuda explizit.

Schritt 3: Überprüfen Sie die GPU-Zugriffsrechte

Nach der Installation überprüfen Sie, ob Docker Model Runner auf Ihre GPU zugreifen kann.

Überprüfen Sie die GPU-Zugriffsrechte des Runner-Containers

Testen Sie die GPU-Zugriffsrechte innerhalb des Docker Model Runner-Containers:

docker exec docker-model-runner nvidia-smi

Dies sollte Ihre GPU-Informationen anzeigt und bestätigt, dass der Container GPU-Zugriffsrechte hat.

Überprüfen Sie den Runner-Status

Überprüfen Sie, ob Docker Model Runner läuft:

docker model status

Sie sollten sehen, dass der Runner aktiv ist und llama.cpp-Unterstützung hat.

Schritt 4: Testen Sie ein Modell mit GPU

Führen Sie ein Modell aus und überprüfen Sie, ob es die GPU verwendet.

Führen Sie ein Modell aus

Starten Sie eine Modellinferenz:

docker model run ai/qwen3:14B-Q6_K "wer sind Sie?"

Überprüfen Sie die GPU-Nutzung in den Protokollen

Überprüfen Sie die Protokolle von Docker Model Runner auf GPU-Bestätigung:

docker model logs | grep -i cuda

Sie sollten Nachrichten sehen, die die GPU-Nutzung bestätigen:

using device CUDA0 (NVIDIA GeForce RTX 4080) - GPU-Gerät erkannt
offloaded 41/41 layers to GPU - Modellebenen wurden auf die GPU geladen
CUDA0 model buffer size = 10946.13 MiB - GPU-Speicherzuordnung
CUDA0 KV buffer size = 640.00 MiB - Schlüssel-Wert-Cache auf der GPU
CUDA0 compute buffer size = 306.75 MiB - Rechenpuffer auf der GPU

Überwachen Sie die GPU-Nutzung

In einem anderen Terminal überwachen Sie die GPU-Nutzung in Echtzeit:

nvidia-smi -l 1

Sie sollten sehen, dass die GPU-Speichernutzung und -Auslastung ansteigt, wenn das Modell läuft.

Für weitere erweiterte GPU-Überwachungsoptionen und Tools siehe unseren Leitfaden zu GPU-Überwachungsanwendungen unter Linux / Ubuntu.

Problembehandlung

Modell nutzt immer noch CPU

Wenn das Modell immer noch auf der CPU läuft:

Überprüfen Sie die Docker-Daemon-Konfiguration:
```
docker info | grep -i runtime
```
Sollte Default Runtime: nvidia anzeigen
Überprüfen Sie die Runtime des Runner-Containers:
```
docker inspect docker-model-runner | grep -A 2 '"Runtime"'
```
Sollte "Runtime": "nvidia" anzeigen
Neuinstallieren Sie den Runner mit GPU-Unterstützung:
```
docker model reinstall-runner --gpu cuda
```
Überprüfen Sie die Protokolle auf Fehler:
```
docker model logs | tail -50
```

GPU nicht erkannt

Wenn die GPU nicht erkannt wird:

Überprüfen Sie, ob das NVIDIA Container Toolkit installiert ist:
```
dpkg -l | grep nvidia-container-toolkit
```
Testen Sie die GPU-Zugriffsrechte mit Standard-Docker:
```
docker run --rm --gpus all nvidia/cuda:12.2.2-base-ubi8 nvidia-smi
```
Für die Problembehandlung von Docker-Problemen siehe unseren Docker Cheatsheet.
Überprüfen Sie die NVIDIA-Treiber:
```
nvidia-smi
```

Leistungsprobleme

Wenn die GPU-Leistung schlecht ist:

Überprüfen Sie die GPU-Auslastung:
```
nvidia-smi
```
Suchen Sie nach einem hohen Prozentsatz der GPU-Auslastung
Überprüfen Sie, ob die Modellschichten auf der GPU sind:
```
docker model logs | grep "offloaded.*layers to GPU"
```
Alle Schichten sollten auf die GPU übertragen werden
Überprüfen Sie auf Speicherprobleme:
```
nvidia-smi
```
Stellen Sie sicher, dass der GPU-Speicher nicht erschöpft ist

Best Practices

Geben Sie immer den GPU-Backend explizit an: Verwenden Sie --gpu cuda anstelle von --gpu auto für NVIDIA-GPUs, um sicherzustellen, dass die Konfiguration korrekt ist.
Überprüfen Sie die Konfiguration nach Änderungen: Prüfen Sie immer docker info | grep -i runtime, nachdem Sie die Docker-Daemon-Einstellungen geändert haben.
Überwachen Sie die GPU-Nutzung: Verwenden Sie nvidia-smi, um die GPU-Speichernutzung und -Auslastung während der Modellinferenz zu überwachen. Für erweiterte Überwachungstools siehe unseren Leitfaden zu GPU-Überwachungsanwendungen unter Linux / Ubuntu.
Überprüfen Sie regelmäßig die Protokolle: Prüfen Sie docker model logs, um sicherzustellen, dass die Modelle GPU-Beschleunigung nutzen.
Verwenden Sie geeignete Modellgrößen: Stellen Sie sicher, dass Ihre GPU genügend Speicher für das Modell hat. Verwenden Sie quantisierte Modelle (Q4, Q5, Q6, Q8) für eine bessere GPU-Speichereffizienz. Für Hilfe bei der Auswahl der richtigen GPU für Ihre KI-Aufgaben siehe unseren Leitfaden zu Vergleich der NVidia-GPU-Spezifikationen für KI.

Sobald die GPU-Unterstützung aktiviert ist, ist Docker Model Runner eine der mehreren Möglichkeiten, LLMs lokal zu hosten. Um zu sehen, wie es sich mit Ollama, vLLM, Cloud-APIs und anderen Optionen verhält, prüfen Sie unseren Leitfaden zu LLM-Hosting: Lokal, Selbstgehostet & Cloud-Infrastruktur Vergleich.