一、为什么 AI 服务需要异步任务与队列
传统 Web 服务通常采用同步请求模型:客户端发送请求,服务端执行逻辑,完成后返回结果。
对于普通 CRUD 接口,这种模式通常足够简单。但 AI 服务的执行过程往往更加复杂。
一次 AI 请求可能涉及:
- 模型推理:调用大语言模型生成内容。
- RAG 检索:查询向量数据库、全文检索系统。
- 文档解析:提取 PDF、Word、图片中的文本。
- 多模态处理:图像识别、语音转写、视频分析。
- Agent 执行:多轮模型调用、工具调用和结果验证。
- 批量任务:批量生成 Embedding、摘要或分类结果。
这些任务通常具有以下特点:
- 执行时间不确定:模型推理可能持续几秒甚至数分钟。
- 资源消耗不均衡:不同请求消耗的 GPU 显存、CPU 和网络资源差异很大。
- 突发流量明显:用户可能在短时间内集中提交大量任务。
- 执行过程复杂:任务可能需要重试、暂停、恢复或人工干预。
- 结果不一定立即需要:用户可以先提交任务,稍后查询执行结果。
如果所有任务都采用同步方式处理,系统很容易出现请求超时、线程耗尽、GPU 过载和级联故障。
因此,需要引入三个核心机制:
| 机制 | 核心职责 | 解决的问题 |
|---|---|---|
| 异步任务 | 解耦提交与执行 | 长耗时请求阻塞 |
| 消息队列 | 缓冲、分发和调度 | 流量突发与生产消费不平衡 |
| 流量控制 | 限制进入系统的负载 | 资源过载与服务雪崩 |
三者不是彼此独立的功能,而是高并发 AI 服务中的一套协同机制。
二、同步执行与异步执行
2.1 同步执行
同步执行意味着请求方必须等待任务完成,才能获得最终结果。
典型过程:
flowchart TD
A["客户端提交请求"] --> B["API 接收请求"]
B --> C["执行模型推理"]
C --> D["处理推理结果"]
D --> E["返回最终响应"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
同步模式的优势:
- 实现简单。
- 请求与结果天然关联。
- 客户端可以直接获得执行结果。
- 不需要额外的任务状态管理。
但它也有明显限制:
- 请求连接需要持续占用。
- 长时间推理会增加连接和线程资源消耗。
- 客户端超时不代表服务端任务已经停止。
- 高并发情况下容易耗尽服务端资源。
- 不适合执行需要持续数分钟的复杂任务。
2.2 异步执行
异步执行将任务提交与任务处理分离。
客户端提交任务后,服务端只负责完成接收、校验、持久化和入队,然后立即返回任务 ID。
后台 Worker 从队列中获取任务并执行,客户端通过任务 ID 查询状态或接收通知。
flowchart TD
A["客户端提交任务"] --> B["API 校验请求"]
B --> C["创建任务记录"]
C --> D["任务写入消息队列"]
D --> E["返回 Task ID"]
D --> F["Worker 获取任务"]
F --> G["执行 AI 任务"]
G --> H["保存执行结果"]
H --> I["更新任务状态"]
I --> J["客户端查询或接收通知"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style D fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style I fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
异步模式将原本由 API 请求线程承担的长时间执行工作转移到后台任务系统。
它特别适合:
- 长文本生成。
- 批量 Embedding 计算。
- 大规模文档解析。
- Agent 长周期任务。
- 数据集生成和模型评估。
- 视频、音频等多模态处理。
2.3 同步与异步如何选择
| 维度 | 同步执行 | 异步执行 |
|---|---|---|
| 返回方式 | 返回最终结果 | 先返回任务 ID |
| 连接占用 | 持续等待 | 提交后即可释放 |
| 执行时间 | 适合较短任务 | 适合长耗时任务 |
| 状态管理 | 相对简单 | 需要任务状态管理 |
| 失败恢复 | 通常依赖请求重试 | 可通过队列和持久化恢复 |
| 系统复杂度 | 较低 | 较高 |
| 典型场景 | 短文本问答、实时对话 | 批量推理、文档处理、Agent |
需要注意:异步不意味着一定要使用消息队列。后台线程、进程池和任务调度器也可以实现异步执行。但当系统需要跨服务通信、持久化、削峰填谷和故障恢复时,消息队列通常更合适。
三、异步任务的核心模型
异步任务不仅是把函数放到后台执行,还需要明确任务的生命周期、状态、执行权和结果管理方式。
3.1 任务的基本组成
一个完整的任务对象通常包含:
| 字段 | 作用 |
|---|---|
| task_id | 唯一任务标识 |
| task_type | 任务类型 |
| payload | 任务输入数据或数据引用 |
| status | 当前任务状态 |
| priority | 任务优先级 |
| created_at | 创建时间 |
| started_at | 开始执行时间 |
| finished_at | 完成时间 |
| retry_count | 已重试次数 |
| max_retries | 最大重试次数 |
| timeout | 任务超时时间 |
| idempotency_key | 幂等键 |
| result_ref | 执行结果存储位置 |
| error | 错误信息 |
任务对象示例:
{
"task_id": "task_20261122_001",
"task_type": "document_analysis",
"payload": {
"document_id": "doc_001"
},
"status": "queued",
"priority": 5,
"retry_count": 0,
"max_retries": 3,
"timeout": 600,
"idempotency_key": "document_analysis_doc_001_v1"
}
对于大型文件和多模态任务,不建议直接将完整文件内容放入消息队列。
更合理的方式是:
- 文件存储在对象存储中。
- 数据库保存任务元数据。
- 消息队列只传递任务 ID、文件地址和必要参数。
这样可以避免消息体过大,降低队列网络传输和存储压力。
3.2 任务生命周期
一个任务通常需要经历多个状态。
| 状态 | 含义 |
|---|---|
| Pending | 任务已经创建,尚未进入可执行队列 |
| Queued | 已进入队列,等待 Worker 获取 |
| Running | 正在执行 |
| Retry Waiting | 执行失败,等待重新执行 |
| Succeeded | 执行成功 |
| Failed | 已达到失败条件,无法继续执行 |
| Cancelled | 被用户或系统取消 |
| Timeout | 超过允许执行时间 |
| Paused | 暂停执行,等待恢复 |
状态流转示意:
flowchart TD
A["Pending"] --> B["Queued"]
B --> C["Running"]
C --> D{"执行结果"}
D -->|"成功"| E["Succeeded"]
D -->|"可重试失败"| F["Retry Waiting"]
D -->|"不可重试失败"| G["Failed"]
D -->|"超时"| H["Timeout"]
F --> I{"是否超过重试上限"}
I -->|"否"| B
I -->|"是"| G
B --> J["Cancelled"]
C --> K["Cancelled"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#EAF3EC,stroke:#83A995,color:#315D49
style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style G fill:#F7EAE7,stroke:#C98D7C,color:#754438
style H fill:#F7EAE7,stroke:#C98D7C,color:#754438
style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style J fill:#F7EAE7,stroke:#C98D7C,color:#754438
style K fill:#F7EAE7,stroke:#C98D7C,color:#754438
状态设计必须明确哪些转换合法。
例如:
- Succeeded 不能重新变成 Running。
- Cancelled 不应该被普通 Worker 自动重新执行。
- Retry Waiting 必须受最大重试次数约束。
- Timeout 与 Failed 可以根据业务定义为不同终态。
- Running 任务如果 Worker 崩溃,需要有恢复机制。
任务状态不能仅依赖消息队列中的消息状态。 消息队列负责传递任务,数据库或持久化任务存储负责维护业务状态。两者需要通过一致性策略协同。
3.3 任务状态与消息状态的区别
两者经常被混淆。
| 任务状态 | 消息状态 |
|---|---|
| 描述业务执行进度 | 描述消息投递与消费进度 |
| 通常保存在数据库 | 通常由消息队列管理 |
| 包含 Running、Succeeded、Failed | 包含 Ready、Unacked、Acknowledged 等 |
| 面向业务查询 | 面向消息传输与消费 |
例如,Worker 已经从队列获取消息,但模型推理还没有完成:
- 消息可能处于未确认状态。
- 业务任务已经处于 Running 状态。
如果 Worker 执行成功并确认消息,但任务结果没有可靠保存,就可能出现消息已消费、业务结果却丢失的问题。
因此,需要设计任务状态更新、结果持久化和消息确认之间的顺序。
四、消息队列的核心作用
消息队列是异步任务系统中的中间缓冲层。
它将任务生产者与任务消费者解耦,使任务提交速度和任务处理速度不必完全一致。
4.1 生产者与消费者
典型架构包含三个角色:
- Producer:任务生产者,负责创建并发送任务。
- Broker:消息代理,负责存储、路由和投递消息。
- Consumer:任务消费者,负责获取消息并执行任务。
flowchart LR
A["API 服务"] --> B["Producer"]
B --> C["Message Broker"]
C --> D["Worker 1"]
C --> E["Worker 2"]
C --> F["Worker 3"]
D --> G["模型推理服务"]
E --> G
F --> H["文档处理服务"]
G --> I["结果存储"]
H --> I
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
4.2 消息队列解决什么问题
第一,服务解耦。
API 服务不需要知道具体由哪个 Worker 执行任务,也不需要维护 Worker 的连接。
第二,削峰填谷。
当短时间内出现大量请求时,队列可以暂时保存任务,让消费者按照自身处理能力逐步执行。
第三,横向扩展。
可以根据任务积压情况增加 Worker 实例,提高整体处理能力。
第四,故障隔离。
某个消费者发生故障时,其他消费者可以继续处理任务,队列可以保留尚未完成的消息。
第五,任务分发。
不同类型的任务可以进入不同队列,由不同的 Worker 集群处理。
4.3 常见消息队列
| 技术 | 特点 | 常见使用场景 |
|---|---|---|
| Redis Streams | 轻量、支持消费组和消息确认 | 中小规模异步任务 |
| RabbitMQ | 路由能力丰富,支持确认机制 | 业务任务与复杂消息路由 |
| Apache Kafka | 高吞吐、持久化、分区机制成熟 | 大规模事件流和数据处理 |
| Apache Pulsar | 多租户、分层存储、消息与计算解耦 | 大规模分布式消息系统 |
| Amazon SQS | 托管队列,运维负担较低 | 云原生异步任务 |
选择消息队列时,不能只看吞吐量,还需要关注:
- 消息持久化能力。
- 消息确认机制。
- 消费者失败后的恢复方式。
- 消息顺序要求。
- 延迟消息和死信队列支持。
- 消费组与分区扩展能力。
- 运维成本和可观测性。
4.4 队列模型
点对点队列(Queue)
一条消息通常由一个消费者成功处理,适合任务分发。
flowchart TD
A["任务生产者"] --> B["任务队列"]
B --> C["Worker A"]
B --> D["Worker B"]
B --> E["Worker C"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
发布订阅(Pub/Sub)
一条事件可以被多个订阅者分别消费,适合事件广播。
flowchart TD
A["事件生产者"] --> B["事件主题"]
B --> C["订阅者 A"]
B --> D["订阅者 B"]
B --> E["订阅者 C"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#EAF3EC,stroke:#83A995,color:#315D49
需要注意,Kafka 的同一消费组内通常由一个消费者处理某个分区中的特定消息,而不同消费组可以独立消费同一主题的数据。这与简单的广播式 Pub/Sub 并不完全相同。
五、队列积压与削峰填谷
消息队列最重要的价值之一,是在生产速度和消费速度不一致时提供缓冲。
5.1 生产速度与消费速度
假设:
- 每秒提交 100 个任务。
- 每个 Worker 每秒处理 5 个任务。
- 当前有 10 个 Worker。
整体处理能力:
生产速度:
队列积压增长速度:
如果持续 60 秒:
系统会积压约 3000 个任务。
队列只能暂时缓冲流量,不能无限吸收超过处理能力的请求。
5.2 队列长度与稳定性
定义:
- \lambda:任务到达速率。
- \mu:单个消费者的处理速率。
- c:消费者数量。
- Q:队列中的待处理任务数。
系统的理论处理能力:
当:
系统通常可以稳定处理任务,但还需要考虑处理时间波动、消费者故障和资源争用。
当:
队列会持续增长。
当:
系统处于临界状态,任何短时波动都可能造成积压。
因此,生产系统不应该长期运行在接近 100% 的理论处理能力上。
5.3 利用率与排队延迟
定义系统利用率:
当 \rho 越接近 1,排队延迟通常越容易显著增加。
对于简单的 M/M/1 排队模型:
其中 W 是系统平均停留时间,包含等待和服务时间。
这个公式只适用于特定的理想排队假设,真实 AI 系统往往具有任务处理时间分布不均、优先级调度和资源竞争等复杂特征,不能直接用它精确预测生产延迟。
工程上更重要的是持续监控:
- 队列长度。
- 最老消息等待时间。
- 任务到达速率。
- 任务完成速率。
- Worker 忙碌比例。
- P95/P99 排队延迟。
5.4 估算队列排空时间
如果队列中有 10,000 个任务:
- Worker 总处理能力:200 tasks/s。
- 新任务到达速度:50 tasks/s。
净排空速度:
队列排空时间:
这可以用于估算系统恢复时间。
但如果新任务持续到达,排空速度必须使用消费能力减去到达速度,而不是直接使用消费者总处理能力。
六、流量控制的核心技术
流量控制的目标不是简单地拒绝请求,而是让系统在负载变化时维持可预测的延迟和稳定性。
常见技术包括:
- 限流(Rate Limiting)。
- 并发控制(Concurrency Limiting)。
- 背压(Backpressure)。
- 熔断(Circuit Breaker)。
- 降级(Degradation)。
- 优先级调度(Priority Scheduling)。
- 负载均衡(Load Balancing)。
这些技术分别控制不同层面的压力。
6.1 限流 Rate Limiting
限流限制单位时间内允许进入系统的请求数量。
例如:
- 每个用户每秒最多提交 10 个请求。
- 每个 API Key 每分钟最多提交 1000 个任务。
- 整个服务每秒最多接收 500 个任务。
常见限流算法如下。
固定窗口(Fixed Window)
将时间划分为固定区间,每个区间单独计数。
例如,每分钟允许 100 次请求。
优点:
- 实现简单。
- 存储开销小。
- 适合基础 API 配额控制。
缺点:
- 存在窗口边界突发问题。
例如:
- 10:00:59 提交 100 次。
- 10:01:00 再提交 100 次。
短时间内可能实际收到 200 次请求。
滑动窗口(Sliding Window)
根据最近一段时间内的请求数量进行限制。
可以使用滑动日志或滑动计数器实现。
优点是比固定窗口更加平滑,但滑动日志会产生更高的存储和计算开销。
令牌桶(Token Bucket)
令牌按照固定速率生成,桶中最多保存一定数量的令牌。
每个请求需要消耗令牌才能通过。
核心参数:
- r:令牌生成速率。
- B:桶容量。
- T:令牌数量。
- \Delta t:经过时间。
令牌更新:
请求到达时,如果令牌数量足够,就消耗令牌并放行;否则拒绝或等待。
flowchart TD
A["请求到达"] --> B["检查令牌桶"]
B --> C{"令牌是否充足"}
C -->|"是"| D["消耗令牌"]
D --> E["放行请求"]
C -->|"否"| F{"是否允许等待"}
F -->|"是"| G["进入等待队列"]
F -->|"否"| H["返回限流响应"]
G --> I["等待令牌补充"]
I --> B
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style H fill:#F7EAE7,stroke:#C98D7C,color:#754438
style I fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
令牌桶允许短时间突发,但长期平均速率受到令牌生成速率限制。
漏桶(Leaky Bucket)
请求进入缓冲区,以固定速率流出。
它更强调平滑输出速度,适合限制下游服务的处理速率。
6.2 限流算法对比
| 算法 | 是否允许突发 | 主要特点 | 典型场景 |
|---|---|---|---|
| 固定窗口 | 窗口内允许集中请求 | 实现简单 | 基础配额 |
| 滑动窗口 | 相对平滑 | 精确控制时间范围 | API 限流 |
| 令牌桶 | 允许有限突发 | 控制长期平均速率 | API 网关 |
| 漏桶 | 输出速率较稳定 | 平滑流量 | 下游资源保护 |
对于 AI 服务,单纯按照请求数量限流往往不够。
因为不同请求的成本差异可能非常大:
- 100 Token 的短问答。
- 100,000 Token 的长上下文请求。
- 一次多轮 Agent 执行。
- 一次批量文档 Embedding。
这些请求虽然都只算一次 API 调用,但实际资源消耗完全不同。
因此,需要引入 Token 维度和资源维度的流量控制。
6.3 Token 级限流
大语言模型服务可以根据 Token 数量限制请求成本。
常见维度:
- 输入 Token 数量。
- 输出 Token 数量。
- 输入与输出 Token 总量。
- 每分钟 Token 数(TPM)。
- 每秒 Token 数(TPS)。
- 用户或租户的 Token 配额。
例如:
| 用户等级 | RPM | TPM |
|---|---|---|
| Free | 10 | 20,000 |
| Pro | 60 | 100,000 |
| Enterprise | 300 | 1,000,000 |
这里的 RPM 表示 Requests Per Minute,TPM 表示 Tokens Per Minute,数值仅为示例。
Token 级限流需要特别注意:
- 输入 Token 可以在推理前通过 Tokenizer 估算。
- 输出 Token 数量通常无法在推理前准确确定。
- 可以根据 max_tokens 预留预算。
- 执行完成后再根据实际使用量结算。
- 对超长上下文请求应单独设置限制。
对于流式生成,还可以在生成过程中持续检查 Token 预算,避免任务超出用户配额。
6.4 并发控制 Concurrency Limiting
限流控制单位时间内允许进入多少请求,并发控制限制同时执行的任务数量。
假设:
- 每秒允许 100 个请求进入。
- 每个请求平均执行 10 秒。
如果不限制并发,理论上可能同时存在约 1000 个执行中的请求。
但 AI 服务的 GPU 显存和推理能力有限,无法无限增加并发。
并发限制可以按不同资源维度配置:
| 限制维度 | 示例 |
|---|---|
| 全局并发 | 同时执行最多 200 个任务 |
| 用户并发 | 每个用户最多 5 个任务 |
| 模型并发 | 某模型最多 64 个并发请求 |
| GPU 并发 | 每张 GPU 限制推理请求数 |
| 任务类型并发 | 文档解析最多 20 个任务 |
| 租户并发 | 每个租户独立资源配额 |
需要注意,并发数量不等于 GPU 实际批处理大小。
在大模型推理服务中,多个请求可以被连续批处理调度器动态组合,真正影响 GPU 资源的是请求长度、KV Cache 占用、批次 Token 数量和模型执行特征。
6.5 背压 Backpressure
背压是指下游处理能力不足时,将压力反馈给上游,阻止上游继续无限制地产生任务。
例如:
- Worker 处理速度下降。
- 队列积压持续增长。
- 队列等待时间超过阈值。
- 系统通知 API 降低接收速度。
- API 延迟提交、拒绝新任务或降低任务优先级。
背压不是单纯的限流。
限流通常根据预设规则限制流量,而背压强调根据下游实时处理能力动态调整上游流量。
flowchart TD
A["客户端提交任务"] --> B["API 服务"]
B --> C["任务队列"]
C --> D["Worker 集群"]
D --> E["下游模型服务"]
E --> F{"处理能力是否充足"}
F -->|"是"| G["正常消费"]
F -->|"否"| H["产生背压信号"]
H --> I["降低生产速率"]
I --> J["延迟接收或拒绝请求"]
J --> B
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style H fill:#F7EAE7,stroke:#C98D7C,color:#754438
style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style J fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
常见背压策略:
- 队列达到阈值时暂停生产。
- 消费者处理速度下降时减少上游并发。
- 队列积压严重时拒绝低优先级任务。
- 对可延迟任务返回排队状态。
- 对无法等待的请求直接返回过载响应。
6.6 熔断 Circuit Breaker
当下游模型服务持续失败时,继续发送请求只会浪费资源。
熔断器根据失败率或超时情况,暂时停止向故障服务发送请求。
通常包含三个状态:
- Closed:正常请求通过,同时统计失败情况。
- Open:达到失败阈值,暂时拒绝请求。
- Half-Open:等待一段时间后放出少量探测请求。
stateDiagram-v2
[*] --> Closed
Closed --> Open: 失败率超过阈值
Open --> HalfOpen: 熔断等待结束
HalfOpen --> Closed: 探测请求成功
HalfOpen --> Open: 探测请求失败
熔断可以保护服务依赖,但需要合理设置:
- 失败率阈值。
- 统计窗口。
- 最小请求样本数。
- 熔断持续时间。
- 半开状态探测请求数量。
如果下游服务只是短暂变慢,不一定需要立即熔断。可以结合超时、并发限制和负载情况共同判断。
6.7 降级 Degradation
当系统资源不足时,可以主动降低部分服务能力。
AI 服务常见降级策略:
| 故障或压力 | 降级策略 |
|---|---|
| 高质量模型过载 | 切换到轻量模型 |
| GPU 资源不足 | 延迟执行非实时任务 |
| 长上下文过载 | 限制最大输入长度 |
| RAG 检索异常 | 使用缓存结果或基础模型回答 |
| Agent 工具不可用 | 返回部分结果或停止工具调用 |
| 队列积压严重 | 暂停低优先级任务 |
| 结果生成超时 | 返回已生成内容或任务状态 |
降级必须有明确的业务边界。
例如,不能在用户要求严格 JSON 输出时,随意切换到一个不具备结构化输出能力的模型。
七、AI 服务中的队列分层设计
AI 服务的任务类型差异很大,通常不应该把所有任务放进同一个队列。
7.1 为什么需要多队列
假设系统有三种任务:
- 实时对话:要求低延迟。
- 文档解析:执行时间较长。
- 批量 Embedding:吞吐量优先。
如果三种任务共用一个 FIFO 队列,可能出现:
- 大量文档解析任务占据队列。
- 实时对话任务排在长任务之后。
- 用户等待时间明显增加。
- GPU 和 CPU 资源无法按业务目标分配。
这属于队头阻塞(Head-of-Line Blocking)。
更合理的方式是按任务类型和优先级拆分队列。
flowchart TD
A["任务入口"] --> B["任务分类器"]
B --> C["实时任务队列"]
B --> D["普通任务队列"]
B --> E["批量任务队列"]
C --> F["实时推理 Worker"]
D --> G["通用 Worker"]
E --> H["批处理 Worker"]
F --> I["GPU 推理资源池"]
G --> J["共享计算资源池"]
H --> I
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style D fill:#EAF3EC,stroke:#83A995,color:#315D49
style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style F fill:#EAF3EC,stroke:#83A995,color:#315D49
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#EAF3EC,stroke:#83A995,color:#315D49
style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style J fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
7.2 按优先级调度
常见优先级:
| 优先级 | 任务类型 | 调度策略 |
|---|---|---|
| P0 | 系统关键任务 | 优先执行 |
| P1 | 实时交互请求 | 低排队延迟 |
| P2 | 普通用户任务 | 正常调度 |
| P3 | 批量处理任务 | 利用空闲资源 |
| P4 | 离线分析任务 | 低峰期执行 |
但是,简单的严格优先级调度会导致低优先级任务长期得不到执行。
这称为饥饿问题(Starvation)。
解决方案包括:
- 优先级老化:等待时间越长,优先级逐渐提高。
- 配额调度:为每类任务预留处理能力。
- 加权公平队列:按照权重分配执行机会。
- 时间片轮转:不同任务队列轮流获得资源。
- 最大等待时间:超过阈值后提升优先级。
7.3 资源池隔离
多队列不一定意味着物理资源完全隔离,但关键任务应该有明确的资源保障。
例如:
- 实时推理使用独立 GPU 资源池。
- 离线批处理使用剩余 GPU 资源。
- 文档解析使用独立 CPU Worker。
- Embedding 使用专门的批处理服务。
- Agent 工具调用使用独立并发配额。
这样可以降低长任务对实时任务的干扰。
八、异步任务的可靠性设计
队列能够提高系统弹性,但并不自动保证任务只执行一次,也不保证任务永远不会丢失。
可靠性需要从消息投递、任务执行、结果持久化和恢复机制多个层面设计。
8.1 至少一次投递 At-Least-Once
至少一次投递意味着消息可能被重复投递,但只要系统持续恢复,消息最终有机会被处理。
例如:
- Worker 获取消息。
- Worker 完成模型推理。
- Worker 在确认消息前崩溃。
- 消息重新进入可消费状态。
- 其他 Worker 再次处理。
此时同一任务可能执行两次。
因此,至少一次投递要求业务处理具备幂等性。
8.2 至多一次投递 At-Most-Once
至多一次投递意味着消息最多被交付一次,但可能因为故障而丢失。
如果 Worker 获取消息后立即确认,再执行任务:
- Worker 获取消息。
- 消息被确认。
- Worker 执行过程中崩溃。
- 消息不会再次投递。
这种模式可能造成任务丢失。
8.3 恰好一次 Exactly-Once
Exactly-Once 是一个容易被误解的概念。
某些消息系统可以提供特定范围内的事务性或恰好一次处理语义,但这不等于外部模型推理、数据库写入、文件存储和工具调用等所有副作用都天然只执行一次。
例如:
- 模型已经完成一次付费推理。
- Worker 在保存结果前崩溃。
- 消息重新投递。
- 模型再次执行。
即使消息系统具有事务机制,也不一定能够回滚第一次外部模型调用。
因此,工程实践中通常采用:
至少一次投递 + 业务幂等 + 状态持久化 + 去重机制。
8.4 幂等性设计
幂等意味着相同请求重复执行,不会产生重复业务结果。
常见方法:
唯一任务 ID
为每个业务任务生成唯一 ID。
幂等键
根据业务参数生成稳定的幂等标识。
例如:
document_summary:doc_001:version_3
数据库唯一约束
对幂等键建立唯一索引,防止重复创建结果记录。
状态检查
Worker 执行前先检查任务状态,如果任务已经成功,则不再重复处理。
结果覆盖保护
使用版本号或条件更新,防止旧任务覆盖新结果。
需要注意,幂等不能只依赖 Worker 内存中的集合。因为 Worker 重启后,内存状态会丢失,去重信息必须持久化。
8.5 消息确认机制
消息确认(ACK)决定消息是否可以从待处理状态转为已完成状态。
常见策略:
- 自动确认:消息投递后自动确认,简单但任务丢失风险较高。
- 手动确认:任务处理成功后确认,适合可靠任务。
- 失败拒绝:处理失败时拒绝消息。
- 重新入队:临时错误时重新排队。
- 死信转移:无法继续处理时转入死信队列。
对于耗时较长的 AI 任务,通常需要合理配置消息可见性超时、消费确认超时或消息租约。
如果任务执行时间可能超过消息租约,需要定期续租,避免任务仍在执行时被其他 Worker 再次获取。
8.6 事务消息与 Outbox Pattern
异步系统中有一个典型问题:
业务数据库写入成功,但消息发送失败。
例如:
- 创建任务记录。
- 数据库事务提交成功。
- 服务发送消息到队列。
- 消息队列暂时不可用。
- 数据库中有任务,但队列中没有消息。
这会造成任务永远无法执行。
另一种情况是消息发送成功,但数据库事务回滚,消费者拿到不存在的任务。
Outbox Pattern 可以解决这类双写一致性问题。
核心思路:
- 在同一个数据库事务中写入业务任务记录。
- 同时写入 Outbox 事件表。
- 独立的发布器扫描 Outbox。
- 将事件发送到消息队列。
- 发送成功后标记 Outbox 事件已发布。
- 如果发布失败,后续继续重试。
flowchart TD
A["接收任务请求"] --> B["开启数据库事务"]
B --> C["写入任务记录"]
C --> D["写入 Outbox 事件"]
D --> E["提交数据库事务"]
E --> F["Outbox 发布器扫描事件"]
F --> G["发送消息到队列"]
G --> H{"发送成功"}
H -->|"是"| I["标记事件已发布"]
H -->|"否"| J["保留事件并重试"]
J --> F
I --> K["Worker 消费任务"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style C fill:#EAF3EC,stroke:#83A995,color:#315D49
style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
style E fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
style G fill:#EAF3EC,stroke:#83A995,color:#315D49
style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F
style J fill:#F7EAE7,stroke:#C98D7C,color:#754438
style K fill:#EAE8FA,stroke:#A49BD5,color:#51477D
Outbox 解决的是数据库与消息队列之间的可靠发布问题,但仍需要处理重复发布,因此消费者仍然需要幂等。
九、重试、退避与死信队列
AI 服务中失败是常态,需要把失败分为不同类型,而不是遇到任何异常都立即重试。
9.1 错误分类
| 错误类型 | 是否建议重试 | 处理方式 |
|---|---|---|
| 网络超时 | 通常可以 | 延迟重试 |
| 模型服务暂时不可用 | 可以 | 指数退避 |
| HTTP 429 | 可以 | 遵循 Retry-After |
| HTTP 500、503 | 通常可以 | 限制重试次数 |
| 参数校验失败 | 不可以 | 直接失败 |
| 文件格式不支持 | 不可以 | 返回业务错误 |
| 权限不足 | 不可以 | 终止任务 |
| Token 超出模型限制 | 不应原样重试 | 截断或重新处理 |
| GPU OOM | 视情况而定 | 降低并发或切换资源 |
| 任务超时 | 视任务语义而定 | 检查执行状态后决定 |