Belajar WebAssembly - WASI 0.2/0.3 & Component Model

#Pendahuluan

Sejauh ini Wasm kita jalankan di browser atau Node.js dengan akses dunia luar yang serba manual — import functions yang kita siapkan sendiri. Pada episode ini kita membuka gerbang menuju dunia server: WASI (WebAssembly System Interface) dan Component Model, dua teknologi yang mengubah Wasm dari "bytecode browser" menjadi "bytecode portabel universal".

Mengapa ini penting? Karena inilah fondasi dari semua topik server-side setelahnya — runtime (episode 11), edge/serverless (episode 12), networking (episode 17), dan plugin systems (episode 19). WASI memberikan Wasm kemampuan sistem operasi yang aman: baca file, tanya waktu, generate random, dan — sejak wasi:http — mengirim request HTTP. Tanpa WASI, Wasm tidak bisa berdiri sebagai pengganti container.

#Masalah yang Dipecahkan WASI

Browser menyediakan sandbox yang bagus, tetapi tidak membawa akses sistem: tidak ada file, tidak ada clock, tidak ada socket. Saat Wasm pindah ke server, ia butuh system interface — tetapi tidak boleh memakai syscall POSIX langsung, karena itu akan mengorbankan keamanan sandbox.

WASI menyelesaikannya dengan capability-based security: setiap modul hanya menerima akses ke sumber daya yang diberikan padanya — bukan semua file, hanya file yang diizinkan; bukan semua jaringan, hanya host dan port tertentu.

#WASI 0.2: Component Model Pertama

WASI 0.2 (Januari 2024) menandai lompatan besar: ia membungkus Wasm dalam Component Model. Component adalah unit komposisi yang bisa saling dihubungkan — modul Rust, C, dan Go bisa digabung dalam satu aplikasi, masing-masing menjadi komponen yang berdialog lewat interface.

Untuk mengkompilasi ke WASI 0.2, Rust memakai target khusus:

rustup target add wasm32-wasip2
cargo build --target wasm32-wasip2

Outputnya berupa component .wasm yang siap dijalankan runtime WASI seperti Wasmtime.

#WIT: Interface Definition

Interface antar komponen didefinisikan dalam file WIT (WebAssembly Interface Types). Contoh:

package example:greeter;
 
interface greet {
  hello: func(name: string) -> string;
}
 
world greeter-world {
  export greet;
  import wasi:clocks/monotonic-clock@0.2.0;
}

WIT mendeskripsikan world — kontrak lengkap yang diexport dan diimport sebuah komponen. Ini seperti package.json + tsconfig untuk dunia Wasm: siapa menyediakan apa, dan siapa membutuhkan apa.

Melihat WIT dari component yang sudah jadi:

wasm-tools component wit target/wasm32-wasip2/release/app.wasm

#WASI 0.3: Native Async

WASI 0.3 (rilis awal 2026) membawa perubahan terbesar sejak 0.2: async native. Operasi I/O yang selama ini memblokir thread — baca file, kirim request, tunggu stream — menjadi async di level component.

Tiga konsep baru:

#async func

Fungsi WIT bisa dideklarasikan async — kompiler menghasilkan state machine yang tidak memblokir thread saat menunggu operasi:

interface fetch {
  async request: func(url: string) -> string;
}

#stream dan future

Tipe stream<T> dan future<T> merepresentasikan aliran data dan hasil yang belum selesai:

• stream<T> — aliran item T yang bisa dikonsumsi secara bertahap (byte chunks, pesan WebSocket).
• future<T> — hasil yang akan datang (seperti Promise<T> di JS).

interface upload {
  stream: func(up: stream<u8>) -> future<u64>;
}

Dampaknya pada runtime: ribuan permintaan bisa dilayani oleh sedikit thread — karena tidak ada operasi yang menunggu dengan memblokir — persis pola async/await di Node.js atau Go, tapi di level bytecode.

#Kompilasi dan Menjalankan

Workflow end-to-end WASI 0.3 dengan Wasmtime:

rustup target add wasm32-wasip2
cargo build --target wasm32-wasip2 --release
wasmtime run target/wasm32-wasip2/release/app.wasm

wasmtime run menyediakan semua interface WASI standar (filesystem, clock, random, HTTP) secara default dengan capability yang dibatasi. Tanpa flags, modul tidak punya akses apa pun — kalian memberikannya eksplisit:

wasmtime run --dir ./data --env KONFIG=produksi app.wasm

#WASI 0.2 vs 0.3: Kapan Memakai Mana

Untuk produksi konservatif, WASI 0.2 masih pilihan teraman. Untuk workload I/O tinggi yang butuh skalabilitas thread minimal, WASI 0.3 adalah arah masa depan — dan kita bedah roadmap-nya lebih dalam di episode 20.

#Penutup

Pada episode 10 ini, kalian telah memahami WASI 0.2/0.3 dan Component Model: system interface capability-based, komposisi antar bahasa via WIT, dan async native.

Inti yang harus dibawa pulang:

• WASI menyediakan system interface aman (files, clocks, HTTP, random) berbasis capability.
• Component Model membungkus modul menjadi komponen yang bisa dikomposisi lintas bahasa.
• WIT mendeskripsikan kontrak interface/world komponen.
• WASI 0.3 menambahkan async native: async func, stream<T>, future<T>.

Di episode 11 selanjutnya kita akan mengenal runtime server-side — Wasmtime, Wasmer, dan WasmEdge — plus embedding runtime dari bahasa seperti Rust memakai crate wasmtime. Sampai jumpa di episode 11!