logo

双卡27B大模型推理服务部署与运维实践

作者:菠萝爱吃肉2026.11.18 11:30浏览量:0

简介:面向开发者与运维人员,给出双卡GPU部署27B级大模型推理服务的可执行方法。文章覆盖操作系统、驱动、运行时与互联校验,模型文件检查,vLLM启动参数与安全绑定,压测脚本及TTFT、TPOT、P99、吞吐口径,并提供监控、告警、回滚和排障清单,帮助降低显存不足、尾延迟失控与公网暴露风险。

一、适用范围与验收目标

本文面向开发者与运维人员,描述如何在双GPU、高带宽互联环境中部署27B级大语言模型推理服务。服务目标是提供稳定文本生成能力,支持单请求、并发请求和流式输出,并持续观察首Token延迟(TTFT)、每Token生成延迟(TPOT)、P99尾延迟、吞吐和成功率。

上线验收不能只看接口是否返回,至少应包含:

  1. /health 健康检查可访问。
  2. /v1/models 或等价接口能返回模型信息。
  3. 单次请求能正常生成,流式输出可分段返回。
  4. 压测脚本能复现并发、输入输出长度和指标口径。
  5. 服务日志、GPU显存、队列长度、错误率可观测。
  6. 具备模型版本、配置版本和启动脚本的回滚能力。

本文不依赖单一厂商型号,但给出可落地的示例框架为 vLLM。不同框架字段不同,但环境校验、参数映射、安全暴露、压测口径和回滚流程可复用。

二、环境校验:先确认硬件、驱动与运行时

1. 操作系统与内核

建议选择稳定企业级Linux环境,并锁定版本。示例基线如下:

  • 操作系统:Ubuntu 22.04 LTS 或同等级Linux。
  • 内核:5.15 或更高版本。
  • NVIDIA驱动:与目标CUDA运行时兼容的稳定版本。
  • CUDA运行时:与驱动、框架官方兼容矩阵一致。
  • Python:3.10 或框架支持版本。
  • 推理框架:vLLM 等,需固定版本,避免使用浮动latest。

检查命令:

  1. uname -a
  2. cat /etc/os-release
  3. nvidia-smi
  4. python3.10 --version

如果驱动无法被系统识别,应先解决驱动、内核和固件问题,再安装推理框架。

2. 双卡识别与互联状态

双卡部署必须确认两张GPU均可见,且互联状态正常。

  1. nvidia-smi -L
  2. nvidia-smi topo -m
  3. nvidia-smi nvlink -s

判读要点:

  • nvidia-smi -L 应显示两张GPU。
  • nvidia-smi topo -m 用于查看GPU之间的连接类型和亲和性。
  • 若支持高速互联,应能观察到对应链路状态。
  • 若链路异常、缺失或频繁报错,需要检查驱动、PCIe/NVLink链路和散热供电。
  • 如果只有通用总线通信,服务仍可启动,但张量并行、显存同步和并发调度的性能影响必须在压测中单独评估。

建议记录检查结果,作为上线基线:

  1. nvidia-smi -L | tee /configs/gpu_list.txt
  2. nvidia-smi topo -m | tee /configs/gpu_topo.txt

3. 安装运行时与推理框架

创建独立虚拟环境,避免污染系统Python:

  1. sudo apt-get update
  2. sudo apt-get install -y python3.10 python3.10-venv
  3. python3.10 -m venv /opt/llm/venv
  4. source /opt/llm/venv/bin/activate
  5. pip install --upgrade pip
  6. pip install vllm==0.6.3

上述版本号只是示例。正式部署时应根据框架官方兼容矩阵锁定驱动、CUDA、Python和vLLM版本。

检查安装结果:

  1. vllm --version
  2. python -c "import torch; print(torch.__version__, torch.cuda.device_count())"

如果 torch.cuda.device_count() 返回2,说明框架层面已经识别到双卡。

4. 权限与目录准备

服务建议使用专用低权限账号运行,不使用root启动推理进程。

  1. sudo useradd --system --no-create-home --shell /usr/sbin/nologin llm
  2. sudo mkdir -p /models /configs /logs /run
  3. sudo chown -R llm:llm /configs /logs /run
  4. sudo chmod -R 750 /configs
  5. sudo chmod -R 750 /logs

模型目录应设置为服务用户可读、不可写,避免误改:

  1. sudo chown -R root:root /models
  2. sudo chmod -R 755 /models
  3. sudo find /models -type f -exec chmod 644 {} \;

如果模型目录包含敏感信息,应进一步限制组权限,仅允许服务账号读取。

三、模型与配置:用明确参数替代通用配置

1. 模型文件放置与校验

将模型放入版本化目录,例如:

  1. /models/llm-27b-v1.0/
  2. /configs/
  3. /logs/
  4. /run/

校验文件完整性和权限:

  1. ls -lh /models/llm-27b-v1.0
  2. sha256sum /models/llm-27b-v1.0/* | tee /configs/llm-27b-v1.0.sha256

检查分词器是否可加载:

  1. source /opt/llm/venv/bin/activate
  2. python - <<'PY'
  3. from transformers import AutoTokenizer
  4. tok = AutoTokenizer.from_pretrained('/models/llm-27b-v1.0', local_files_only=True)
  5. print('vocab_size=', tok.vocab_size)
  6. print('model_max_length=', tok.model_max_length)
  7. PY

如果权重分片、配置文件、分词器文件缺失,启动阶段会失败或生成异常。正式服务前应先完成离线加载检查。

2. 使用版本软链接

为便于回滚,建议通过软链接指向当前模型版本:

  1. sudo ln -sfn /models/llm-27b-v1.0 /models/current

后续启动命令使用 /models/current。升级时只切换软链接,不修改模型文件本身。

3. vLLM启动命令示例

vLLM是常见推理框架,提供OpenAI兼容接口。以下命令默认只绑定本机,避免直接公网暴露:

  1. CUDA_VISIBLE_DEVICES=0,1 vllm serve /models/current \
  2. --host 127.0.0.1 \
  3. --port 8080 \
  4. --tensor-parallel-size 2 \
  5. --dtype auto \
  6. --max-model-len 8192 \
  7. --gpu-memory-utilization 0.90 \
  8. --max-num-seqs 32 \
  9. --max-num-batched-tokens 16384 \
  10. --served-model-name llm-27b \
  11. --disable-log-requests

如果框架版本不支持 vllm serve,可使用等价模块入口:

  1. CUDA_VISIBLE_DEVICES=0,1 python -m vllm.entrypoints.openai.api_server \
  2. --model /models/current \
  3. --host 127.0.0.1 \
  4. --port 8080 \
  5. --tensor-parallel-size 2 \
  6. --max-model-len 8192 \
  7. --gpu-memory-utilization 0.90

4. 关键参数映射

参数 作用 主要解析组件
--host 127.0.0.1 只监听本机,降低公网暴露风险 vLLM HTTP服务
--port 8080 服务端口 vLLM HTTP服务
--tensor-parallel-size 2 双卡张量并行 vLLM执行器、模型切分、GPU通信库
--max-model-len 8192 限制最大上下文长度 模型配置、分词器、调度器
--gpu-memory-utilization 0.90 控制推理运行时显存使用比例 vLLM显存管理
--max-num-seqs 32 限制并发序列数量 vLLM调度器
--max-num-batched-tokens 16384 控制单批token预算 vLLM批处理调度
--served-model-name llm-27b 对外模型名称 vLLM OpenAI兼容接口

参数必须结合模型结构、上下文长度、并发目标和显存余量调整。若出现显存不足,应优先降低 max-model-len、max-num-seqs、max-num-batched-tokens,而不是盲目提高并发。

5. 安全绑定原则

默认不要使用 --host 0.0.0.0。如果服务只在本机或内网调用,应优先绑定:

  1. --host 127.0.0.1

如果必须绑定内网IP,应确认地址只属于受控网段,并配置防火墙、安全组和认证。

  1. ip -brief addr
  2. sudo ufw status

公网或跨域访问建议通过反向代理、TLS、认证和限流转发到本地推理服务,而不是直接暴露推理端口。

四、启动安全:前台验证、后台托管、最小权限

1. 前台启动验证

第一次部署建议前台启动,观察完整日志:

  1. source /opt/llm/venv/bin/activate
  2. CUDA_VISIBLE_DEVICES=0,1 vllm serve /models/current \
  3. --host 127.0.0.1 \
  4. --port 8080 \
  5. --tensor-parallel-size 2 \
  6. --max-model-len 8192 \
  7. --gpu-memory-utilization 0.90

重点观察:

  • 模型权重是否加载完成。
  • 双卡是否被正确识别。
  • 是否出现显存不足。
  • 是否出现NCCL或GPU通信错误。
  • 服务端口是否成功监听。
  • 是否出现配置解析失败。

2. 健康检查与接口验证

服务启动后,先执行基础检查:

  1. curl -sS http://127.0.0.1:8080/health
  2. curl -sS http://127.0.0.1:8080/v1/models

非流式调用测试:

  1. curl -sS http://127.0.0.1:8080/v1/chat/completions \
  2. -H "Content-Type: application/json" \
  3. -d '{
  4. "model": "llm-27b",
  5. "messages": [{"role": "user", "content": "请用一句话介绍云计算。"}],
  6. "stream": false,
  7. "max_tokens": 32
  8. }'

流式调用测试:

  1. curl -N -sS http://127.0.0.1:8080/v1/chat/completions \
  2. -H "Content-Type: application/json" \
  3. -d '{
  4. "model": "llm-27b",
  5. "messages": [{"role": "user", "content": "请用三句话介绍运维监控。"}],
  6. "stream": true,
  7. "max_tokens": 64
  8. }'

3. systemd托管

将服务托管为系统服务,避免终端退出后进程终止。

创建 /etc/systemd/system/llm-inference.service:

  1. [Unit]
  2. Description=LLM Inference Service
  3. After=network-online.target
  4. [Service]
  5. User=llm
  6. Group=llm
  7. Environment=CUDA_VISIBLE_DEVICES=0,1
  8. ExecStart=/opt/llm/venv/bin/vllm serve /models/current --host 127.0.0.1 --port 8080 --tensor-parallel-size 2 --max-model-len 8192 --gpu-memory-utilization 0.90 --max-num-seqs 32 --served-model-name llm-27b --disable-log-requests
  9. Restart=on-failure
  10. RestartSec=5
  11. [Install]
  12. WantedBy=multi-user.target

启用并查看日志:

  1. sudo systemctl daemon-reload
  2. sudo systemctl enable --now llm-inference
  3. systemctl status llm-inference
  4. journalctl -u llm-inference -f

4. 安全控制清单

上线前至少完成:

  • 推理服务不直接监听公网地址。
  • 使用专用低权限用户运行。
  • 模型目录只读或受控读取。
  • 配置目录权限最小化。
  • 日志不记录完整用户输入输出。
  • 如需外部访问,增加认证、TLS、限流和访问控制。
  • 防火墙或安全组只开放必要来源和端口。

示例反向代理配置:

  1. server {
  2. listen 10.0.0.10:443 ssl;
  3. location / {
  4. proxy_pass http://127.0.0.1:8080;
  5. auth_basic "llm-inference";
  6. limit_req zone=llm burst=10 nodelay;
  7. }
  8. }

该示例仅说明架构思路,具体证书、认证和限流参数需按组织安全规范落地。

五、压测验证:给出口径、工具和梯度

1. 压测目标

压测不是简单发送请求,而是用统一口径回答:

  • 不同并发下服务是否稳定。
  • 首Token延迟是否可接受。
  • 生成过程是否流畅。
  • 尾部延迟是否可控。
  • 吞吐是否随并发和批处理变化。
  • 显存和队列是否接近上限。

2. 指标口径

指标 口径
TTFT 从请求发出到首个内容Token返回的时间
TPOT 从首Token后到最后一个Token的平均单Token生成时间
E2E 从请求发出到请求完成的整体耗时
P99 将样本排序后,99%请求不差于该值
吞吐 成功生成Token总数除以统计窗口墙钟时间
成功率 成功完成请求数除以总请求数

公式:

  1. TTFT = 首Token到达时间 - 请求开始时间
  2. TPOT = (请求结束时间 - 首Token到达时间) / max(1, 输出Token数 - 1)
  3. 吞吐 = 成功请求的输出Token总数 / (最晚请求结束时间 - 最早请求开始时间)
  4. 成功率 = 成功请求数 / 总请求数
  5. P99 = 排序后的第99百分位

3. 压测脚本示例

安装依赖:

  1. source /opt/llm/venv/bin/activate
  2. pip install httpx transformers

保存为 bench_ttft.py:

  1. import argparse
  2. import asyncio
  3. import json
  4. import statistics
  5. import time
  6. import httpx
  7. from transformers import AutoTokenizer
  8. def p99(values):
  9. values = sorted(values)
  10. if not values:
  11. return None
  12. idx = max(0, int(len(values) * 0.99) - 1)
  13. return values[idx]
  14. async def one_request(client, sem, args, tokenizer):
  15. async with sem:
  16. start = time.perf_counter()
  17. try:
  18. async with client.stream(
  19. "POST",
  20. args.url + "/v1/chat/completions",
  21. json={
  22. "model": args.model,
  23. "messages": [{"role": "user", "content": args.prompt}],
  24. "stream": True,
  25. "max_tokens": args.max_tokens,
  26. "temperature": 0.0,
  27. },
  28. timeout=600,
  29. ) as resp:
  30. first = None
  31. chunks = []
  32. async for line in resp.aiter_lines():
  33. if not line.startswith("data: "):
  34. continue
  35. payload = line[6:]
  36. if payload == "[DONE]":
  37. break
  38. delta = json.loads(payload)["choices"][0]["delta"].get("content", "")
  39. if delta:
  40. if first is None:
  41. first = time.perf_counter()
  42. chunks.append(delta)
  43. end = time.perf_counter()
  44. output_tokens = len(
  45. tokenizer.encode("".join(chunks), add_special_tokens=False)
  46. )
  47. return {
  48. "ok": True,
  49. "start": start,
  50. "end": end,
  51. "ttft": first - start if first else None,
  52. "tokens": output_tokens,
  53. }
  54. except Exception as exc:
  55. end = time.perf_counter()
  56. return {
  57. "ok": False,
  58. "start": start,
  59. "end": end,
  60. "error": str(exc),
  61. }
  62. async def main():
  63. parser = argparse.ArgumentParser()
  64. parser.add_argument("--url", default="http://127.0.0.1:8080")
  65. parser.add_argument("--model", default="llm-27b")
  66. parser.add_argument("--tokenizer", required=True)
  67. parser.add_argument("--prompt", default="请用中文写一段关于云计算的说明文。")
  68. parser.add_argument("--concurrency", type=int, nargs="+", default=[1, 4, 8])
  69. parser.add_argument("--requests", type=int, default=32)
  70. parser.add_argument("--max-tokens", type=int, default=256)
  71. args = parser.parse_args()
  72. tokenizer = AutoTokenizer.from_pretrained(args.tokenizer, local_files_only=True)
  73. for concurrency in args.concurrency:
  74. sem = asyncio.Semaphore(concurrency)
  75. async with httpx.AsyncClient() as client:
  76. results = await asyncio.gather(
  77. *[
  78. one_request(client, sem, args, tokenizer)
  79. for _ in range(args.requests)
  80. ]
  81. )
  82. ok = [r for r in results if r["ok"] and r["ttft"]]
  83. wall_start = min(r["start"] for r in results)
  84. wall_end = max(r["end"] for r in results)
  85. output_tokens = sum(r["tokens"] for r in ok)
  86. throughput = output_tokens / (wall_end - wall_start) if wall_end > wall_start else 0
  87. print(
  88. f"concurrency={concurrency} "
  89. f"success={len(ok)}/{len(results)} "
  90. f"throughput_tok_s={throughput:.2f}"
  91. )
  92. if ok:
  93. ttfts = [r["ttft"] for r in ok]
  94. print(
  95. f"TTFT p50={statistics.median(ttfts):.3f}s "
  96. f"p99={p99(ttfts):.3f}s"
  97. )
  98. tpots = []
  99. for r in ok:
  100. if r["tokens"] > 1:
  101. tpots.append((r["end"] - r["ttft"] - r["start"]) / (r["tokens"] - 1))
  102. if tpots:
  103. print(
  104. f"TPOT p50={statistics.median(tpots):.4f}s/token "
  105. f"p99={p99(tpots):.4f}s/token"
  106. )
  107. if __name__ == "__main__":
  108. asyncio.run(main())

执行示例:

  1. python bench_ttft.py \
  2. --url http://127.0.0.1:8080 \
  3. --model llm-27b \
  4. --tokenizer /models/current \
  5. --prompt "请用中文写一段关于云计算的说明文。" \
  6. --concurrency 1 4 8 \
  7. --requests 32 \
  8. --max-tokens 256

4. 压测变量控制

为保证结果可比较,压测时应固定:

  • 模型版本。
  • 量化或精度配置。
  • 最大上下文长度。
  • 输入长度。
  • 输出长度。
  • 流式开关。
  • 请求超时。
  • 温度等采样参数。

建议至少覆盖以下组合:

场景 输入长度 输出长度 关注点
短输入短输出 短 短 基础可用性和TTFT
短输入长输出 短 长 生成阶段吞吐和TPOT
长输入短输出 长 短 预填充、显存和排队
混合长度 混合 混合 真实业务尾延迟

输入长度应通过分词器确认,而不是只按字符数估算。输出长度可通过 max_tokens 控制。

5. 压测观察项

每轮压测应记录:

  • 并发数。
  • 总请求数。
  • 成功请求数。
  • 失败请求数与失败类型。
  • TTFT的P50、P95、P99。
  • TPOT的P50、P95、P99。
  • E2E的P50、P95、P99。
  • 输出Token吞吐。
  • GPU利用率和显存占用。
  • 等待队列长度。
  • 服务错误日志。
  • 系统磁盘和日志增长情况。

如果压测中P99持续升高、错误率上升或显存接近上限,应降低并发、批处理规模或上下文长度,而不是直接扩容或反复重启。

六、运维与回滚:监控、告警、版本切换

1. 日常监控命令

GPU状态:

  1. nvidia-smi --query-gpu=index,utilization.gpu,memory.used,memory.total --format=csv -l 1

服务日志:

  1. journalctl -u llm-inference -f

如果框架暴露指标接口,可采集HTTP指标:

  1. curl -sS http://127.0.0.1:8080/metrics | head

不同版本指标名称可能不同。可重点关注:

  • 请求成功数。
  • 请求失败数。
  • 运行中请求数。
  • 等待队列长度。
  • KV缓存或显存缓存使用率。
  • 服务启动时间。
  • 请求延迟相关指标。

2. 告警建议

告警应覆盖服务不可用和性能劣化两类问题。

建议监控:

  • /health 是否连续失败。
  • 服务进程是否退出。
  • 请求成功率是否下降。
  • TTFT是否超过业务SLA。
  • P99是否超过业务SLA。
  • 等待队列是否持续增加。
  • GPU显存是否接近上限。
  • 日志是否出现连续错误。
  • 磁盘空间是否不足。

告警阈值应基于压测基线和业务SLA设置,并保留变更记录。不要使用未经目标环境验证的经验值作为唯一依据。

3. 日志管理

建议开启结构化日志,但避免记录敏感内容:

  • 启动日志。
  • 请求访问日志。
  • 错误堆栈日志。
  • 性能采样日志。
  • 配置变更日志。
  • 模型加载日志。
  • 健康检查日志。

启动参数中可使用:

  1. --disable-log-requests

该参数用于减少请求内容进入日志的风险。若业务审计需要访问日志,应在网关层记录脱敏后的请求元数据,而不是在推理服务中记录完整提示词和生成结果。

4. 版本回滚清单

回滚前应准备:

  1. 上一版本模型目录。
  2. 上一版本配置文件。
  3. 上一版本启动脚本或systemd单元文件。
  4. 上一版本健康检查方式。
  5. 上一版本压测基线。
  6. 模型文件校验值。
  7. 回滚操作命令。
  8. 回滚后的验证记录。

示例回滚流程:

  1. sudo systemctl stop llm-inference
  2. sudo cp /configs/vllm.env /configs/vllm.env.backup
  3. sudo ln -sfn /models/llm-27b-v1.0 /models/current
  4. sudo systemctl start llm-inference
  5. systemctl status llm-inference
  6. curl -sS http://127.0.0.1:8080/health

如果配置通过systemd管理,应同步恢复上一版本配置或环境变量文件:

  1. sudo cp /configs/vllm.env.previous /configs/vllm.env
  2. sudo systemctl daemon-reload
  3. sudo systemctl restart llm-inference

回滚后必须重新执行:

  • 健康检查。
  • 单次请求验证。
  • 流式输出验证。
  • 小并发压测。
  • 日志错误检查。
  • GPU显存检查。

5. 常见故障排查

启动失败:

  1. journalctl -u llm-inference -n 200
  2. nvidia-smi -L
  3. ls -l /models/current

常见原因包括模型路径错误、文件缺失、显存不足、端口占用、驱动不兼容、配置解析失败。

显存不足:

  1. nvidia-smi
  2. journalctl -u llm-inference -n 200

处理方式:

  • 降低 --max-model-len。
  • 降低 --max-num-seqs。
  • 降低 --max-num-batched-tokens。
  • 检查模型精度和量化配置是否符合预期。
  • 检查是否存在异常长请求。
  • 检查显存是否被其他进程占用。

首Token延迟升高:

  • 查看等待队列是否增长。
  • 检查并发是否超过当前处理能力。
  • 检查输入长度是否过长。
  • 检查双卡互联状态。
  • 检查是否存在大量长请求混合进入。
  • 对比不同并发下的TTFT曲线。

并发提升后延迟增加:

  • 记录TPOT和P99变化。
  • 区分短请求和长请求。
  • 检查批处理窗口是否过大。
  • 检查请求长度差异是否过大。
  • 检查超时和重试策略是否放大故障。
  • 必要时按业务类型拆分队列或实例。

七、上线检查清单

上线前建议逐项确认:

  • OS、内核、驱动、CUDA、Python、vLLM版本已记录。
  • nvidia-smi -L 可见两张GPU。
  • nvidia-smi topo -m 已记录互联状态。
  • 模型文件完整,校验值可验证。
  • 分词器可本地加载。
  • 模型目录权限最小化。
  • 服务使用低权限用户运行。
  • 服务默认绑定本机或受控内网地址。
  • 未直接暴露公网端口。
  • 如需公网访问,已配置认证、TLS、限流和访问控制。
  • /health 可访问。
  • /v1/models 可访问。
  • 流式和非流式请求均可调用。
  • 压测脚本、并发梯度、输入输出长度和指标口径已固化。
  • TTFT、TPOT、P99、吞吐、成功率有基线记录。
  • 监控、日志、告警和回滚流程已演练。

通过上述步骤,可以在双卡环境中较完整地完成27B级大模型推理服务部署。上线后应持续基于监控和压测数据调整参数,确保服务在显存、并发、首Token延迟和尾延迟之间保持可控。

发表评论

活动