Ollama 面试题

FROM llama3.2:8b-instruct-q4_K_M
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096
PARAMETER stop "<|eot_id|>"
PARAMETER stop "<|start_header_id|>"
SYSTEM """You are a DevOps engineer specializing in cloud-native technologies."""
TEMPLATE """XQOPEN .System XQCLOSE<|start_header_id|>user<|end_header_id|>

XQOPEN .Prompt XQCLOSE<|eot_id|><|start_header_id|>assistant<|end_header_id|>

"""
LICENSE """MIT License"""

# 拉取指定量化标签
ollama pull llama3.2:8b-instruct-q4_K_M

# 查看本地模型详情（量化级别、context length、Modelfile）
ollama show llama3.2:8b-instruct-q4_K_M

# 自定义模型
ollama create my-custom-model -f Modelfile

# 推送至 ollama.com（需注册账号）
ollama push jangrui/my-custom-model

# 仅使用第一块 GPU
CUDA_VISIBLE_DEVICES=0 ollama serve

# macOS Metal 自动启用，无需额外配置
ollama run llama3.2

# 允许 4 个并发请求
export OLLAMA_NUM_PARALLEL=4

# 允许同时加载 2 个模型（需足够显存）
export OLLAMA_MAX_LOADED_MODELS=2

# 拉取时即指定大上下文
ollama pull llama3.2:8b-instruct-q4_K_M

# 创建自定义模型并设置上下文
ollama create my-model -f - <<EOF
FROM llama3.2:8b-instruct-q4_K_M
PARAMETER num_ctx 32768
PARAMETER num_predict 2048
EOF

# API 请求中覆盖上下文
import ollama
response = ollama.chat(
    model="llama3.2",
    options={"num_ctx": 16384},
    messages=[{"role": "user", "content": "..."}]
)

# 模型空闲 10 分钟后自动卸载
export OLLAMA_KEEP_ALIVE=10m

# 模型永不自动卸载（一直占用显存）
export OLLAMA_KEEP_ALIVE=-1

# 请求时指定 keep_alive
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Hello"}],
  "keep_alive": "5m"
}'

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama 不验证 API key，值可为任意非空字符串
)

# 对话补全
response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "解释 Kubernetes Service 类型"}]
)
print(response.choices[0].message.content)

# 嵌入向量
embed = client.embeddings.create(
    model="nomic-embed-text",
    input="Kubernetes 集群高可用架构"
)
print(len(embed.data[0].embedding))  # 768

from langchain_ollama import ChatOllama, OllamaEmbeddings

llm = ChatOllama(model="llama3.2", base_url="http://localhost:11434")
embeddings = OllamaEmbeddings(model="nomic-embed-text")

# 拉取 embedding 模型
ollama pull nomic-embed-text

# 生成嵌入向量
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "Kubernetes 集群高可用架构"
}'

import ollama

# 批量生成向量
docs = ["Kubernetes Service", "Deployment 控制器", "Ingress 路由"]
embeddings = [ollama.embed(model="nomic-embed-text", input=doc)["embedding"] for doc in docs]
# 每条向量长度 768

# ChromaDB 集成示例
import chromadb
client = chromadb.HttpClient(host="localhost", port=8000)
collection = client.get_collection("docs")

query_embed = ollama.embed(model="nomic-embed-text", input=query)["embedding"]
results = collection.query(query_embeddings=[query_embed], n_results=3)
context = "\n".join(results["documents"][0])

response = ollama.chat(model="llama3.2", messages=[
    {"role": "system", "content": f"根据以下上下文回答：\n{context}"},
    {"role": "user", "content": query}
])

import ollama

# 单张图片问答
with open("k8s-architecture.png", "rb") as f:
    response = ollama.chat(
        model="llava",
        messages=[{
            "role": "user",
            "content": "描述图中的 Kubernetes 架构组件",
            "images": [f.read()]
        }]
    )
print(response["message"]["content"])

# 多张图片对比
with open("before.png", "rb") as f1, open("after.png", "rb") as f2:
    response = ollama.chat(
        model="llava",
        messages=[{
            "role": "user",
            "content": "对比这两张截图中的差异",
            "images": [f1.read(), f2.read()]
        }]
    )

import ollama
import json

functions = [
    {
        "name": "get_weather",
        "description": "获取指定城市的天气",
        "parameters": {
            "city": "城市名称",
            "unit": "温度单位（celsius/fahrenheit）"
        }
    }
]

prompt = f"""可用函数：{json.dumps(functions, ensure_ascii=False)}

用户说："北京今天天气如何？"
如果用户意图匹配某函数，仅返回 JSON：
XQOPEN"function": "get_weather", "parameters": {{"city": "北京", "unit": "celsius"XQCLOSE}}
否则返回："no_function""

response = ollama.generate(model="llama3.2", prompt=prompt)

# llama3.1 内置 tool calling 模式
response = ollama.chat(model="llama3.1:8b", messages=[
    {"role": "system", "content": "对用户请求返回 JSON，包含 intention 和参数"},
    {"role": "user", "content": "北京明天天气"}
])

# 对话（streaming 关闭）
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "什么是 SRE？"}],
  "stream": false,
  "options": {"temperature": 0.2, "num_ctx": 4096}
}'

# 生成（streaming）
curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Generate a Dockerfile for Go application",
  "stream": true
}'

# 查看当前加载的模型
curl http://localhost:11434/api/ps

# 查看模型详情
curl http://localhost:11434/api/show -d '{"model": "llama3.2:8b"}'

# 删除模型
curl -X DELETE http://localhost:11434/api/delete -d '{"model": "old-model:latest"}'

# 复制模型
curl http://localhost:11434/api/copy -d '{
  "source": "llama3.2:8b",
  "destination": "my-llama:prod"
}'

# 添加社区 Helm 仓库并部署
helm repo add ollama-helm https://otwld.github.io/ollama-helm/
helm install ollama ollama-helm/ollama \
  --set runtimeClassName=nvidia \
  --set ollama.gpu.enabled=true \
  --set ollama.models[0].name=llama3.2:8b \
  --set ollama.models[1].name=nomic-embed-text \
  --set service.type=ClusterIP \
  --set persistence.enabled=true \
  --set persistence.size=50Gi

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama
  template:
    metadata:
      labels:
        app: ollama
    spec:
      runtimeClassName: nvidia
      containers:
      - name: ollama
        image: ollama/ollama:latest
        ports:
        - containerPort: 11434
        env:
        - name: OLLAMA_HOST
          value: "0.0.0.0"
        - name: OLLAMA_KEEP_ALIVE
          value: "24h"
        - name: NVIDIA_VISIBLE_DEVICES
          value: "all"
        resources:
          limits:
            nvidia.com/gpu: "1"
            memory: "16Gi"
        volumeMounts:
        - name: models
          mountPath: /root/.ollama
      volumes:
      - name: models
        persistentVolumeClaim:
          claimName: ollama-models
apiVersion: v1
kind: Service
metadata:
  name: ollama
spec:
  ports:
  - port: 11434
    targetPort: 11434
  selector:
    app: ollama

# Open WebUI Deployment 连接 Ollama Service
apiVersion: apps/v1
kind: Deployment
metadata:
  name: open-webui
spec:
  template:
    spec:
      containers:
      - name: open-webui
        image: ghcr.io/open-webui/open-webui:main
        env:
        - name: OLLAMA_BASE_URL
          value: "http://ollama.default.svc.cluster.local:11434"
        ports:
        - containerPort: 8080

# 仅使用 GPU 0 和 GPU 2
export CUDA_VISIBLE_DEVICES=0,2
ollama serve

# 四卡 A100 80GB 加载 llama3.1:70b
# 自动分配大约：GPU 0: 20层, GPU 1: 20层, GPU 2: 20层, GPU 3: 20层
CUDA_VISIBLE_DEVICES=0,1,2,3 ollama run llama3.1:70b

# 支持 4 并发推理（一个模型同时处理 4 个请求）
export OLLAMA_NUM_PARALLEL=4

# 同时驻留 3 个不同模型
export OLLAMA_MAX_LOADED_MODELS=3

# 查看模型层在 GPU/CPU 上的分布
ollama ps

# 示例输出：
# NAME          ID           SIZE    PROCESSOR    UNTIL
# llama3.2:8b   abc123...    5.9 GB  100% GPU    4 minutes from now

# 生产环境 Service 启动配置
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_ORIGINS="https://webui.example.com,https://api.example.com"
export OLLAMA_KEEP_ALIVE=24h
export OLLAMA_NUM_PARALLEL=4
export OLLAMA_MAX_LOADED_MODELS=3
ollama serve

# systemd Unit
[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_ORIGINS=*"
Environment="OLLAMA_KEEP_ALIVE=24h"
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_MAX_LOADED_MODELS=2"
ExecStart=/usr/local/bin/ollama serve

# Nginx 并发限制与排队
upstream ollama_backend {
    server 127.0.0.1:11434;
}

limit_req_zone $binary_remote_addr zone=ollama_limit:10m rate=10r/s;

server {
    location /api/ {
        limit_req zone=ollama_limit burst=20 nodelay;
        proxy_pass http://ollama_backend;
        proxy_read_timeout 300s;
    }
}

# 启动调试模式
OLLAMA_DEBUG=1 ollama serve 2>&1 | tee ollama-debug.log

# OLLAMA_DEBUG=1 输出
time=... level=INFO source=... msg="starting llama runner" cmd="/tmp/ollama20999/rocm-smi/ollama_llama_server"
time=... level=INFO source=... msg="model loaded" model=llama3.2:8b layers=32 gpuLayers=32 mem=5.4GB
time=... level=INFO source=... msg="llama runner started" duration="2.3s"
time=... level=INFO source=... msg="request" method=POST uri=/api/chat status=200 duration=3.2s

# OLLAMA_DEBUG=2 额外输出
time=... level=DEBUG source=... msg="loaded 1536MB of model to GPU 0"
time=... level=DEBUG source=... msg="allocated KV cache" size=524288

# 实时监控模型状态
watch -n 2 'curl -s http://localhost:11434/api/ps | jq .'

# 查看 runner 日志位置
ls /tmp/ollama*/ollama_llama_server

# chat 模式模板示例（llama3.2 格式）
TEMPLATE """XQOPEN if .System XQCLOSE<|start_header_id|>system<|end_header_id|>

XQOPEN .System XQCLOSE<|eot_id|>XQOPEN end XQCLOSEXQOPEN range .Messages XQCLOSEXQOPEN if eq .Role "user" XQCLOSE<|start_header_id|>user<|end_header_id|>

XQOPEN .Content XQCLOSE<|eot_id|><|start_header_id|>assistant<|end_header_id|>

XQOPEN else if eq .Role "assistant" XQCLOSEXQOPEN .Content XQCLOSE<|eot_id|>XQOPEN end XQCLOSEXQOPEN end XQCLOSE"""

# generate 模式模板示例
TEMPLATE """XQOPEN .System XQCLOSE
### Instruction:
XQOPEN .Prompt XQCLOSE
### Response:
XQOPEN .Response XQCLOSE"""

# 安全部署示例：反代 + Nginx Basic Auth
export OLLAMA_HOST=127.0.0.1:11434

# Nginx 反代配置
# 生成 htpasswd: htpasswd -c /etc/nginx/.htpasswd ollama-admin

server {
    listen 443 ssl;
    server_name ollama.internal.example.com;

    ssl_certificate     /etc/nginx/ssl/fullchain.pem;
    ssl_certificate_key /etc/nginx/ssl/privkey.pem;

    auth_basic "Ollama API";
    auth_basic_user_file /etc/nginx/.htpasswd;

    location / {
        proxy_pass http://127.0.0.1:11434;
        proxy_read_timeout 300s;
    }
}

User/App --> Auth Gateway (OAuth2/OIDC) --> LiteLLM Proxy --> Ollama (127.0.0.1 only)
                  |
            Rate Limiting + Audit Log

FROM llama3.2:8b-instruct-q4_K_M
PARAMETER num_gpu 999
PARAMETER num_thread 14
PARAMETER num_batch 1024
PARAMETER num_ctx 8192

# 启用 Flash Attention
export OLLAMA_FLASH_ATTENTION=1
ollama serve

Ollama CLI / SDK
      |
   Ollama Serve (Go)
      |
   runner (llama.cpp C/C++ 子进程)
      |
   CUDA / Metal / ROCm / CPU BLAS

ollama --version
# ollama version is 0.5.7
# llama.cpp version is b4385

# 重启 serve 并绑定所有网卡
OLLAMA_HOST=0.0.0.0:11434 ollama serve

# 排查网络与 registry 连通性
curl -I https://registry.ollama.ai/v2/

# 检查代理设置
env | grep -i proxy

# 手动验证模型存在
curl -s https://ollama.com/library/llama3.2 | grep -o "llama3.2.*"

# 清理损坏下载
rm -rf ~/.ollama/models/blobs/sha256-<partial-hash>
ollama pull <model>

# 验证 CUDA 驱动
nvidia-smi

# 查看 serve 日志中的 GPU 检测信息
OLLAMA_DEBUG=1 ollama serve 2>&1 | grep -i "gpu\|cuda\|rocm"

# 确认 llama.cpp runner 是否编译了 CUDA support
ollama serve 2>&1 | grep "cuda\|rocm\|metal"

Browser --> Open WebUI (8080) --> Ollama (11434)

version: "3.8"
services:
  ollama:
    image: ollama/ollama:latest
    volumes:
      - ollama_data:/root/.ollama
    environment:
      - OLLAMA_KEEP_ALIVE=24h
      - OLLAMA_HOST=0.0.0.0
    deploy:
      resources:
        reservations:
          devices:
          - driver: nvidia
            count: 1
            capabilities: [gpu]

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "8080:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - webui_data:/app/backend/data

volumes:
  ollama_data:
  webui_data:

Client --> LiteLLM Proxy (4000) --> Ollama (11434)
              |
        Auth + Rate Limit + Logging + Cost Tracking

# LiteLLM Proxy config
model_list:
  - model_name: gpt-4o-mini
    litellm_params:
      model: ollama/llama3.2:8b-instruct-q4_K_M
      api_base: http://ollama:11434
  - model_name: text-embedding-3-small
    litellm_params:
      model: ollama/nomic-embed-text
      api_base: http://ollama:11434

general_settings:
  master_key: ${LITELLM_MASTER_KEY}

litellm_settings:
  num_retries: 3
  request_timeout: 300
  set_verbose: true
  drop_params: true

pip install 'litellm[proxy]'
litellm --config proxy_config.yaml --port 4000

upstream ollama {
    server 127.0.0.1:11434;
}

server {
    listen 443 ssl;
    server_name llm.internal.company.com;

    ssl_certificate     /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;

    # 服务间认证
    auth_request /auth;
    auth_request_set $auth_status $upstream_status;

    # 速率限制：每 IP 10 req/s，burst 20
    limit_req_zone $binary_remote_addr zone=ollama:10m rate=10r/s;
    limit_req zone=ollama burst=20 nodelay;

    location / {
        proxy_pass http://ollama;
        proxy_read_timeout 300s;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    location = /auth {
        internal;
        proxy_pass http://127.0.0.1:8081/validate;  # 自建 Auth Service
        proxy_pass_request_body off;
        proxy_set_header X-Original-URI $request_uri;
        proxy_set_header X-Api-Key $http_authorization;
    }
}

graph TD
    Nginx["Nginx (443: Auth)"]
    O1["Ollama #1 (llama3.2)"]
    O2["Ollama #2"]
    O3["Ollama #3 (llama3.1)"]
    PV["Shared PV (models/)"]

    Nginx --> O1
    Nginx --> O2
    Nginx --> O3
    O1 --> PV
    O2 --> PV
    O3 --> PV