Belajar Rust - Rust di Cloud, Containers, dan WebAssembly

#Pendahuluan

Rust bisa dikompilasi menjadi binary kecil dan mandiri — keunggulan yang membuatnya ideal untuk cloud. Episode 16 membahas dua dunia tempat Rust bersinar: container dan cloud (Kubernetes, Cloud Run, serverless) serta WebAssembly (berjalan di browser dan edge).

Kalian akan membangun image Docker ramping dengan binary statis musl, men-deploy-nya, lalu mengompilasi Rust menjadi WebAssembly dengan wasm-pack dan wasm-bindgen. Di akhir episode, satu bahasa melayani backend dan frontend.

#Binary Statis dengan Musl

#Mengapa Binary Statis

Binary Rust default menautkan glibc secara dinamis, sehingga tidak berjalan di image yang tidak memilikinya. Dengan target musl, Rust menghasilkan binary sepenuhnya statis: tidak ada dependency pada library sistem. Hasilnya satu file yang berjalan di container minimal mana pun.

#Build Cross dengan Target Musl

rustup target add x86_64-unknown-linux-musl
cargo build --release --target x86_64-unknown-linux-musl

rustup target add x86_64-unknown-linux-musl menambahkan target kompilasi. cargo build --release --target x86_64-unknown-linux-musl menghasilkan binary statis di target/x86_64-unknown-linux-musl/release. Binary ini bisa disalin ke image minimal.

#Docker dan Distroless

#Dockerfile Multi-Stage

Gunakan builder Rust untuk mengompilasi, lalu salin binary ke image runtime minimal:

FROM rust:1.85-alpine AS builder
WORKDIR /app
COPY . .
RUN cargo build --release
 
FROM gcr.io/distroless/cc-debian12
COPY --from=builder /app/target/release/aplikasi /aplikasi
EXPOSE 3000
USER nonroot
ENTRYPOINT ["/aplikasi"]

Stage pertama mengompilasi dengan toolchain lengkap; stage kedua hanya berisi binary, runtime library minimal, dan user non-root. gcr.io/distroless/cc-debian12 adalah image distroless yang tidak punya shell — permukaan serangannya sangat kecil.

#Build dan Jalankan

docker build -t aplikasi:latest .
docker run --rm -p 3000:3000 aplikasi:latest

docker build -t aplikasi:latest . membangun image, docker run menjalankannya. docker build memakai konteks saat ini; pastikan .dockerignore mengecualikan target/ agar build cepat. Image Rust yang dioptimasi bisa berukuran puluhan megabyte saja.

#Deploy ke Kubernetes dan Cloud Run

#Deployment di Kubernetes

apiVersion: apps/v1
kind: Deployment
metadata:
  name: aplikasi
spec:
  replicas: 3
  selector:
    matchLabels:
      app: aplikasi
  template:
    metadata:
      labels:
        app: aplikasi
    spec:
      containers:
        - name: aplikasi
          image: registry.contoh.com/aplikasi:1.0.0
          ports:
            - containerPort: 3000
          readinessProbe:
            httpGet:
              path: /readyz
              port: 3000

Terapkan dengan kubectl apply -f deployment.yaml. Manifest ini memakai probe yang kita bangun di episode 15. kubectl scale deployment aplikasi --replicas=5 menambah kapasitas sesuai beban.

#Cloud Run dan Serverless

Cloud Run mengeksekusi container tanpa mengelola Kubernetes: cukup push image, deploy, dan platform menangani scaling. Binary Rust yang kecil dan mulai cepat sangat cocok untuk serverless karena meminimalkan cold start. Arsitektur serupa berlaku untuk platform seperti Fly.io dan AWS App Runner — semuanya mengeksekusi container OCI standar.

#WebAssembly dengan Rust

#Mengapa Rust untuk WASM

WebAssembly memungkinkan kode dikompilasi menjadi bytecode yang berjalan di browser dan runtime edge dengan kecepatan native. Rust adalah bahasa kelas satu untuk ini: toolchain wasm32-unknown-unknown menghasilkan modul WASM tanpa runtime tambahan.

#wasm-bindgen dan wasm-pack

wasm-bindgen menghubungkan tipe Rust dan JavaScript, sedangkan wasm-pack mengatur build, packaging, dan publishing:

cargo new --lib hitung-wasm
cd hitung-wasm
cargo add wasm-bindgen

cat > src/lib.rs <<'EOF'
use wasm_bindgen::prelude::*;
 
#[wasm_bindgen]
pub fn kuadrat(x: u32) -> u32 {
    x * x
}
EOF
cargo build --target wasm32-unknown-unknown

#[wasm_bindgen] mengekspor fungsi ke JavaScript. cargo add wasm-bindgen menambahkan dependency; build menargetkan wasm32-unknown-unknown. cargo build --release lalu bundel dengan wasm-pack:

wasm-pack build --target web

wasm-pack build --target web menghasilkan modul ES yang siap diimport:

Pemakaian di JavaScript

import init, { kuadrat } from "./pkg/hitung_wasm.js";
 
await init();
console.log(kuadrat(9));

Setelah init() memuat modul WASM, kuadrat(9) memanggil fungsi Rust dari JavaScript. Contoh ini menjadi fondasi library dan aplikasi WASM yang jauh lebih besar.

#Yew dan Frontend Rust

Untuk aplikasi web penuh di browser, yew adalah framework React-like yang ditulis murni Rust: komponen, state, dan event handling dalam satu bahasa. Cocok saat tim ingin berbagi logika backend dan frontend, atau membutuhkan performa maksimal di browser. Untuk kebanyakan proyek, kombinasi Rust backend + WASM module untuk bagian kritis adalah pilihan yang paling pragmatis.

#Penutup

Inti yang harus dibawa pulang:

• Binary statis musl berjalan di image container minimal mana pun.
• Dockerfile multi-stage menghasilkan image ramping tanpa shell.
• Distroless meminimalkan permukaan serangan di production.
• Kubernetes dan Cloud Run mengeksekusi image OCI standar.
• wasm-bindgen menghubungkan Rust dan JavaScript; wasm-pack mengemasnya.
• Yew memungkinkan frontend murni Rust di browser.

Di episode 17 selanjutnya kita akan membahas CI/CD, testing, dan release workflow — unit, integration, dan property-based testing dengan cargo test dan proptest, pipeline build dan test dengan GitHub Actions, GitLab CI, atau Tekton, serta release management, semantic versioning, dan distribusi binary.