WebAssembly 组件模型与 WASI 0.2：语言无关的可组合运行时工程实战

(module
  (import "env" "http_get" (func $get (param i32 i32) (result i32)))
  (memory (export "memory") 1)
  (func (export "handle") (param i32) (result i32) ...))

// http-handler.wit
package example:handler@0.1.0;

interface handler {
  record request {
    method: string,
    path: string,
    headers: list<tuple<string, string>>,
    body: option<list<u8>>,
  }

  record response {
    status: u16,
    body: list<u8>,
  }

  handle(req: request) -> result<response, string>;
}

world http-handler {
  export handler;
}

[package]
name = "http-handler"
version = "0.1.0"

[lib]
crate-type = ["cdylib"]

[dependencies]
wit-bindgen = "0.31"

// src/lib.rs
#[allow(warnings)]
mod bindings;

use bindings::exports::example::handler::handler::{Guest, Request, Response};

struct Component;

impl Guest for Component {
    fn handle(req: Request) -> Result<Response, String> {
        if req.path.starts_with("/health") {
            return Ok(Response {
                status: 200,
                body: b"ok".to_vec(),
            });
        }

        // 业务计算：这里可以换成任意 CPU 密集逻辑
        let digest = req
            .path
            .bytes()
            .fold(0u64, |acc, b| acc.wrapping_mul(31).wrapping_add(b as u64));

        Ok(Response {
            status: 200,
            body: format!("{{\"digest\":{digest}}}").into_bytes(),
        })
    }
}

bindings::export!(Component with_types_in bindings);

cargo component build --release
# 产物: target/wasm32-wasip1/release/http_handler.wasm  ← 这是一个 Component，不是 Module

wasm-tools component wit target/wasm32-wasip1/release/http_handler.wasm

// ratelimit.wit
package example:ratelimit@0.1.0;

world ratelimit {
  import example:handler/handler@0.1.0;   // 依赖下游
  export example:handler/handler@0.1.0;   // 对外提供同样接口
}

impl Guest for Ratelimit {
    fn handle(req: Request) -> Result<Response, String> {
        if !TOKEN_BUCKET.with(|b| b.try_acquire()) {
            return Ok(Response { status: 429, body: b"rate limited".to_vec() });
        }
        // 直接调用被组合进来的下游组件，零序列化开销
        bindings::example::handler::handler::handle(req)
    }
}

wasm-tools compose \
  ratelimit.wasm --adapt wasi_snapshot_preview1=wasi_snapshot_preview1.wasm \
  -o composed.wasm \
  business.wasm

// 一个需要 HTTP 出站能力的 world
world fetch-worker {
  import wasi:io/streams@0.2.0;
  import wasi:clocks/monotonic-clock@0.2.0;
  import wasi:http/outgoing-handler@0.2.0;
  export wasi:http/incoming-handler@0.2.0;
}

use wasi::http::outgoing_handler;

fn fetch(url: &str) -> Result<Vec<u8>, String> {
    let req = outgoing::Request::new(&outgoing::Headers::new());
    req.set_method(&Method::Get)
        .map_err(|_| "method".to_string())?;
    req.set_scheme(Some(&Scheme::Https))
        .map_err(|_| "scheme".to_string())?;
    req.set_authority(Some("api.example.com"))
        .map_err(|_| "authority".to_string())?;
    req.set_path_and_query(Some(url))
        .map_err(|_| "path".to_string())?;

    // 返回的是 future，可以 await，不会阻塞整个实例
    let resp = outgoing_handler::handle(req, None).map_err(|e| format!("{e:?}"))?;
    let resp = resp.get().expect("HTTP error").map_err(|e| format!("{e:?}"))?;

    if resp.status() != 200 {
        return Err(format!("status {}", resp.status()));
    }
    let body = resp.consume().map_err(|_| "consume".to_string())?;
    let mut out = Vec::new();
    let mut stream = body.stream().map_err(|_| "stream".to_string())?;
    while !stream.is_ended() {
        out.extend_from_slice(&stream.read(64 * 1024).map_err(|_| "read".to_string())?);
    }
    Ok(out)
}