Belajar WebAssembly - Runtime: Wasmtime, Wasmer, WasmEdge

#Pendahuluan

Setelah di episode 10 kita memahami WASI dan Component Model — pada episode ini kita bertemu dengan para eksekutornya: runtime WebAssembly di sisi server. Jika di browser engine-nya V8/SpiderMonkey, di server kita memilih runtime sendiri — dan pilihan itu menentukan fitur, performa, dan ekosistem yang kalian dapatkan.

Mengapa runtime penting? Karena runtime adalah "sistem operasi mini" untuk modul Wasm kalian: ia menyediakan WASI, mengelola memory, mengisolasi instance, dan menyediakan API embedding. Memilih runtime yang tepat — dan tahu cara meng-embed-nya — adalah keterampilan inti untuk membangun aplikasi host yang menjalankan plugin Wasm, yang kita lanjutkan di episode 19.

#Peta Runtime Utama

#Wasmtime: Runtime Referensi Bytecode Alliance

Wasmtime dikembangkan oleh Bytecode Alliance — konsorsium yang juga mengelola WASI dan Component Model — sehingga selalu yang paling cepat mengadopsi spesifikasi terbaru. Ia dirancang untuk embedding: menjadi library di dalam aplikasi host.

#CLI: wasmtime run

Cara termudah mencoba adalah CLI:

curl https://wasmtime.dev/install.sh | bash
wasmtime --version

Jalankan komponen WASI:

wasmtime run --dir ./data app.wasm

#Embedding di Rust (crate wasmtime)

Kekuatan Wasmtime ada pada API embedding-nya. Tambahkan dependency:

cargo add wasmtime

Kode host paling sederhana:

use anyhow::Result;
use wasmtime::{Engine, Module, Store, Linker};
 
fn main() -> Result<()> {
    let engine = Engine::default();
    let module = Module::from_file(&engine, "hello.wasm")?;
 
    let mut store = Store::new(&engine, ());
    let linker = Linker::new(&engine);
 
    let instance = linker.instantiate(&mut store, &module)?;
    let hello = instance.get_typed_func::<(), ()>(&mut store, "hello")?;
    hello.call(&mut store, ())?;
    Ok(())
}

Engine → kompilasi; Module → bytecode yang dikompilasi; Store → state per instance; Linker → penghubung imports. Empat konsep ini dipakai di hampir semua embedding Wasm, apa pun runtime-nya.

#Wasmer: Runtime Multi-Bahasa

Wasmer menjanjikan performa mendekati native (~95%) dan SDK untuk banyak bahasa — Rust, Python, Go, C#, Ruby, dan lainnya — sehingga host tidak harus ditulis dalam Rust. Ia punya sistem package wapm dan mendukung WASI serta WASIX.

curl https://get.wasmer.io -sSfL | sh
wasmer run app.wasm

Dari Python:

Embed Wasmer dari Python

import wasmer
 
module = wasmer.Module(wasmer.Store(), open("app.wasm", "rb").read())
instance = wasmer.Instance(module)
print(instance.exports.hello())

Kekuatan Wasmer ada pada portabilitas embedding — tim yang menulis host dalam Python atau Go tidak perlu belajar Rust.

#WasmEdge: Khusus Edge dan IoT

WasmEdge adalah runtime yang diarahkan untuk edge computing dan perangkat IoT: binary kecil, startup cepat, dan konsumsi memori rendah. Didukung ekosistem CNCF (Cloud Native Computing Foundation) dan sering dipakai sebagai engine FaaS di edge — misalnya di platform yang butuh menjalankan banyak fungsi kecil dengan overhead minimal.

wasmedge --version
wasmedge app.wasm

Ciri khasnya: dukungan WebAssembly System Interface yang lengkap, integrasi dengan framework AI/ML, dan kemampuannya berjalan di perangkat constrained — topik yang bersinggungan dengan edge functions di episode 12.

#Spin: Framework Aplikasi (Fermyon/Akamai)

Spin bukan sekadar runtime — ini framework aplikasi serverless berbasis Wasm. Kalian menulis handler HTTP, aplikasi menjalankannya di atas runtime Wasmtime, dan Spin mengurus HTTP server, routing, dan state management. Fermyon diakuisisi Akamai, memperkuat posisi Wasm di infrastruktur edge (topik episode 12).

use spin_sdk::http::{IntoResponse, Request, Response, Router};
use spin_sdk::http_component;
 
#[http_component]
fn handle(req: Request) -> impl IntoResponse {
    Router::new()
        .get("/hello/:name", |_, ctx| {
            let name = ctx.params.get("name").unwrap();
            Response::new(200, format!("Halo, {name}!"))
        })
        .handle(req)
}

spin up menjalankan aplikasi ini sebagai service HTTP lokal; ke production, ia di-deploy ke Fermyon Cloud atau SpinKube (Kubernetes) — kita lihat di episode 12.

#Memilih Runtime

Aturan praktis pemilihan:

• Butuh embedding kontrol penuh → Wasmtime (Rust host) — paling dekat dengan spesifikasi.
• Host bukan Rust (Python/Go/Node) → Wasmer — SDK multi-bahasa paling lengkap.
• Target edge/IoT, resource terbatas → WasmEdge — ringan dan cepat.
• Membangun aplikasi serverless cepat → Spin — framework siap pakai.

#Common Pitfalls

• Salah versi WASI — modul wasm32-wasip1 lama tidak berjalan di runtime yang hanya mendukung WASI 0.2/0.3; rebuild dengan target yang tepat.
• Lupa capability — di Wasmtime, --dir/--env menentukan akses; modul yang butuh file tapi tidak diberi akses akan gagal di runtime.
• Membuat instance per request — mahal; buat sekali lalu jalankan banyak instance dari Module yang sama.
• Mengabaikan Store — setiap thread butuh Store sendiri; berbagi Store antar thread menyebabkan panic.

#Penutup

Pada episode 11 ini, kalian telah mengenal empat runtime utama server-side dan cara meng-embed-nya.

Inti yang harus dibawa pulang:

• Wasmtime (Bytecode Alliance, LTS 36.x) adalah runtime referensi dengan embedding Rust yang matang.
• Wasmer unggul untuk host multi-bahasa (~95% native speed).
• WasmEdge cocok untuk edge/IoT dengan resource terbatas.
• Spin (Fermyon/Akamai) adalah framework aplikasi serverless berbasis Wasm.

Di episode 12 selanjutnya kita akan membahas edge functions & serverless (FaaS) — Cloudflare Workers, Fastly Compute, Akamai EdgeWorkers, dan Spin/Kubernetes (SpinKube) — dengan cold start hitungan milidetik, plus pola HTTP handler dan streaming response. Sampai jumpa di episode 12!