Rust 在 AI 基础设施中的边界:哪些代码值得改写,哪些该做成可插拔组件

Rust 不是用来把整个 AI 平台重写一遍的。这篇按「高频调用、边界复杂、需要隔离、对延迟敏感」四条判据给出「该用 Rust / 不该用 Rust」对照表,再顺着原生 Rust → WASI Preview 2 的路线,讲清 WIT 接口、能力注入与可插拔推理组件的加载流程,并补上宿主安全分层表、常见误区与四步落地路线。

文章目录

原文:Rust 在 AI 基础设施中的边界:从 WASI Preview 2 到可插拔推理组件

给 AI 平台做性能优化时,「把核心链路用 Rust 重写一遍」几乎是最常被提出来的建议。它听起来很硬:更快、更稳、更扛并发。但真正在生产环境里跑过一轮的人都知道,Rust 化的收益从来不是均摊在整个 AI 技术栈上的,它高度集中在少数几个位置上。

这篇文章想讲清楚的是 Rust 在 AI 基础设施里的边界:哪些代码值得迁移,哪些不该碰,为什么「比 Python 快」只是最表层的理由,以及从原生 Rust 走到 WASI Preview 2 之后,可插拔推理组件这条路为什么值得认真考虑。文中的判据表和落地路线,可以直接拿去对照你自己的系统做取舍。

1、先泼盆冷水:不是所有 AI 代码都该改写成 Rust

1、先泼盆冷水:不是所有 AI 代码都该改写成 Rust(AI 生成示意图)

1、先泼盆冷水:不是所有 AI 代码都该改写成 Rust · AI 生成示意图

一条典型的 AI 请求链路大致是:身份认证与租户限流 → Prompt 预处理 → Tokenizer → 模型路由与策略判断 → 推理调用 → 输出过滤与结构化 → 日志、计量与审计。

真正吃 GPU 的只有中间那段推理。而其余环节全都跑在请求主路径上,并且有几个共同特征:每个请求都要执行一次;输入来自用户或外部系统;需要严格控制内存、CPU 与超时;可能由不同团队开发甚至动态更新;不能因为其中一个扩展点崩了就把整个网关拖垮。

高频调用、边界复杂、需要隔离、对延迟敏感——这四条就是 Rust 的最佳落点。 可以用下面这张表对照自己的系统做判断:

判据 该用 Rust 不该用 Rust
调用频率 每个请求都要走一遍的热路径 低频触发、偶尔才跑一次的离线任务
边界形态 输入输出清晰、可用类型描述的窄接口 业务规则还在天天改、接口也跟着天天变
隔离要求 来自第三方、或需要按租户隔离的扩展点 团队内部自维护、随服务一起发布的代码
延迟敏感度 对 P95 抖动敏感,等待时间被用户直接感知 批量任务,多跑一会儿也不心疼
主要瓶颈 CPU、内存、锁竞争、系统调用开销 GPU kernel、显存带宽、集合通信
迭代节奏 需要稳定运行数月以上的模块 还在快速试验阶段、天天要改的逻辑

GPU 侧的瓶颈 Rust 帮不上忙。 如果卡点在 kernel 写法、模型并行切分或 GPU 之间通信,换一门语言不会凭空消掉它。反过来,如果业务逻辑还在快速迭代期,把还热着的 Python 逻辑翻译成 Rust,往往会拖慢实验节奏——这类代码的正确选择通常不是 Rust,而是继续留在 Python 里。

2、Rust 的价值不只是「快」,而是把内存安全和资源控制带进了系统

如果 Rust 的价值只是「比 Python 快」,那它就只是一门更快的脚本语言,和很多工具没什么区别。它真正不一样的地方在于:把内存安全与资源控制变成编译期就能保证的性质,而不是运行期祈祷。

具体是三件事。一是所有权与借用检查在编译期拦下悬垂指针、数据竞争和手动释放错误,这类问题在 Python 里往往要等到线上高并发时才以崩溃的形式冒出来;二是资源生命周期跟着类型走,RAII 让文件句柄、连接、缓冲区在离开作用域时自动释放,不必依赖 try/finally 和人工纪律;三是显式的错误处理,Result 与 Option 把「这一步可能失败」写进类型里,调用方没办法假装它不会失败。

一个能说明问题的例子是 Tokenizer。Hugging Face 的 tokenizers 就是 Rust 实现,再被 Python、Node.js 等语言调用。 它没有取代 Python 的模型编排,而是把性能敏感、边界清晰的底层活儿下沉到 Rust——这正是「边界组件」该有的样子:被调用,不取代。

Rust 也有它的账要算:编译时间更长、心智负担更陡、异步生态需要重新学。如果团队维护的是每周都在改的实验代码,这笔账未必划算。

3、从原生 Rust 到 WASI Preview 2:给插件划一条稳定的能力边界

原生 Rust 服务直接使用操作系统的网络、文件与线程能力,性能好、生态完整,隔离主要靠进程、容器和操作系统权限。可一旦允许第三方团队往链路上装插件,直接加载动态库或运行脚本就会放大供应链风险。

WASI Preview 2 走的是另一条路:把插件做成 Wasm 组件,用 WIT(WebAssembly Interface Types) 描述语言无关的接口。

传统 Wasm 模块的交互很容易退化成「传指针 + 传长度」,宿主与模块必须自己约定内存布局,字符串、列表、错误处理全靠手工编码。组件模型要解决的就是这件事:

package ai:plugin;

interface policy {
    record request {
        tenant: string,
        prompt: string,
    }

    record decision {
        allowed: bool,
        reason: option<string>,
    }

    check: func(input: request) -> decision;
}

world ai-policy {
    export policy;
}

注意这里的 string、record、option——它们不再是需要调用方手动解释的指针,而是由接口定义直接约束的数据交换规则。

WASI Preview 2 的主要价值也不在「让 Wasm 更快」,而在于给插件划出一条稳定的能力边界:宿主用 WIT 定义插件能导入导出什么,只注入明确授权的能力(文件、网络、随机数、时钟),再由服务端运行时(例如 Wasmtime)负责实例化、传参与资源管理。插件不会自动获得宿主的全部文件、网络和进程权限。

这对 AI 基础设施很具体:输出过滤插件只需要读取请求内容和配置,就不该拥有任意网络访问权;模型路由插件可能需要读模型目录,但不该有宿主机写权限。

4、可插拔推理组件:把扩展点从「链接进服务」变成「加载进服务」

上面的能力模型落到代码上,大致是这样一支策略组件:

// lib.rs
// WIT 生成的绑定通常单独放在 bindings 模块里,
// 负责把 WIT 的 string、record 映射成 Rust 类型。
mod bindings {
    wit_bindgen::generate!({
        path: "../wit",
        world: "ai-policy",
    });
}

use bindings::exports::ai::plugin::policy::{Guest, Request, Decision};

struct Policy;

impl Guest for Policy {
    fn check(input: Request) -> Decision {
        // 示例规则:生产环境应使用结构化策略,而不是简单字符串匹配。
        let blocked = input.prompt.contains("secret-key");

        Decision {
            allowed: !blocked,
            reason: if blocked {
                Some("prompt contains a restricted pattern".to_string())
            } else {
                None
            },
        }
    }
}

bindings::export!(Policy with_types_in bindings);

构建时用 Rust 工具链里的 wasm32-wasip2 目标:

rustup target add wasm32-wasip2

cargo build --target wasm32-wasip2 --release

这里有个细节最容易踩坑:产物文件后缀是 .wasm,不等于它就是符合 WIT 接口的组件。 是不是组件取决于构建工具链与组件适配步骤,工程上应该用 wasm-tools 的组件相关命令去检查产物,而不是看扩展名。

宿主侧的加载流程可以抽象成这样:

读取组件制品
  -> 校验哈希或签名
  -> 创建运行时 Engine
  -> 配置资源上限
  -> 只挂载允许的能力
  -> 实例化组件
  -> 调用 check()
  -> 记录耗时、错误与资源使用

到这里,「可插拔推理组件」的意思就清楚了:推理链路上的策略判断、路由规则、输出过滤、格式转换这些扩展点,可以从「编译进服务」变成「加载进服务」——一个插件出问题只影响它自己,一个插件升级也不需要重启整条网关。

5、最容易踩的坑:把「沙箱」误解成「无限安全」

组件模型解决的是执行边界,不是安全策略本身。 如果宿主开放了完整文件系统、任意网络和无限内存,那么放进沙箱的组件照样能造成破坏。真正的安全得靠组合治理:

层次 该做的事
接口层 限制输入长度、字段数量与版本范围
运行时 配置燃料、内存、表和实例数量上限
能力层 只注入必要的文件、网络和时钟接口
生命周期 按请求或租户决定实例是否复用,避免状态串租户
供应链 锁定依赖、校验哈希、签名验证、灰度加载
观测层 记录调用耗时、拒绝原因与资源峰值

还有一个容易被忽略的区别:计算限制不等于时间限制。 限制执行量能挡住死循环,但外部 I/O、宿主函数调用和等待操作,仍然需要超时与取消机制。只配上限、没有请求级取消,卡死问题照样存在。

6、落地路线:四步,别指望一步到位

第一步:挑低耦合组件,并先测量。 优先选输入输出清晰、不碰 GPU 的模块:Prompt 脱敏、JSON 结构化、Token 计量、租户策略、输出格式校验、模型路由规则。测量 P50 / P95 延迟、内存峰值、失败率与部署复杂度,别只比单次函数跑得多快。

第二步:用 WIT 把接口固定下来。 接口稳定比语言选择更重要——接口没设计清楚,换成组件只会把问题更早地固化下来。可以先约定:新增字段默认可选,删除字段至少跨一个兼容周期,改变语义就升级接口包版本,错误处理不许用空字符串代替失败。

第三步:建立宿主的能力模型。 给每类插件写一份能力清单,比如策略插件只给时钟、不给网络和文件系统,路由插件给只读配置和模型元数据。不要把宿主的全部能力一次性暴露给所有插件。

第四步:补齐测试与供应链。 至少要覆盖正常与异常输入、超长 Prompt、Unicode 与多字节字符串、组件重复调用、超时与取消、内存上限、WIT 版本兼容,以及恶意或错误插件的行为。

写在最后

Rust 在 AI 基础设施里不是一次全量重写,而是一次精准的取舍:把模型外面那段「每个请求都要走一遍、边界清晰、必须隔离、对延迟敏感」的代码换成 Rust,再把其中一部分做成可用 WASI Preview 2 加载的组件,其余继续留在 Python 里。

我的判断是:接下来更值得关注的不是「谁把整个 AI 平台改成了 Rust」,而是谁把边界划得最准——哪些代码进 Rust、哪些变成组件、哪些坚决不碰,这套判断力比任何一门语言都值钱。而 AI 正在降低组件的生产成本,同时也抬高了对组件治理的要求,签名、版本兼容、权限边界和可观测性,会比组件的数量更早成为瓶颈。

如果你正在做 AI 平台的性能改造,可以先回答一个问题:你的链路里,哪一段是每个请求都要跑、但从来没人认真优化过的? 那大概率就是第一个该考虑 Rust 的地方。

相关阅读

文中链接

整理自本文的外部链接,请以来源页面说明为准。

Rust 在 AI 基础设施中的边界:哪些代码值得改写,哪些该做成可插拔组件 · 阿凡达博客