Trade-off Arsitektur Runtime: Native Go vs Sandboxed Rust VM

Memilih antara eksekusi native terkompilasi (seperti Go) dan lingkungan sandboxed berbasis VM (seperti engine interpreter berbasis Rust pada Gossamer atau WebAssembly runtimes) menentukan batas keamanan serta efisiensi resource backend multi-tenant. Native Go memberikan eksekusi bare-metal dengan latensi rendah, namun memiliki batas isolasi memori yang lemah untuk kode pihak ketiga (untrusted code). Sebaliknya, Rust-based VM menegakkan isolasi deterministik dan limitasi resource per-tenant dengan bayaran overhead interpretasi dan batas alokasi memori runtime.

Model Eksekusi dan Batas Isolasi (Isolation Boundaries)

Pada Go native runtime, isolasi antar-task berada pada level goroutine yang berbagi address space heap yang sama. Jika menjalankan kode untrusted atau script plugin pengguna di dalam goroutine Go, panic yang lolos atau alokasi memori berlebih dapat menyebabkan crash global (OOM killer pada OS level) atau pembacaan pointer yang tidak diotorisasi.

Arsitektur sandboxed berbasis Rust (misalnya interpreter Gossamer atau wasmtime runtime) mengisolasi state eksekusi pada level runtime VM instance. Rust mengontrol alokasi stack/heap VM secara eksplisit via memory allocator khusus atau array virtual tanpa garbage collector eksternal.

// Rust: Menjalankan eksekusi script dengan batas komputasi dan memori ketat
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;

pub struct SandboxLimits {
    pub max_instructions: usize,
    pub max_memory_bytes: usize,
}

pub struct ExecutionContext {
    pub instruction_counter: usize,
    pub memory_allocated: Arc<AtomicUsize>,
    pub limits: SandboxLimits,
}

impl ExecutionContext {
    #[inline(always)]
    pub fn track_step(&mut self) -> Result<(), &'static str> {
        self.instruction_counter += 1;
        if self.instruction_counter > self.limits.max_instructions {
            return Err("CPU execution limit exceeded");
        }
        Ok(())
    }

    pub fn allocate(&self, bytes: usize) -> Result<(), &'static str> {
        let current = self.memory_allocated.fetch_add(bytes, Ordering::Relaxed);
        if current + bytes > self.limits.max_memory_bytes {
            self.memory_allocated.fetch_sub(bytes, Ordering::Relaxed);
            return Err("Memory quota exceeded");
        }
        Ok(())
    }
}

Snippet di atas menunjukkan cara VM sandboxed di Rust menginterupsi eksekusi untrusted code via runtime gas/counter deterministik. Pola ini mencegah loop tak terhingga dan eksploitasi OOM tanpa perlu dependensi OS namespace atau cgroups container level.

Benchmarking Komparatif: Profil Latensi dan Memori

Pengujian dilakukan pada spesifikasi mesin c6i.xlarge (4 vCPU, 8 GB RAM) menjalankan tugas kalkulasi parsing payload JSON dan komputasi array 100.000 iterasi.

Analisis Cold Start dan Heap Footprint

Goroutine Go unggul dalam skenario short-lived task dengan latensi sub-mikrodetik. Namun, runtime Go menggunakan dynamic stack (mulai dari 2KB dan berkembang otomatis) yang tidak memungkinkan pembatasan alokasi per-task secara kaku di level bahasa.

Rust VM memerlukan cold start lebih tinggi akibat parsing bytecode dan instansiasi state isolated memory arena. Setelah instance aktif, pool VM yang di-recycle (object pooling) dapat memangkas cold start hingga di bawah 15 mikrodetik.

Use Case: Multi-Tenant Agent Execution

Pada platform AI Agent atau serverless workflows, sistem menjalankan fungsi transformasi buatan pengguna akhir (user-defined code). Karakteristik kode ini: non-deterministic, rawan eksploitasi, dan berpotensi starvation.

Kapan Memilih Native Go?

• Kode dikompilasi dari internal code base yang terverifikasi (trusted first-party code).
• Sistem membutuhkan throughput I/O sangat tinggi, seperti proxy gateway, gRPC routing, atau event streaming pipeline.
• Batas isolasi dijamin oleh infrastructure layer (misalnya 1 Pod Kubernetes = 1 Tenant, atau Firecracker MicroVM).

Kapan Memilih Sandboxed Rust VM?

• Multi-tenant eksekusi kode dinamis pada shared infrastructure tanpa overhead container deployment.
• Kebutuhan hard enforcement terhadap konsumsi memori dan limit siklus instruksi (deterministic resource quotas).
• Waktu eksekusi mikro (10-100 ms) di mana overhead startup cgroups/Docker (~200ms) tidak dapat ditoleransi.

Kalkulasi Biaya Operasional (TCO) Serverless Backend

Simulasi beban kerja: 10.000.000 eksekusi per hari, durasi eksekusi rata-rata 50 ms pada provider serverless berbasis konsumsi vCPU/RAM (misal pricing AWS Lambda: $0.0000166667 per GB-detik, baseline 128 MB RAM tier).

• Skenario Native Go (1 Worker Container, Isolate via MicroVM per Request):
  Overhead cold-start VM: +150 ms per request baru.
  Eksekusi aktif: 50 ms.
  Total durasi: 200 ms @ 128 MB.
  Komputasi: 10.000.000 x 0.2s x 0.125 GB = 250.000 GB-detik = $4.16 per hari.
• Skenario Sandboxed Rust VM (Shared Persistent Host Instance):
  Host c6i.large (2 vCPU, 4GB RAM) reserved: $1.63 per hari.
  Kapasitas concurrency: VM sandboxed berjalan in-process. 512 KB per VM worker memungkinkan ribuan task concurrent di memory 4GB tanpa container context switching.
  Durasi murni: ~70 ms (overhead VM 1.4x dari native 50 ms).
  Efisiensi utilisasi resource meningkat hingga 60% karena eliminasi container virtualization overhead.

Maintainability dan Kompleksitas Rekayasa

Native Go menawarkan kurva belajar rendah dengan debugging standar (pprof, delve). Kesalahan runtime mudah diinvestigasi via standard stack traces.

Arsitektur Rust VM memperkenalkan kompleksitas Foreign Function Interface (FFI) jika diintegrasikan dengan host backend Go (via cgo atau Rust C-ABI). Selain itu, pengembang harus mendesain bindings API yang aman untuk I/O (filesystem, network access), karena sandbox VM secara default menonaktifkan seluruh system call OS kernel.