医疗人工智能的Harness Engineering：面向安全、可控与合规的大模型系统工程（二）

第二章 基础工程底盘：Rust 构建可靠的运行时环境

2.1 引言：底盘决定上层建筑

医疗 AI Harness 作为模型与真实世界之间的唯一通道，其运行时环境必须满足一系列严苛属性：确定性的延迟、可预测的资源消耗、故障隔离、以及不可绕过的安全约束。若底层网络框架、异步调度、数据库交互等组件自身存在隐患，则上层护栏与审计设计将形同虚设——正如一座大楼，地下室漏水终将侵蚀整个地基。本章从 Rust 生态中精选关键基础设施 crate，详细论述如何构建一个满足医疗场景要求的可靠运行时底座，并展示如何利用 Rust 类型系统将部分运行时错误前移至编译期。

本章不会重复官方教程，而是聚焦在“医疗 Harness 场景下的工程抉择”：何时该用 tokio 的 JoinSet 而非简单 spawn，为何 axum 的状态共享模式优于全局变量，如何通过 sqlx 的编译期查询校验杜绝 SQL 注入，以及如何设计领域错误类型使得一次 ? 传递既能捕获上下文又不泄露内部结构。

2.2 异步运行时：tokio 的深度集成与资源控制

Rust 异步生态以 tokio 为事实标准。tokio 提供工作窃取调度器、I/O 驱动、定时器，以及丰富的工具层（sync、task）。在医疗 Harness 中，我们关心三个核心能力：任务取消传播、资源预算控制、优雅停机。

2.2.1 请求生命周期与 CancellationToken

每个到达 Harness 的临床请求（例如 CDS Hooks 调用、患者问答请求）都应绑定一个 CancellationToken。该令牌由请求入口创建，并在以下场景被触发：客户端断开连接、请求超时、上游护栏检测到风险需立即中断推理。所有异步子任务（调用向量数据库、调用模型服务、写入审计日志）均需在 select! 或 with_cancellation 中感知取消，从而避免资源浪费与悬空操作。

use tokio_util::sync::CancellationToken;
use tokio::time::{
   
   timeout, Duration};

async fn handle_request(token: CancellationToken) -> Result<Response, Error> {
   
   
    let timeout_dur = Duration::from_secs(30);
    let result = tokio::select! {
   
   
        _ = token.cancelled() => {
   
   
            Err(Error::Cancelled)
        }
        res = timeout(timeout_dur, process(token.child_token())) => {
   
   
            res.map_err(|_| Error::Timeout)?
        }
    };
    result
}

async fn process(token: CancellationToken) -> Result<Response, Error> {
   
   
    // 并发执行检索和护栏检查，均感知取消
    let retrieval = async {
   
    retrieve_knowledge(token.child_token()).await };
    let guard = async {
   
    run_safety_guard(token.child_token()).await };
    tokio::try_join!(retrieval, guard)?;
    // ...
}

通过 child_token() 创建子树令牌，当父请求取消时，所有子任务一起取消，实现“一键清场”。该模式避免了 Python asyncio 中常见的取消不彻底导致的僵尸任务。

2.2.2 并发限制与任务预算

医疗推理通常涉及 GPU 资源竞争，上游 Harness 必须对并发量进行约束，避免压垮模型服务。tokio 提供 Semaphore 可控制并发任务数。更进一步，可为每个任务分配内存预算（例如限定 JSON 解析最大深度、向量检索最大返回行数），超出则提前终止并返回降级结果。

use tokio::sync::Semaphore;
use std::sync::Arc;

struct InferenceLimiter {
   
   
    semaphore: Arc<Semaphore>,
}

impl InferenceLimiter {
   
   
    fn new(max_concurrent: usize) -> Self {
   
   
        Self {
   
    semaphore: Arc::new(Semaphore::new(max_concurrent)) }
    }

    async fn call<F, T>(&self, f: F) -> Result<T, Error>
    where
        F: std::future::Future<Output = Result<T, Error>>,
    {
   
   
        let _permit = self.semaphore.acquire().await.map_err(|_| Error::Shutdown)?;
        f.await
    }
}

该限制器确保推理请求队列在可控范围内，避免突发流量导致的服务雪崩。同时结合 tower::limit::RateLimit 中间件可对单个客户 IP 或用户进行速率限制，满足 HIPAA 要求的“访问控制”。

2.2.3 优雅停机与状态保存

医疗 Harness 不能因重启而丢失正在处理的请求状态。通过监听 SIGTERM 信号，先停止接受新请求，再等待现有任务完成（最长宽限期），最后释放资源。tokio 的 graceful_shutdown 模式如下：

use tokio::signal;
use std::time::Duration;

pub async fn shutdown_signal() {
   
   
    let ctrl_c = async {
   
   
        signal::ctrl_c().await.expect("failed to install Ctrl+C handler");
    };

    #[cfg(unix)]
    let terminate = async {
   
   
        signal::unix::signal(signal::unix::SignalKind::terminate())
            .expect("failed to install signal handler")
            .recv()
            .await;
    };

    #[cfg(not(unix))]
    let terminate = std::future::pending::<()>();

    tokio::select! {
   
   
        _ = ctrl_c => {
   
   },
        _ = terminate => {
   
   },
    }

    tracing::info!("shutdown signal received, starting graceful shutdown");
}

// 在 main 中：
let (tx, mut rx) = tokio::sync::mpsc::channel(1);
// 启动服务器
axum::Server::bind(&addr)
    .serve(app.into_make_service())
    .with_graceful_shutdown(async move {
   
   
        shutdown_signal().await;
        tx.send(()).await.ok();
    })
    .await?;

// 等待进行中的请求完成
while let Some(handle) = join_set.join_next().await {
   
   
    // ...
}

此种方式保证了在滚动更新或故障转移时，未完成的审计日志能落盘，未响应的请求能得到明确超时错误，而非静默丢弃。

2.3 网络服务框架：axum 与强类型 API 设计

axum 构建在 tower 和 hyper 之上，提供基于类型的路由、提取器（Extractors）与响应。其核心优势是编译期保证的路由参数解析：路径参数、查询参数、请求体反序列化均利用 serde，若类型不匹配则编译失败。

2.3.1 应用状态共享与零锁设计

医疗 Harness 需要全局状态：数据库连接池、推理服务客户端、配置等。axum 通过 Arc 共享状态，只要求状态类型实现 Clone + Send + Sync。我们可将经常读取、几乎不修改的配置包裹在 Arc<Config> 中，将连接池包裹在 Pool（已实现 Clone），无需引入 RwLock，极大减少争用。

#[derive(Clone)]
pub struct AppState {
   
   
    pub db: sqlx::PgPool,
    pub infer_limiter: Arc<InferenceLimiter>,
    p