DeepSeek Model 部署教程

1.1 安装 Ollama

# Linux / macOS
curl -fsSL https://ollama.com/install.sh | sh

# Windows
# 下载安装包：https://ollama.com/download/windows
# 双击安装即可

1.2 部署 DeepSeek 模型

# 部署 DeepSeek R1 8B（推荐入门）
ollama run deepseek-r1:8b

# 部署 DeepSeek Coder 6.7B（编程场景）
ollama run deepseek-coder:6.7b

# 部署 DeepSeek V3 671B（企业级，需 404GB 空间）
ollama run deepseek-v3

1.3 配置 Ollama 服务

Ollama 默认在 localhost:11434 提供 API 服务。如需远程访问或调整配置：

# 设置环境变量允许远程访问
# Linux/macOS
export OLLAMA_HOST=0.0.0.0:11434

# 设置模型存储路径
export OLLAMA_MODELS=/path/to/models

# 设置并发请求数
export OLLAMA_NUM_PARALLEL=4

# 重启 Ollama 使配置生效
systemctl restart ollama # Linux
# macOS: 退出 Ollama 应用后重新打开

1.4 验证部署

# 查看运行中的模型
ollama ps

# 测试 API 接口
curl http://localhost:11434/api/chat -d '{
"model": "deepseek-r1:8b",
"messages": [{"role": "user", "content": "你好"}]
}'

# 查看模型列表
ollama list

2.1 使用 Docker 部署 Ollama

# 拉取 Ollama 官方镜像
docker pull ollama/ollama

# 运行 Ollama 容器（CPU 模式）
docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

# 运行 Ollama 容器（GPU 模式，需要 nvidia-docker）
docker run -d --gpus all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

2.2 在容器中部署 DeepSeek 模型

# 进入容器执行命令
docker exec -it ollama ollama pull deepseek-r1:8b

# 或者直接运行
docker exec -it ollama ollama run deepseek-r1:8b

2.3 Docker Compose 编排（推荐）

创建 docker-compose.yml：

version: '3.8'
services:
ollama:
image: ollama/ollama
container_name: ollama
ports:
- "11434:11434"
volumes:
- ollama_data:/root/.ollama
environment:
- OLLAMA_KEEP_ALIVE=24h
- OLLAMA_HOST=0.0.0.0
restart: unless-stopped
# GPU 支持（取消注释）
# deploy:
# resources:
# reservations:
# devices:
# - driver: nvidia
# count: 1
# capabilities: [gpu]

# 可选：Open WebUI 前端
open-webui:
image: ghcr.io/open-webui/open-webui:main
container_name: open-webui
ports:
- "3000:8080"
volumes:
- open-webui:/app/backend/data
environment:
- OLLAMA_BASE_URL=http://ollama:11434
restart: unless-stopped

volumes:
ollama_data:
open-webui:

# 启动所有服务
docker compose up -d

# 部署模型
docker exec -it ollama ollama pull deepseek-r1:8b

3.1 安装 vLLM

# 安装 vLLM（需要 CUDA 环境）
pip install vllm

# 验证安装
python -c "import vllm; print(vllm.__version__)"

3.2 部署 DeepSeek R1 蒸馏版

# 启动 vLLM 推理服务
python -m vllm.entrypoints.openai.api_server \
--model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
--tensor-parallel-size 2 \
--max-model-len 32768 \
--gpu-memory-utilization 0.95 \
--port 8000

# 参数说明：
# --tensor-parallel-size: GPU 数量（张量并行）
# --max-model-len: 最大上下文长度
# --gpu-memory-utilization: GPU 显存使用率

3.3 部署 DeepSeek V3（671B）

DeepSeek V3 是 MoE 模型，需要多卡集群部署：

# 8 卡 H100/A100 部署 DeepSeek V3
python -m vllm.entrypoints.openai.api_server \
--model deepseek-ai/DeepSeek-V3 \
--tensor-parallel-size 8 \
--max-model-len 131072 \
--gpu-memory-utilization 0.90 \
--trust-remote-code \
--port 8000

3.4 测试 API 接口

# vLLM 提供 OpenAI 兼容 API
curl http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
"messages": [{"role": "user", "content": "你好"}]
}'

3.5 性能对比

3.6 vLLM 核心技术：Continuous Batching（连续批处理）

传统推理引擎使用 Static Batching（静态批处理）：必须等一个 batch 中所有请求都完成才能返回结果，短请求被长请求阻塞，GPU 利用率低。vLLM 的 Continuous Batching 允许请求动态加入和离开 batch——当一个请求生成完毕，立即从 batch 中移除，新请求可以无缝加入，无需等待整个 batch 完成。这在高并发场景下可将吞吐量提升 10 倍以上。

3.7 PagedAttention 详解

PagedAttention 是 vLLM 的核心创新，灵感来源于操作系统的虚拟内存分页机制。传统推理中，KV Cache 使用连续内存分配，导致严重的显存碎片化（内部碎片 + 外部碎片），实际显存利用率仅 20%-40%。PagedAttention 将 KV Cache 切分为固定大小的 Block（类似内存页），按需分配、非连续存储，彻底消除碎片化，将显存利用率提升至 96%。

3.8 Tensor Parallelism vs Pipeline Parallelism

部署大模型时，需要多 GPU 并行。vLLM 支持两种并行策略：

# 混合并行示例：4 节点 × 8 GPU 部署 DeepSeek V3
python -m vllm.entrypoints.openai.api_server \
--model deepseek-ai/DeepSeek-V3 \
--tensor-parallel-size 8 \
--pipeline-parallel-size 4 \
--max-model-len 131072

3.9 Prefix Caching（前缀缓存）

Prefix Caching 自动检测并缓存相同前缀的 KV Cache。当多个请求共享相同的 System Prompt 或 Few-shot 示例时，vLLM 只计算一次前缀的 KV Cache，后续请求直接复用，大幅降低首 Token 延迟（TTFT）。

3.10 Speculative Decoding（推测解码）

Speculative Decoding 使用一个 小型草稿模型（Draft Model） 快速生成多个候选 Token，再由大模型一次性验证。验证通过则接受多个 Token，验证失败则回退重算。在低延迟场景（如聊天、代码补全）中可将吞吐量提升 1.5-3 倍，同时不损失生成质量。

# vLLM 推测解码配置示例
python -m vllm.entrypoints.openai.api_server \
--model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
--speculative-model deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B \
--num-speculative-tokens 5 \
--tensor-parallel-size 2

推荐草稿模型：DeepSeek-R1-Distill-Qwen-1.5B（仅 1.1GB，比主模型快 5-10 倍，验证准确率 >85%）

什么是 llama.cpp？

llama.cpp 是由 Georgi Gerganov 开发的纯 C/C++ LLM 推理引擎，目标是让大模型在消费级硬件上高效运行。它支持 CPU 推理（AVX2/AVX512 指令集加速）、GPU 推理（CUDA/Metal/Vulkan）、混合推理（CPU+GPU），以及多种量化格式（Q2_K 到 Q8_0）。llama.cpp 是 Ollama 的底层推理引擎——Ollama 在 llama.cpp 之上封装了模型管理、API 服务和用户友好的 CLI。

安装 llama.cpp

# 克隆仓库并编译
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# CPU 模式编译（默认，支持 AVX2）
make -j$(nproc)

# CUDA 加速编译
make LLAMA_CUDA=1 -j$(nproc)

# Metal 加速编译（macOS）
make LLAMA_METAL=1 -j$(nproc)

# Vulkan 加速编译（跨平台 GPU）
make LLAMA_VULKAN=1 -j$(nproc)

# 验证安装
./llama-cli --version

将 DeepSeek 模型转换为 GGUF 格式

llama.cpp 使用 GGUF（GPT-Generated Unified Format）格式。如果已有 HuggingFace 格式的 DeepSeek 模型，需要先转换为 GGUF：

# 安装转换依赖
pip install transformers torch sentencepiece

# 使用 llama.cpp 自带的转换脚本
python convert_hf_to_gguf.py deepseek-ai/DeepSeek-R1-Distill-Qwen-8B \
--outtype q8_0 \
--outfile deepseek-r1-8b.Q8_0.gguf

# 量化到更小的格式（Q4_K_M 推荐，体积减半，质量几乎无损）
./llama-quantize deepseek-r1-8b.Q8_0.gguf deepseek-r1-8b.Q4_K_M.gguf Q4_K_M

也可以直接下载社区预转换的 GGUF 模型，无需手动转换。HuggingFace 上搜索 "deepseek gguf" 即可找到。访问 DeepSeek 下载 了解模型获取方式。

运行 DeepSeek R1 推理

# 命令行交互模式
./llama-cli -m deepseek-r1-8b.Q4_K_M.gguf -p "你好，请介绍一下你自己" -n 512

# 交互式对话模式（-cnv 启用对话模板）
./llama-cli -m deepseek-r1-8b.Q4_K_M.gguf -cnv

# CPU 推理优化（指定线程数）
./llama-cli -m deepseek-r1-8b.Q4_K_M.gguf -p "Hello" -t 8 -n 256

# GPU 推理（指定 GPU 层数）
./llama-cli -m deepseek-r1-8b.Q4_K_M.gguf -p "Hello" -ngl 33 -n 256

# 参数说明：
# -m: 模型文件路径
# -p: 输入提示词
# -n: 最大生成 token 数
# -t: CPU 线程数
# -ngl: 卸载到 GPU 的层数（-1 = 全部）
# -cnv: 对话模式（自动应用 chat template）

Server 模式（提供 API 服务）

llama.cpp 提供内置的 HTTP Server，兼容 OpenAI API 格式：

# 启动 llama.cpp HTTP Server
./llama-server -m deepseek-r1-8b.Q4_K_M.gguf \
--host 0.0.0.0 \
--port 8080 \
--n-gpu-layers 33 \
--ctx-size 8192 \
--threads 8

# 测试 API
curl http://localhost:8080/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "deepseek-r1-8b",
"messages": [{"role": "user", "content": "你好"}]
}'

# 查看 Server 状态
curl http://localhost:8080/health

llama.cpp 量化格式选择指南

何时直接用 llama.cpp 而非 Ollama？

大多数用户推荐直接用 Ollama，它已经封装了 llama.cpp 的最佳实践。只有当你需要上述高度定制化场景时，才考虑直接使用 llama.cpp。访问 DeepSeek 使用指南 了解更多。

什么是 SGLang？

SGLang 是一个专为 LLM 推理优化的高性能服务框架，核心创新包括 RadixAttention（基于 Radix Tree 的前缀缓存）、Structured Outputs（结构化输出约束解码）、Constrained Decoding（约束解码）。SGLang 在多个基准测试中展示出 8-15 倍于传统推理的吞吐量，尤其适合需要 JSON 输出、Function Calling、代码生成等结构化场景。

安装 SGLang

# 安装 SGLang（包含所有依赖）
pip install "sglang[all]"

# 或仅安装核心推理引擎
pip install sglang

# 验证安装
python -c "import sglang; print(sglang.__version__)"

启动 SGLang 推理服务

# 部署 DeepSeek R1 蒸馏版（32B）
python -m sglang.launch_server \
--model-path deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
--tp 2 \
--host 0.0.0.0 \
--port 30000

# 部署 DeepSeek R1 蒸馏版（8B，单卡）
python -m sglang.launch_server \
--model-path deepseek-ai/DeepSeek-R1-Distill-Qwen-8B \
--tp 1 \
--host 0.0.0.0 \
--port 30000

# 参数说明：
# --model-path: HuggingFace 模型 ID 或本地路径
# --tp: 张量并行 GPU 数量
# --host: 监听地址
# --port: 服务端口

测试 API 接口

SGLang 完全兼容 OpenAI API 格式，无缝迁移：

# 使用 curl 测试
curl http://localhost:30000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
"messages": [{"role": "user", "content": "你好，请介绍你自己"}],
"temperature": 0.7,
"max_tokens": 512
}'

# 使用 OpenAI Python SDK 调用
from openai import OpenAI

client = OpenAI(
base_url="http://localhost:30000/v1",
api_key="not-needed"
)

response = client.chat.completions.create(
model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
messages=[{"role": "user", "content": "你好"}]
)
print(response.choices[0].message.content)

SGLang 结构化输出示例

SGLang 的核心优势是结构化输出。以下示例展示如何使用 JSON Schema 约束输出格式：

# 使用 JSON Schema 约束输出
curl http://localhost:30000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
"messages": [
{"role": "user", "content": "列出3本推荐的人工智能书籍"}
],
"response_format": {
"type": "json_schema",
"json_schema": {
"name": "book_recommendations",
"schema": {
"type": "object",
"properties": {
"books": {
"type": "array",
"items": {
"type": "object",
"properties": {
"title": {"type": "string"},
"author": {"type": "string"},
"year": {"type": "integer"},
"reason": {"type": "string"}
},
"required": ["title", "author", "reason"]
}
}
},
"required": ["books"]
}
}
}
}'

SGLang vs vLLM：如何选择？

如果业务场景大量依赖结构化输出（JSON/Function Calling），SGLang 是更好的选择。如果主要是通用对话场景，vLLM 的社区生态更成熟。访问 DeepSeek 模型详情 了解模型能力对比。

什么是 TGI？

TGI（Text Generation Inference）是 HuggingFace 开发和维护的生产级推理服务器，专为 HuggingFace 模型生态设计。它提供 Tensor Parallelism（张量并行）、GPTQ/AWQ 量化、Watermarking（水印）、SafeTensors 加载 等特性。TGI 与 HuggingFace Hub 无缝集成，支持直接通过 model-id 加载模型，无需手动下载。

使用 Docker 部署 TGI

TGI 推荐使用 Docker 部署，官方镜像预配置了所有依赖：

# 拉取 TGI 官方镜像
docker pull ghcr.io/huggingface/text-generation-inference:latest

# 部署 DeepSeek R1 蒸馏版（32B，2 GPU）
docker run --gpus all \
-p 8080:80 \
-v $PWD/data:/data \
-e HUGGING_FACE_HUB_TOKEN=hf_your_token_here \
ghcr.io/huggingface/text-generation-inference:latest \
--model-id deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
--num-shard 2 \
--max-input-length 4096 \
--max-total-tokens 8192

# 部署 DeepSeek R1 蒸馏版（8B，单 GPU）
docker run --gpus all \
-p 8080:80 \
-v $PWD/data:/data \
ghcr.io/huggingface/text-generation-inference:latest \
--model-id deepseek-ai/DeepSeek-R1-Distill-Qwen-8B \
--num-shard 1 \
--max-input-length 4096 \
--max-total-tokens 8192

# 参数说明：
# --model-id: HuggingFace 模型 ID
# --num-shard: GPU 分片数（张量并行）
# --max-input-length: 最大输入长度
# --max-total-tokens: 最大总 token 数（输入+输出）
# -v $PWD/data:/data: 模型缓存目录

使用量化模型部署（降低显存需求）

# 使用 GPTQ 量化模型（显存减半）
docker run --gpus all \
-p 8080:80 \
-v $PWD/data:/data \
ghcr.io/huggingface/text-generation-inference:latest \
--model-id TheBloke/DeepSeek-R1-Distill-Qwen-32B-GPTQ \
--num-shard 1 \
--quantize gptq

# 使用 AWQ 量化模型
docker run --gpus all \
-p 8080:80 \
-v $PWD/data:/data \
ghcr.io/huggingface/text-generation-inference:latest \
--model-id TheBloke/DeepSeek-R1-Distill-Qwen-32B-AWQ \
--num-shard 1 \
--quantize awq

测试 API 接口

# TGI 使用 OpenAI 兼容的 Messages API
curl http://localhost:8080/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "tgi",
"messages": [{"role": "user", "content": "你好，请介绍 DeepSeek 模型"}],
"max_tokens": 512,
"stream": false
}'

# 查看模型信息
curl http://localhost:8080/info

TGI Docker Compose 配置

version: '3.8'
services:
tgi:
image: ghcr.io/huggingface/text-generation-inference:latest
container_name: tgi-deepseek
ports:
- "8080:80"
volumes:
- ./data:/data
environment:
- HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
command:
- --model-id
- deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
- --num-shard
- "2"
- --max-input-length
- "4096"
- --max-total-tokens
- "8192"
deploy:
resources:
reservations:
devices:
- driver: nvidia
count: 2
capabilities: [gpu]
restart: unless-stopped

# 启动 TGI 服务
docker compose up -d

# 查看日志
docker compose logs -f tgi

TGI 性能特征

TGI 的吞吐量约为传统推理的 5-10 倍，低于 vLLM 和 SGLang，但优势在于与 HuggingFace 生态的深度集成。如果团队已经在使用 HuggingFace Hub 管理模型，并依赖 HF 的 Safetensors、模型卡片、自动下载等功能，TGI 是最自然的选择。

TGI 适合 HuggingFace 重度用户，或需要 Watermarking 等安全特性的企业场景。访问 DeepSeek 模型列表 了解各模型详细信息。

选型建议

没有「最好」的引擎，只有「最合适」的选择。建议根据实际业务场景和资源条件选择，必要时可以组合使用多个引擎。访问 DeepSeek 使用指南 和 DeepSeek 模型列表 了解更多技术细节。

4.1 部署 Dify

# 克隆 Dify 仓库
git clone https://github.com/langgenius/dify.git
cd dify/docker

# 复制环境变量配置
cp .env.example .env

# 启动 Dify
docker compose up -d

# 访问 http://localhost:3000 进入 Dify 管理界面

4.2 接入 DeepSeek 模型

1. 登录 Dify 管理界面，进入「设置 → 模型供应商」
2. 找到「OpenAI-API-compatible」供应商
3. 填入以下信息：
   • API Base URL：http://localhost:11434/v1（Ollama）或 http://localhost:8000/v1（vLLM）
   • 模型名称：deepseek-r1:8b
4. 保存后即可在 Dify 应用中使用 DeepSeek 模型

4.3 Dify 应用场景

5.1 Nginx 反向代理配置

Nginx 作为反向代理，将外部请求转发到后端 Ollama（11434 端口）或 vLLM（8000 端口），同时提供连接池、缓冲和负载均衡。

# /etc/nginx/sites-available/deepseek-proxy
upstream deepseek_backend {
# vLLM 后端（推荐生产环境）
server 127.0.0.1:8000 max_fails=3 fail_timeout=30s;
keepalive 32;
}

upstream ollama_backend {
# Ollama 后端（开发环境）
server 127.0.0.1:11434 max_fails=3 fail_timeout=30s;
keepalive 16;
}

server {
listen 80;
server_name deepseek.yourdomain.com;
return 301 https://$server_name$request_uri;
}

server {
listen 443 ssl http2;
server_name deepseek.yourdomain.com;

# SSL 证书（Let's Encrypt）
ssl_certificate /etc/letsencrypt/live/deepseek.yourdomain.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/deepseek.yourdomain.com/privkey.pem;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers HIGH:!aNULL:!MD5;

# 安全头
add_header Strict-Transport-Security "max-age=63072000" always;
add_header X-Content-Type-Options nosniff;

# 请求体大小限制（大文件上传）
client_max_body_size 100M;

# API Key 认证
location /v1/ {
# 验证 API Key
if ($http_authorization !~ "^Bearer sk-[a-zA-Z0-9]{48}$") {
return 401 '{"error":"Unauthorized: invalid or missing API key"}';
add_header Content-Type application/json;
}

# 速率限制
limit_req zone=deepseek_api burst=20 nodelay;
limit_req_status 429;

# 代理到 vLLM
proxy_pass http://deepseek_backend;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;

# SSE 流式输出支持
proxy_buffering off;
proxy_cache off;
proxy_read_timeout 300s;
proxy_send_timeout 300s;
}

# 健康检查端点
location /health {
proxy_pass http://deepseek_backend/health;
access_log off;
}
}

5.2 速率限制配置

在 Nginx 主配置中定义速率限制区域，防止 API 滥用：

# /etc/nginx/nginx.conf 的 http 块中添加
http {
# 定义限速区域：10 请求/秒，突发 20
limit_req_zone $binary_remote_addr zone=deepseek_api:10m rate=10r/s;

# 按 API Key 限速（更精细）
limit_req_zone $http_authorization zone=deepseek_per_key:10m rate=50r/s;

# 并发连接限制
limit_conn_zone $binary_remote_addr zone=conn_per_ip:10m;
}

5.3 Let's Encrypt SSL 证书自动续期

# 安装 Certbot
sudo apt install certbot python3-certbot-nginx

# 申请证书
sudo certbot --nginx -d deepseek.yourdomain.com

# 自动续期（已内置 timer）
sudo systemctl status certbot.timer

# 手动测试续期
sudo certbot renew --dry-run

5.4 健康检查端点

vLLM 自带健康检查端点，可用于负载均衡器的健康探测：

# vLLM 健康检查
curl http://localhost:8000/health
# 返回空响应，HTTP 200 = 健康

# Ollama 健康检查（自定义脚本）
# /usr/local/bin/healthcheck-ollama.sh
#!/bin/bash
curl -sf http://localhost:11434/api/tags > /dev/null && echo "OK" || echo "FAIL"

5.5 API Key 生成与管理

生产环境建议使用 API Gateway（如 Kong、APISIX）或自建简单的 Key 管理：

# 生成安全的 API Key
openssl rand -hex 24
# 输出示例：a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2

# 在 Nginx 中映射 API Key 到用户
# /etc/nginx/api_keys.conf
map $http_authorization $api_user {
"Bearer sk-a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2" "user_prod";
"Bearer sk-z9y8x7w6v5u4t3s2r1q0p9o8n7m6l5k4j3i2h1g0" "user_dev";
default "unknown";
}

6.1 K8s Deployment（Ollama + DeepSeek）

# deepseek-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: deepseek-ollama
namespace: deepseek
labels:
app: deepseek-ollama
spec:
replicas: 1
selector:
matchLabels:
app: deepseek-ollama
strategy:
type: Recreate # GPU 资源独占，不支持滚动更新
template:
metadata:
labels:
app: deepseek-ollama
spec:
# GPU 节点调度
nodeSelector:
accelerator: nvidia-gpu
tolerations:
- key: "nvidia.com/gpu"
operator: "Exists"
effect: "NoSchedule"
containers:
- name: ollama
image: ollama/ollama:latest
ports:
- containerPort: 11434
name: http
env:
- name: OLLAMA_HOST
value: "0.0.0.0"
- name: OLLAMA_KEEP_ALIVE
value: "24h"
- name: OLLAMA_NUM_PARALLEL
value: "4"
resources:
requests:
memory: "16Gi"
cpu: "4"
nvidia.com/gpu: "1"
limits:
memory: "32Gi"
cpu: "8"
nvidia.com/gpu: "1"
volumeMounts:
- name: model-storage
mountPath: /root/.ollama
# 启动后自动拉取模型
lifecycle:
postStart:
exec:
command: ["/bin/sh", "-c", "sleep 10 && ollama pull deepseek-r1:8b"]
livenessProbe:
httpGet:
path: /api/tags
port: 11434
initialDelaySeconds: 120
periodSeconds: 30
readinessProbe:
httpGet:
path: /api/tags
port: 11434
initialDelaySeconds: 60
periodSeconds: 10
volumes:
- name: model-storage
persistentVolumeClaim:
claimName: deepseek-models-pvc

6.2 K8s Service 配置

# deepseek-service.yaml
apiVersion: v1
kind: Service
metadata:
name: deepseek-ollama-svc
namespace: deepseek
labels:
app: deepseek-ollama
spec:
type: ClusterIP
selector:
app: deepseek-ollama
ports:
- name: http
port: 11434
targetPort: 11434
protocol: TCP
sessionAffinity: ClientIP # 保持会话粘性

6.3 K8s Ingress 配置

# deepseek-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: deepseek-ingress
namespace: deepseek
annotations:
nginx.ingress.kubernetes.io/proxy-body-size: "100m"
nginx.ingress.kubernetes.io/proxy-read-timeout: "300"
nginx.ingress.kubernetes.io/proxy-send-timeout: "300"
nginx.ingress.kubernetes.io/proxy-buffering: "off"
# SSL 自动管理
cert-manager.io/cluster-issuer: "letsencrypt-prod"
# 速率限制
nginx.ingress.kubernetes.io/limit-rps: "10"
nginx.ingress.kubernetes.io/limit-burst-multiplier: "3"
spec:
ingressClassName: nginx
tls:
- hosts:
- api.deepseek.example.com
secretName: deepseek-tls
rules:
- host: api.deepseek.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: deepseek-ollama-svc
port:
number: 11434

6.4 PersistentVolume 模型存储

# deepseek-pv.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
name: deepseek-models-pv
labels:
type: local
spec:
storageClassName: manual
capacity:
storage: 500Gi # 足够存放多个模型
accessModes:
- ReadWriteOnce
persistentVolumeReclaimPolicy: Retain
hostPath:
path: "/mnt/data/deepseek-models"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: deepseek-models-pvc
namespace: deepseek
spec:
storageClassName: manual
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 500Gi

生产环境建议使用云存储 CSI 驱动（如 AWS EBS、阿里云 NAS）替代 hostPath，确保 Pod 迁移时数据不丢失。访问 DeepSeek 模型列表 了解各模型存储需求。

6.5 GPU 节点调度配置

确保 K8s 集群已安装 NVIDIA Device Plugin，并将 GPU 节点打上标签：

# 安装 NVIDIA Device Plugin
kubectl create -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v0.15.0/deployments/static/nvidia-device-plugin.yml

# 给 GPU 节点打标签
kubectl label nodes gpu-node-1 accelerator=nvidia-gpu
kubectl label nodes gpu-node-2 accelerator=nvidia-gpu

# 验证 GPU 资源
kubectl describe node gpu-node-1 | grep nvidia.com/gpu

6.6 一键部署脚本

# 创建命名空间并部署全部资源
kubectl create namespace deepseek
kubectl apply -f deepseek-pv.yaml
kubectl apply -f deepseek-deployment.yaml
kubectl apply -f deepseek-service.yaml
kubectl apply -f deepseek-ingress.yaml

# 查看部署状态
kubectl -n deepseek get pods,svc,ingress,pvc

# 查看日志
kubectl -n deepseek logs -f deployment/deepseek-ollama

7.1 云平台方案对比

7.2 AWS 部署方案

AWS EC2：直接启动 GPU 实例，手动部署 Ollama 或 vLLM。灵活度最高，适合有运维经验的团队。

# AWS CLI 启动 g5.xlarge 实例
aws ec2 run-instances \
--image-id ami-0abcdef1234567890 \
--instance-type g5.xlarge \
--key-name my-key-pair \
--security-group-ids sg-xxxxxxxxx \
--block-device-mappings '[{"DeviceName":"/dev/xvda","Ebs":{"VolumeSize":200,"VolumeType":"gp3"}}]' \
--tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=deepseek-server}]'

# SSH 登录后部署
ssh -i my-key-pair.pem ubuntu@
curl -fsSL https://ollama.com/install.sh | sh
ollama pull deepseek-r1:8b

AWS SageMaker：托管机器学习平台，一键部署模型端点，自带自动扩缩容和监控。适合不想管理基础设施的团队。

SageMaker 比 EC2 贵约 30%-50%，但省去了运维成本。如果只是测试，先用 EC2 按需实例。访问 DeepSeek 使用指南 了解更多。

7.3 阿里云部署方案

GPU 云服务器：阿里云提供 gn7i（A10）、gn7（V100）等 GPU 实例系列，适合国内用户低延迟部署。

# 阿里云 ECS GPU 实例部署
# 1. 在控制台创建 gn7i-c8g1.2xlarge 实例
# 2. 选择 Ubuntu 22.04 镜像，系统盘 200GB
# 3. 安装 NVIDIA 驱动和 CUDA
wget https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda_12.4.0_550.54.14_linux.run
sudo sh cuda_12.4.0_550.54.14_linux.run

# 4. 安装 Ollama
curl -fsSL https://ollama.com/install.sh | sh
ollama pull deepseek-r1:8b

PAI-EAS（弹性算法服务）：阿里云 AI 平台，支持一键部署 DeepSeek 模型，提供在线推理服务。内置模型管理、版本控制、自动扩缩容、灰度发布。适合企业级 AI 应用快速上线。

7.4 AutoDL（国内性价比之选）

AutoDL 是国内最大的 GPU 租用平台之一，主打性价比。按小时计费，价格是云厂商的 1/3-1/5。支持 RTX 3090/4090、A100、H100 等多种 GPU。

# AutoDL 实例启动后一键部署
# 实例已预装 CUDA 和 PyTorch
curl -fsSL https://ollama.com/install.sh | sh
ollama serve &
ollama pull deepseek-r1:32b # RTX 4090 完美运行 32B

# 或使用 vLLM
pip install vllm
python -m vllm.entrypoints.openai.api_server \
--model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
--tensor-parallel-size 1 \
--port 8000

7.5 成本优化建议

8.1 接入方式

DeepSeek 官方 API 提供与 OpenAI 完全兼容的接口格式，无需修改代码即可迁移。只需替换 base_url 和 api_key。

8.2 API 定价（远低于 OpenAI）

8.3 Python 调用示例

# 使用 OpenAI SDK 调用 DeepSeek
# pip install openai

from openai import OpenAI

client = OpenAI(
api_key="sk-your-deepseek-api-key",
base_url="https://api.deepseek.com"
)

# 普通对话（V3）
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "解释量子计算的基本原理"}
],
temperature=0.7,
max_tokens=2048,
stream=False
)

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

# 深度推理（R1）
response = client.chat.completions.create(
model="deepseek-reasoner",
messages=[
{"role": "user", "content": "证明根号2是无理数"}
]
)

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

8.4 JavaScript/Node.js 调用示例

// 使用 OpenAI SDK 调用 DeepSeek
// npm install openai

import OpenAI from 'openai';

const client = new OpenAI({
apiKey: 'sk-your-deepseek-api-key',
baseURL: 'https://api.deepseek.com'
});

// 流式输出
const stream = await client.chat.completions.create({
model: 'deepseek-chat',
messages: [
{ role: 'user', content: '写一首关于人工智能的诗' }
],
stream: true
});

for await (const chunk of stream) {
const content = chunk.choices[0]?.delta?.content || '';
process.stdout.write(content);
}

8.5 官方 API vs 自部署对比

建议：先用官方 API 验证业务场景，确认需求后再决定是否自建。大部分场景下官方 API 更经济高效。访问 DeepSeek 模型详情 了解模型能力对比。

9.1 Prometheus + Grafana 监控体系

vLLM 内置 Prometheus 指标端点，配合 Grafana 可视化面板，可实时监控推理服务的健康状态。

# vLLM 启动时自动暴露 Prometheus 指标
python -m vllm.entrypoints.openai.api_server \
--model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
--tensor-parallel-size 2
# 指标自动暴露在 http://localhost:8000/metrics

# 查看指标
curl http://localhost:8000/metrics | head -30

9.2 Prometheus 配置

# prometheus.yml
global:
scrape_interval: 15s
evaluation_interval: 15s

scrape_configs:
- job_name: 'vllm'
static_configs:
- targets: ['localhost:8000']
metrics_path: '/metrics'
scrape_interval: 10s

- job_name: 'node-exporter'
static_configs:
- targets: ['localhost:9100']

- job_name: 'nginx'
static_configs:
- targets: ['localhost:9113']

9.3 关键监控指标

9.4 Grafana 仪表盘配置

# docker-compose 启动 Prometheus + Grafana
# monitoring-stack.yaml
version: '3.8'
services:
prometheus:
image: prom/prometheus:latest
ports:
- "9090:9090"
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml
- prometheus_data:/prometheus
command:
- '--config.file=/etc/prometheus/prometheus.yml'

grafana:
image: grafana/grafana:latest
ports:
- "3000:3000"
environment:
- GF_SECURITY_ADMIN_PASSWORD=admin
volumes:
- grafana_data:/var/lib/grafana
- ./grafana-dashboards:/etc/grafana/provisioning/dashboards

volumes:
prometheus_data:
grafana_data:

Grafana 导入 Dashboard ID 19004（NVIDIA DCGM Exporter）监控 GPU 指标，导入 1860（Node Exporter）监控系统资源。vLLM 自定义 Dashboard 可从社区获取或自行构建。

9.5 日志管理

# vLLM 日志重定向到文件
python -m vllm.entrypoints.openai.api_server \
--model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
--tensor-parallel-size 2 \
2>&1 | tee -a /var/log/vllm/server.log

# 使用 logrotate 管理日志轮转
# /etc/logrotate.d/vllm
/var/log/vllm/*.log {
daily
rotate 30
compress
delaycompress
missingok
notifempty
copytruncate
}

# 使用 Loki + Promtail 收集日志（可选）
# 将日志发送到 Loki，在 Grafana 中统一查询

9.6 自动扩缩容

对于 K8s 部署，可基于 GPU 利用率或请求队列长度实现自动扩缩容：

# deepseek-hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: deepseek-hpa
namespace: deepseek
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: deepseek-ollama
minReplicas: 1
maxReplicas: 4
metrics:
- type: External
external:
metric:
name: vllm_num_requests_waiting
selector:
matchLabels:
app: deepseek-ollama
target:
type: AverageValue
averageValue: "5"
behavior:
scaleDown:
stabilizationWindowSeconds: 300 # 5 分钟后才缩容
scaleUp:
stabilizationWindowSeconds: 30 # 30 秒即可扩容

GPU 资源稀缺且昂贵，建议设置合理的 maxReplicas 避免成本失控。同时GPU 扩容受限于集群可用 GPU 数量，建议配合 Cluster Autoscaler 动态扩容节点。访问 DeepSeek 下载 了解模型获取方式。

9.7 告警规则

# prometheus-alerts.yml
groups:
- name: deepseek_alerts
rules:
- alert: HighTTFT
expr: histogram_quantile(0.95, vllm:time_to_first_token_seconds) > 1.0
for: 5m
labels:
severity: warning
annotations:
summary: "TTFT p95 超过 1 秒"

- alert: HighGPUUsage
expr: vllm:gpu_cache_usage_perc > 95
for: 5m
labels:
severity: critical
annotations:
summary: "GPU 显存使用率超过 95%"

- alert: RequestQueueBacklog
expr: vllm:num_requests_waiting > 20
for: 2m
labels:
severity: warning
annotations:
summary: "请求队列积压超过 20"

- alert: ServiceDown
expr: up{job="vllm"} == 0
for: 1m
labels:
severity: critical
annotations:
summary: "vLLM 服务不可用"