2026年のWebAssembly: WASI、Component Model、そして本番環境でのWasm実行

// http-handler.wit
package my:service;

interface handler {
  use wasi:http/types@0.2.0.{incoming-request, outgoing-response, response-outparam};
  handle: func(request: incoming-request, response-out: response-outparam);
}

world http-service {
  export handler;
}

// worker.js — loading a compiled Rust Wasm module
import wasm from './my-lib_bg.wasm';
import { init, process_payload } from './my-lib.js';

export default {
  async fetch(request) {
    await init(wasm);
    const body = await request.arrayBuffer();
    const result = process_payload(new Uint8Array(body));
    return new Response(result, {
      headers: { 'content-type': 'application/json' }
    });
  }
};

use wasm_bindgen::prelude::*;
use serde_json::Value;

#[wasm_bindgen]
pub fn process_payload(data: &[u8]) -> String {
    let parsed: Value = serde_json::from_slice(data)
        .unwrap_or(Value::Null);
    // ... processing logic
    serde_json::to_string(&parsed).unwrap()
}

wasm-pack build --target bundler
wrangler deploy

# spin.toml
spin_manifest_version = 2

[application]
name = "api-service"
version = "0.1.0"

[[trigger.http]]
route = "/users/..."
component = "user-handler"

[[trigger.http]]
route = "/auth/..."
component = "auth-handler"

[component.user-handler]
source = "target/wasm32-wasip1/release/user_handler.wasm"
allowed_outbound_hosts = ["https://db.internal"]

[component.auth-handler]
source = "target/wasm32-wasip1/release/auth_handler.wasm"
allowed_outbound_hosts = []

use spin_sdk::http::{IncomingRequest, ResponseBuilder};
use spin_sdk::http_component;
use spin_sdk::variables;

#[http_component]
async fn handle(req: IncomingRequest) -> anyhow::Result<impl IntoResponse> {
    let db_url = variables::get("db_url")?;
    // Spin's built-in SQLite or PostgreSQL via spin_sdk::pg
    let conn = spin_sdk::pg::Connection::open(&db_url).await?;
    let rows = conn.query("SELECT id, name FROM users LIMIT 20", &[]).await?;

    let users: Vec<serde_json::Value> = rows.iter().map(|r| {
        serde_json::json!({
            "id": r.get::<i64>(0),
            "name": r.get::<&str>(1)
        })
    }).collect();

    Ok(ResponseBuilder::new(200)
        .header("content-type", "application/json")
        .body(serde_json::to_vec(&users)?)
        .build())
}

from wasmtime import Store, Module, Linker, WasiConfig
from pathlib import Path

class WasmPluginRunner:
    def __init__(self, wasm_path: str):
        self.store = Store()
        wasi = WasiConfig()
        wasi.inherit_stdout()
        self.store.set_wasi(wasi)

        self.linker = Linker(self.store.engine)
        self.linker.define_wasi()

        module = Module.from_file(self.store.engine, wasm_path)
        self.instance = self.linker.instantiate(self.store, module)

    def run_transform(self, input_data: bytes) -> bytes:
        memory = self.instance.exports(self.store)["memory"]
        transform = self.instance.exports(self.store)["transform"]

        # Allocate in Wasm linear memory, call the function, read result back
        alloc = self.instance.exports(self.store)["alloc"]
        ptr = alloc(self.store, len(input_data))
        memory.write(self.store, input_data, ptr)

        result_ptr = transform(self.store, ptr, len(input_data))
        # Read length prefix + data from result_ptr
        result_len = int.from_bytes(
            memory.read(self.store, result_ptr, result_ptr + 4), 'little'
        )
        return bytes(memory.read(self.store, result_ptr + 4, result_ptr + 4 + result_len))