Moet ik Docker Model Runner opnieuw installeren om de GPU te activeren?

Ja, als Docker Model Runner al is geïnstalleerd zonder GPU-ondersteuning, moet u het opnieuw installeren met behulp van docker model reinstall-runner –gpu cuda. Dit haalt de CUDA-versie (docker/model-runner_latest-cuda) op in plaats van de CPU-only-versie.

Wat als nvidia-container-runtime zich op een ander locatie bevindt?

Gebruik de juiste nvidia-container-runtime om de installatiepad te vinden, en pas daarna de “path”-waarde in /etc/docker/daemon.json daarop aan. Het pad is meestal /usr/bin/nvidia-container-runtime, maar kan variëren afhankelijk van je installatie.

Hoe kan ik controleren of de GPU wordt gebruikt?

Controleer de Docker Model Runner logs met docker model logs | grep -i cuda. Je zou berichten zoals “using device CUDA0”, “offloaded X/X layers to GPU” en “CUDA0 model buffer size” moeten zien. Je kunt ook de GPU-gebruik bijhouden met nvidia-smi terwijl je een model uitvoert.

Welke GPU-backends worden ondersteund?

Docker Model Runner ondersteunt meerdere GPU-backends: cuda (NVIDIA CUDA), rocm (AMD ROCm), musa (Moore Threads MUSA), cann (Huawei CANN), auto (automatische detectie) en none (alleen CPU). Gebruik de –gpu vlag tijdens de installatie om je backend op te geven.

Op welke plek past Docker Model Runner met GPU in het landschap van LLM-hosting?

Docker Model Runner is één van de lokale/self-hosted opties. Onze hoofdrichtlijn voor LLM-hosting vergelijkt het met Ollama, vLLM, LocalAI en cloudproviders, inclusief kosten- en infrastructuurcompromissen.

Is het instellen van een GPU met Ollama makkelijker dan met Docker Model Runner?

Ja. Ollama detecteert en gebruikt automatisch GPUs zonder dat er een daemon of herinstallatie nodig is. Docker Model Runner vereist de Docker daemon, NVIDIA runtime en een installatie van een CUDA-gestuurde runner. Beide opties worden behandeld in de LLM Hosting gids.

GPU-onsteunigheid van NVIDIA toevoegen aan Docker Model Runner

Q: Waarom gebruikt Docker Model Runner de GPU niet standaard?

Docker Model Runner vereist expliciete GPU-configuratie omdat het moet worden geïnstalleerd met de CUDA-versie. In tegenstelling tot standaard docker run-opdrachten, ondersteunt docker model run geen –gpus-flags, dus moet GPU-ondersteuning worden geconfigureerd op de Docker-daemon-niveau en tijdens de installatie van de runner.

Stel GPU-acceleratie in voor Docker Model Runner met ondersteuning voor NVIDIA CUDA

Docker Model Runner is Docker’s officiële tool om AI-modellen lokaal uit te voeren, maar NVIDIA GPU-acceleratie inschakelen in Docker Model Runner vereist specifieke configuratie.

In tegenstelling tot standaard docker run-opdrachten, ondersteunt docker model run geen --gpus of -e-vlaggen, dus GPU-ondersteuning moet worden geconfigureerd op de Docker-daemon-niveau en tijdens de installatie van de runner.

Als je op zoek bent naar een alternatief LLM-hostingsoplossing met eenvoudigere GPU-configuratie, overweeg dan Ollama, die ingebouwde GPU-ondersteuning en eenvoudigere installatie biedt. Docker Model Runner biedt echter betere integratie met de Docker-ecosysteem en OCI-artefactdistributie. Voor een breder overzicht van Docker Model Runner in vergelijking met Ollama, vLLM, LocalAI en cloudproviders—met inbegrip van kosten en infrastructuurcompromissen—zie LLM Hosting: Lokale, Self-Hosted & Cloudinfrastructuur vergeleken.

Docker Model Runner met NVIDIA GPU-ondersteuning Deze mooie afbeelding is gegenereerd door AI model Flux 1 dev.

Voorwaarden

Voordat je GPU-ondersteuning configureert, zorg er dan voor dat je hebt:

NVIDIA GPU met compatibele drivers geïnstalleerd. Voor hulp bij het kiezen van de juiste GPU voor AI-werkbelastingen, zie onze gids over Vergelijken van NVidia GPU-specs geschiktheid voor AI.
NVIDIA Container Toolkit geïnstalleerd (zie NVIDIA RTX-ondersteuning sectie)
Docker Model Runner geïnstalleerd (kan opnieuw worden geïnstalleerd met GPU-ondersteuning)

Controleer of je GPU beschikbaar is:

nvidia-smi

Test Docker GPU-toegang:

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

Voor meer Docker-opdrachten en configuratieopties, zie onze Docker Cheatsheet.

Stap 1: Configureer Docker-daemon voor NVIDIA-runtime

Docker Model Runner vereist dat de NVIDIA-runtime als standaardruntime in de Docker-daemonconfiguratie wordt ingesteld.

Zoek de NVIDIA Container Runtime Locatie

Eerst, bepaal waar nvidia-container-runtime is geïnstalleerd:

which nvidia-container-runtime

Dit geeft meestal /usr/bin/nvidia-container-runtime weer. Noteer deze locatie voor de volgende stap.

Configureer Docker-daemon

Maak of pas /etc/docker/daemon.json aan om NVIDIA als standaardruntime in te stellen:

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

Belangrijk: Als which nvidia-container-runtime een andere locatie heeft geretourneerd, pas dan de "path"-waarde in de JSON-configuratie daarop aan.

Herstart de Docker-service

Pas de configuratie aan door Docker opnieuw te starten:

sudo systemctl restart docker

Controleer de configuratie

Bevestig dat de NVIDIA-runtime is geconfigureerd:

docker info | grep -i runtime

Je zou Default Runtime: nvidia moeten zien in de uitvoer.

Stap 2: Installeer Docker Model Runner met GPU-ondersteuning

Docker Model Runner moet worden geïnstalleerd of opnieuw geïnstalleerd met expliciete GPU-ondersteuning. Het runner-container zelf moet de CUDA-geenablede versie zijn.

Stop huidig runner (indien actief)

Als Docker Model Runner al is geïnstalleerd, stop het dan eerst:

docker model stop-runner

Installeer/Herinstalleer met CUDA-ondersteuning

Installeer of herinstalleer Docker Model Runner met CUDA GPU-ondersteuning:

docker model reinstall-runner --gpu cuda

Deze opdracht:

Haalt de CUDA-geenablede versie (docker/model-runner:latest-cuda) op in plaats van de CPU-only versie
Stelt de runner-container in om de NVIDIA-runtime te gebruiken
Schakelt GPU-acceleratie in voor alle modellen

Opmerking: Als je Docker Model Runner al hebt geïnstalleerd zonder GPU-ondersteuning, moet je het opnieuw installeren met de --gpu cuda-vlag. Alleen het configureren van de Docker-daemon is niet voldoende—de runner-container zelf moet de CUDA-geenablede versie zijn.

Beschikbare GPU-backends

Docker Model Runner ondersteunt meerdere GPU-backends:

cuda - NVIDIA CUDA (meest gebruikt voor NVIDIA GPUs)
rocm - AMD ROCm (voor AMD GPUs)
musa - Moore Threads MUSA
cann - Huawei CANN
auto - Automatische detectie (standaard, werkt mogelijk niet correct)
none - Alleen CPU

Voor NVIDIA GPUs, gebruik altijd --gpu cuda expliciet.

Stap 3: Verifieer GPU-toegang

Na de installatie, controleer of Docker Model Runner toegang heeft tot je GPU.

Controleer GPU-toegang in runner-container

Test GPU-toegang binnen de Docker Model Runner-container:

docker exec docker-model-runner nvidia-smi

Dit zou je GPU-informatie tonen, wat bevestigt dat de container GPU-toegang heeft.

Controleer runner-status

Controleer of Docker Model Runner actief is:

docker model status

Je zou moeten zien dat de runner actief is met llama.cpp-ondersteuning.

Stap 4: Test model met GPU

Voer een model uit en controleer of het GPU gebruikt.

Voer een model uit

Start een modelinference:

docker model run ai/qwen3:14B-Q6_K "wie ben jij?"

Controleer GPU-gebruik in logboeken

Controleer de Docker Model Runner-logboeken op GPU-bevestiging:

docker model logs | grep -i cuda

Je zou berichten moeten zien die aangeven dat de GPU wordt gebruikt:

using device CUDA0 (NVIDIA GeForce RTX 4080) - GPU-apparaat gedetecteerd
offloaded 41/41 layers to GPU - Modellagen geladen op GPU
CUDA0 model buffer size = 10946.13 MiB - GPU-geheugenallocatie
CUDA0 KV buffer size = 640.00 MiB - Sleutel-waarde cache op GPU
CUDA0 compute buffer size = 306.75 MiB - Rekenbuffer op GPU

Monitor GPU-gebruik

In een ander terminalvenster, monitor het GPU-gebruik in real-time:

nvidia-smi -l 1

Je zou moeten zien dat het GPU-geheugen en de利用率 stijgen wanneer het model draait.

Voor meer geavanceerde GPU-monitoringopties en tools, zie onze gids over GPU-monitoringtoepassingen in Linux / Ubuntu.

Probleemoplossing

Model gebruikt nog steeds CPU

Als het model nog steeds op de CPU draait:

Controleer Docker-daemonconfiguratie:
```
docker info | grep -i runtime
```
Moet Default Runtime: nvidia tonen
Controleer runtime van runner-container:
```
docker inspect docker-model-runner | grep -A 2 '"Runtime"'
```
Moet "Runtime": "nvidia" tonen
Herinstalleer runner met GPU-ondersteuning:
```
docker model reinstall-runner --gpu cuda
```
Controleer logboeken op fouten:
```
docker model logs | tail -50
```

GPU niet gedetecteerd

Als de GPU niet gedetecteerd wordt:

Controleer of NVIDIA Container Toolkit is geïnstalleerd:
```
dpkg -l | grep nvidia-container-toolkit
```
Test GPU-toegang met standaard Docker:
```
docker run --rm --gpus all nvidia/cuda:12.2.2-base-ubi8 nvidia-smi
```
Voor het oplossen van Dockerproblemen, zie onze Docker Cheatsheet.
Controleer NVIDIA drivers:
```
nvidia-smi
```

Prestatieproblemen

Als de GPU-prestaties slecht zijn:

Controleer GPU-utilisatie:
```
nvidia-smi
```
Zoek naar een hoge percentage GPU-utilisatie
Controleer of modellagen op GPU zijn:
```
docker model logs | grep "offloaded.*layers to GPU"
```
Alle lagen moeten worden verplaatst naar GPU
Controleer op geheugenproblemen:
```
nvidia-smi
```
Zorg ervoor dat het GPU-geheugen niet is opgebruikt

Beste praktijken

Specificeer altijd GPU-backend expliciet: Gebruik --gpu cuda in plaats van --gpu auto voor NVIDIA GPUs om de juiste configuratie te garanderen.
Controleer configuratie na wijzigingen: Controleer altijd docker info | grep -i runtime na wijzigingen in de Docker-daemoninstellingen.
Monitor GPU-gebruik: Gebruik nvidia-smi om GPU-geheugen en -utilisatie te monitoren tijdens modelinference. Voor geavanceerde monitoringtools, zie onze gids over GPU-monitoringtoepassingen in Linux / Ubuntu.
Controleer logboeken regelmatig: Bekijk docker model logs om ervoor te zorgen dat modellen GPU-acceleratie gebruiken.
Gebruik geschikte modelgroottes: Zorg ervoor dat je GPU voldoende geheugen heeft voor het model. Gebruik gequantiseerde modellen (Q4, Q5, Q6, Q8) voor betere GPU-geheugenefficiëntie. Voor hulp bij het kiezen van de juiste GPU voor je AI-werkbelastingen, zie onze gids over Vergelijken van NVidia GPU-specs geschiktheid voor AI.

Zodra GPU-ondersteuning is ingeschakeld, is Docker Model Runner één van meerdere manieren om LLMs lokaal uit te voeren. Om te zien hoe het past bij Ollama, vLLM, cloud APIs en andere opties, controleer dan onze LLM Hosting: Lokale, Self-Hosted & Cloudinfrastructuur vergeleken gids.