ブラウザを超えたWebAssembly: 高性能マイクロサービスの構築

# A Wasm module CANNOT:
# - Read files (without --dir grant)
# - Open network sockets (without --tcplisten grant)
# - Access environment variables (without --env grant)
# - Execute other processes

# You must explicitly grant each capability:
wasmtime run \
  --dir /data::./data \             # grant read/write to ./data, mapped as /data inside wasm
  --env DATABASE_URL=$DATABASE_URL \ # grant access to specific env var
  my-service.wasm

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Add WASI target
rustup target add wasm32-wasip1

# Install Spin CLI
curl -fsSL https://developer.fermyon.com/downloads/install.sh | bash
sudo mv spin /usr/local/bin/

# Create a new Spin HTTP project
spin new -t http-rust my-wasm-api
cd my-wasm-api

# spin.toml
spin_manifest_version = 2

[application]
name = "my-wasm-api"
version = "0.1.0"

[[trigger.http]]
route = "/api/..."
component = "api"

[component.api]
source = "target/wasm32-wasip1/release/my_wasm_api.wasm"
[component.api.build]
command = "cargo build --target wasm32-wasip1 --release"

// src/lib.rs
use spin_sdk::http::{IntoResponse, Request, Response};
use spin_sdk::http_component;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
    email: String,
}

#[derive(Serialize, Deserialize)]
struct CreateUserRequest {
    name: String,
    email: String,
}

#[derive(Serialize)]
struct ApiError {
    error: String,
    code: u16,
}

#[http_component]
fn handle_request(req: Request) -> anyhow::Result<impl IntoResponse> {
    let path = req.uri().path();
    let method = req.method().as_str();

    match (method, path) {
        ("GET", "/api/users") => get_users(),
        ("POST", "/api/users") => create_user(req),
        ("GET", p) if p.starts_with("/api/users/") => {
            let id: u32 = p.trim_start_matches("/api/users/").parse()?;
            get_user_by_id(id)
        }
        _ => Ok(Response::builder()
            .status(404)
            .header("Content-Type", "application/json")
            .body(serde_json::to_string(&ApiError {
                error: "Not found".to_string(),
                code: 404,
            })?)
            .build()),
    }
}

fn get_users() -> anyhow::Result<impl IntoResponse> {
    // In production: query your database via spin-sdk's SQLite or MySQL component
    let users = vec![
        User { id: 1, name: "Alice".to_string(), email: "alice@example.com".to_string() },
        User { id: 2, name: "Bob".to_string(), email: "bob@example.com".to_string() },
    ];

    Ok(Response::builder()
        .status(200)
        .header("Content-Type", "application/json")
        .header("Cache-Control", "public, max-age=60")
        .body(serde_json::to_string(&users)?)
        .build())
}

fn create_user(req: Request) -> anyhow::Result<impl IntoResponse> {
    let body = req.body();
    let input: CreateUserRequest = serde_json::from_slice(body)?;

    // Validation
    if input.name.is_empty() || input.email.is_empty() {
        return Ok(Response::builder()
            .status(422)
            .header("Content-Type", "application/json")
            .body(serde_json::to_string(&ApiError {
                error: "name and email are required".to_string(),
                code: 422,
            })?)
            .build());
    }

    let user = User { id: 3, name: input.name, email: input.email };

    Ok(Response::builder()
        .status(201)
        .header("Content-Type", "application/json")
        .body(serde_json::to_string(&user)?)
        .build())
}

fn get_user_by_id(id: u32) -> anyhow::Result<impl IntoResponse> {
    // Simulated lookup
    let user = User { id, name: format!("User {id}"), email: format!("user{id}@example.com") };

    Ok(Response::builder()
        .status(200)
        .header("Content-Type", "application/json")
        .body(serde_json::to_string(&user)?)
        .build())
}

# Build to Wasm
spin build

# Run locally — Spin handles the HTTP server + Wasm runtime
spin up --listen 127.0.0.1:3000

# Test it
curl http://localhost:3000/api/users
# [{"id":1,"name":"Alice","email":"alice@example.com"},...]

curl -X POST http://localhost:3000/api/users \
  -H "Content-Type: application/json" \
  -d '{"name":"Charlie","email":"charlie@example.com"}'
# {"id":3,"name":"Charlie","email":"charlie@example.com"}

wrk -t4 -c100 -d30s http://localhost:3000/api/users

# spin.toml — add database capability
[component.api]
source = "target/wasm32-wasip1/release/my_wasm_api.wasm"

[component.api.variables]
db_url = { required = true }

[[component.api.sqlite_databases]]
# Use Spin's built-in SQLite (for development)
# In production, use spin-managed MySQL or PostgreSQL via spin-sdk
database = "default"

use spin_sdk::sqlite::Connection;

fn get_users() -> anyhow::Result<impl IntoResponse> {
    let conn = Connection::open_default()?;
    
    let results = conn.execute(
        "SELECT id, name, email FROM users LIMIT 100",
        &[],
    )?;
    
    let users: Vec<User> = results.rows().map(|row| User {
        id: row.get::<u32>(0).unwrap_or(0),
        name: row.get::<String>(1).unwrap_or_default(),
        email: row.get::<String>(2).unwrap_or_default(),
    }).collect();

    Ok(Response::builder()
        .status(200)
        .header("Content-Type", "application/json")
        .body(serde_json::to_string(&users)?)
        .build())
}

spin deploy   # deploys to Fermyon Cloud — no Kubernetes required
# Your service is live at https://my-wasm-api-<hash>.fermyon.app

# Install SpinKube operator
helm install spin-operator \
  --namespace spin-operator \
  --create-namespace \
  oci://ghcr.io/spinkube/charts/spin-operator

# Deploy your Wasm app as a SpinApp CRD
kubectl apply -f - <<EOF
apiVersion: core.spinkube.dev/v1alpha1
kind: SpinApp
metadata:
  name: my-wasm-api
spec:
  image: "ghcr.io/myorg/my-wasm-api:latest"
  replicas: 3
  executor: containerd-shim-spin
EOF