DeepSeek 部署提速实战：从显存占用到高并发的完整优化命令

发布人：慈云数据-客服中心发布时间：1 天前阅读量：1

DeepSeek 性能优化教程｜附完整命令

DeepSeek 系列模型在代码生成、数学推理、中文问答、智能体工作流等场景中表现突出，但在实际部署时，很多人会遇到这些问题：响应慢、显存不够、并发上不去、首字延迟高、长上下文容易爆显存、吞吐量不稳定。
本文将围绕 DeepSeek 的本地部署与服务化推理，系统讲解性能优化思路，并给出可直接复制执行的完整命令。

说明：本文主要面向 Linux 服务器环境，适用于 DeepSeek-R1、DeepSeek-V3、DeepSeek-Coder、DeepSeek 蒸馏模型等。不同模型参数规模、权重格式和推理框架会有差异，命令可按实际模型路径替换。

一、DeepSeek 性能优化的核心思路

在优化 DeepSeek 推理性能前，需要先明确几个关键指标。

1. 首字延迟

首字延迟指用户发出请求后，模型生成第一个 token 所需的时间。

影响因素包括：

模型加载是否完成
Prompt 长度
KV Cache 初始化
GPU 计算能力
推理框架调度效率
是否启用连续批处理

如果你的应用是聊天机器人、客服助手、IDE 编程助手，首字延迟会直接影响用户体验。

2. 吞吐量

吞吐量通常用 tokens/s 衡量，表示单位时间内模型生成 token 的数量。

吞吐量受以下因素影响：

GPU 型号和数量
模型大小
精度类型，例如 FP16、BF16、INT8、INT4
Batch size
并发请求数量
上下文长度
推理框架，例如 vLLM、SGLang、TGI、llama.cpp

3. 显存占用

显存主要由三部分组成：

模型权重
KV Cache
临时计算缓存

模型越大，占用显存越多；上下文越长，KV Cache 占用也越高。

例如，部署一个 32B 模型和部署一个 7B 模型，显存压力完全不同。如果要支持长上下文和高并发，KV Cache 往往会成为瓶颈。

二、硬件选择建议

1. 单卡部署建议

如果你只是个人使用或小规模服务，可以选择如下方案：

模型规模	推荐显存	推荐方式
1.5B / 7B	8GB - 16GB	Ollama / llama.cpp / vLLM
14B	24GB	vLLM / llama.cpp 量化
32B	48GB - 80GB	vLLM / 多卡切分
70B+	80GB 多卡	vLLM / SGLang / Tensor Parallel

如果显存有限，优先使用量化模型，例如 GGUF 的 Q4_K_M、Q5_K_M，或者 GPTQ、AWQ 格式。

2. 多卡部署建议

如果你使用的是多张 NVIDIA GPU，例如 2 张 A100、4 张 L40S 或 8 张 H100，可以使用 Tensor Parallel。

典型命令中会出现：

--tensor-parallel-size 2

或者：

--tensor-parallel-size 4

Tensor Parallel 可以将模型权重切分到多张 GPU 上，从而部署更大的模型。

三、系统环境优化

在正式部署前，建议先优化服务器基础环境。

1. 查看 GPU 状态

nvidia-smi

持续监控 GPU：

watch -n 1 nvidia-smi

查看 CUDA 版本：

nvcc --version

如果没有安装 nvcc，可以查看驱动支持的 CUDA 版本：

nvidia-smi

2. 更新系统依赖

Ubuntu / Debian：

sudo apt update
sudo apt install -y git curl wget htop nvtop build-essential python3 python3-pip python3-venv

安装 GPU 监控工具：

sudo apt install -y nvtop

CentOS / Rocky Linux：

sudo yum update -y
sudo yum install -y git curl wget gcc gcc-c++ make python3 python3-pip

3. 设置最大文件数

高并发推理服务会打开大量 socket 和文件句柄，建议提高限制。

临时设置：

ulimit -n 1048576

查看当前限制：

ulimit -n

永久设置：

sudo bash -c 'cat >> /etc/security/limits.conf <



4. 优化网络队列
对于 API 服务，网络栈参数也会影响高并发表现。
sudo bash -c 'cat >> /etc/sysctl.conf <


四、使用 Ollama 快速部署 DeepSeek
Ollama 的优点是简单、易用，适合个人电脑、本地开发、轻量化服务。
1. 安装 Ollama
Linux：
curl -fsSL https://ollama.com/install.sh | sh
启动服务：
ollama serve
如果使用 systemd：
sudo systemctl enable ollama
sudo systemctl start ollama
查看服务状态：
systemctl status ollama

2. 拉取 DeepSeek 模型
例如拉取 DeepSeek-R1 蒸馏模型：
ollama pull deepseek-r1:7b
运行模型：
ollama run deepseek-r1:7b
如果需要更小模型：
ollama pull deepseek-r1:1.5b
ollama run deepseek-r1:1.5b
如果机器性能较好，可以尝试更大模型：
ollama pull deepseek-r1:14b
ollama run deepseek-r1:14b

3. Ollama API 调用
curl http://localhost:11434/api/generate \
  -d '{
    "model": "deepseek-r1:7b",
    "prompt": "请用中文解释什么是KV Cache",
    "stream": true
  }'
聊天接口：
curl http://localhost:11434/api/chat \
  -d '{
    "model": "deepseek-r1:7b",
    "messages": [
      {
        "role": "user",
        "content": "写一个Python快速排序示例"
      }
    ],
    "stream": true
  }'

4. Ollama 性能优化
设置模型常驻，减少重复加载时间：
curl http://localhost:11434/api/generate \
  -d '{
    "model": "deepseek-r1:7b",
    "prompt": "你好",
    "keep_alive": "30m"
  }'
设置并发参数：
sudo systemctl edit ollama
加入以下内容：
[Service]
Environment="OLLAMA_NUM_PARALLEL=4"
Environment="OLLAMA_MAX_LOADED_MODELS=1"
Environment="OLLAMA_KEEP_ALIVE=30m"
重启 Ollama：
sudo systemctl daemon-reload
sudo systemctl restart ollama
验证环境变量：
systemctl show ollama | grep Environment
如果显存不足，可以降低并发：
Environment="OLLAMA_NUM_PARALLEL=1"
如果首字延迟高，可以延长模型驻留时间：
Environment="OLLAMA_KEEP_ALIVE=2h"

五、使用 vLLM 部署 DeepSeek 高性能 API
如果你需要生产级 API、高并发、多用户访问，推荐使用 vLLM。

vLLM 的优势是连续批处理、PagedAttention、OpenAI 兼容接口、吞吐量高。

1. 创建 Python 虚拟环境
python3 -m venv vllm-env
source vllm-env/bin/activate
升级 pip：
pip install -U pip setuptools wheel
安装 vLLM：
pip install vllm
检查安装：
python -c "import vllm; print(vllm.__version__)"

2. 下载 DeepSeek 模型
你可以使用 Hugging Face 下载模型。
安装工具：
pip install -U huggingface_hub
登录 Hugging Face：
huggingface-cli login
下载模型，例如：
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
  --local-dir /data/models/DeepSeek-R1-Distill-Qwen-7B
如果是 32B：
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
  --local-dir /data/models/DeepSeek-R1-Distill-Qwen-32B

3. 单卡启动 vLLM
python -m vllm.entrypoints.openai.api_server \
  --model /data/models/DeepSeek-R1-Distill-Qwen-7B \
  --served-model-name deepseek-r1-7b \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype auto \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.9
参数说明：

--model：本地模型路径或 Hugging Face 模型名
--served-model-name：API 暴露的模型名称
--dtype auto：自动选择合适精度
--max-model-len：最大上下文长度
--gpu-memory-utilization：显存使用比例


4. 多卡启动 vLLM
双卡：
CUDA_VISIBLE_DEVICES=0,1 python -m vllm.entrypoints.openai.api_server \
  --model /data/models/DeepSeek-R1-Distill-Qwen-32B \
  --served-model-name deepseek-r1-32b \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype auto \
  --tensor-parallel-size 2 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.9
四卡：
CUDA_VISIBLE_DEVICES=0,1,2,3 python -m vllm.entrypoints.openai.api_server \
  --model /data/models/DeepSeek-R1-Distill-Qwen-32B \
  --served-model-name deepseek-r1-32b \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype auto \
  --tensor-parallel-size 4 \
  --max-model-len 16384 \
  --gpu-memory-utilization 0.92

5. vLLM API 测试
查看模型列表：
curl http://127.0.0.1:8000/v1/models
聊天请求：
curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1-7b",
    "messages": [
      {
        "role": "user",
        "content": "请解释DeepSeek推理服务中KV Cache的作用"
      }
    ],
    "temperature": 0.6,
    "max_tokens": 1024,
    "stream": true
  }'
非流式请求：
curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1-7b",
    "messages": [
      {
        "role": "user",
        "content": "写一个Go语言HTTP服务器示例"
      }
    ],
    "temperature": 0.3,
    "max_tokens": 512
  }'

六、vLLM 性能优化参数
1. 控制最大上下文长度
如果你不需要超长上下文，不要盲目设置很大。
例如：
--max-model-len 4096
或：
--max-model-len 8192
过大的上下文会增加 KV Cache 占用，降低并发能力。

2. 提高显存利用率
--gpu-memory-utilization 0.9
如果显存充足且稳定，可以提高到：
--gpu-memory-utilization 0.95
如果频繁 OOM，降低到：
--gpu-memory-utilization 0.85

3. 限制单请求生成长度
过大的 max_tokens 会占用更多时间和缓存。

在 API 层建议设置合理上限，例如 1024 或 2048。
示例：
{
  "max_tokens": 1024
}

4. 启用 Chunked Prefill
长 Prompt 场景下，Chunked Prefill 可以降低调度阻塞，提高并发体验。
python -m vllm.entrypoints.openai.api_server \
  --model /data/models/DeepSeek-R1-Distill-Qwen-7B \
  --served-model-name deepseek-r1-7b \
  --host 0.0.0.0 \
  --port 8000 \
  --max-model-len 8192 \
  --enable-chunked-prefill \
  --gpu-memory-utilization 0.9

5. 控制最大并发序列数
--max-num-seqs 64
如果显存不足：
--max-num-seqs 16
如果服务器显存大、请求短、并发高：
--max-num-seqs 128
完整示例：
python -m vllm.entrypoints.openai.api_server \
  --model /data/models/DeepSeek-R1-Distill-Qwen-7B \
  --served-model-name deepseek-r1-7b \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype auto \
  --max-model-len 8192 \
  --max-num-seqs 64 \
  --enable-chunked-prefill \
  --gpu-memory-utilization 0.9

七、使用 llama.cpp 部署量化 DeepSeek
如果你没有高端 GPU，或者希望在 CPU、Mac、低显存 GPU 上运行 DeepSeek，可以选择 llama.cpp。
llama.cpp 适合 GGUF 量化模型，常见量化格式包括：

Q4_K_M：体积小，速度快，质量尚可
Q5_K_M：质量更好，显存略高
Q8_0：接近原始精度，资源需求较高


1. 编译 llama.cpp
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
CPU 编译：
cmake -B build
cmake --build build --config Release -j
NVIDIA CUDA 编译：
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j
验证：
./build/bin/llama-cli --help

2. 运行 GGUF 模型
假设模型路径为：
/data/models/deepseek-r1-7b-q4_k_m.gguf
运行命令：
./build/bin/llama-cli \
  -m /data/models/deepseek-r1-7b-q4_k_m.gguf \
  -p "请用中文介绍DeepSeek模型的优势" \
  -n 512 \
  -c 4096 \
  -t 8
参数说明：

-m：模型路径
-p：Prompt
-n：生成 token 数
-c：上下文长度
-t：CPU 线程数


3. GPU 加速运行
如果模型部分或全部放到 GPU：
./build/bin/llama-cli \
  -m /data/models/deepseek-r1-7b-q4_k_m.gguf \
  -p "写一个Python爬虫示例" \
  -n 1024 \
  -c 4096 \
  -t 8 \
  -ngl 99
-ngl 99 表示尽可能多地将层 offload 到 GPU。
如果显存不足，可以降低：
-ngl 20

4. 启动 llama.cpp API 服务
./build/bin/llama-server \
  -m /data/models/deepseek-r1-7b-q4_k_m.gguf \
  --host 0.0.0.0 \
  --port 8080 \
  -c 4096 \
  -t 8 \
  -ngl 99
测试接口：
curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek",
    "messages": [
      {
        "role": "user",
        "content": "请写一个Linux性能排查清单"
      }
    ],
    "temperature": 0.7,
    "max_tokens": 512
  }'

八、Docker 部署 vLLM
生产环境中建议使用 Docker，便于隔离依赖和迁移。
1. 安装 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/$distribution/libnvidia-container.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 update
sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
测试 GPU 容器：
docker run --rm --gpus all nvidia/cuda:12.4.1-base-ubuntu22.04 nvidia-smi

2. Docker 启动 vLLM
docker run -d \
  --name deepseek-vllm \
  --gpus all \
  --ipc=host \
  -p 8000:8000 \
  -v /data/models:/models \
  vllm/vllm-openai:latest \
  --model /models/DeepSeek-R1-Distill-Qwen-7B \
  --served-model-name deepseek-r1-7b \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype auto \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.9
查看日志：
docker logs -f deepseek-vllm
停止服务：
docker stop deepseek-vllm
删除容器：
docker rm deepseek-vllm

九、Nginx 反向代理与超时优化
如果你对外提供 API，建议在 vLLM 前面加 Nginx。
1. 安装 Nginx
sudo apt install -y nginx

2. 配置反向代理
创建配置：
sudo nano /etc/nginx/sites-available/deepseek.conf
写入：
server {
    listen 80;
    server_name your-domain.com;

    client_max_body_size 20m;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_http_version 1.1;

        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_connect_timeout 300s;
        proxy_send_timeout 300s;
        proxy_read_timeout 300s;

        proxy_buffering off;
        proxy_cache off;
    }
}
启用配置：
sudo ln -s /etc/nginx/sites-available/deepseek.conf /etc/nginx/sites-enabled/deepseek.conf
sudo nginx -t
sudo systemctl reload nginx

十、性能压测方法
优化必须基于数据，而不是凭感觉。
1. 使用 curl 简单测试
time curl http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1-7b",
    "messages": [
      {
        "role": "user",
        "content": "请写一篇关于AI推理优化的短文"
      }
    ],
    "max_tokens": 512
  }'

2. 使用 Python 并发压测
安装依赖：
pip install aiohttp
创建 bench.py：
cat > bench.py <<'PY'
import asyncio
import aiohttp
import time

URL = "http://127.0.0.1:8000/v1/chat/completions"
MODEL = "deepseek-r1-7b"
CONCURRENCY = 10
REQUESTS = 50

payload = {
    "model": MODEL,
    "messages": [
        {"role": "user", "content": "请用中文解释什么是大模型推理优化，控制在300字以内。"}
    ],
    "max_tokens": 300,
    "temperature": 0.6
}

async def one(session, i):
    start = time.time()
    async with session.post(URL, json=payload, timeout=300) as resp:
        text = await resp.text()
        cost = time.time() - start
        return cost, resp.status, len(text)

async def main():
    connector = aiohttp.TCPConnector(limit=CONCURRENCY)
    async with aiohttp.ClientSession(connector=connector) as session:
        tasks = []
        start = time.time()
        for i in range(REQUESTS):
            tasks.append(one(session, i))
            if len(tasks) >= CONCURRENCY:
                results = await asyncio.gather(*tasks)
                for r in results:
                    print(r)
                tasks = []
        if tasks:
            results = await asyncio.gather(*tasks)
            for r in results:
                print(r)
        total = time.time() - start
        print(f"Total time: {total:.2f}s")
        print(f"QPS: {REQUESTS / total:.2f}")

asyncio.run(main())
PY
运行：
python bench.py
你可以逐步调整：
CONCURRENCY = 20
REQUESTS = 100
观察延迟、QPS、GPU 利用率和显存变化。

十一、常见性能问题与解决方案
1. 显存溢出 OOM
表现：

服务启动失败
请求中断
日志出现 CUDA out of memory

解决：
--max-model-len 4096
降低显存利用率：
--gpu-memory-utilization 0.85
降低并发：
--max-num-seqs 16
使用更小模型或量化模型。

2. 首字延迟太高
解决方向：

缩短 Prompt
使用流式输出
模型常驻内存
减少上下文长度
使用 vLLM 的连续批处理

API 开启流式：
{
  "stream": true
}

3. GPU 利用率低
可能原因：

并发太低
Batch 太小
CPU 或网络成为瓶颈
Prompt 太短导致调度不充分

可以提高并发压测：
--max-num-seqs 64
同时客户端提高并发请求数。

4. 长上下文请求拖慢整体服务
长 Prompt 的 Prefill 会占用大量计算资源，导致短请求等待。
解决：
--enable-chunked-prefill
或者将长文本任务和短对话任务拆成两个服务：
# 短对话服务
--max-model-len 4096

# 长文本服务
--max-model-len 32768

十二、推荐生产启动命令
1. 单卡 7B 通用服务
python -m vllm.entrypoints.openai.api_server \
  --model /data/models/DeepSeek-R1-Distill-Qwen-7B \
  --served-model-name deepseek-r1-7b \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype auto \
  --max-model-len 8192 \
  --max-num-seqs 64 \
  --enable-chunked-prefill \
  --gpu-memory-utilization 0.9

2. 双卡 32B 高质量服务
CUDA_VISIBLE_DEVICES=0,1 python -m vllm.entrypoints.openai.api_server \
  --model /data/models/DeepSeek-R1-Distill-Qwen-32B \
  --served-model-name deepseek-r1-32b \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype auto \
  --tensor-parallel-size 2 \
  --max-model-len 8192 \
  --max-num-seqs 32 \
  --enable-chunked-prefill \
  --gpu-memory-utilization 0.9

3. Docker 生产命令
docker run -d \
  --name deepseek-vllm \
  --restart always \
  --gpus all \
  --ipc=host \
  -p 8000:8000 \
  -v /data/models:/models \
  vllm/vllm-openai:latest \
  --model /models/DeepSeek-R1-Distill-Qwen-7B \
  --served-model-name deepseek-r1-7b \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype auto \
  --max-model-len 8192 \
  --max-num-seqs 64 \
  --enable-chunked-prefill \
  --gpu-memory-utilization 0.9

十三、优化参数速查表



优化目标
推荐参数或方法




降低显存占用
降低 --max-model-len、使用量化模型、降低 --max-num-seqs


提高吞吐量
使用 vLLM、提高并发、启用连续批处理


降低首字延迟
模型常驻、流式输出、减少 Prompt 长度


支持长上下文
增大 --max-model-len，同时启用 --enable-chunked-prefill


多卡部署
使用 --tensor-parallel-size


服务稳定
Docker 部署、Nginx 反代、设置超时时间


防止 OOM
降低 --gpu-memory-utilization、减少并发


低显存运行
使用 llama.cpp + GGUF 量化模型




十四、总结
DeepSeek 性能优化不是单一参数的调整，而是模型规模、硬件资源、推理框架、上下文长度、并发策略和业务场景之间的综合平衡。
如果你追求简单本地使用，推荐：
ollama run deepseek-r1:7b
如果你追求生产级高并发 API，推荐：
python -m vllm.entrypoints.openai.api_server \
  --model /data/models/DeepSeek-R1-Distill-Qwen-7B \
  --served-model-name deepseek-r1-7b \
  --host 0.0.0.0 \
  --port 8000 \
  --max-model-len 8192 \
  --max-num-seqs 64 \
  --enable-chunked-prefill \
  --gpu-memory-utilization 0.9
如果你显存有限，推荐：
./build/bin/llama-server \
  -m /data/models/deepseek-r1-7b-q4_k_m.gguf \
  --host 0.0.0.0 \
  --port 8080 \
  -c 4096 \
  -t 8 \
  -ngl 99
实际部署时，建议先从较保守的参数开始，保证稳定运行，再通过压测逐步提高并发、上下文长度和显存利用率。最终目标不是单纯追求最高 tokens/s，而是在稳定性、响应速度、成本和模型效果之间取得最优平衡。

优化目标	推荐参数或方法
降低显存占用	降低 `--max-model-len`、使用量化模型、降低 `--max-num-seqs`
提高吞吐量	使用 vLLM、提高并发、启用连续批处理
降低首字延迟	模型常驻、流式输出、减少 Prompt 长度
支持长上下文	增大 `--max-model-len`，同时启用 `--enable-chunked-prefill`
多卡部署	使用 `--tensor-parallel-size`
服务稳定	Docker 部署、Nginx 反代、设置超时时间
防止 OOM	降低 `--gpu-memory-utilization`、减少并发
低显存运行	使用 llama.cpp + GGUF 量化模型


                                
                                                                        
                                        文章标签：
                                                                                DeepSeek性能优化
                                                                                vLLM部署
                                                                                显存优化
                                                                                高并发推理
                                                                            
                                                                        
                                        上一篇：站长接入 DeepSeek 后，如何把速度、成本和稳定性一起优化到位
                                    
                                                                        
                                        下一篇：DeepSeek 本地部署提速实战：显存、并发、推理命令一次讲透

产品与服务

新闻帮助

生态合作

了解我们

DeepSeek 部署提速实战：从显存占用到高并发的完整优化命令

DeepSeek 性能优化教程｜附完整命令

一、DeepSeek 性能优化的核心思路

1. 首字延迟

2. 吞吐量

3. 显存占用

二、硬件选择建议

1. 单卡部署建议

2. 多卡部署建议

三、系统环境优化

1. 查看 GPU 状态

2. 更新系统依赖

3. 设置最大文件数

4. 优化网络队列

四、使用 Ollama 快速部署 DeepSeek

1. 安装 Ollama

2. 拉取 DeepSeek 模型

3. Ollama API 调用

4. Ollama 性能优化

五、使用 vLLM 部署 DeepSeek 高性能 API

1. 创建 Python 虚拟环境

2. 下载 DeepSeek 模型

3. 单卡启动 vLLM

4. 多卡启动 vLLM

5. vLLM API 测试

六、vLLM 性能优化参数

1. 控制最大上下文长度

2. 提高显存利用率

3. 限制单请求生成长度

4. 启用 Chunked Prefill

5. 控制最大并发序列数

七、使用 llama.cpp 部署量化 DeepSeek

1. 编译 llama.cpp

2. 运行 GGUF 模型

3. GPU 加速运行

4. 启动 llama.cpp API 服务

八、Docker 部署 vLLM

1. 安装 NVIDIA Container Toolkit

2. Docker 启动 vLLM

九、Nginx 反向代理与超时优化

1. 安装 Nginx

2. 配置反向代理

十、性能压测方法

1. 使用 curl 简单测试

2. 使用 Python 并发压测

十一、常见性能问题与解决方案

1. 显存溢出 OOM

2. 首字延迟太高

3. GPU 利用率低

4. 长上下文请求拖慢整体服务

十二、推荐生产启动命令

1. 单卡 7B 通用服务

2. 双卡 32B 高质量服务

3. Docker 生产命令

十三、优化参数速查表

十四、总结