डॉकर मॉडल रनर चीटशीट: कमांड्स और उदाहरण

# 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

docker model --help

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

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

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

which nvidia-container-runtime

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

sudo systemctl restart docker

docker info | grep -i runtime

# वर्तमान रनर को रोकें
docker model stop-runner

# CUDA GPU समर्थन के साथ रीइंस्टॉल करें
docker model reinstall-runner --gpu cuda

docker exec docker-model-runner nvidia-smi

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

docker model logs | grep -i cuda

# बेसिक पुल
docker model pull ai/llama2

# विशिष्ट संस्करण पुल करें
docker model pull ai/llama2:7b-q4

# कस्टम रजिस्ट्री से पुल करें
docker model pull myregistry.com/models/mistral:latest

# एक नैमस्पेस में उपलब्ध मॉडल्स की सूची देखें
docker search ai/

# बेसिक रन (इंटरैक्टिव)
docker model run ai/llama2 "What is Docker?"

# सर्विस के रूप में चलाएं (बैकग्राउंड)
docker model run -d

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

Run a model and interact with it using a submitted prompt or chat mode

Options:
      --color string                  Use colored output (auto|yes|no) (default "auto")
      --debug                         Enable debug logging
  -d, --detach                        Load the model in the background without interaction
      --ignore-runtime-memory-check   Do not block pull if estimated runtime memory for model exceeds system resources.

# सभी डाउनलोड किए गए मॉडल्स की सूची देखें
docker model ls

# चल रहे मॉडल्स की सूची देखें
docker model ps

# विस्तृत जानकारी के साथ सूची देखें
docker model ls --json

# विस्तृत जानकारी के साथ सूची देखें
docker model ls --openai

# शुस्त हाशकोड्स रिटर्न करेंगे
docker model ls -q

# विशिष्ट मॉडल को हटाएं
docker model rm ai/llama2

# बलपूर्वक हटाएं (चल रहे होने पर भी)
docker model rm -f ai/llama2

# अनुपयोगी मॉडल्स को हटाएं
docker model prune

# सभी मॉडल्स को हटाएं
docker model rm $(docker model ls -q)

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

...
models:
  llm_model:
    model: ai/gemma3-qat:4B
    context_size: 10240
...

# बेसिक पैकेजिंग
docker model package --gguf /path/to/model.gguf myorg/mymodel:latest

# मेटाडेटा के साथ पैकेजिंग
docker model package \
  --gguf /path/to/model.gguf \
  --label "description=Custom Llama model" \
  --label "version=1.0" \
  myorg/mymodel:v1.0

# पैकेज और पुश एक कमांड में
docker model package --gguf /path/to/model.gguf --push myorg/mymodel:latest

# कस्टम कॉन्टेक्स्ट साइज के साथ पैकेजिंग
docker model package \
  --gguf /path/to/model.gguf \
  --context 8192 \
  myorg/mymodel:latest

# डॉकर हब में लॉगिन करें
docker login

# डॉकर हब में पुश करें
docker model push myorg/mymodel:latest

# प्राइवेट रजिस्ट्री में पुश करें
docker login myregistry.com
docker model push myregistry.com/models/mymodel:latest

# टैग और पुश करें
docker model tag mymodel:latest myorg/mymodel:v1.0
docker model push myorg/mymodel:v1.0

# एपीआई के साथ मॉडल शुरू करें
docker model run -d -p 8080:8080 --name llm ai/llama2

# चैट कम्प्लीशन
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama2",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

# टेक्स्ट जनरेशन
curl http://localhost:8080/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama2",
    "prompt": "Once upon a time",
    "max_tokens": 100
  }'

# स्ट्रीमिंग रिस्पॉन्स
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama2",
    "messages": [{"role": "user", "content": "Tell me a story"}],
    "stream": true
  }'

# एपीआई के माध्यम से उपलब्ध मॉडल्स की सूची देखें
curl http://localhost:8080/v1/models

# मॉडल जानकारी
curl http://localhost:8080/v1/models/llama2

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

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"

# तापमान (0.0-1.0)
MODEL_TEMPERATURE=0.7

# टॉप-प सैम्पलिंग
MODEL_TOP_P=0.9

# टॉप-क सैम्पलिंग
MODEL_TOP_K=40

# अधिकतम टोकन
MODEL_MAX_TOKENS=2048

# जीपीयू परतों की संख्या
MODEL_GPU_LAYERS=35

# बैच साइज़
MODEL_BATCH_SIZE=512

# थ्रेड काउंट (सीपीयू)
MODEL_THREADS=8

# वर्बोज़ लॉगिंग सक्षम करें
MODEL_VERBOSE=true

# प्रमाणिकता के लिए एपीआई की
MODEL_API_KEY=your-secret-key

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

# सभी जीपीयूज़ का उपयोग करें
docker model run --gpus all ai/llama2

# विशिष्ट जीपीयू का उपयोग करें
docker model run --gpus 0 ai/llama2

# कई विशिष्ट जीपीयूज़ का उपयोग करें
docker model run --gpus 0,1,2 ai/llama2

# जीपीयू के साथ मेमोरी सीमा
docker model run --gpus all --memory 16g ai/llama2

docker model run --no-gpu ai/llama2

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

# मॉडल कॉन्फ़िगरेशन का निरीक्षण करें
docker model inspect ai/llama2

# मॉडल परतें देखें
docker model history ai/llama2

# मॉडल साइज़ और मेटाडेटा की जांच करें
docker model inspect --format='{{.Size}}' ai/llama2

# मॉडल लॉग्स देखें
docker model logs llm

# रियल-टाइम में लॉग्स फॉलो करें
docker model logs -f llm

# अंतिम 100 पंक्तियाँ देखें
docker model logs --tail 100 llm

# टाइमस्टैम्प के साथ लॉग्स देखें
docker model logs -t llm

# संसाधन उपयोग
docker model stats

# विशिष्ट मॉडल सांख्यिकी
docker model stats llm

# JSON प्रारूप में सांख्यिकी
docker model stats --format json

# डिफ़ॉल्ट पोर्ट (8080)
docker model run -p 8080:8080 ai/llama2

# कस्टम पोर्ट
docker model run -p 3000:8080 ai/llama2

# विशिष्ट इंटरफेस पर बाइंड करें
docker model run -p 127.0.0.1:8080:8080 ai/llama2

# कई पोर्ट
docker model run -p 8080:8080 -p 9090:9090 ai/llama2

# कस्टम नेटवर्क बनाएं
docker network create llm-network

# कस्टम नेटवर्क पर मॉडल चलाएं
docker model run --network llm-network --name llm ai/llama2

# मौजूदा नेटवर्क से कनेक्ट करें
docker model run --network host ai/llama2

# एपीआई की प्रमाणिकता के साथ चलाएं
docker model run \
  -e MODEL_API_KEY=my-secret-key \
  ai/llama2

# प्रमाणिकता के साथ उपयोग करें
curl http://localhost:8080/v1/chat/completions \
  -H "Authorization: Bearer my-secret-key" \
  -H "Content-Type: application/json" \
  -d '{"model": "llama2", "messages": [...]}'

# प्राइवेट रजिस्ट्री में लॉगिन करें
docker login myregistry.com -u username -p password

# प्राइवेट रजिस्ट्री से पुल करें
docker model pull myregistry.com/private/model:latest

# क्रेडेंशियल्स हेल्पर का उपयोग करें
docker login --password-stdin < token.txt

# तेज़ इन्फरेंस के लिए क्वांटाइज़्ड मॉडल का उपयोग करें
docker model pull ai/llama2:7b-q4     # 4-बिट क्वांटाइज़ेशन
docker model pull ai/llama2:7b-q5     # 5-बिट क्वांटाइज़ेशन
docker model pull ai/llama2:7b-q8     # 8-बिट क्वांटाइज़ेशन

# मॉडल वैरिएंट्स की जांच करें
docker search ai/llama2

# मेमोरी सीमाएं निर्धारित करें
docker model run --memory 8g --memory-swap 16g ai/llama2

# सीपीयू सीमाएं निर्धारित करें
docker model run --cpus 4 ai/llama2

# जीपीयू मेमोरी सीमा
docker model run --gpus all --gpu-memory 8g ai/llama2

# हेल्थ चेक के साथ चलाएं
docker model run \
  --health-cmd "curl -f http://localhost:8080/health || exit 1" \
  --health-interval 30s \
  --health-timeout 10s \
  --health-retries 3 \
  ai/llama2

# उदाहरण: क्यूबर्नेट्स क्लस्टर पर तैनात करें
kubectl apply -f llm-deployment.yaml

# डिप्लॉयमेंट स्केल करें
kubectl scale deployment llm --replicas=3

# सेवा के रूप में एक्सपोज़ करें
kubectl expose deployment llm --type=LoadBalancer --port=8080

# उपलब्ध डिस्क स्पेस की जांच करें
df -h

# विस्तृत त्रुटि लॉग्स देखें
docker model logs --tail 50 llm

# जीपीयू उपलब्धता की पुष्टि करें
nvidia-smi  # एनवीडिया जीपीयूज़ के लिए

# छोटे क्वांटाइज़्ड मॉडल का उपयोग करें
docker model pull ai/llama2:7b-q4

# संदर्भ साइज़ कम करें
docker model run -e MODEL_CONTEXT=2048 ai/llama2

# बैच साइज़ सीमा
docker model run -e MODEL_BATCH_SIZE=256 ai/llama2

# जीपीयू उपयोग की जांच करें
docker model stats llm

# यह सुनिश्चित करें कि जीपीयू का उपयोग हो रहा है
docker model logs llm | grep -i gpu

# जीपीयू परतें बढ़ाएं
docker model run -e MODEL_GPU_LAYERS=40 ai/llama2

# सिस्टम जानकारी
docker model system info

# डिस्क उपयोग
docker model system df

# अनुपयोगी संसाधनों को साफ़ करें
docker model system prune

# पूर्ण साफ़ साफ़ी (सभी मॉडल हटाएं)
docker model system prune -a

import openai

# Docker Model Runner के लिए क्लाइंट कॉन्फ़िगर करें
client = openai.OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="not-needed"  # DMR डिफ़ॉल्ट रूप से की की आवश्यकता नहीं है
)

# चैट पूर्णता
response = client.chat.completions.create(
    model="llama2",
    messages=[
        {"role": "user", "content": "नमस्ते!"}
    ]
)

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

# स्ट्रीमिंग
stream = client.chat.completions.create(
    model="llama2",
    messages=[{"role": "user", "content": "मुझे एक कहानी सुनाएं"}],
    stream=True
)

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

#!/bin/bash

# अगर चल रहा नहीं है तो मॉडल शुरू करें
if ! docker model ps | grep -q "llm"; then
    docker model run -d --name llm -p 8080:8080 ai/llama2
    echo "मॉडल शुरू होने की प्रतीक्षा कर रहे हैं..."
    sleep 10
fi

# एपीआई कॉल करें
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'

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

// उपयोग
const response = await chat('डॉकर मॉडल रनर क्या है?');
console.log(response);