RAG 一个请求吃掉 8 个核,chat 只要 0.16 个

上一篇做完 RAG 重排,说下一篇要把它装进 Docker 压一压。这篇是结果。

结论和预期不同:同一个 Spring Boot 进程、同一个容器,两个接口的 CPU 峰值差 50 倍以上。 chat 只有 16%,RAG 打到 866%。

再往下拆一层:RAG 的 CPU 几乎全花在 reranker 上。把它换成纯词法重排,CPU 从 8 核掉到 0.7 核。

先给结论:

  1. 镜像 879MB,冷启动 50.15s,热启动 6.33s,模型卷 674MB。
  2. /api/chat 不吃 CPU------并发翻倍 QPS 跟着翻倍,延迟几乎不变,瓶颈在 DeepSeek 的网络往返。
  3. /api/rag/ask 是 CPU 密集型,峰值 797%--866%(约 8 核) 。
  4. 摘掉 reranker 换成 lexical,CPU 掉到 66%--74%(约 0.7 核) ,差约 12 倍。
  5. 所以 RAG 的 CPU 大头是 reranker,不是 embedding------文档向量在启动时就编码完了。

一、实验条件

项 值
JDK 17
Spring Boot 4.1.1
Spring AI 2.0.1
生成模型 deepseek-chat(兼容别名,实际路由 deepseek-flash),temperature 0.7
Embedding BGE-small-zh-v1.5(Xenova ONNX,512 维,mean pooling)
Reranker bge-reranker-base 量化版,266 MB,rerank-max-length = 512
向量库 SimpleVectorStore(内存,暴力检索)
知识库 4 篇 Markdown,chunk-size 300 切完 6 块
镜像 ai-agent-lab:local(多阶段构建,eclipse-temurin:17-jre)
容器资源 Docker Desktop 10 核 / 8.3 GB,CPU 不限制
推理后端 ONNX Runtime CPUExecutionProvider (未指定 EP,默认 CPU;依赖为 CPU 版 onnxruntime:1.21.1)
硬件 Apple Silicon(arm64),有集成 GPU,本次未启用
宿主端口 127.0.0.1:18080(APP_PORT 覆盖)
压测工具 scripts/load_test.py(Python 标准库)

两个必须前置说明的口径。

一、Docker Desktop 在 macOS 上跑的是虚拟机 ,CPU 统计与裸机可能有偏差。下面所有 CPU 百分比都来自 docker stats,按 1 核 = 100% 计,也就是 800% 约等于 8 个核。

二、全程走 ONNX Runtime 的 CPU 执行提供者。 创建会话时只设了优化级别,没指定 EP,走的是默认 CPUExecutionProvider;依赖是 CPU 版 onnxruntime:1.21.1,没有启用 CoreML / CUDA。

机器本身是 Apple Silicon,有集成 GPU,这次没用上。 这条决定了全文结论的适用范围:换成更小的 reranker、把 rerank-max-length 从 512 降到 128、或者换用 GPU 执行提供者,「reranker 是 CPU 大头」都不再成立。理由见第十二节局限。

二、镜像与启动

指标 值 说明
镜像大小 879 MB 基础 JRE 约 650 MB + jar 218 MB + curl
jar 大小 218 MB 含 ONNX Runtime 原生库
冷启动 50.15 s 启动时下载 90 MB 的 embedding 模型
热启动(卷有缓存) 6.33 s 模型从挂载卷读取
首次 RAG 调用 197 s 额外下载 DJL 和 266 MB 的 reranker
模型卷占用 674 MB embedding 90 + reranker 266 + DJL 约 200

冷启动那 50 秒,大头是在下 90MB 的 embedding 模型,不是 JVM 起得慢。

但真正会咬人的不是这 50 秒,是卷。

模型和原生库一共 674MB。不挂卷,每次重建容器都要重下这 674MB,热启动 6 秒变成 4 分钟。

更隐蔽的是:DJL 那 200MB 不在 Spring AI 的模型缓存目录下 ,默认落在 ~/.djl.ai。只挂 Spring AI 那个目录,reranker 保住了,PyTorch 那 200MB 每次重建照样重下。必须再用 DJL_CACHE_DIR 单独指过去。

三、多阶段构建

Dockerfile

bash 复制代码
# ---------- 构建阶段 ----------
FROM maven:3.9-eclipse-temurin-17 AS build
WORKDIR /workspace
​
# 先只拷 pom,利用层缓存:改代码不会重新下载依赖
COPY pom.xml .
RUN mvn -B -q dependency:go-offline
​
COPY src ./src
RUN mvn -B -q -DskipTests package
​
# ---------- 运行阶段 ----------
FROM eclipse-temurin:17-jre
​
# 健康检查需要 curl
RUN apt-get update \
    && apt-get install -y --no-install-recommends curl \
    && rm -rf /var/lib/apt/lists/*
​
# 非 root 运行
RUN groupadd --system app \
    && useradd --system --gid app --create-home --home-dir /home/app app
​
WORKDIR /app
COPY --from=build /workspace/target/ai-agent-lab-*.jar app.jar
​
# 模型缓存目录(由 compose 挂载命名卷复用,避免每次启动重新下载)
RUN mkdir -p /home/app/.cache/spring-ai-models && chown -R app:app /home/app
​
USER app
​
ENV SERVER_ADDRESS=0.0.0.0 \
    MCP_ENABLED=false \
    DJL_CACHE_DIR=/home/app/.cache/spring-ai-models/djl \
    JAVA_OPTS="-XX:MaxRAMPercentage=75 -XX:+UseG1GC"
​
EXPOSE 8080
​
HEALTHCHECK --interval=30s --timeout=5s --start-period=90s --retries=3 \
    CMD curl -fsS http://127.0.0.1:8080/actuator/health || exit 1
​
# exec 让 java 成为 1 号进程,SIGTERM 能直接送达,优雅停机才生效
ENTRYPOINT ["sh", "-c", "exec java $JAVA_OPTS -jar app.jar"]

两个点值得展开。

一、先拷 pom.xml 跑 dependency:go-offline,再拷 src。

Docker 的层缓存只在这一层没变时才复用。把依赖解析和源码拷贝拆开,改一行 Java 代码就不会触发依赖重下,重建从几分钟降到几十秒。这是我改了三版 Dockerfile 才抠出来的收益。

二、ENTRYPOINT 里的 exec 不能省。

少了它,sh 是容器的 1 号进程,JVM 挂在它下面。docker stop 发出的 SIGTERM 会被 shell 吞掉,JVM 根本收不到,只能等 30 秒停机窗口走完被 SIGKILL------在途请求全断,下一节的优雅停机就白配了。

四、compose:端口、卷、健康检查

docker-compose.yml

yml 复制代码
services:
  app:
    build: .
    image: ai-agent-lab:local
    container_name: ai-agent-lab
    # 只发布到本机回环地址,保持"不暴露公网"的项目约定
    ports:
      # 宿主端口可用 APP_PORT 覆盖,避免和本地 IDE 实例冲突
      - "127.0.0.1:${APP_PORT:-8080}:8080"
    environment:
      DEEPSEEK_API_KEY: ${DEEPSEEK_API_KEY:?请在项目根目录的 .env 中设置 DEEPSEEK_API_KEY}
      DEEPSEEK_MODEL: ${DEEPSEEK_MODEL:-deepseek-chat}
      DEEPSEEK_TEMPERATURE: ${DEEPSEEK_TEMPERATURE:-0.7}
      RAG_RERANK: ${RAG_RERANK:-none}
      # 容器内没有 Node,关闭 MCP
      MCP_ENABLED: "false"
      SERVER_ADDRESS: 0.0.0.0
    volumes:
      # 复用模型缓存,避免每次重建容器都下载 95MB / 266MB 模型
      - model-cache:/home/app/.cache/spring-ai-models
    healthcheck:
      test: ["CMD", "curl", "-fsS", "http://127.0.0.1:8080/actuator/health"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 90s
    stop_grace_period: 30s
    restart: unless-stopped
​
volumes:
  model-cache:

四个设计点:

  • 端口只发布到 127.0.0.1。这个工程没有鉴权,暴露到局域网就是给人开门。
  • 模型缓存挂命名卷 model-cache,重建容器不重下。
  • healthcheck 打 /actuator/health ,start_period: 90s 给冷启动留足时间。
  • stop_grace_period: 30s,和应用侧的停机窗口对齐。

有个坑必须提:.env 会被 compose 自动注入 。我 .env 里写着 RAG_RERANK=cross,它直接盖掉了 compose 的默认值 none,导致容器起来就加载 266MB 的 reranker。要换模式得显式覆盖:

ini 复制代码
RAG_RERANK=lexical APP_PORT=18080 docker compose up -d

五、优雅停机

src/main/resources/application.yml

yml 复制代码
spring:
  lifecycle:
    # 停止时先拒绝新请求,再等 30 秒让在途请求完成
    timeout-per-shutdown-phase: 30s
​
server:
  port: 8080
  # 容器内由 SERVER_ADDRESS=0.0.0.0 覆盖,宿主侧仍只发布到 127.0.0.1
  address: 127.0.0.1
  shutdown: graceful

address 这行有个反直觉的地方:应用内只监听 127.0.0.1,容器里宿主访问不到,所以 Dockerfile 用 SERVER_ADDRESS=0.0.0.0 覆盖;但 compose 的 ports 又只发布到宿主的 127.0.0.1。两头各收一次,最终仍然不出本机。

六、压测方法

scripts/load_test.py 是标准库实现,用 ThreadPoolExecutor 打并发,输出 QPS 与 P50/P95/P99。

py 复制代码
# chat:50 请求 / 并发 3
python3 scripts/load_test.py --url http://127.0.0.1:18080/api/chat \
  --requests 50 --concurrency 3 --label "chat c=3"
​
# RAG:注意字段是 question,不是 message
python3 scripts/load_test.py --url http://127.0.0.1:18080/api/rag/ask \
  --requests 50 --concurrency 2 --field question \
  --message "退货要保留什么?" --label "rag cross"

这次的方法有三条规定,和第一轮不同:

  1. 每组 50 个请求。 第一轮只有 6--12 个,P95 在那个量级上没有意义。
  2. 压测前预热一次。 /api/chat 和 /api/rag/ask 各打一发,让 ONNX session 先初始化完。
  3. CPU / 内存按 1--2 秒采样取峰值 ,不是只取一次 docker stats 快照。

第三条是关键。为什么,见第十节。

七、结果

场景 请求/并发 成功率 QPS 平均 P95 CPU 峰值 内存峰值
/api/chat 50 / 3 100% 3.54 0.84 s 1.22 s 11.44% 1598 MiB
/api/chat 50 / 6 100% 5.83 0.93 s 1.22 s 16.16% 1602 MiB
/api/rag/ask(cross) 50 / 2 100% 1.45 1.36 s 1.70 s 797.22% 1627 MiB
/api/rag/ask(lexical) 50 / 2 100% 1.72 1.15 s 1.56 s 74.32% 854 MiB

独立复测一轮(cross / lexical 各再跑 50 请求):

场景 QPS 平均 P95 CPU 峰值
/api/rag/ask(cross) 1.31 1.53 s 1.88 s 865.77%
/api/rag/ask(lexical) 1.81 1.10 s 1.44 s 66.48%

两轮可复现。QPS 与第一轮也全部对得上(chat 3.12→3.54 / 5.82→5.83,rag 1.32→1.45 / 1.54→1.72),只有 lexical 的 CPU 差了 6.6 倍。

八、chat 为什么不吃 CPU

并发从 3 提到 6:

  • QPS 从 3.54 涨到 5.83,接近翻倍
  • 延迟从 0.84 s 到 0.93 s,几乎没动
  • CPU 从 11.44% 到 16.16%,始终不超过 0.2 核

并发翻倍、QPS 也翻倍、延迟不动 ,这三件事同时成立只说明一个问题:应用层不是瓶颈。它在等外部,等 deepseek-flash 把话生成完。

内存稳定在 1.6GB 左右,那是 JVM 加上 jar 里那堆 ONNX 原生库的底座,跟并发量基本无关。

九、RAG 为什么吃 8 个核

同一个进程、同一个容器,换成 /api/rag/ask,cross 模式 797%,复测 866%。

我把 reranker 换成 LexicalReranker(纯字符 bigram + 向量分数加权,不做模型推理),掉到 74%,复测 66%。

差 12 倍。

原因有三条,摆一起就清楚:

一、文档向量在启动时就编码完了。 4 篇文档切成 6 个块,进知识库时编码一次,之后每次检索都是拿现成向量比距离。

二、每次请求只需要编码问题本身。 「退货要保留什么?」十几个 token,单独量过是 2.88 ms(取 32 token 输入、默认线程数下的 total p50)。

三、CrossEncoderReranker 每次要给 5 个候选各跑一遍交叉编码,每条截断到 512 token。按一次 40 ms 算,光重排就是 200 ms,还会把 10 个 ONNX 线程全吃满。

所以 RAG 的时间大部分在等生成,CPU 全花在重排上。这两件事不是一回事:延迟看的是端到端,成本看的是 CPU。

顺带一个和小容器有关的坑:ONNX Runtime 默认按核数开 intra-op 线程,我这台 10 核就开 10 个,单请求就能拉满 8 核。容器要是只给 2 核,这 10 个线程会互相抢,延迟反而更差。要么给够核,要么显式限制线程数------开关是 OrtSession.SessionOptions.setIntraOpNumThreads。

代码里现在没设这个值,小容器下把线程限下来到底能改善多少,我没测,只能给出这个入口。

十、一次快照,我读错了两个星期

第一轮压测(2026-10-26)我是这么记的:lexical 模式 CPU 492%,并写下结论「即使不用 reranker,embedding 本身也要 4.9 核」。

这个结论错了。真值是 66%--74%。

错在哪?第一轮每组只有 6--12 个请求,CPU 只取了一次 docker stats --no-stream 快照,而且容器重启后没预热。

我按原协议复现了一遍(重启 → 不预热 → 6 请求 / 并发 2),按秒采样:

makefile 复制代码
13:04:23   311.14%
13:04:25    66.31%
13:04:28     2.11%

第一次请求负责 ONNX session 初始化,CPU 冲高;后面回到 66%;跑完落到 2%。docker stats --no-stream 在 Docker Desktop 上单次调用约 2 秒,5 秒的压测只够取到 1--3 个点,取到哪一点就报哪个数。

延迟也印证同一件事:那一轮平均 1.68 s,但 P50 只有 1.25 s、P95 是 2.92 s------首个请求明显更慢。

三个教训:

  1. 压测必须预热,否则启动开销会污染稳态数据。
  2. CPU / 内存要采样后取峰值或稳态,不能只取一次快照。
  3. 样本量越小,单次异常的权重越大:6 个请求里启动开销占 1/6,50 个里占 1/50。

还有一条更根本的:不要用「对照组相减」代替实测。第一轮我把 lexical 的 CPU 直接当成 embedding 的开销,这个隐含假设从来没被验证过。

十一、坑

  1. 端口冲突 :本地 IDE 实例占着 8080,容器起不来。APP_PORT=18080 起容器,互不影响。
  2. .env 被 compose 自动注入 :RAG_RERANK 会用 .env 里的值,盖掉 compose 默认值。换模式要显式覆盖环境变量。
  3. DJL 缓存目录 :不设 DJL_CACHE_DIR,那 200MB 落在 ~/.djl.ai,不在模型卷里,重建即重下。
  4. 容器内必须监听 0.0.0.0 :application.yml 里写的是 127.0.0.1,不回环就绑定在容器自己的 loopback 上,宿主访问不到。
  5. 压测字段写错 :/api/rag/ask 要 question 不是 message。第一轮 6 次请求全 400,日志里是 MethodArgumentNotValidException------反倒顺手验证了参数校验是生效的。

十二、局限

  1. 知识库只有 4 篇文档、6 个块,召回本身不是瓶颈,结论不能外推到大规模语料。
  2. Docker Desktop 在 macOS 上跑的是虚拟机,CPU 统计与裸机可能有偏差。
  3. 第十节引用的 embedding 耗时(stage2-a)是 2026-11-06 进程内测的,和容器压测不是同一次实验,只能说明绝对耗时,不能和 QPS 相乘。
  4. 单一生成模型(deepseek-chat)、单一硬件(Apple Silicon)。
  5. 未做镜像瘦身,879MB 偏大;也没有单独测只读层对冷启动的影响。
  6. 结论是环境相关的,这是本文最大的局限。 全程走默认的 CPUExecutionProvider, 未启用 CoreML / CUDA------机器有集成 GPU,只是没启用,不是没有 GPU。 reranker 用 266MB 的量化 base 版,rerank-max-length 取 512。 三条能显著降低重排开销的路我都没测:换更小的 reranker、把窗口降到 128、 换用 GPU 执行提供者。任何一条成立,「reranker 是 CPU 大头」就不成立了------ CPU 会掉回和 chat 一个量级,瓶颈转到显存和加速器。 本文的「大头」结论,只在上面这套配置下成立。

十三、怎么部署

yml 复制代码
app:
  rag:
    rerank: ${RAG_RERANK:none}              # none / lexical / llm / cross
    candidate-k: 5
    rerank-snippet-length: 600              # 别设成 200
bash 复制代码
APP_PORT=18080 docker compose up -d --build
docker inspect --format '{{.State.Health.Status}}' ai-agent-lab
curl -s http://127.0.0.1:18080/api/rag/stats

默认仍然是 none。 上一篇的理由是 reranker 多占 690MB 内存,换来 1% 的 hit@1。这一篇补上另一半------它还要 8 个核。

小规格容器里,这一条比内存更容易把机器打死。


如果你们也在容器里跑 RAG,欢迎说说 reranker 是怎么摆的。我这边只在 10 核的 Docker Desktop 上测过,2 核 / 4 核的小容器下 intra-op 线程怎么设,那个场景我没数据。


这是「入职日志」系列的第 7 篇。完整连载在同名公众号,从第 1 篇看更连贯。

相关推荐
aurora_zjj29 分钟前
Nginx $request_length 为什么会变成负数?一次流量统计异常的源码排查
后端
旋律41436 分钟前
布隆过滤器(Bloom Filter)
后端
站大爷IP44 分钟前
Python的构造方法把我坑惨了,原来__new__和__init__的区别这么大
后端
Gopher_HBo1 小时前
一串裸 uint64,怎么攒成一份 pprof 文件?
后端
代码丰1 小时前
从重复点击到多实例并发:异步报表导出的五层幂等与防重设计
后端
斯维赤1 小时前
三级缓存为什么是三级?二级缓存不够吗
前端·后端·面试
Rain的Java大神之路1 小时前
把数组本身变成哈希表:原地哈希搞定 LeetCode 41「缺失的第一个正数」
java·后端·leetcode
K71 小时前
别再搜「LangChain 教程」了——你学的 Chain 已经被判了死刑
langchain·ai编程
卷无止境1 小时前
FDE全解析:把软件真正落地到客户现场的那类工程师
后端