Docker Model Runner Cheatsheet: Perintah & Contoh

Referensi cepat untuk perintah Docker Model Runner

Docker Model Runner (DMR) adalah solusi resmi Docker untuk menjalankan model AI secara lokal, yang diperkenalkan pada April 2025. Cheat sheet ini memberikan referensi cepat untuk semua perintah penting, konfigurasi, dan praktik terbaik.

daftar model gemma yang tersedia di docker model runner

Instalasi

Docker Desktop

Aktifkan Docker Model Runner melalui GUI:

  1. Buka Docker Desktop
  2. Pergi ke Pengaturan → AI tab
  3. Klik Aktifkan Docker Model Runner
  4. Restart 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)

Pasang paket plugin:

# 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

Verifikasi instalasi:

docker model --help

Perintah Inti

Mengunduh Model

Unduh model yang dikemas sebelumnya dari Docker Hub:

# Unduh dasar
docker model pull ai/llama2

# Unduh versi spesifik
docker model pull ai/llama2:7b-q4

# Unduh dari registry kustom
docker model pull myregistry.com/models/mistral:latest

# Daftar model yang tersedia dalam namespace
docker search ai/

Menjalankan Model

Mulai model dengan pelayanan API otomatis:

# Jalankan dasar (interaktif)
docker model run ai/llama2 "Apa itu Docker?"

# Jalankan sebagai layanan (dalam latar belakang)
docker model run -d --name my-llm ai/llama2

# Jalankan dengan port kustom
docker model run -p 8080:8080 ai/llama2

# Jalankan dengan spesifikasi GPU
docker model run --gpus 0,1 ai/llama2

# Jalankan dengan batas memori
docker model run --memory 8g ai/llama2

# Jalankan dengan variabel lingkungan
docker model run -e MODEL_CONTEXT=4096 ai/llama2

# Jalankan dengan pemasangan volume untuk data yang bertahan
docker model run -v model-data:/data ai/llama2

Daftar Model

Lihat model yang diunduh dan sedang berjalan:

# Daftar semua model yang diunduh
docker model ls

# Daftar model yang sedang berjalan
docker model ps

# Daftar dengan informasi terperinci
docker model ls --all --format json

# Filter berdasarkan nama
docker model ls --filter "name=llama"

Menghentikan Model

Hentikan instance model yang sedang berjalan:

# Hentikan model spesifik
docker model stop my-llm

# Hentikan semua model yang sedang berjalan
docker model stop $(docker model ps -q)

# Hentikan dengan timeout
docker model stop --time 30 my-llm

Menghapus Model

Hapus model dari penyimpanan lokal:

# Hapus model spesifik
docker model rm ai/llama2

# Hapus dengan paksa (meskipun sedang berjalan)
docker model rm -f ai/llama2

# Hapus model yang tidak digunakan
docker model prune

# Hapus semua model
docker model rm $(docker model ls -q)

Mengemas Model Kustom

Membuat Artifact OCI dari GGUF

Kemas model GGUF Anda sendiri:

# Pengemasan dasar
docker model package --gguf /path/to/model.gguf myorg/mymodel:latest

# Pengemasan dengan metadata
docker model package \
  --gguf /path/to/model.gguf \
  --label "description=Model Llama kustom" \
  --label "version=1.0" \
  myorg/mymodel:v1.0

# Pengemasan dan push dalam satu perintah
docker model package --gguf /path/to/model.gguf --push myorg/mymodel:latest

# Pengemasan dengan ukuran konteks kustom
docker model package \
  --gguf /path/to/model.gguf \
  --context 8192 \
  myorg/mymodel:latest

Menerbitkan Model

Push model ke registri:

# Masuk ke Docker Hub
docker login

# Push ke Docker Hub
docker model push myorg/mymodel:latest

# Push ke registri pribadi
docker login myregistry.com
docker model push myregistry.com/models/mymodel:latest

# Tag dan push
docker model tag mymodel:latest myorg/mymodel:v1.0
docker model push myorg/mymodel:v1.0

Penggunaan API

Endpoint yang Kompatibel dengan OpenAI

Docker Model Runner secara otomatis menampilkan API yang kompatibel dengan OpenAI:

# Mulai model dengan API
docker model run -d -p 8080:8080 --name llm ai/llama2

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

# Generasi teks
curl http://localhost:8080/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama2",
    "prompt": "Pada suatu waktu",
    "max_tokens": 100
  }'

# Respons streaming
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama2",
    "messages": [{"role": "user", "content": "Ceritakan sebuah kisah"}],
    "stream": true
  }'

# Daftar model yang tersedia melalui API
curl http://localhost:8080/v1/models

# Informasi model
curl http://localhost:8080/v1/models/llama2

Konfigurasi Docker Compose

File Compose Dasar

version: '3.8'

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

volumes:
  model-data:

Pengaturan Multi-Model

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"

Untuk konfigurasi Docker Compose yang lebih lanjut dan perintah, lihat Docker Compose Cheatsheet yang mencakup jaringan, volume, dan pola orkestrasi.

Variabel Lingkungan

Konfigurasikan perilaku model dengan variabel lingkungan:

# Ukuran jendela konteks
MODEL_CONTEXT=4096

# Suhu (0.0-1.0)
MODEL_TEMPERATURE=0.7

# Sampling top-p
MODEL_TOP_P=0.9

# Sampling top-k
MODEL_TOP_K=40

# Token maksimum
MODEL_MAX_TOKENS=2048

# Jumlah lapisan GPU
MODEL_GPU_LAYERS=35

# Ukuran batch
MODEL_BATCH_SIZE=512

# Jumlah thread (CPU)
MODEL_THREADS=8

# Aktifkan log verbose
MODEL_VERBOSE=true

# Kunci API untuk otentikasi
MODEL_API_KEY=your-secret-key

Jalankan dengan variabel lingkungan:

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

Konfigurasi GPU

Deteksi GPU Otomatis

DMR secara otomatis mendeteksi dan menggunakan GPU yang tersedia:

# Gunakan semua GPU
docker model run --gpus all ai/llama2

# Gunakan GPU spesifik
docker model run --gpus 0 ai/llama2

# Gunakan beberapa GPU spesifik
docker model run --gpus 0,1,2 ai/llama2

# GPU dengan batas memori
docker model run --gpus all --memory 16g ai/llama2

Mode Hanya CPU

Paksa inferensi hanya CPU meskipun GPU tersedia:

docker model run --no-gpu ai/llama2

Tensor Parallelisme Multi-GPU

Distribusikan model besar ke beberapa GPU:

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

Inspeksi dan Debugging

Lihat Detail Model

# Inspeksi konfigurasi model
docker model inspect ai/llama2

# Lihat lapisan model
docker model history ai/llama2

# Periksa ukuran model dan metadata
docker model inspect --format='{{.Size}}' ai/llama2

Log dan Monitoring

# Lihat log model
docker model logs llm

# Ikuti log secara real-time
docker model logs -f llm

# Lihat 100 baris terakhir
docker model logs --tail 100 llm

# Lihat log dengan timestamp
docker model logs -t llm

Statistik Kinerja

# Penggunaan sumber daya
docker model stats

# Statistik model spesifik
docker model stats llm

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

Jaringan

Menampilkan API

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

# Port kustom
docker model run -p 3000:8080 ai/llama2

# Bind ke antarmuka spesifik
docker model run -p 127.0.0.1:8080:8080 ai/llama2

# Banyak port
docker model run -p 8080:8080 -p 9090:9090 ai/llama2

Konfigurasi Jaringan

# Buat jaringan kustom
docker network create llm-network

# Jalankan model pada jaringan kustom
docker model run --network llm-network --name llm ai/llama2

# Hubungkan ke jaringan yang ada
docker model run --network host ai/llama2

Keamanan

Kontrol Akses

# Jalankan dengan otentikasi API key
docker model run \
  -e MODEL_API_KEY=my-secret-key \
  ai/llama2

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

Otentikasi Registri

# Masuk ke registri pribadi
docker login myregistry.com -u username -p password

# Unduh dari registri pribadi
docker model pull myregistry.com/private/model:latest

# Gunakan helper kredensial
docker login --password-stdin < token.txt

Praktik Terbaik

Pemilihan Model

# Gunakan model yang dikuantisasi untuk inferensi yang lebih cepat
docker model pull ai/llama2:7b-q4     # Kuantisasi 4-bit
docker model pull ai/llama2:7b-q5     # Kuantisasi 5-bit
docker model pull ai/llama2:7b-q8     # Kuantisasi 8-bit

# Periksa variasi model
docker search ai/llama2

Manajemen Sumber Daya

# Tetapkan batas memori
docker model run --memory 8g --memory-swap 16g ai/llama2

# Tetapkan batas CPU
docker model run --cpus 4 ai/llama2

# Batasi memori GPU
docker model run --gpus all --gpu-memory 8g ai/llama2

Pemeriksaan Kesehatan

# Jalankan dengan pemeriksaan kesehatan
docker model run \
  --health-cmd "curl -f http://localhost:8080/health || exit 1" \
  --health-interval 30s \
  --health-timeout 10s \
  --health-retries 3 \
  ai/llama2

Orkestrasi Produksi

Untuk penggunaan produksi dengan Kubernetes, container Docker Model Runner dapat diorkestrasi menggunakan manifest Kubernetes standar. Definisikan deployment dengan batas sumber daya, autoscaling, dan load balancing. Untuk referensi perintah k8s dan pola deployment yang komprehensif, lihat Kubernetes Cheatsheet.

# Contoh: Deploy ke cluster Kubernetes
kubectl apply -f llm-deployment.yaml

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

# Tampilkan sebagai service
kubectl expose deployment llm --type=LoadBalancer --port=8080

Penyelesaian Masalah

Masalah Umum

Model tidak dapat dimulai:

# Periksa ruang disk yang tersedia
df -h

# Lihat log kesalahan terperinci
docker model logs --tail 50 llm

# Verifikasi ketersediaan GPU
nvidia-smi  # Untuk GPU NVIDIA

Kesalahan memori habis:

# Gunakan model yang dikuantisasi lebih kecil
docker model pull ai/llama2:7b-q4

# Kurangi ukuran konteks
docker model run -e MODEL_CONTEXT=2048 ai/llama2

# Batasi ukuran batch
docker model run -e MODEL_BATCH_SIZE=256 ai/llama2

Inferensi lambat:

# Periksa penggunaan GPU
docker model stats llm

# Pastikan GPU digunakan
docker model logs llm | grep -i gpu

# Tingkatkan jumlah lapisan GPU
docker model run -e MODEL_GPU_LAYERS=40 ai/llama2

Perintah Diagnostik

# Informasi sistem
docker model system info

# Penggunaan disk
docker model system df

# Bersihkan sumber daya yang tidak digunakan
docker model system prune

# Bersihkan penuh (hapus semua model)
docker model system prune -a

Contoh Integrasi

Integrasi Python

import openai

# Konfigurasi klien untuk Docker Model Runner
client = openai.OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="not-needed"  # DMR tidak memerlukan kunci secara default
)

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

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

# Streaming
stream = client.chat.completions.create(
    model="llama2",
    messages=[{"role": "user", "content": "Ceritakan sebuah kisah"}],
    stream=True
)

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

Skrip Bash

#!/bin/bash

# Mulai model jika belum berjalan
if ! docker model ps | grep -q "llm"; then
    docker model run -d --name llm -p 8080:8080 ai/llama2
    echo "Menunggu model untuk mulai..."
    sleep 10
fi

# Buat panggilan API
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'

Integrasi Node.js

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;
}

// Penggunaan
const response = await chat('Apa itu Docker Model Runner?');
console.log(response);

Tautan Berguna

Dokumentasi Resmi

Cheat Sheet Terkait

Artikel Perbandingan