WebAssembly Ngoài Trình Duyệt: Xây Dựng Microservices Hiệu Năng Cao

Trong nhiều năm, WebAssembly (Wasm) đồng nghĩa với việc mang điện toán hiệu năng cao đến trình duyệt. Là một nhà phát triển backend, tôi từng nghĩ nó là một điều mới lạ của frontend — một thứ gì đó thú vị cho Figma hoặc các trình chỉnh sửa video dựa trên web, nhưng không liên quan đến thế giới Kubernetes, microservices và API phía máy chủ của tôi.

Ôi, thời thế đã thay đổi.

Ngày nay, WebAssembly phía máy chủ đang âm thầm thay đổi cách chúng ta xây dựng, triển khai và mở rộng các dịch vụ backend. Bằng cách chạy Wasm bằng các runtime như Wasmtime hoặc WasmEdge, bạn có thể xây dựng các dịch vụ với tốc độ gần như native, tính độc lập ngôn ngữ thực sự và mô hình cách ly bảo mật khiến các container truyền thống trông như miếng phô mai Thụy Sĩ khi so sánh.

Bài đăng này đề cập đến lý do tại sao Wasm trên backend lại quan trọng, cách xây dựng một microservice HTTP thực sự với Rust + WASI, so sánh hiệu năng của nó với một Docker tương đương và triển khai nó trong sản xuất bằng cách sử dụng framework Spin.

Tại sao WebAssembly cho Backend?

Nếu bạn đã sử dụng Docker và Kubernetes, câu hỏi này là hợp lý: Wasm bổ sung những gì mà các container chưa cung cấp?

Khởi động lạnh tức thì

Thời gian khởi động container được đo bằng giây — ngay cả với các image được tối ưu hóa, việc khởi động một bản sao mới của dịch vụ Python hoặc Node.js mất 2-10 giây. Một module Wasm khởi tạo trong mili giây đến micro giây:

Đối với các workload tự động mở rộng, sự khác biệt này là rất lớn. Một FaaS dựa trên Wasm có thể mở rộng từ 0 đến xử lý một yêu cầu trong cùng thời gian một container vẫn đang kéo image của nó.

Sandbox bảo mật dựa trên khả năng

Không giống như các container (chia sẻ kernel của máy chủ và cần các cấu hình seccomp để hạn chế các syscall), các module Wasm chạy trong một sandbox từ chối theo mặc định nghiêm ngặt. Giao diện hệ thống WebAssembly (WASI) yêu cầu cấp quyền rõ ràng cho mọi tài nguyên:

# 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

Điều này về cơ bản an toàn hơn các container. Một microservice Wasm bị xâm nhập không thể đọc /etc/passwd, tạo shell hoặc truy cập hệ thống tệp của các container khác — nó không có khả năng đó và bạn không thể vô tình cấp quyền đó thông qua một cấu hình seccomp bị lỗi.

Tính độc lập ngôn ngữ thực sự

Wasm là một mục tiêu biên dịch, không phải là một ngôn ngữ. Giao diện nhị phân .wasm tương tự hoạt động bất kể ngôn ngữ nguồn:

Một gateway được viết bằng Rust có thể gọi một plugin được viết bằng Go, xử lý dữ liệu từ một thành phần Python — tất cả đều là các module Wasm, không có chi phí giao tiếp giữa các tiến trình.

Xây dựng một Microservice HTTP thực sự

Hãy xây dựng một microservice HTTP kiểu sản xuất bằng Rust được biên dịch thành Wasm, chạy qua framework Spin — cách tiện lợi nhất để viết các dịch vụ HTTP Wasm hiện nay.

Thiết lập

# 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

Ứng dụng: Một JSON REST Endpoint

# 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())
}

Xây dựng và chạy

# 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"}

Tệp .wasm đã biên dịch có kích thước ~400KB. So sánh với một image Docker Python FastAPI tối thiểu (~150MB). Toàn bộ microservice nằm gọn trong một tệp nhị phân duy nhất nhỏ hơn một hình ảnh PNG thông thường.

Điểm chuẩn hiệu suất: Wasm so với Docker

Sử dụng wrk trên một máy 4 lõi (thông số kỹ thuật tương tự như máy chủ phát triển locionic), đo điểm chuẩn cùng một endpoint danh sách JSON:

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

Phiên bản Wasm đạt khoảng ~6% thông lượng của Rust native trong khi sử dụng ít bộ nhớ hơn 67% so với Rust native Docker. Khoảng cách với Rust native là chi phí của trình biên dịch JIT của Wasmtime — dự kiến sẽ thu hẹp khi biên dịch AOT của Wasmtime trưởng thành.

Kết nối với các dịch vụ bên ngoài

Một microservice chỉ chạy trong bộ nhớ không phải là sản phẩm. Đây là cách Spin kết nối với cơ sở dữ liệu:

# 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())
}

Đối với PostgreSQL/MySQL bên ngoài, hãy sử dụng các thành phần spin-sdk outbound-mysql hoặc outbound-postgres.

Triển khai vào sản xuất

Fermyon Cloud (Được quản lý)

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

Fermyon Cloud xử lý việc mở rộng, TLS và quản lý runtime Wasm. Không yêu cầu điều phối container.

Tự lưu trữ trên Kubernetes (SpinKube)

Đối với các nhóm đã chạy Kubernetes, SpinKube chạy các ứng dụng Spin nguyên bản dưới dạng workload Kubernetes:

# 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

SpinKube sử dụng containerd-shim-spin để chạy các module Wasm trực tiếp bên trong các node Kubernetes — không có lớp image container, không có Docker daemon, khởi động lạnh 5ms trong cluster.

Khi nào nên sử dụng Wasm so với Docker

Câu trả lời trung thực vào năm 2026: Wasm đang thắng thế ở biên và serverless, và đang có những bước tiến mạnh mẽ trong các microservice tiêu chuẩn. Đối với bất kỳ thứ gì liên quan đến hệ sinh thái ML của Python, Docker vẫn là lựa chọn thực dụng.

Câu hỏi thường gặp

Tôi có thể sử dụng Wasm cho các dịch vụ Python không? Có, nhưng có những hạn chế. WasmEdge hỗ trợ Python thông qua bản dựng CPython của nó. PyO3 cho phép bạn viết các tiện ích mở rộng tương thích với Python bằng Rust được biên dịch thành Wasm. Đối với các dịch vụ Python thuần túy với các phụ thuộc nặng (FastAPI + SQLAlchemy + Pydantic), Docker vẫn là lựa chọn thực tế — hệ sinh thái Python Wasm đang trưởng thành nhưng chưa sẵn sàng cho sản xuất đối với các ứng dụng phức tạp tính đến năm 2026.

Wasm đã sẵn sàng cho sản xuất vào năm 2026 chưa? Đối với các microservice HTTP bằng Rust, Go và C/C++ — có, hoàn toàn. Cloudflare Workers (chạy khoảng 50% lưu lượng biên của internet), Fastly Compute và Fermyon Cloud đều là Wasm sản xuất ở quy mô lớn. Đối với các workload Python/Node.js, điều đó phụ thuộc vào các phụ thuộc cụ thể của bạn.

Lợi ích bảo mật so với container là gì? Container yêu cầu cấu hình cẩn thận (seccomp, AppArmor, hệ thống tệp chỉ đọc) để đạt được sự cách ly tốt, và một cấu hình sai có thể khiến kernel máy chủ bị lộ. Mô hình khả năng của Wasm là từ chối theo mặc định ở cấp độ runtime — một lỗi trong module Wasm của bạn không thể leo thang để truy cập máy chủ vì khả năng đó chưa bao giờ được cấp, bất kể cấu hình.

Wasm có hỗ trợ async/await không? Có — async/await của Rust biên dịch thành Wasm một cách chính xác với các runtime hỗ trợ WASI preview 2 (Wasmtime 14+, Spin 2.0+). Mô hình async ánh xạ tới các coroutine stackful của Wasm ở cấp độ runtime.

Tóm tắt

WebAssembly phía máy chủ đã vượt qua ranh giới từ một thử nghiệm thú vị trở thành công nghệ sẵn sàng cho sản xuất. Sự kết hợp giữa hiệu suất gần như native, khởi động lạnh dưới mili giây, bảo mật dựa trên khả năng và tính độc lập ngôn ngữ thực sự làm cho nó trở nên mạnh mẽ độc đáo cho điện toán biên, các chức năng serverless và kiến trúc plugin.

Framework Spin làm cho trải nghiệm của nhà phát triển thân thiện hơn đáng kể so với Wasmtime thô — nếu bạn định thử Wasm phía máy chủ ngay hôm nay, đó là điểm khởi đầu.

Đối với microservice greenfield tiếp theo của bạn, hãy hỏi: liệu điều này có cần hệ sinh thái ML của Python không? Nếu không, hãy cân nhắc xây dựng nó bằng Rust hoặc Go được biên dịch thành Wasm. Bạn sẽ nhận được một artifact triển khai an toàn hơn, nhanh hơn và nhỏ hơn đáng kể.

Bạn cũng có thể thích

• WebAssembly (Wasm) Beyond the Browser: A New Era of Compute
• Memory Safety in Zig
• Compiling C Programs with Make: What I Wish I Knew
• Unwritten Rules of Terminal Programs