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 snabbreferensen ger en översikt över alla viktiga kommandon, konfigurationer och bästa praxis.

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

Installation

Docker Desktop

Aktivera Docker Model Runner genom gränssnittet:

  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 plugin-paketet:

# 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 LLMs 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

därefter kan du köra containrar med --gpus all

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

kontrollera att containern 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öder docker model run inte --gpus eller -e-flaggor. 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 vä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

Anteckning: Om which nvidia-container-runtime returnerar en annan väg, uppdatera värdet "path" i JSON-konfigurationen därefter.

Starta om Docker:

sudo systemctl restart docker

Verifiera konfigurationen:

docker info | grep -i runtime

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

  1. Installera om Docker Model Runner med GPU-stöd

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

# Stäng den nuvarande körningen
docker model stop-runner

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

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

  1. Verifiera GPU-åtkomst

Kontrollera att Docker Model Runner-containern 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 "vem är du?"

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

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 - containern själv måste vara den CUDA-aktiverade versionen.

Tillgängliga GPU-backends:

  • cuda - NVIDIA CUDA (vanligast)
  • rocm - AMD ROCm
  • musa - Moore Threads MUSA
  • cann - Huawei CANN
  • auto - Automatisk detektering (standard)
  • none - CPU-endast

Grundläggande kommandon

Hämtning av modeller

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

# Grundläggande hämtning
docker model pull ai/llama2

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

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

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

Körning av modeller

Starta en modell med automatisk API-tjänst:

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

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

överlag har vi inte många alternativ när det gäller att köra modeller via CLI:

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

Kör en modell och interagerar med den med hjälp av en inskickad prompt eller chat-lä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örningsminne för modellen överstiger systemresurserna.

Lista över 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 endast hash-koder
docker model ls -q

Ta bort modeller

Radera modeller från lokal lagring:

# Ta bort specifik modell
docker model rm ai/llama2

# Ta bort med tvång (även om den körs)
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 modellkontextstorlekar

Vi kan inte använda CLI för att ange kontextstorlek för en specifik förfrågan.

Grundläggande kan du bara kontrollera modellkontextstorleken på tre sätt:

  1. Paketera modellen själv, med angiven hårdkodad kontextstorlek (Se mer om detta i nästa avsnitt.)

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

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

Därefter kan du ringa curl till det, men du kan inte göra docker moder run... - det kommer att ignorera konfigurationen.

  1. I docker-compose.yaml-filen, men vi kan inte använda docker-model-runner-image på det här sättet, eftersom det 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 den dedikerade inlägget om detta: Angivande av kontextstorlek i DMR

Paketering av egna 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 skicka 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

Publicering av modeller

Skicka modeller till registrer:

# Logga in på Docker Hub
docker login

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

# Skicka till privat registry
docker login myregistry.com
docker model push myregistry.com/models/mymodel:latest

# Märk och skicka
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

# Chat-komplettering
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": "Det var en gång",
    "max_tokens": 100
  }'

# Strömmande svar
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama2",
    "messages": [{"role": "user", "content": "Berätta en saga"}],
    "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-modelluppsättning

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 som täcker nätverk, volymer och orkestreringsmönster.

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

# Maximal antal tokens
MODEL_MAX_TOKENS=2048

# Antal GPU-lager
MODEL_GPU_LAYERS=35

# Batchstorlek
MODEL_BATCH_SIZE=512

# Antal trådar (CPU)
MODEL_THREADS=8

# Aktivera detaljerad loggning
MODEL_VERBOSE=true

# API-nyckel för autentisering
MODEL_API_KEY=din-hemliga-nyckel

Kör med miljövariabler:

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

GPU-konfiguration

Automatisk GPU-detektering

DMR detekterar och använder tillgängliga GPUs automatiskt:

# Använd alla GPUs
docker model run --gpus all ai/llama2

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

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

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

CPU-endast-läge

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

docker model run --no-gpu ai/llama2

Multi-GPU Tensor-parallelism

Fördela stora modeller över GPUs:

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 modellager
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 senaste 100 raderna
docker model logs --tail 100 llm

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

Prestandastatistik

# Resursanvändning
docker model stats

# Specifika modellstatistik
docker model stats llm

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

Nätverk

Exponering av API:er

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

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

# Binda 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": [...]}'

Registreringsautentisering

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

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

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

Bäst praxis

Modellval

# Använd kvantiserade 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 minnesbegränsningar
docker model run --memory 8g --memory-swap 16g ai/llama2

# Ställ in CPU-begränsningar
docker model run --cpus 4 ai/llama2

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

Hälsokontroller

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

Produktionsorkestrerings

För produktionsdistributioner med Kubernetes kan Docker Model Runner-containrar orkestreras med standard Kubernetes-manifest. Definiera distributioner med resursbegränsningar, autoskalning och lastbalansering. För omfattande Kubernetes-kommandoreferens och distributionsmönster, kontrollera vårt Kubernetes Cheatsheet.

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

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

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

Felsökning

Vanliga problem

Modell startar inte:

# Kontrollera tillgängligt diskutrymme
df -h

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

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

Minne slut:

# Använd mindre kvantiserad 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

Långsam 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
)

# Chattkomplettering
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 saga"}],
    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örs
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);

Användbara länkar

Officiell dokumentation

Relaterade Cheatsheets

Jämförande artiklar