Docker Model Runner Cheatsheet: Kommandon & Exempel

Snabbreferens för Docker Model Runner-kommandon

Docker Model Runner (DMR) är Docks officiella lösning för att köra AI-modeller lokalt, introducerad i april 2025. Den här cheatsheten ger en snabb referens för alla viktiga kommandon, konfigurationer och bästa praxis.

För en bredare jämförelse mellan Docker Model Runner och Ollama, vLLM, LocalAI samt molntjänstleverantörer – inklusive kostnads- och infrastrukturtrade-offar – se LLM Hosting: Lokalt, självvärddat & Molninfrastruktur jämförd.

lista över gemma-modeller tillgängliga i docker model runner

Installation

Docker Desktop

Aktivera Docker Model Runner genom GUI:n:

  1. Öppna Docker Desktop
  2. Gå till Inställningar → AI-fliken
  3. Klicka på Aktivera Docker Model Runner
  4. Starta om Docker Desktop

/home/rg/prj/hugo-pers/content/post/2025/10/docker-model-runner-cheatsheet/docker-model-runner_w678.jpg docker model runner windows

Docker Engine (Linux)

Installera pluginpaketet:

# Ubuntu/Debian
sudo apt-get update
sudo apt-get install docker-model-plugin

# Fedora/RHEL
sudo dnf install docker-model-plugin

# Arch Linux
sudo pacman -S docker-model-plugin

Verifiera installationen:

docker model --help

NVIDIA RTX-stöd för Docker

För att aktivera att LLM:er körs på GPU istället för CPU, installera nvidia-container-toolkit:

distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
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/stable/deb/nvidia-container-toolkit.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-get update
sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

sedan kan du köra behållare med --gpus all

docker run --rm --gpus all <image> <command>

kolla att behållaren kan se GPU:n:

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

Lägga till NVidia-stöd för Docker Model Runner

Docker Model Runner kräver explicit GPU-konfiguration. Till skillnad från standard docker run-kommandon, stöds inte --gpus eller -e-flaggor hos docker model run. Istället måste du:

  1. Konfigurera Docker-daemon för att använda NVIDIA-runtime som standard

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

which nvidia-container-runtime

Detta kommer vanligtvis att returnera /usr/bin/nvidia-container-runtime. Använd den här sökvägen i konfigurationen nedan.

Skapa eller uppdatera /etc/docker/daemon.json:

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

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

Starta om Docker:

sudo systemctl restart docker

Verifiera konfigurationen:

docker info | grep -i runtime

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

  1. Reinstallera Docker Model Runner med GPU-stöd

Docker Model Runner måste installeras/ominstalleras med explicit GPU-stöd:

# Stoppa den aktuella runner:n
docker model stop-runner

# Reinstallera med CUDA GPU-stöd
docker model reinstall-runner --gpu cuda

Detta kommer att hämta den CUDA-aktiverade versionen (docker/model-runner:latest-cuda) istället för den endast CPU-versionen.

  1. Verifiera GPU-tillgänglighet

Kontrollera att Docker Model Runner-behållaren kan komma åt GPU:n:

docker exec docker-model-runner nvidia-smi
  1. Testa modell med GPU

Kör en modell och kontrollera loggarna för att bekräfta GPU-användning:

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

Kontrollera loggarna för GPU-bekräftelse:

docker model logs | grep -i cuda

Du bör se meddelanden som:

  • using device CUDA0 (NVIDIA GeForce RTX 4080)
  • offloaded 41/41 layers to GPU
  • CUDA0 model buffer size = 10946.13 MiB

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

Tillgängliga GPU-bakend:

  • cuda - NVIDIA CUDA (vanligast)
  • rocm - AMD ROCm
  • musa - Moore Threads MUSA
  • cann - Huawei CANN
  • auto - Automatisk upptäckt (standard)
  • none - Endast CPU

Core Commands

Pulla Modeller

Hämta förpackade modeller från Docker Hub:

# Grundläggande pull
docker model pull ai/llama2

# Hämta specifik version
docker model pull ai/llama2:7b-q4

# Hämta från anpassad register
docker model pull myregistry.com/models/mistral:latest

# Lista tillgängliga modeller i ett namnutrymme
docker search ai/

Kör Modeller

Starta en modell med automatisk API-server:

# Grundläggande kör (interaktiv)
docker model run ai/llama2 "Vad är Docker?"

# Kör som tjänst (bakgrund)
docker model run -d

overall vi inte har många alternativ med att köra modeller via CLI:

docker model run --help
Usage:  docker model run MODEL [PROMPT]

Kör en modell och interagera med den med en inkommande prompt eller chattläge

Alternativ:
      --color string                  Använd färgad utdata (auto|yes|no) (standard "auto")
      --debug                         Aktivera felsökningsloggning
  -d, --detach                        Ladda modellen i bakgrunden utan interaktion
      --ignore-runtime-memory-check   Blockera inte hämtning om uppskattad körningstid minne för modell överstiger systemresurser.

Lista Modeller

Visa nedladdade och körande modeller:

# Lista alla nedladdade modeller
docker model ls

# Lista körande modeller
docker model ps

# Lista med detaljerad information
docker model ls --json

# Lista med detaljerad information
docker model ls --openai

# Returnerar bara hashkoder
docker model ls -q

Ta bort Modeller

Rensa modeller från lokal lagring:

# Ta bort specifik modell
docker model rm ai/llama2

# Ta bort med tvång (även om den kör)
docker model rm -f ai/llama2

# Ta bort oanvända modeller
docker model prune

# Ta bort alla modeller
docker model rm $(docker model ls -q)

Konfigurera Modell Kontextstorlekar

Vi kan inte använda CLI för att ange kontextstorlek för en specifik begäran.

Basis kan man endast kontrollera modellens kontextstorlek på tre sätt:

  1. Packa modellen själv, specifiera önskad hårdkodad kontextstorlek (Se mer om detta i nästa avsnitt.)

  2. När du använder docker model runner konfigurera kommandot med –context-size-parameter som

docker model configure --context-size=10000 ai/gemma3-qat:4B

Sedan kan du anropa curl till den, men kan inte göra docker moder run... - den kommer att ignorera konfigurationen.

  1. I docker-compose.yaml-filen, men vi kan inte använda docker-model-runner-bild på detta sätt, eftersom den skickar en hårdkodad kontextstorlek på 4096 till modellen
...
models:
  llm_model:
    model: ai/gemma3-qat:4B
    context_size: 10240
...

För mer detaljer se dedikerad post om detta: Specificera kontextstorlek i DMR

Packa Anpassade Modeller

Skapa OCI-artefakt från GGUF

Paketera dina egna GGUF-modeller:

# Grundläggande paketering
docker model package --gguf /path/to/model.gguf myorg/mymodel:latest

# Paketera med metadata
docker model package \
  --gguf /path/to/model.gguf \
  --label "description=Anpassad Llama-modell" \
  --label "version=1.0" \
  myorg/mymodel:v1.0

# Paketera och pusha i ett kommando
docker model package --gguf /path/to/model.gguf --push myorg/mymodel:latest

# Paketera med anpassad kontextstorlek
docker model package \
  --gguf /path/to/model.gguf \
  --context 8192 \
  myorg/mymodel:latest

Publicera Modeller

Pusha modeller till register:

# Logga in på Docker Hub
docker login

# Pusha till Docker Hub
docker model push myorg/mymodel:latest

# Pusha till privat register
docker login myregistry.com
docker model push myregistry.com/models/mymodel:latest

# Tagga och pusha
docker model tag mymodel:latest myorg/mymodel:v1.0
docker model push myorg/mymodel:v1.0

API-användning

OpenAI-kompatibla slutpunkter

Docker Model Runner exponerar automatiskt OpenAI-kompatibla API:er:

# Starta modell med API
docker model run -d -p 8080:8080 --name llm ai/llama2

# Chatkomplettering
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama2",
    "messages": [{"role": "user", "content": "Hej!"}]
  }'

# Textgenerering
curl http://localhost:8080/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama2",
    "prompt": "En gång på en tid",
    "max_tokens": 100
  }'

# Strömmad svar
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama2",
    "messages": [{"role": "user", "content": "Berätta en historia"}],
    "stream": true
  }'

# Lista tillgängliga modeller via API
curl http://localhost:8080/v1/models

# Modellinformation
curl http://localhost:8080/v1/models/llama2

Docker Compose-konfiguration

Grundläggande Compose-fil

version: '3.8'

services:
  llm:
    image: docker-model-runner
    model: ai/llama2:7b-q4
    ports:
      - "8080:8080"
    environment:
      - MODEL_TEMPERATURE=0.7
    volumes:
      - docker-model-runner-models:/models
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  docker-model-runner-models:
    external: true

Multi-Modellkonfiguration

version: '3.8'

services:
  llama:
    image: docker-model-runner
    model: ai/llama2
    ports:
      - "8080:8080"
    
  mistral:
    image: docker-model-runner
    model: ai/mistral
    ports:
      - "8081:8080"
    
  embedding:
    image: docker-model-runner
    model: ai/nomic-embed-text
    ports:
      - "8082:8080"

För mer avancerade Docker Compose-konfigurationer och kommandon, se vår Docker Compose Cheatsheet.

Miljövariabler

Konfigurera modellbeteende med miljövariabler:

# Temperatur (0.0-1.0)
MODEL_TEMPERATURE=0.7

# Top-p sampling
MODEL_TOP_P=0.9

# Top-k sampling
MODEL_TOP_K=40

# Max antal token
MODEL_MAX_TOKENS=2048

# Antal GPU-lager
MODEL_GPU_LAYERS=35

# Batchstorlek
MODEL_BATCH_SIZE=512

# Trådantal (CPU)
MODEL_THREADS=8

# Aktivera detaljerad loggning
MODEL_VERBOSE=true

# API-nyckel för autentisering
MODEL_API_KEY=your-secret-key

Kör med miljövariabler:

docker model run \
  -e MODEL_TEMPERATURE=0.8 \
  -e MODEL_API_KEY=secret123 \
  ai/llama2

GPU-konfiguration

Automatisk GPU-upptäckt

DMR upptäcker automatiskt och använder tillgängliga GPU:er:

# Använd alla GPU:er
docker model run --gpus all ai/llama2

# Använd specifik GPU
docker model run --gpus 0 ai/llama2

# Använd flera specifika GPU:er
docker model run --gpus 0,1,2 ai/llama2

# GPU med minnesgräns
docker model run --gpus all --memory 16g ai/llama2

Endast CPU-läge

Tvinga CPU-inferens när GPU är tillgänglig:

docker model run --no-gpu ai/llama2

Multi-GPU Tensorparallelism

Fördela stora modeller över GPU:er:

docker model run \
  --gpus all \
  --tensor-parallel 2 \
  ai/llama2-70b

Inspektion och felsökning

Visa modellinformation

# Inspektera modellkonfiguration
docker model inspect ai/llama2

# Visa modelllager
docker model history ai/llama2

# Kontrollera modellstorlek och metadata
docker model inspect --format='{{.Size}}' ai/llama2

Loggar och övervakning

# Visa modellloggar
docker model logs llm

# Följ loggar i realtid
docker model logs -f llm

# Visa de sista 100 raderna
docker model logs --tail 100 llm

# Visa loggar med tidsstämplar
docker model logs -t llm

Prestandastatistik

# Resursanvändning
docker model stats

# Specifik modellstatistik
docker model stats llm

# Statistik i JSON-format
docker model stats --format json

Nätverk

Exponera API:er

# Standardport (8080)
docker model run -p 8080:8080 ai/llama2

# Anpassad port
docker model run -p 3000:8080 ai/llama2

# Bind till specifik gränssnitt
docker model run -p 127.0.0.1:8080:8080 ai/llama2

# Flera portar
docker model run -p 8080:8080 -p 9090:9090 ai/llama2

Nätverkskonfiguration

# Skapa anpassat nätverk
docker network create llm-network

# Kör modell på anpassat nätverk
docker model run --network llm-network --name llm ai/llama2

# Anslut till befintligt nätverk
docker model run --network host ai/llama2

Säkerhet

Åtkomstkontroll

# Kör med API-nyckelautentisering
docker model run \
  -e MODEL_API_KEY=my-secret-key \
  ai/llama2

# Använd med autentisering
curl http://localhost:8080/v1/chat/completions \
  -H "Authorization: Bearer my-secret-key" \
  -H "Content-Type: application/json" \
  -d '{"model": "llama2", "messages": [...]}'

Registerautentisering

# Logga in på privat register
docker login myregistry.com -u username -p password

# Hämta från privat register
docker model pull myregistry.com/private/model:latest

# Använd autentiseringshjälpare
docker login --password-stdin < token.txt

Bästa praxis

Modellval

# Använd kvantiseringade modeller för snabbare inferens
docker model pull ai/llama2:7b-q4     # 4-bit kvantisering
docker model pull ai/llama2:7b-q5     # 5-bit kvantisering
docker model pull ai/llama2:7b-q8     # 8-bit kvantisering

# Kontrollera modellvarianter
docker search ai/llama2

Resurshantering

# Ställ in minnesgränser
docker model run --memory 8g --memory-swap 16g ai/llama2

# Ställ in CPU-gränser
docker model run --cpus 4 ai/llama2

# Begränsa GPU-minne
docker model run --gpus all --gpu-memory 8g ai/llama2

Hälsocheckar

# Kör med hälsocheck
docker model run \
  --health-cmd "curl -f http://localhost:8080/health || exit 1" \
  --health-interval 30s \
  --health-timeout 10s \
  --health-retries 3 \
  ai/llama2

Produktionsskala

För produktionsskala deployment med Kubernetes, kan Docker Model Runner-behållare orchestras med standard Kubernetes-manifester. Definiera deployment med resursgränser, autoskalning och belastningsutjämning. För en omfattande Kubernetes-kommandoreferens och deployment-mönster, se vår Kubernetes Cheatsheet.

# Exempel: Deploya till Kubernetes-kluster
kubectl apply -f llm-deployment.yaml

# Skala deployment
kubectl scale deployment llm --replicas=3

# Exponera som tjänst
kubectl expose deployment llm --type=LoadBalancer --port=8080

Felsökning

Vanliga problem

Modellen startar inte:

# Kontrollera tillgänglig diskutrymme
df -h

# Visa detaljerade felloggar
docker model logs --tail 50 llm

# Verifiera GPU-tillgänglighet
nvidia-smi  # För NVIDIA-GPU:n

Minnesfel:

# Använd en mindre kvantiseringad modell
docker model pull ai/llama2:7b-q4

# Minska kontextstorlek
docker model run -e MODEL_CONTEXT=2048 ai/llama2

# Begränsa batchstorlek
docker model run -e MODEL_BATCH_SIZE=256 ai/llama2

Svagt inferens:

# Kontrollera GPU-användning
docker model stats llm

# Se till att GPU används
docker model logs llm | grep -i gpu

# Öka GPU-lager
docker model run -e MODEL_GPU_LAYERS=40 ai/llama2

Diagnostiska kommandon

# Systeminformation
docker model system info

# Diskanvändning
docker model system df

# Rensa oanvända resurser
docker model system prune

# Fullständig rensning (ta bort alla modeller)
docker model system prune -a

Integrationsexempel

Python-integration

import openai

# Konfigurera klient för Docker Model Runner
client = openai.OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="not-needed"  # DMR kräver inte nyckel som standard
)

# Chatkomplettering
response = client.chat.completions.create(
    model="llama2",
    messages=[
        {"role": "user", "content": "Hej!"}
    ]
)

print(response.choices[0].message.content)

# Strömning
stream = client.chat.completions.create(
    model="llama2",
    messages=[{"role": "user", "content": "Berätta en historia"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Bash-skript

#!/bin/bash

# Starta modell om den inte kör
if ! docker model ps | grep -q "llm"; then
    docker model run -d --name llm -p 8080:8080 ai/llama2
    echo "Väntar på att modellen ska starta..."
    sleep 10
fi

# Gör API-anrop
curl -s http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama2",
    "messages": [{"role": "user", "content": "'"$1"'"}]
  }' | jq -r '.choices[0].message.content'

Node.js-integration

import OpenAI from 'openai';

const client = new OpenAI({
    baseURL: 'http://localhost:8080/v1',
    apiKey: 'not-needed'
});

async function chat(message) {
    const completion = await client.chat.completions.create({
        model: 'llama2',
        messages: [{ role: 'user', content: message }]
    });
    
    return completion.choices[0].message.content;
}

// Användning
const response = await chat('Vad är Docker Model Runner?');
console.log(response);

För att se hur Docker Model Runner passar ihop med Ollama, vLLM, LocalAI och molntjänstleverantörer, se vår LLM Hosting: Lokalt, självvärddat & Molninfrastruktur jämförd-guide.

Nyttafulla länkar

Officiell dokumentation

Relaterade artiklar