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

Aktivera GPU-beskleuning 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 aktivering av NVidia GPU-accelerering i Docker Model Runner kräver specifik konfiguration.

Till skillnad 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 runner-installationen.

Om du letar efter ett alternativt LLM-värdningslösning med enklare GPU-konfiguration, överväg Ollama, som har inbyggt GPU-stöd och enklare uppsättning. Dock erbjuder Docker Model Runner bättre integration med Docks ekosystem och OCI-artefaktfördelning.

Docker Model Runner med NVIDIA GPU-stöd Det här trevliga bilden är genererad av AI-modell Flux 1 dev.

Förutsättningar

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

Verifiera att din GPU är tillgänglig:

nvidia-smi

Testa Docker GPU-åtkomst:

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

För fler Docker-kommandon och konfigureringsalternativ, 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-daemon-konfigurationen.

Hitta NVIDIA Container Runtime Sökväg

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

which nvidia-container-runtime

Detta ger vanligtvis /usr/bin/nvidia-container-runtime. Anteckna 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 värdet "path" i JSON-konfigurationen därefter.

Starta om Docker-tjänsten

Tillämpa konfigurationen genom att starta om Docker:

sudo systemctl restart docker

Verifiera Konfiguration

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 installeras om med explicit GPU-stöd. Runner-containern själv måste vara CUDA-aktiverad versionen.

Stanna nuvarande runner (om den körs)

Om Docker Model Runner redan är installerad, stanna den först:

docker model stop-runner

Installera/Installera om med CUDA-stöd

Installera eller installera om Docker Model Runner med CUDA GPU-stöd:

docker model reinstall-runner --gpu cuda

Det här kommandot:

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

Anteckning: Om du redan har installerat Docker Model Runner utan GPU-stöd, måste du installera om det med --gpu cuda-flaggan. Att bara konfigurera Docker-daemon räcker inte—runner-containern själv måste vara CUDA-aktiverad versionen.

Tillgängliga GPU-backends

Docker Model Runner stöder flera GPU-backends:

  • 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 detektering (standard, kan inte fungera korrekt)
  • none - CPU-endast

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

Steg 3: Verifiera GPU-åtkomst

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

Kontrollera runner container GPU-åtkomst

Testa GPU-åtkomst från inom Docker Model Runner-containern:

docker exec docker-model-runner nvidia-smi

Detta bör visa din GPU-information, vilket bekräftar att containern har GPU-åtkomst.

Kontrollera runner status

Verifiera att Docker Model Runner körs:

docker model status

Du bör se att runnern är aktiv med llama.cpp-stöd.

Steg 4: Testa modell med GPU

Kör en modell och verifiera att den använder GPU:n.

Kör en modell

Starta modellinferens:

docker model run ai/qwen3:14B-Q6_K "vem är du?"

Verifiera GPU-användning i loggar

Kontrollera Docker Model Runner-loggarna för GPU-bekräftelse:

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 detekterad
  • offloaded 41/41 layers to GPU - Modellager laddade på GPU
  • CUDA0 model buffer size = 10946.13 MiB - GPU-minnesallokering
  • CUDA0 KV buffer size = 640.00 MiB - Nyckelvärdescache på GPU
  • CUDA0 compute buffer size = 306.75 MiB - Beräkningsbuffer på GPU

Övervaka GPU-användning

I ett annat terminalfönster, övervaka GPU-användning i realtid:

nvidia-smi -l 1

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

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

Felsökning

Modell använder fortfarande CPU

Om modellen fortfarande körs på CPU:

  1. Verifiera Docker daemon-konfiguration:

    docker info | grep -i runtime

    Bör visa Default Runtime: nvidia

  2. Kontrollera runner container runtime:

    docker inspect docker-model-runner | grep -A 2 '"Runtime"'

    Bör visa "Runtime": "nvidia"

  3. Installera om runner med GPU-stöd:

    docker model reinstall-runner --gpu cuda

  4. Kontrollera loggar för fel:

    docker model logs | tail -50

GPU detekteras inte

Om GPU inte detekteras:

  1. Verifiera att NVIDIA Container Toolkit är installerat:

    dpkg -l | grep nvidia-container-toolkit

  2. Testa GPU-åtkomst med standard Docker:

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

    För felsökning av Docker-problem, hänvisa till vår Docker Cheatsheet.

  3. Kontrollera NVIDIA-drivrutiner:

    nvidia-smi

Prestandaproblem

Om GPU-prestanda är dålig:

  1. Kontrollera GPU-utnyttjande:

    nvidia-smi

    Leta efter hög GPU-utnyttjandeprocent

  2. Verifiera att modellager är på GPU:

    docker model logs | grep "offloaded.*layers to GPU"

    Alla lager bör vara överförda till GPU

  3. Kontrollera för minnesproblem:

    nvidia-smi

    Se till att GPU-minnet inte är uttömt

Bästa praxis

  1. Ange alltid 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.

  2. Verifiera konfiguration efter ändringar: Kontrollera alltid docker info | grep -i runtime efter att ha ändrat Docker-daemon-inställningar.

  3. Övervaka GPU-användning: Använd nvidia-smi för att övervaka GPU-minne och utnyttjande under modellinferens. För mer avancerade övervakningsverktyg, se vår guide om GPU-övervakningsprogram i Linux / Ubuntu.

  4. Kontrollera loggar regelbundet: Granska docker model logs för att säkerställa att modellerna använder GPU-accelerering.

  5. Använd lämpliga modellstorlekar: Se till att din GPU har tillräckligt med minne för modellen. Använd kvantiserade modeller (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-arbetsbelastningar, se vår guide om Jämföra NVidia GPU-specifikationer lämplighet för AI.

Användbara länkar