返回专栏
· 33 分钟阅读

AI 模型服务的高可用设计


一、为什么 AI 模型服务需要高可用设计

AI 模型服务与传统 Web 服务相比,具有更复杂的运行环境和资源依赖。

传统 Web 服务通常可以通过增加应用实例实现横向扩展,而 AI 模型服务还需要考虑模型权重、GPU 显存、推理引擎、KV Cache、模型加载时间以及计算资源之间的协调。

一个完整的 AI 模型服务可能依赖:

  • API Gateway:接收请求并执行身份验证、路由和限流。
  • Model Router:根据模型版本、负载和资源状态选择推理实例。
  • Model Server:加载模型并执行推理。
  • GPU Worker:提供 GPU 计算资源。
  • Cache:缓存模型权重、Prefix Cache、KV Cache 或推理结果。
  • Model Registry:管理模型文件、版本和部署配置。
  • Object Storage:保存模型权重、数据集和推理结果。
  • Scheduler:负责任务调度和资源分配。
  • Monitoring:采集运行指标、日志和链路追踪数据。

其中任何一个关键环节发生故障,都可能影响用户请求。

1.1 AI 模型服务的典型故障

故障类型 典型表现 影响
GPU 故障 GPU Xid、设备掉线、计算异常 推理实例不可用
显存不足 CUDA Out of Memory 请求失败或进程崩溃
模型加载失败 权重损坏、下载超时 实例无法启动
推理进程崩溃 Segmentation Fault、Runtime Error 当前实例停止服务
网络故障 节点间连接中断 请求超时或结果丢失
缓存故障 Redis 不可用、缓存雪崩 延迟升高、计算压力增加
流量突增 并发量超过处理能力 请求积压、超时增加
调度器故障 无法分配 GPU 或 Worker 新请求无法执行
模型版本故障 新模型存在兼容性问题 推理错误或性能退化
依赖服务故障 Tokenizer、向量数据库等不可用 推理链路中断

高可用设计并不是保证所有组件永远不发生故障,而是确保故障发生后:

  1. 能够及时发现。
  2. 能够隔离故障范围。
  3. 能够自动切换或恢复。
  4. 能够保护剩余健康资源。
  5. 能够尽可能维持核心业务能力。

1.2 高可用的核心指标

高可用设计通常需要明确几个关键指标。

可用性(Availability)

表示服务在指定时间范围内能够正常提供服务的比例。

Availability= \frac{Uptime}{TotalTime}\times100\%

也可以从停机时间计算:

Availability= 1-\frac{Downtime}{TotalTime}

常见可用性目标:

可用性目标 年度理论停机时间
99% 约 87.6 小时
99.9% 约 8.76 小时
99.95% 约 4.38 小时
99.99% 约 52.56 分钟
99.999% 约 5.26 分钟

这里的停机时间是理论预算,实际是否达标取决于服务等级目标(SLO)的定义和统计窗口。

SLO(Service Level Objective)

服务等级目标,用于定义系统需要达到的可靠性水平。

例如:

  • 月度可用性不低于 99.95%。
  • 在线推理请求成功率不低于 99.9%。
  • P95 TTFT 不超过 2 秒。
  • P99 推理请求错误率低于指定阈值。

SLI(Service Level Indicator)

服务等级指标,是衡量 SLO 的实际观测数据。

例如:

  • 成功请求数 / 总请求数。
  • 正常服务时间 / 总服务时间。
  • P95、P99 请求延迟。
  • 超时率。
  • 模型推理失败率。

RTO(Recovery Time Objective)

恢复时间目标,表示发生故障后允许的最长恢复时间。

RPO(Recovery Point Objective)

恢复点目标,表示故障发生时可以容忍的数据丢失范围。

对于无状态推理实例,通常不需要恢复历史推理进度;但模型配置、任务状态、会话记录和业务数据可能需要严格的 RPO。

二、AI 模型服务的高可用架构

2.1 单实例部署的问题

最简单的模型服务架构是一个 API 服务连接一个模型推理实例。

flowchart TD
    A["用户请求"] --> B["API 服务"]
    B --> C["单个模型推理实例"]
    C --> D["GPU"]
    D --> E["返回结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#E5F0E9,stroke:#83A995,color:#315D49

这种架构简单,但存在明显的单点故障:

  • API 服务崩溃,所有请求无法进入。
  • GPU 故障,模型无法继续推理。
  • 模型进程 OOM,服务整体不可用。
  • 模型升级期间,服务可能需要停机。
  • 流量超过单实例能力时,所有请求都受到影响。

这种部署适合开发、测试和低流量内部应用,不适合有明确 SLA 要求的生产环境。

2.2 多实例冗余架构

提高可用性的第一步是部署多个独立模型实例。

flowchart TD
    A["用户请求"] --> B["API Gateway"]
    B --> C["负载均衡器"]
    C --> D["Model Server A"]
    C --> E["Model Server B"]
    C --> F["Model Server C"]
    D --> G["GPU 节点 A"]
    E --> H["GPU 节点 B"]
    F --> I["GPU 节点 C"]
    G --> J["推理结果"]
    H --> J
    I --> J

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    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:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style J fill:#E5F0E9,stroke:#83A995,color:#315D49

多个实例能够实现:

  • 实例故障时切换到其他实例。
  • 将流量分散到多个 GPU 节点。
  • 支持滚动升级。
  • 支持按负载动态扩缩容。
  • 降低单节点故障对整体服务的影响。

但需要注意:多个实例不一定代表真正的高可用。

如果三个模型实例都部署在同一台物理服务器上,那么服务器故障仍然会导致全部实例不可用。

因此,冗余必须覆盖不同故障域。

2.3 多层高可用架构

生产级 AI 模型服务通常采用多层冗余设计。

flowchart TD
    A["客户端"] --> B["DNS / 全局流量管理"]
    B --> C["区域 A 入口"]
    B --> D["区域 B 入口"]
    C --> E["API Gateway 集群"]
    D --> F["API Gateway 集群"]
    E --> G["区域 A 模型路由器"]
    F --> H["区域 B 模型路由器"]
    G --> I["模型推理实例池 A"]
    H --> J["模型推理实例池 B"]
    I --> K["GPU 资源池 A"]
    J --> L["GPU 资源池 B"]
    K --> M["共享模型制品与配置管理"]
    L --> M
    E --> N["监控与告警"]
    F --> N
    G --> N
    H --> N

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    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:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style L fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style M fill:#E5F0E9,stroke:#83A995,color:#315D49
    style N fill:#F7F4E8,stroke:#C7B77A,color:#675A2D

这种架构从多个层面消除单点故障:

层次 高可用措施
DNS / 流量入口 多区域入口、健康检查、流量切换
API Gateway 多实例、无状态部署
Model Router 多副本、状态外置
Model Server 多实例冗余
GPU 节点 跨主机、跨机架部署
模型制品 多副本存储、校验与版本管理
元数据存储 主从复制、集群或多区域容灾
监控系统 独立部署、故障告警

需要区分两个概念:

  • 高可用(HA):发生故障时,系统能够继续提供服务或快速恢复。
  • 灾难恢复(DR):发生区域级、机房级或大规模基础设施故障时,系统能够恢复业务。

多区域部署属于更高层次的容灾能力,但也会增加数据同步、网络、模型分发和运维成本。

三、故障域与冗余设计

高可用架构的关键不只是增加实例数量,而是让故障尽可能局部化。

3.1 故障域

故障域(Failure Domain)是指可能因为同一个故障原因而同时受到影响的一组资源。

常见故障域包括:

故障域 典型故障
进程级 Python 进程崩溃、内存泄漏
容器级 容器退出、健康检查失败
主机级 操作系统崩溃、GPU 故障
机架级 电源、交换机或网络故障
可用区级 机房网络、电力或基础设施故障
区域级 大范围云服务或网络故障

如果多个模型实例共享同一个故障域,它们的故障并不独立。

因此,部署时应尽可能分散:

  • 不同物理主机。
  • 不同 GPU 节点。
  • 不同机架。
  • 不同可用区。
  • 不同区域。

3.2 N+1 冗余

N+1 冗余表示系统正常运行需要 N 个实例,同时额外准备 1 个备用实例。

例如:

  • 正常需要 4 个模型实例。
  • 实际部署 5 个实例。
  • 一个实例发生故障时,其余 4 个实例继续承担业务。

但 N+1 不一定适用于所有 GPU 服务。

如果 GPU 资源非常昂贵,可能会采用:

  • N+1 热备。
  • 部分容量预留。
  • 多实例共享冗余容量。
  • 跨区域冷备。

需要根据恢复时间目标和成本进行选择。

3.3 Active-Active:双活部署

Active-Active 表示多个实例同时处理请求。

例如:

Region A:承担 50% 请求
Region B:承担 50% 请求

优点:

  • 所有节点都能提供实际服务。
  • 资源不会长期闲置。
  • 故障切换通常更快。
  • 可以跨区域分担流量。

缺点:

  • 模型版本需要保持兼容。
  • 数据和缓存需要考虑一致性。
  • 跨区域流量可能增加网络延迟。
  • 多区域资源调度更加复杂。

对于无状态推理服务,Active-Active 通常比较容易实现。

但对于有状态会话、任务执行进度和分布式推理,需要额外设计状态同步和恢复机制。

3.4 Active-Standby:主备部署

Active-Standby 表示主实例处理请求,备用实例在故障时接管。

正常状态:
Primary -> 处理全部请求
Standby -> 等待接管

故障状态:
Primary -> 不可用
Standby -> 接管请求

优点:

  • 架构相对简单。
  • 备用资源可以按需配置。
  • 适合低流量但要求快速恢复的服务。

缺点:

  • 备用资源可能长期闲置。
  • 需要健康检测和切换机制。
  • 备用模型可能尚未加载到 GPU。
  • 故障切换可能存在明显冷启动时间。

对于大型模型,备用节点加载权重可能需要较长时间,因此真正要求低 RTO 的服务通常需要预热备用实例。

四、模型实例的健康检查

高可用系统必须能够判断一个模型实例是否真的可以处理请求。

传统 Web 服务通常通过 HTTP 健康检查即可完成基本判断,但 AI 模型服务的健康状态更加复杂。

4.1 三种基础健康检查

Liveness Probe:存活探针

检查进程是否仍然存活。

例如:

  • HTTP 服务是否能够响应。
  • 主循环是否仍在运行。
  • 关键线程是否正常。
  • 是否发生死锁。

如果存活探针失败,平台可以重启容器。

但存活探针不应过度依赖模型推理,否则 GPU 短暂繁忙就可能导致容器反复重启。

Readiness Probe:就绪探针

检查实例是否已经具备处理真实请求的能力。

典型检查内容:

  • 模型权重是否加载完成。
  • Tokenizer 是否可用。
  • GPU 是否可正常访问。
  • 推理引擎是否初始化完成。
  • 关键依赖是否满足要求。
  • 当前是否处于排空或升级状态。

Readiness 失败时,实例应从流量池中摘除,但不一定需要重启。

Startup Probe:启动探针

用于保护启动时间较长的服务。

大型模型可能需要较长时间:

  • 下载模型权重。
  • 加载权重到 GPU。
  • 初始化 CUDA。
  • 创建 KV Cache 管理结构。
  • 执行预热推理。

Startup Probe 可以避免服务启动期间被过早判定为异常。

4.2 AI 模型服务的健康状态

建议将模型实例的状态划分为:

状态 含义 是否接收新请求
STARTING 正在启动 否
LOADING 正在加载模型 否
WARMING 正在预热 通常否
READY 可以正常服务 是
DEGRADED 性能下降或部分能力异常 视策略决定
DRAINING 正在排空请求 否
UNHEALTHY 健康检查失败 否
TERMINATED 已停止 否

健康状态转换:

flowchart TD
    A["STARTING"] --> B["LOADING"]
    B --> C["WARMING"]
    C --> D{"预热是否成功?"}
    D -->|是| E["READY"]
    D -->|否| F["UNHEALTHY"]
    E --> G{"运行状态正常?"}
    G -->|是| E
    G -->|部分异常| H["DEGRADED"]
    H --> I{"是否恢复?"}
    I -->|是| E
    I -->|否| F
    E --> J["DRAINING"]
    H --> J
    J --> K["TERMINATED"]
    F --> L["重启或重新调度"]

    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:#F7EAE7,stroke:#C98D7C,color:#754438
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style K fill:#E5F0E9,stroke:#83A995,color:#315D49
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49

4.3 为什么健康检查不能只看 HTTP 200

模型服务可能出现以下情况:

  • HTTP 进程正常,但 GPU 已经不可用。
  • 模型加载完成,但推理引擎内部发生死锁。
  • 服务能够返回健康检查结果,但推理队列已经严重积压。
  • 模型能够推理,但实际输出持续异常。
  • GPU 正常,但关键 Tokenizer 文件丢失。

因此,应将健康检查拆分为多个层次:

  1. 进程健康。
  2. 服务健康。
  3. 模型健康。
  4. GPU 健康。
  5. 推理能力健康。
  6. 性能健康。

其中性能健康可以通过延迟、队列积压、超时率和资源压力判断,而不是只依赖一个布尔状态。

五、流量管理与负载均衡

多个模型实例部署完成后,还需要决定请求发送到哪个实例。

5.1 负载均衡策略

常见策略如下:

策略 工作方式 适用场景
Round Robin 轮流分配请求 实例能力相近
Weighted Round Robin 按权重分配请求 实例规格不同
Least Connections 选择连接数较少的实例 请求持续时间差异较大
Least Outstanding Requests 选择未完成请求较少的实例 推理时长差异明显
Latency-aware 根据历史延迟选择实例 追求低延迟
Resource-aware 根据 GPU、显存和队列状态路由 AI 推理服务
Consistent Hashing 按 Key 进行稳定映射 需要缓存局部性

对于 AI 模型服务,普通 Round Robin 往往不够。

因为不同请求的计算成本可能相差很大。

例如:

  • 请求 A:输入 100 Token,输出 50 Token。
  • 请求 B:输入 10000 Token,输出 2000 Token。

如果两个请求被视为相同工作量,简单轮询可能导致某些 GPU 节点积压大量长请求。

更合理的做法是根据以下指标进行调度:

  • 当前活动请求数。
  • 排队请求数。
  • GPU 计算利用率。
  • GPU 显存占用。
  • KV Cache 可用空间。
  • 请求输入 Token 数。
  • 预计输出 Token 数。
  • 预估执行时间。
  • Prefix Cache 命中情况。

5.2 请求路由架构

flowchart TD
    A["请求进入"] --> B["API Gateway"]
    B --> C["身份验证与配额检查"]
    C --> D["Model Router"]
    D --> E["获取实例健康状态"]
    E --> F["获取资源与队列指标"]
    F --> G["检查模型版本和请求能力"]
    G --> H{"是否存在可用实例?"}
    H -->|是| I["计算路由评分"]
    H -->|否| J["限流、排队或返回错误"]
    I --> K["选择目标实例"]
    K --> L["转发推理请求"]
    L --> M{"请求是否成功?"}
    M -->|是| N["返回推理结果"]
    M -->|否| O["判断是否允许重试"]
    O --> P{"可安全重试?"}
    P -->|是| D
    P -->|否| Q["返回错误或降级结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style J fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style N fill:#E5F0E9,stroke:#83A995,color:#315D49
    style O fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style P fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style Q fill:#F7EAE7,stroke:#C98D7C,color:#754438

5.3 请求重试与重复执行

模型实例发生故障后,Router 可能将请求重新发送到其他实例。

但要注意:请求超时不代表模型没有执行。

例如:

  1. 请求已经发送到 GPU 节点 A。
  2. 节点 A 完成推理。
  3. 结果返回途中网络中断。
  4. API Gateway 认为请求超时。
  5. 请求被重新发送到节点 B。
  6. 相同任务可能再次执行。

这可能导致:

  • 重复消耗 GPU 资源。
  • 重复执行工具调用。
  • 重复生成业务副作用。
  • 不同实例返回不同结果。

因此,需要通过 Request ID、Idempotency Key 和任务状态管理控制重复执行。

对于纯文本推理,重复执行可能主要造成成本和延迟问题;对于 Agent 工具调用、数据库写入和外部 API 操作,则可能产生实际业务风险。

六、超时、重试与熔断机制

高可用系统不能无限等待故障恢复,也不能在依赖服务异常时持续发送请求。

6.1 Timeout:超时控制

超时是指请求超过预设时间后,不再继续等待当前操作。

AI 模型服务需要区分不同阶段的超时:

超时类型 含义
Connect Timeout 建立连接超时
Queue Timeout 请求排队超时
Model Load Timeout 模型加载超时
Prefill Timeout 输入处理超时
First Token Timeout 首 Token 超时
Idle Timeout 流式输出长时间无数据
Total Request Timeout 请求总耗时超时
Dependency Timeout 依赖服务调用超时

对于流式推理,不能简单使用一个很短的总请求超时。

因为生成较长文本可能需要几十秒甚至更长时间。

更合理的方式是:

  • 控制连接建立时间。
  • 控制排队时间。
  • 控制首 Token 时间。
  • 控制两次 Token 输出之间的最大空闲时间。
  • 设置合理的总执行时间上限。

6.2 Retry:重试机制

重试适用于可能暂时恢复的故障。

常见可重试错误:

  • 网络连接暂时失败。
  • GPU Worker 暂时不可用。
  • 服务返回 503。
  • 下游依赖出现短暂超时。
  • 负载过高导致请求被拒绝。

不应盲目重试的错误:

  • 参数格式错误。
  • 模型版本不存在。
  • 身份验证失败。
  • 用户权限不足。
  • Token 数超过硬性限制。
  • 不支持的输入格式。

常见重试策略是指数退避:

Delay_n=\min(Delay_{max},Delay_0\times2^n)

例如:

重试次数 基础等待时间
第 1 次 1 秒
第 2 次 2 秒
第 3 次 4 秒
第 4 次 8 秒

实际系统还应加入随机抖动(Jitter),避免大量请求在同一时间重新发起。

6.3 Circuit Breaker:熔断器

熔断器用于防止持续访问已经发生故障的服务。

一般包含三种状态:

  • CLOSED:正常状态,允许请求通过。
  • OPEN:熔断状态,直接拒绝或快速失败。
  • HALF-OPEN:半开状态,允许少量探测请求。

工作流程:

flowchart TD
    A["收到请求"] --> B["熔断器"]
    B --> C{"当前状态"}
    C -->|CLOSED| D["调用模型服务"]
    C -->|OPEN| E["快速失败或降级"]
    C -->|HALF-OPEN| F["允许少量探测请求"]
    D --> G{"调用结果"}
    G -->|成功| H["成功计数与状态恢复"]
    G -->|失败| I["失败计数增加"]
    I --> J{"是否超过熔断阈值?"}
    J -->|是| K["进入 OPEN"]
    J -->|否| L["继续观察"]
    F --> M{"探测是否成功?"}
    M -->|是| N["恢复 CLOSED"]
    M -->|否| K
    K --> O["等待熔断窗口"]
    O --> F

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style F fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#E5F0E9,stroke:#83A995,color:#315D49
    style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style J fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style K fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style N fill:#E5F0E9,stroke:#83A995,color:#315D49
    style O fill:#EAF3EC,stroke:#83A995,color:#315D49

熔断器需要按依赖或模型实例进行隔离。

例如:

  • Model A 故障,不应影响 Model B。
  • GPU 节点 A 故障,不应熔断整个推理集群。
  • Redis 故障,不应直接导致所有模型服务不可用。

6.4 Retry 与 Circuit Breaker 的区别

机制 解决的问题 核心作用
Timeout 请求等待过久 限制等待时间
Retry 临时性故障 尝试恢复
Circuit Breaker 下游持续故障 阻止无效请求
Fallback 主服务不可用 提供替代能力
Bulkhead 资源相互影响 隔离故障范围

这些机制需要协同工作,而不是彼此替代。

七、故障隔离与舱壁模式

舱壁模式(Bulkhead Pattern)源于船舶隔舱设计思想:一个区域发生故障时,不应让整个系统被拖垮。

在 AI 模型服务中,舱壁模式尤其重要,因为不同模型和任务的资源消耗差异很大。

7.1 按模型隔离

不同模型使用独立的推理资源池。

例如:

Model A
  -> GPU Pool A
  -> Worker A

Model B
  -> GPU Pool B
  -> Worker B

Model C
  -> GPU Pool C
  -> Worker C

这样可以避免某个模型发生 OOM 或推理异常后影响其他模型。

7.2 按任务类型隔离

不同类型的 AI 任务使用不同的资源池:

任务类型 推荐隔离方式
在线 LLM 推理 独立 GPU 池
Embedding 独立推理队列或资源池
OCR 独立 CPU/GPU Worker
文档解析 CPU 与内存资源池
批量 RAG 索引 独立异步任务池
模型训练 独立训练集群

特别要避免大规模离线任务抢占在线推理资源。

7.3 按租户隔离

多租户 AI 平台需要控制不同租户的资源使用。

可以设置:

  • 每个租户最大并发数。
  • 每分钟请求次数。
  • 每日 Token 配额。
  • 最大上下文长度。
  • 最大输出 Token 数。
  • GPU 资源预算。
  • 优先级和服务等级。

这样可以避免单个租户的异常流量影响其他租户。

7.4 资源隔离的完整结构

flowchart TD
    A["AI 模型服务"] --> B["请求分类"]
    B --> C["租户 A"]
    B --> D["租户 B"]
    B --> E["后台任务"]
    C --> F["在线推理资源池"]
    D --> G["独立推理资源池"]
    E --> H["离线任务资源池"]
    F --> I["GPU Worker A"]
    G --> J["GPU Worker B"]
    H --> K["CPU / GPU Worker C"]
    I --> L["独立队列与配额"]
    J --> M["独立队列与配额"]
    K --> N["独立队列与配额"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#E5F0E9,stroke:#83A995,color:#315D49
    style M fill:#E5F0E9,stroke:#83A995,color:#315D49
    style N fill:#E5F0E9,stroke:#83A995,color:#315D49

八、故障转移与自动恢复

故障转移(Failover)是指主服务或节点发生故障后,将请求转移到其他可用实例。

8.1 故障转移的基本过程

典型流程包括:

  1. 监控系统检测异常。
  2. 健康检查确认实例不可用。
  3. 将异常实例标记为 Unhealthy。
  4. 从负载均衡池中摘除。
  5. 将新请求路由到健康实例。
  6. 对可安全重试的请求执行重试。
  7. 启动替代实例。
  8. 实例预热完成后重新加入流量池。
flowchart TD
    A["模型实例正常运行"] --> B["健康检查与指标监控"]
    B --> C{"实例是否健康?"}
    C -->|是| A
    C -->|否| D["标记实例 Unhealthy"]
    D --> E["从流量池摘除"]
    E --> F["路由到其他健康实例"]
    F --> G["检查请求是否可重试"]
    G --> H{"是否允许重试?"}
    H -->|是| I["重新发送请求"]
    H -->|否| J["返回错误或降级"]
    D --> K["启动替代实例"]
    K --> L["加载模型权重"]
    L --> M["执行预热与健康检查"]
    M --> N{"是否就绪?"}
    N -->|是| O["重新加入流量池"]
    N -->|否| P["继续恢复或隔离"]
    I --> Q["监控恢复状态"]
    J --> Q
    O --> Q
    P --> Q

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#EAF3EC,stroke:#83A995,color:#315D49
    style N fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style O fill:#E5F0E9,stroke:#83A995,color:#315D49
    style P fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style Q fill:#E5F0E9,stroke:#83A995,color:#315D49

8.2 故障检测不能过于敏感

如果健康检查过于敏感,可能发生误判:

  • GPU 短暂繁忙。
  • 网络瞬间抖动。
  • 模型推理排队时间变长。
  • 偶发请求超时。

这些情况不一定代表实例真正故障。

建议使用:

  • 连续失败次数。
  • 多个时间窗口。
  • 指标阈值组合。
  • 主动探测请求。
  • 被动请求失败率。

例如,只有连续多次健康检查失败,才将实例摘除。

还可以设置恢复观察期,避免实例刚恢复就立即接收大量请求。

8.3 自动恢复与人工介入

并非所有故障都应该自动重启。

例如:

  • GPU 驱动异常可能需要节点重启。
  • 模型权重损坏需要重新下载。
  • 显存泄漏可能需要替换进程。
  • 错误配置可能导致新实例持续崩溃。
  • 数据损坏可能需要人工修复。

建议建立分级恢复策略:

故障级别 处理方式
短暂网络故障 自动重试
单请求推理失败 隔离请求并记录错误
模型进程异常 重启进程
GPU 设备异常 摘除节点并重新调度
模型文件损坏 重新拉取和校验模型
配置发布错误 回滚配置
区域级故障 启动跨区域容灾

九、模型部署与版本升级的高可用设计

模型升级是 AI 服务中非常重要的风险来源。

新模型可能出现:

  • 模型权重不兼容。
  • Tokenizer 不匹配。
  • 推理引擎不支持新算子。
  • 输出质量下降。
  • 推理延迟增加。
  • 显存占用增加。
  • 特定输入导致进程崩溃。

因此,模型部署需要具备渐进式发布和快速回滚能力。

9.1 Rolling Update:滚动更新

滚动更新是逐步替换旧实例的部署方式。

例如,原本有 4 个实例:

  1. 先启动新版本实例。
  2. 等待新实例完成模型加载和预热。
  3. 将一个旧实例从流量池摘除。
  4. 等待旧实例处理完在途请求。
  5. 更新下一个实例。
  6. 全部更新完成后结束发布。

这样可以在升级过程中维持一定的服务能力。

需要注意,滚动更新期间新旧版本可能同时存在,因此 API 协议、模型输入输出和依赖服务必须保持兼容。

9.2 Blue-Green Deployment:蓝绿部署

蓝绿部署准备两套完整环境:

  • Blue:当前生产环境。
  • Green:准备发布的新环境。

新版本在 Green 环境完成部署、预热和验证后,再将流量切换过去。

flowchart TD
    A["当前流量"] --> B["流量入口"]
    B --> C["Blue 环境:旧版本"]
    D["部署新版本"] --> E["Green 环境"]
    E --> F["加载模型并预热"]
    F --> G["执行验证测试"]
    G --> H{"验证是否通过?"}
    H -->|否| I["停止发布并保留 Blue"]
    H -->|是| J["切换生产流量到 Green"]
    J --> K["观察新版本指标"]
    K --> L{"是否出现异常?"}
    L -->|否| M["发布完成"]
    L -->|是| N["回滚到 Blue"]
    N --> O["恢复旧版本流量"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style J fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style M fill:#E5F0E9,stroke:#83A995,color:#315D49
    style N fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style O fill:#EAF3EC,stroke:#83A995,color:#315D49

蓝绿部署的优点是回滚路径清晰,但缺点是需要额外准备一套环境。

对于大型模型,额外的 GPU 资源和模型权重存储成本可能很高。

9.3 Canary Release:金丝雀发布

金丝雀发布是先将少量流量导入新版本,再逐渐扩大流量比例。

例如:

阶段 1:1% 流量进入新版本
阶段 2:5% 流量进入新版本
阶段 3:20% 流量进入新版本
阶段 4:50% 流量进入新版本
阶段 5:100% 流量进入新版本

每个阶段都需要观察:

  • 请求成功率。
  • P95/P99 延迟。
  • TTFT 和 TPOT。
  • GPU 显存使用。
  • OOM 次数。
  • 模型输出质量。
  • Token 成本。
  • 用户反馈。

对于生成式 AI,不能只观察系统性能,还需要监控模型质量。

例如,新模型虽然运行正常,但可能出现:

  • 回答准确率下降。
  • 幻觉率增加。
  • JSON 输出格式不稳定。
  • 工具调用成功率下降。
  • 特定语言表现退化。

因此,模型发布需要结合自动化评测与线上指标。

9.4 发布策略对比

策略 优点 缺点 适用场景
Rolling Update 资源开销较小 回滚相对复杂 普通模型升级
Blue-Green 切换与回滚清晰 资源开销较大 高可靠模型发布
Canary 风险逐步释放 需要流量分配和指标分析 大规模线上模型升级
Shadow Deployment 可对比新旧模型 增加计算成本 模型质量验证

Shadow Deployment(影子部署)将生产请求复制到新模型,但不将新模型结果返回用户。

这样可以在真实流量下观察新模型的延迟、资源占用和输出差异。