大模型高并发接入:排障、降本与压测全流程

作者:沙与沫2026.11.17 03:33浏览量:0

简介:高并发下调用卡顿、费用超预期,多半出在链路、配额和调用方式上。本文给出延迟指标口径、四步排查顺序、Token成本公式和可直接运行的并发与压测代码,帮你同时解决慢和贵的问题,并避免API Key泄露。

一、先把”慢”和”贵”拆成可测量的指标

“感觉慢”无法优化,只有指标可以。大模型调用的延迟至少要拆成五项:

指标 测量口径 主要影响
首 Token 时延 从发出请求到收到第一个含内容的 chunk,单位毫秒 交互体感,对话是否卡顿
包间时延 流式输出中相邻两个内容 chunk 的时间差,报告 P95 输出是否一顿一顿
OTPS 输出 Token 数除以首 Token 之后的生成时长 长回答的完成时间
整句时延 从发出请求到收到结束标记的总时间 批处理任务的吞吐
OLPS 输出字符数除以首 Token 之后的生成时长 前端渲染与用户感知

测量前提如下,缺一条,结果都可能无法复现:

  • 使用流式接口。非流式只能拿到整句时延,看不到首 Token 和包间时延。
  • 调用方与服务位于同一地域或同一网络环境。否则链路差异会被误判成模型慢。
  • 同一批真实 prompt 不少于 200 条,长短请求都要覆盖。
  • 业务高峰和低谷各跑一轮,记录 P50、P95、P99。平均值会掩盖少数极慢的请求,而这些请求正是用户投诉的来源。
  • 包间时延汇总所有请求的相邻内容 chunk 间隔,不含首 Token。
  • OTPS 以服务端返回的输出 Token 数计算,OLPS 以字符数计算。两者口径不同,不能混用。

二、四步排查顺序

排查按链路、模型规格、并发配额、调用方式的顺序进行。前一步正常再看下一步,避免在错误的方向上调参数。

第一步,查链路。在调用方机器上测 DNS 解析、TCP 建连和 TLS 握手耗时。若建连耗时明显高于同地域的基线,检查代理、出口网络和跨地域调用。

第二步,查输入规格。把 prompt 按长度分桶,分别统计首 Token 时延。若首 Token 随输入长度明显增长,说明输入过长,应考虑截断、摘要或拆分。冷启动也会推高首 Token,应在同一时段对比多次结果。模型的上下文上限、输出上限和是否支持流式,以所用平台的官方文档为准,不要凭经验判断。

第三步,查并发配额。出现 429 响应、包间时延突然抖动,或首 Token 随并发数上升而变高,通常说明已触及并发限制或服务端在排队。判定方法是逐步提高并发数,记录错误率和 P95 包间时延。两者出现拐点的前一个并发档位,就是当前可用的上限。具体限额以控制台或官方文档为准。

第四步,查调用方式。检查是否每个请求都新建了 client,是否复用了连接池,超时设置是否合理,是否存在本可并发却被写成串行的代码。单并发与多并发的吞吐对比,能快速暴露这类问题。

常见现象与优先排查的步骤如下:

现象 优先排查
首 Token 高,包间正常 链路、输入长度、排队
包间抖动大,错误率升高 并发配额、服务端排队
整句慢,首 Token 与包间都正常 输出长度、调用方式
成本超出预期 输入长度、缓存命中率、重试次数

三、并发配额与调用方式

并发控制要在客户端完成。用信号量限制同时在途的请求数,并把它作为压测的主变量。

重试只针对可恢复的错误:超时、连接失败、429 和 5xx。其余 4xx 错误,如参数错误或鉴权失败,重试没有意义,应直接报错。重试采用指数退避加随机抖动,避免大量请求在同一时刻再次涌入。重试次数要设上限。

调用方式上,同一进程内复用一个 client 实例,让底层连接池生效。每个请求都设置超时,防止个别慢请求占满并发名额。流式读取时,逐块消费输出,不要等整段结束再处理。

四、Token 成本估算公式

成本由输入和输出两部分组成。输入中命中缓存的部分通常按更低单价计费,重试产生的调用也要计入。公式如下:

日成本 = 日调用次数 × (1 + 重试率) × [输入 Token 数 × (缓存命中率 × 命中单价 + (1 − 缓存命中率) × 未命中单价) + 输出 Token 数 × 输出单价] ÷ 1,000,000

单价以每百万 Token 计。下面的算例使用假设单价,仅用于演示计算方法,不代表任何平台的真实价格:

  • 未命中输入单价 2 元/百万 Token,命中输入单价 0.2 元/百万 Token,输出单价 8 元/百万 Token
  • 日调用 10 万次,平均输入 2000 Token,平均输出 500 Token,缓存命中率 40%,重试率 5%

单次输入有效单价为 0.4 × 0.2 + 0.6 × 2 = 1.28 元/百万 Token,输入成本为 2000 × 1.28 ÷ 1,000,000 = 0.00256 元。输出成本为 500 × 8 ÷ 1,000,000 = 0.004 元。单次合计 0.00656 元。日成本为 100000 × 1.05 × 0.00656 = 688.8 元。

使用真实数据前,先到官方定价页核对单价,并把核对日期和单价写在配置注释里。价格变动后,成本模型要同步更新。

五、可运行的并发调用与压测代码

环境要求为 Python 3.10 及以上版本,并安装 openai 库:pip install openai。

API Key、地址和模型名全部从环境变量读取,代码中不出现任何密钥。运行前设置:

  1. export LLM_BASE_URL="你的服务地址"
  2. export LLM_API_KEY="你的密钥"
  3. export LLM_MODEL="模型名"
  4. export LLM_CONCURRENCY=4

prompt 文件每行一条,至少 200 行,覆盖长短不同的请求。运行方式为 python bench.py prompts.txt。

  1. import asyncio
  2. import os
  3. import random
  4. import sys
  5. import time
  6. from dataclasses import dataclass, field
  7. from openai import (
  8. APIConnectionError,
  9. APIStatusError,
  10. APITimeoutError,
  11. AsyncOpenAI,
  12. )
  13. BASE_URL = os.environ["LLM_BASE_URL"]
  14. API_KEY = os.environ["LLM_API_KEY"]
  15. MODEL = os.environ["LLM_MODEL"]
  16. CONCURRENCY = int(os.environ.get("LLM_CONCURRENCY", "4"))
  17. MAX_RETRIES = int(os.environ.get("LLM_MAX_RETRIES", "3"))
  18. TIMEOUT_S = float(os.environ.get("LLM_TIMEOUT_S", "60"))
  19. RETRYABLE_STATUS = {429, 500, 502, 503, 504}
  20. # SDK 自身不重试,重试逻辑统一由下方 call_with_retry 控制
  21. client = AsyncOpenAI(api_key=API_KEY, base_url=BASE_URL,
  22. timeout=TIMEOUT_S, max_retries=0)
  23. @dataclass
  24. class Result:
  25. ok: bool
  26. ttft_ms: float | None = None
  27. total_ms: float | None = None
  28. gaps_ms: list[float] = field(default_factory=list)
  29. out_tokens: int | None = None
  30. out_chars: int = 0
  31. error: str | None = None
  32. async def stream_once(prompt: str) -> Result:
  33. start = time.perf_counter()
  34. first = last = None
  35. gaps: list[float] = []
  36. chars = 0
  37. out_tokens = None
  38. stream = await client.chat.completions.create(
  39. model=MODEL,
  40. messages=[{"role": "user", "content": prompt}],
  41. stream=True,
  42. stream_options={"include_usage": True},
  43. )
  44. async for chunk in stream:
  45. if chunk.usage is not None:
  46. out_tokens = chunk.usage.completion_tokens
  47. if not chunk.choices:
  48. continue
  49. text = chunk.choices[0].delta.content
  50. if not text:
  51. continue
  52. now = time.perf_counter()
  53. if first is None:
  54. first = now
  55. else:
  56. gaps.append((now - last) * 1000)
  57. last = now
  58. chars += len(text)
  59. end = time.perf_counter()
  60. if first is None:
  61. return Result(ok=False, error="empty_stream")
  62. return Result(
  63. ok=True,
  64. ttft_ms=(first - start) * 1000,
  65. total_ms=(end - start) * 1000,
  66. gaps_ms=gaps,
  67. out_tokens=out_tokens,
  68. out_chars=chars,
  69. )
  70. async def call_with_retry(sem: asyncio.Semaphore, prompt: str) -> Result:
  71. for attempt in range(MAX_RETRIES + 1):
  72. try:
  73. async with sem:
  74. return await stream_once(prompt)
  75. except (APITimeoutError, APIConnectionError) as e:
  76. err, retryable = type(e).__name__, True
  77. except APIStatusError as e:
  78. err = f"HTTP {e.status_code}"
  79. retryable = e.status_code in RETRYABLE_STATUS
  80. # 只记录异常类型和状态码,不记录 prompt 与响应内容
  81. if not retryable or attempt == MAX_RETRIES:
  82. return Result(ok=False, error=err)
  83. await asyncio.sleep(min(30, 2 ** attempt) + random.uniform(0, 1))
  84. return Result(ok=False, error="unreachable")
  85. def pct(values: list[float], p: float) -> float | None:
  86. if not values:
  87. return None
  88. s = sorted(values)
  89. idx = min(len(s) - 1, round(p / 100 * (len(s) - 1)))
  90. return s[idx]
  91. def fmt(v: float | None, nd: int = 0) -> str:
  92. return "-" if v is None else f"{v:.{nd}f}"
  93. async def main() -> None:
  94. with open(sys.argv[1], encoding="utf-8") as f:
  95. prompts = [line.strip() for line in f if line.strip()]
  96. sem = asyncio.Semaphore(CONCURRENCY)
  97. results = await asyncio.gather(
  98. *(call_with_retry(sem, p) for p in prompts))
  99. ok = [r for r in results if r.ok]
  100. errors = [r.error for r in results if not r.ok]
  101. ttft = [r.ttft_ms for r in ok]
  102. total = [r.total_ms for r in ok]
  103. gaps = [g for r in ok for g in r.gaps_ms]
  104. gen = [r for r in ok if r.total_ms > r.ttft_ms]
  105. otps = [r.out_tokens / ((r.total_ms - r.ttft_ms) / 1000)
  106. for r in gen if r.out_tokens]
  107. olps = [r.out_chars / ((r.total_ms - r.ttft_ms) / 1000)
  108. for r in gen if r.out_chars]
  109. print(f"请求数 {len(results)},成功 {len(ok)},失败 {len(errors)}")
  110. print(f"首Token(ms) P50={fmt(pct(ttft, 50))} "
  111. f"P95={fmt(pct(ttft, 95))} P99={fmt(pct(ttft, 99))}")
  112. print(f"包间(ms) P95={fmt(pct(gaps, 95))} "
  113. f"P99={fmt(pct(gaps, 99))}")
  114. print(f"整句(ms) P50={fmt(pct(total, 50))} "
  115. f"P95={fmt(pct(total, 95))} P99={fmt(pct(total, 99))}")
  116. print(f"OTPS(tok/s) P50={fmt(pct(otps, 50), 1)}")
  117. print(f"OLPS(字符/s) P50={fmt(pct(olps, 50), 1)}")
  118. for name in sorted(set(errors)):
  119. print(f"错误 {name}: {errors.count(name)}")
  120. if __name__ == "__main__":
  121. asyncio.run(main())

代码中的 include_usage 参数用于获取输出 Token 数。若所用服务不支持该参数,删除这一行即可,此时 OTPS 无法计算,只输出 OLPS。

六、安全注意事项

  • API Key 只通过环境变量传入,不写进代码、配置文件或版本库。
  • 日志中不输出 prompt、响应正文和密钥,只记录错误类型、状态码和耗时。
  • 压测使用独立的 Key,与生产 Key 分开,便于单独限额和吊销。
  • 压测从低并发起步,逐档加压。不在业务高峰期压测生产环境,避免误伤真实用户。

七、压测清单

  • 样本不少于 200 条,长短请求都有覆盖。
  • 业务高峰和低谷各跑一轮,结果分开记录。
  • 记录首 Token、包间、整句、OTPS、OLPS 的 P50、P95、P99。
  • 记录错误率、429 次数和重试次数。
  • 按 4、8、16 等档位逐步提高并发,找到错误率或 P95 包间时延的拐点。
  • 按上一节公式估算单日成本,并核对当天的单价与核对日期。
  • 结果、配置和代码版本一并留档,便于下次对比。