WebAssembly vào năm 2026: Vượt xa trình duyệt — WASI, Edge và Hệ thống Plugin

Khi WebAssembly (Wasm) lần đầu tiên được công bố, nó được ca ngợi là công nghệ cuối cùng sẽ phá vỡ sự độc quyền của JavaScript trong trình duyệt. Nó cho phép các nhà phát triển biên dịch C++, Rust và Go thành định dạng nhị phân chạy với tốc độ gần như native trên web.

Vào năm 2026, tác động sâu sắc nhất của Wasm không phải là trong trình duyệt — mà là trong đám mây. WebAssembly đã phát triển từ một công nghệ web thành một runtime tính toán phổ quát, an toàn và nhanh chóng, đang thay thế các container trong các môi trường nhạy cảm về độ trễ và đa người thuê.

Bài đăng này đi sâu vào thực tế: bạn sẽ biên dịch Rust sang WASI, nhúng một runtime Wasm vào Python, xây dựng một hệ thống plugin được sandbox với Extism và hiểu khi nào Wasm thực sự vượt trội hơn container.

Tại sao Wasm trên Backend? (So sánh thực tế)

Lập luận tiêu chuẩn là "Wasm nhanh hơn container." Điều đó chỉ đúng một phần. Đây là so sánh chính xác:

Sự khác biệt về thời gian khởi động là yếu tố quan trọng. Khởi động một Docker container bị giới hạn bởi nhân Linux thiết lập các namespace — bạn không thể tránh được. Một khởi tạo module Wasm là một cấp phát bộ nhớ và một biên dịch JIT, được đo bằng micro giây. Đây là lý do tại sao Cloudflare Workers có thể chạy 50 triệu phiên bản Wasm đồng thời trên mạng của họ.

Kiến trúc cốt lõi: WASI Preview 2

Wasm ban đầu không có I/O. Nó là một công cụ tính toán thuần túy — nó không thể đọc tệp, mở socket mạng hoặc thậm chí lấy thời gian hiện tại mà không có máy chủ cung cấp rõ ràng các khả năng đó.

WASI (WebAssembly System Interface) định nghĩa các giao diện hệ thống tiêu chuẩn. WASI Preview 2 (ổn định năm 2024) đã giới thiệu Mô hình thành phần — một ABI an toàn kiểu cho phép các module Wasm từ các ngôn ngữ khác nhau tương tác.

Khi bạn biên dịch một chương trình Rust sang wasm32-wasip2, bạn sẽ nhận được một tệp nhị phân .wasm chạy trên bất kỳ runtime tương thích WASI nào (Wasmtime, WasmEdge, Wasmer) trên bất kỳ hệ điều hành và kiến trúc nào mà không cần sửa đổi.

Thực hành: Biên dịch Rust sang WASI

# Install the WASI target
rustup target add wasm32-wasip2

# Create a simple HTTP handler
cargo new wasm-handler
cd wasm-handler

# Cargo.toml
[dependencies]
wasi = "0.13"
serde = { version = "1", features = ["derive"] }
serde_json = "1"

// src/main.rs
use std::io::{self, Read, Write};
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct Request {
    name: String,
    multiplier: u32,
}

#[derive(Serialize)]
struct Response {
    message: String,
    result: u64,
}

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();

    let req: Request = serde_json::from_str(&input).unwrap_or(Request {
        name: "world".to_string(),
        multiplier: 1,
    });

    let response = Response {
        message: format!("Hello, {}!", req.name),
        result: fibonacci(req.multiplier as u64),
    };

    io::stdout()
        .write_all(serde_json::to_string(&response).unwrap().as_bytes())
        .unwrap();
}

fn fibonacci(n: u64) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let mut a = 0u64;
            let mut b = 1u64;
            for _ in 2..=n {
                let c = a + b;
                a = b;
                b = c;
            }
            b
        }
    }
}

cargo build --target wasm32-wasip2 --release
# Output: target/wasm32-wasip2/release/wasm-handler.wasm (< 500 KB)

# Run with wasmtime
echo '{"name":"developer","multiplier":30}' | wasmtime target/wasm32-wasip2/release/wasm-handler.wasm
# Output: {"message":"Hello, developer!","result":832040}

Tệp .wasm thu được chạy trên Linux x86, macOS ARM, Windows x86 và bất kỳ PoP biên nào — tệp nhị phân giống hệt nhau, không cần biên dịch lại.

Nhúng Wasmtime vào Python

Bạn có thể sử dụng Wasm làm runtime plugin bên trong bất kỳ ngôn ngữ máy chủ nào. Đây là một trong những mẫu mạnh mẽ nhất: ứng dụng cốt lõi của bạn là Python, nhưng logic quan trọng về hiệu suất hoặc do người dùng gửi chạy trong Wasm được sandbox:

pip install wasmtime

# host.py
from wasmtime import Store, Module, Instance, Linker, WasiConfig
import json

def run_wasm_handler(wasm_path: str, input_data: dict) -> dict:
    store = Store()

    # Configure WASI capabilities — deny-by-default
    wasi_config = WasiConfig()
    # We do NOT grant filesystem or network access — pure computation only
    store.set_wasi(wasi_config)

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

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

    # The WASM module reads from stdin and writes to stdout
    # For real production use, consider wasmtime's memory API for direct buffer passing
    import subprocess
    result = subprocess.run(
        ["wasmtime", wasm_path],
        input=json.dumps(input_data).encode(),
        capture_output=True,
        timeout=5,  # hard timeout — Wasm can't escape it
    )

    return json.loads(result.stdout)

result = run_wasm_handler(
    "target/wasm32-wasip2/release/wasm-handler.wasm",
    {"name": "Python host", "multiplier": 40}
)
print(result)  # {"message": "Hello, Python host!", "result": 102334155}

timeout=5 được thực thi bởi hệ điều hành — một module Wasm độc hại không thể vượt qua nó. Module cũng không thể truy cập hệ thống tệp hoặc mạng vì WasiConfig không cấp các khả năng đó.

Xây dựng hệ thống plugin được Sandbox với Extism

Extism là cách sạch nhất để nhúng các plugin Wasm vào một ứng dụng máy chủ. Nó xử lý sự phức tạp của ABI khi truyền chuỗi/byte giữa máy chủ và Wasm.

Plugin (Rust)

cargo install extism-pdk
cargo new --lib my-plugin
cd my-plugin

# Cargo.toml
[lib]
crate-type = ["cdylib"]

[dependencies]
extism-pdk = "1"
serde = { version = "1", features = ["derive"] }

// src/lib.rs
use extism_pdk::*;
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct Input {
    text: String,
    max_words: usize,
}

#[derive(Serialize)]
struct Output {
    summary: String,
    word_count: usize,
}

#[plugin_fn]
pub fn summarize(input: Json<Input>) -> FnResult<Json<Output>> {
    let words: Vec<&str> = input.text.split_whitespace().collect();
    let truncated = words[..words.len().min(input.max_words)].join(" ");

    Ok(Json(Output {
        summary: if words.len() > input.max_words {
            format!("{}...", truncated)
        } else {
            truncated
        },
        word_count: words.len(),
    }))
}

cargo build --target wasm32-unknown-unknown --release

Máy chủ (Python)

# host.py
import extism
import json

manifest = {"wasm": [{"path": "target/wasm32-unknown-unknown/release/my_plugin.wasm"}]}

with extism.Plugin(manifest) as plugin:
    result = plugin.call(
        "summarize",
        json.dumps({"text": "WebAssembly is a portable compilation target...", "max_words": 5})
    )
    print(json.loads(result))
    # {"summary": "WebAssembly is a portable compilation...", "word_count": 8}

Plugin chạy trong một sandbox Wasm. Nó không thể:

• Truy cập hệ thống tệp của máy chủ
• Thực hiện các yêu cầu mạng
• Đọc các biến môi trường
• Làm sập tiến trình máy chủ

Đây là mẫu để thực thi an toàn mã do người dùng gửi ở quy mô lớn — plugin của mỗi người thuê chạy cách ly với tất cả những người khác.

Các trường hợp sử dụng thực tế vào năm 2026

1. Serverless thế hệ tiếp theo (Khởi động lạnh dưới mili giây)

Serverless truyền thống (AWS Lambda, Google Cloud Functions) bị ảnh hưởng bởi khởi động lạnh vì khởi tạo container mất 500ms–2s. Các nền tảng native Wasm loại bỏ điều này:

• Cloudflare Workers: Mỗi Worker là một isolate Wasm. Khởi động lạnh là < 1ms. Hơn 50 triệu isolate chạy đồng thời trên mạng toàn cầu của họ.
• Fermyon Spin: spin deploy gửi một tệp nhị phân Wasm đến nền tảng được quản lý của họ. Không có Dockerfile, không có registry container.
• Fastly Compute: Cùng một mô hình, mạng PoP khác.

# Deploy a Rust Axum app to Fermyon Spin
spin new -t http-rust my-app
cd my-app
spin build
spin deploy

2. Hệ thống plugin SaaS có thể mở rộng

Stripe, Shopify và Figma đều cho phép plugin. Cách tiếp cận truyền thống: buộc người dùng phải viết bằng một DSL cụ thể hoặc lưu trữ một endpoint webhook bên ngoài.

Với Wasm: người dùng viết plugin bằng bất kỳ ngôn ngữ nào, tải lên một tệp .wasm và nền tảng của bạn thực thi nó trong một sandbox. Không có cơ sở hạ tầng để quản lý, không có ranh giới tin cậy để thực thi thủ công.

3. Suy luận AI biên

ONNX Runtime hiện đã có backend Wasm. Bạn có thể chạy các mô hình ML được lượng tử hóa ở biên mà không cần khởi động máy chủ GPU:

# Run inference at the edge
wasm-pack build --target web
# Deploy to Cloudflare Workers — inference runs in each PoP

Mô hình thành phần: Tương tác đa ngôn ngữ

Mô hình thành phần của WASI Preview 2 giải quyết điểm khó khăn lịch sử: các module Wasm chỉ có thể trao đổi các byte thô. Việc truyền một chuỗi từ một module Rust sang một module Python yêu cầu tính toán con trỏ thủ công.

Mô hình thành phần định nghĩa một ngôn ngữ mô tả giao diện an toàn kiểu (WIT — WebAssembly Interface Types). Bạn mô tả giao diện một lần:

// my-interface.wit
package my:plugin;

interface transform {
    summarize: func(text: string, max-words: u32) -> string;
}

Sau đó tạo các ràng buộc trong bất kỳ ngôn ngữ nào. Một plugin Rust triển khai summarize có thể được gọi từ một máy chủ Go, một máy chủ Python hoặc một máy chủ JavaScript — mà không cần mã hóa tuần tự hóa thủ công.

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

Sử dụng Wasm khi:

• Bạn cần khởi động lạnh dưới mili giây (các hàm biên, serverless)
• Bạn đang xây dựng một hệ thống plugin đa người thuê
• Bạn cần cách ly nghiêm ngặt giữa các đường dẫn mã không đáng tin cậy
• Tính di động nhị phân quan trọng (IoT, các đội hình không đồng nhất)

Giữ nguyên Docker khi:

• Bạn cần một môi trường POSIX đầy đủ (cơ sở dữ liệu, các phụ thuộc OS phức tạp)
• Ngăn xếp của bạn dựa vào các tiến trình daemon chạy dài
• Bạn cần điều phối trưởng thành (Kubernetes, ECS)
• Độ trễ khởi động lạnh có thể chấp nhận được (> 500ms)

Wasm và Docker không loại trừ lẫn nhau. Nhiều kiến trúc sản xuất sử dụng container cho lớp điều phối và Wasm cho lớp tính toán bên trong các container đó.

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

• WebAssembly vào năm 2026: Runtime phổ quát
• Axum vs Actix-web: Xây dựng API REST sản xuất bằng Rust
• Docker BuildKit Cache Mount và Tối ưu hóa đa giai đoạn
• Kỹ thuật nền tảng cho AI: Kiến trúc cơ sở hạ tầng cho các tác nhân tự trị