Varför använder inte Docker Model Runner GPU som standard?

Docker Model Runner kräver explicit GPU-konfiguration eftersom det måste installeras med den CUDA-aktiverade versionen. Skiljer sig från standardkommandona docker run stöder docker model run inte –gpus-flaggor, så GPU-stöd måste konfigureras på Docker-daemon-nivå och under installationen av runner.

Behöver jag återinstallera Docker Model Runner för att aktivera GPU?

Ja, om Docker Model Runner redan är installerat utan stöd för GPU, måste du installera om det med kommandot docker model reinstall-runner –gpu cuda. Detta hämtar versionen med CUDA-stöd (docker/model-runner_latest-cuda) istället för den endast CPU-baserade versionen.

Vad händer om nvidia-container-runtime finns i en annan plats?

Använd den nvidia-container-runtime som du vill använda för att hitta installationsvägen, och uppdatera sedan värdet “path” i /etc/docker/daemon.json enligt detta. Sökvägen är vanligtvis /usr/bin/nvidia-container-runtime men kan variera beroende på din installation.

Hur kan jag verifiera att GPU används?

Kontrollera Docker Model Runner-loggarna med kommandot docker model logs | grep -i cuda. Du bör se meddelanden som “using device CUDA0”, “offloaded X/X layers to GPU” och “CUDA0 model buffer size”. Du kan också övervaka GPU-användningen med nvidia-smi när du kör en modell.

Vilka GPU-backendar stöds?

Docker Model Runner stöder flera GPU-backendar – cuda (NVIDIA CUDA), rocm (AMD ROCm), musa (Moore Threads MUSA), cann (Huawei CANN), auto (automatisk upptäckt) och none (endast CPU). Använd –gpu-flaggan under installationen för att ange din backend.

Var platsar Docker Model Runner med GPU i landskapet för LLM-värdtjänster?

Docker Model Runner är en lokal/eget värdalternativ. Vår huvudsakliga guide för LLM-värdtjänster jämför det med Ollama, vLLM, LocalAI och molntjänstefournisser, inklusive kostnads- och infrastrukturväxelverkan.

Är GPU-konfiguration enklare med Ollama än med Docker Model Runner?

Ja. Ollama identifierar automatiskt och använder GPU:er utan daemon- eller återinstalleringsskrid. Docker Model Runner kräver Docker daemon, NVIDIA runtime och en CUDA-aktiverad runner-installation. Båda alternativen beskrivs i guiden för LLM-värdtjänster.

Lägg till stöd för NVIDIA GPU i Docker Model Runner

Aktivera GPU-accelerering för Docker Model Runner med stöd för NVIDIA CUDA

Docker Model Runner är Docks officiella verktyg för att köra AI-modeller lokalt, men aktivera NVidia GPU-acceleration i Docker Model Runner kräver specifik konfiguration.

Olika från standard docker run-kommandon stöder docker model run inte --gpus eller -e-flaggor, så GPU-stöd måste konfigureras på Docker-daemon-nivå och under installation av runner.

Om du söker en alternativ LLM-värdlösning med enklare GPU-konfiguration, överväg Ollama, som har inbyggt GPU-stöd och enklare installation. Emellertid erbjuder Docker Model Runner bättre integration med Docks ekosystem och OCI-artefaktdistribution. För en bredare jämförelse mellan Docker Model Runner och Ollama, vLLM, LocalAI och molntjänstleverantörer – inklusive kostnad och infrastrukturväxlingar – se LLM Hosting: Lokal, självvärdad & Molninfrastruktur jämförd.

Docker Model Runner med NVIDIA GPU-stöd Detta fina bild är genererad av AI-modell Flux 1 dev.

Förutsättningar

Innan du konfigurerar GPU-stöd, se till att du har:

NVIDIA GPU med kompatibla drivrutiner installerade. För hjälp med att välja rätt GPU för AI-belastningar, se vår guide om Jämföra NVidia GPU-specifikationers lämplighet för AI.
NVIDIA Container Toolkit installerat (se NVIDIA RTX-stödavsnittet)
Docker Model Runner installerat (kan återinstalleras med GPU-stöd)

Verifiera att din GPU är tillgänglig:

nvidia-smi

Testa Docker GPU-tillgång:

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

För fler Docker-kommandon och konfigurationsalternativ, se vår Docker Cheatsheet.

Steg 1: Konfigurera Docker-daemon för NVIDIA-runtime

Docker Model Runner kräver att NVIDIA-runtime är inställt som standardruntime i Docker-daemonkonfigurationen.

Hitta NVIDIA Container Runtime-sökväg

Först, hitta var nvidia-container-runtime är installerad:

which nvidia-container-runtime

Detta kommer vanligtvis att visa /usr/bin/nvidia-container-runtime. Notera denna sökväg för nästa steg.

Konfigurera Docker-daemon

Skapa eller uppdatera /etc/docker/daemon.json för att ställa in NVIDIA som standardruntime:

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

Viktigt: Om which nvidia-container-runtime returnerade en annan sökväg, uppdatera "path"-värdet i JSON-konfigurationen enligt detta.

Starta om Docker-tjänsten

Tillämpa konfigurationen genom att starta om Docker:

sudo systemctl restart docker

Verifiera konfigurationen

Bekräfta att NVIDIA-runtime är konfigurerad:

docker info | grep -i runtime

Du bör se Default Runtime: nvidia i utdata.

Steg 2: Installera Docker Model Runner med GPU-stöd

Docker Model Runner måste installeras eller återinstalleras med explicit GPU-stöd. Runner-kontot självt måste vara den CUDA-aktiverade versionen.

Stoppa aktuell runner (om den kör)

Om Docker Model Runner redan är installerad, stäng den först av:

docker model stop-runner

Installera/Återinstallera med CUDA-stöd

Installera eller återinstallera Docker Model Runner med CUDA GPU-stöd:

docker model reinstall-runner --gpu cuda

Detta kommando:

Hämtar den CUDA-aktiverade versionen (docker/model-runner:latest-cuda) istället för den endast CPU-versionen
Konfigurerar runner-kontot att använda NVIDIA-runtime
Aktiverar GPU-acceleration för alla modeller

Notera: Om du redan har installerat Docker Model Runner utan GPU-stöd, måste du återinstallera den med flaggan --gpu cuda. Enbart att konfigurera Docker-daemon är inte tillräckligt – runner-kontot självt måste vara den CUDA-aktiverade versionen.

Tillgängliga GPU-backend

Docker Model Runner stöder flera GPU-backend:

cuda - NVIDIA CUDA (vanligast för NVIDIA-GPU:er)
rocm - AMD ROCm (för AMD-GPU:er)
musa - Moore Threads MUSA
cann - Huawei CANN
auto - Automatisk upptäckt (standard, kan inte fungera korrekt)
none - Endast CPU

För NVIDIA-GPU:er, använd alltid --gpu cuda explicit.

Steg 3: Verifiera GPU-tillgång

Efter installation, verifiera att Docker Model Runner kan komma åt din GPU.

Kontrollera GPU-tillgång i runner-kontot

Testa GPU-tillgång från inuti Docker Model Runner-kontot:

docker exec docker-model-runner nvidia-smi

Detta bör visa din GPU-information, bekräftande att kontot har tillgång till GPU.

Kontrollera runner-status

Bekräfta att Docker Model Runner kör:

docker model status

Du bör se att runner är aktiv med stöd för llama.cpp.

Steg 4: Testa modell med GPU

Kör en modell och bekräfta att den använder GPU.

Kör en modell

Starta en modellinferens:

docker model run ai/qwen3:14B-Q6_K "who are you?"

Verifiera GPU-användning i loggar

Kontrollera Docker Model Runner-loggar för bekräftelse på GPU:

docker model logs | grep -i cuda

Du bör se meddelanden som indikerar GPU-användning:

using device CUDA0 (NVIDIA GeForce RTX 4080) - GPU-enhet upptäckt
offloaded 41/41 layers to GPU - Modellskikt laddade på GPU
CUDA0 model buffer size = 10946.13 MiB - GPU-minnesallokering
CUDA0 KV buffer size = 640.00 MiB - Nyckel-värde-cache på GPU
CUDA0 compute buffer size = 306.75 MiB - Beräkningsbuffert på GPU

Övervaka GPU-användning

I en annan terminal, övervaka GPU-användning i realtid:

nvidia-smi -l 1

Du bör se ökad GPU-minnesanvändning och utnyttjande när modellen körs.

För mer avancerade alternativ för GPU-övervakning och verktyg, se vår guide om GPU-övervakningsprogram i Linux / Ubuntu.

Felsökning

Modellen använder fortfarande CPU

Om modellen fortfarande kör på CPU:

Verifiera Docker-daemonkonfiguration:
```
docker info | grep -i runtime
```
Skulle visa Default Runtime: nvidia
Kontrollera runner-kontots runtime:
```
docker inspect docker-model-runner | grep -A 2 '"Runtime"'
```
Skulle visa "Runtime": "nvidia"

Återinstallera runner med GPU-stöd:

docker model reinstall-runner --gpu cuda

Kontrollera loggar för fel:
```
docker model logs | tail -50
```

GPU upptäcks inte

Om GPU inte upptäcks:

Verifiera att NVIDIA Container Toolkit är installerat:
```
dpkg -l | grep nvidia-container-toolkit
```
Testa GPU-tillgång med standard Docker:
```
docker run --rm --gpus all nvidia/cuda:12.2.2-base-ubi8 nvidia-smi
```
För felsökning av Docker-problem, se vår Docker Cheatsheet.
Kontrollera NVIDIA-drivrutiner:
```
nvidia-smi
```

Prestandaproblem

Om GPU-prestanda är dålig:

Kontrollera GPU-användning:
```
nvidia-smi
```
Leta efter hög GPU-användningsprocent
Verifiera att modellskikt är på GPU:
```
docker model logs | grep "offloaded.*layers to GPU"
```
Alla skikt bör överföras till GPU
Kontrollera för minnesproblem:
```
nvidia-smi
```
Se till att GPU-minne inte är uttömt

Bästa praxis

Specifika GPU-backend explicit: Använd --gpu cuda istället för --gpu auto för NVIDIA-GPU:er för att säkerställa korrekt konfiguration.
Verifiera konfiguration efter ändringar: Kontrollera alltid docker info | grep -i runtime efter att ha ändrat Docker-daemoninställningar.
Övervaka GPU-användning: Använd nvidia-smi för att övervaka GPU-minne och användning under modellinferens. För mer avancerade övervakningsverktyg, se vår guide om GPU-övervakningsprogram i Linux / Ubuntu.
Kontrollera loggar regelbundet: Granska docker model logs för att säkerställa att modeller använder GPU-acceleration.
Använd lämpliga modellstorlekar: Se till att din GPU har tillräckligt med minne för modellen. Använd kvantisering (Q4, Q5, Q6, Q8) för bättre GPU-minneseffektivitet. För hjälp med att välja rätt GPU för dina AI-belastningar, se vår guide om Jämföra NVidia GPU-specifikationers lämplighet för AI.

När GPU-stöd är aktiverat är Docker Model Runner en av flera sätt att köra LLM:er lokalt. För att se hur den passar in med Ollama, vLLM, molntjänst-API:er och andra alternativ, kontrollera vår LLM Hosting: Lokal, självvärdad & Molninfrastruktur jämförd-guide.