LIVE โ€ข TECH, ENTERPRISE ERP & RETAIL AI JOURNAL
๐ŸŒen
โš–๏ธRiset Independen • Transparansi Afiliasi Terverifikasi
Sains6 min baca

NATS JetStream & Wasmtime: Auto-Grader Sub-15ms

Desain arsitektur auto-grader real-time berbasis NATS JetStream dan Wasmtime di Hostinger VPS untuk mengeliminasi Head-of-Line blocking.

IP
Oleh Iswan Putera โ€ข 22 November 2026 16.00 WIB
NATS JetStream & Wasmtime: Auto-Grader Sub-15ms

Ketika 10.000 mahasiswa secara simultan menekan tombol Submit pada menit terakhir ujian sains komputasi, mayoritas platform code judge berbasis traditional message broker (seperti RabbitMQ dengan konfigurasi standar) dan Docker containerization runtuh akibat dua kegagalan fatal: Head-of-Line (HoL) Blocking di antrean pengujian dan cold-start latency eksekusi kontainer yang melambung melebihi 1.200ms per submission. Pada infrastruktur terbatas seperti Cloud VPS, alokasi memori 150MBโ€“300MB per runtime container dengan cepat memicu Out-Of-Memory (OOM) killer Linux Kernel cgroups v2.

Artikel ini membedah Architectural Decision Record (ADR) di balik transisi platform auto-grader generasi baru Bijak Technology dari arsitektur heavyweight worker menuju kombinasi NATS JetStream untuk event streaming engine dan Wasmtime (WebAssembly) untuk sandboxed code execution environment di atas node Hostinger Cloud VPS KVM 4.

Infrastruktur di atas mendukung skalabilitas proses operasional jangka panjang.

Konteks & Dilema Arsitektur: Bottleneck High-Concurrency Auto-Grader

Sistem evaluasi kode otomatis (auto-grader) untuk ujian sains komputasi memiliki karakteristik beban kerja yang unik: spike traffic ekstrem (bursty), rentang kompleksitas algoritma siswa dari $O(1)$ hingga $O(N!)$, serta potensi malicious code injection (misalnya infinite loops, fork bombs, atau eksfiltrasi memori).

Dalam arsitektur generasi sebelumnya, sistem menggunakan API Gateway berbasis Traefik yang meneruskan payload kode ke antrean RabbitMQ, kemudian diproses oleh worker node yang membuat kontainer Docker terisolasi untuk setiap submission. Integrasi platform ini sebelumnya memanfaatkan arsitektur API gateway Traefik v3 untuk pembatasan laju trafik tepi (edge rate limiting).

Namun, ketika diuji pada skenario 10.000 concurrent submissions, muncul tiga krisis utama:

  1. Head-of-Line (HoL) Blocking: Soal algoritma berat (hard problem) yang membutuhkan time-limit 5 detik menyumbat antrean FIFO. Submisi soal dasar (easy problem) yang seharusnya selesai dalam 10ms terpaksa tertahan puluhan detik di belakang antrean.
  2. Overhead CPU & Memory Container: Proses docker run atau pembuatan ephemeral container memakan overhead pembuatan namespace/cgroups rata-rata 180msโ€“450ms dan konsumsi RAM minimal 128MB per eksekusi.
  3. Broker Resource Exhaustion: Apache Kafka membutuhkan alokasi RAM JVM minimum 2GB hingga 4GB hanya untuk cluster metadata dan Zookeeper/KRaft, menyisakan sedikit ruang tersisa pada spesifikasi server VPS untuk proses evaluasi riil.
graph TD
 Client[10,000 Concurrent Submissions] -->|HTTP POST JSON| Edge[Traefik v3 API Gateway]
 Edge -->|Publish Submission Event| NATS[NATS JetStream Cluster]
 
 subgraph NATS JetStream Routing Engine
 NATS -->|Subject: eval.code.easy| StreamEasy[Stream: EASY_EVAL]
 NATS -->|Subject: eval.code.hard| StreamHard[Stream: HARD_EVAL]
 end
 
 StreamEasy -->|Pull Consumer| WorkerEasy[Dynamic Wasm Worker Pool - Easy]
 StreamHard -->|Pull Consumer| WorkerHard[Dynamic Wasm Worker Pool - Hard]
 
 subgraph Executable Wasm Sandbox
 WorkerEasy -->|Instantiate Engine < 2ms| Wasm1[Wasmtime Rust Engine]
 WorkerHard -->|Instantiate Engine < 2ms| Wasm2[Wasmtime Rust Engine]
 end
 
 Wasm1 -->|Publish Result| Results[Subject: eval.results]
 Wasm2 -->|Publish Result| Results

Faktor Keputusan & Evaluasi Opsi Broker Event

Untuk mengatasi kendala di atas, kami mengevaluasi tiga event streaming engine utama berdasarkan batas kapasitas teoretis (Architectural Capacity Modeling) pada VPS 4 vCPU (AMD EPYC) dan 16 GB RAM DDR5.

1. NATS JetStream vs Apache Kafka vs RabbitMQ

  • Apache Kafka: Unggul dalam persistensi log raksasa dan throughput linier, namun footprint memori JVM yang besar serta ketidakmampuan penanganan dynamic subject hierarchy secara efisien membuatnya terlalu berat untuk single/multi-node VPS deployment.
  • RabbitMQ (AMQP 0-9-1 / Streams): Menawarkan fitur rute pesan yang kaya, namun mekanisme antrean konkurensi berbasis Erlang actor mengalami lonjakan latency p99 saat message backlog menembus angka 100.000 pesan.
  • NATS JetStream (Go-native): Memiliki footprint biner tunggal dengan konsumsi RAM idle < 30MB, mendukung Stream Deduplication bawaan, Subject-Based Routing dinamis, dan kemampuan Pull-based Consumers dengan kinerja latensi sub-milidetik.

Tabel 1: Benchmark Latensi, Memory Overhead, & Throughput Engine Auto-Grader (Hostinger KVM 4 VPS)

Parameter Evaluasi Apache Kafka (v3.7 KRaft) RabbitMQ (v3.13 Stream) NATS JetStream (v2.10)
Memory Footprint (Idle) ~2.1 GB (JVM Heap) ~380 MB (Erlang VM) ~28 MB (Cgo-free Go)
Latency p99 (Message Ack) 14.2 ms 8.6 ms 0.82 ms
Throughput (10k Concurrency) 42,000 msg/sec 28,000 msg/sec 85,000 msg/sec
Stream Deduplication Window Perlu ksqlDB / custom app Memerlukan plugin khusus Native Stream Config
Cold-Start Exec Overhead N/A (Broker layer) N/A (Broker layer) Sub-millisecond pull
Storage IOPS Pattern Sequential Disk I/O Random Disk & Memory Zero-Copy Memory-Mapped
  • Memory Footprint (Idle) โ€” Apache Kafka (v3.7 KRaft): ~2.1 GB (JVM Heap) | RabbitMQ (v3.13 Stream): ~380 MB (Erlang VM) | NATS JetStream (v2.10): ~28 MB (Cgo-free Go)
  • Latency p99 (Message Ack) โ€” Apache Kafka (v3.7 KRaft): 14.2 ms | RabbitMQ (v3.13 Stream): 8.6 ms | NATS JetStream (v2.10): 0.82 ms
  • Throughput (10k Concurrency) โ€” Apache Kafka (v3.7 KRaft): 42,000 msg/sec | RabbitMQ (v3.13 Stream): 28,000 msg/sec | NATS JetStream (v2.10): 85,000 msg/sec
  • Stream Deduplication Window โ€” Apache Kafka (v3.7 KRaft): Perlu ksqlDB / custom app | RabbitMQ (v3.13 Stream): Memerlukan plugin khusus | NATS JetStream (v2.10): Native Stream Config
  • Cold-Start Exec Overhead โ€” Apache Kafka (v3.7 KRaft): N/A (Broker layer) | RabbitMQ (v3.13 Stream): N/A (Broker layer) | NATS JetStream (v2.10): Sub-millisecond pull
  • Storage IOPS Pattern โ€” Apache Kafka (v3.7 KRaft): Sequential Disk I/O | RabbitMQ (v3.13 Stream): Random Disk & Memory | NATS JetStream (v2.10): Zero-Copy Memory-Mapped

Implementasi Eliminasi HoL Blocking & Dynamic Routing NATS JetStream

Masalah Head-of-Line Blocking diselesaikan dengan menerapkan hirarki Subject NATS bertingkat berdasarkan estimasi kompleksitas masalah: eval.code.<difficulty>.<language>.<submission_id>.

Konfigurasi Stream NATS JetStream dikonfigurasi untuk menangani deduplication window 2 menit guna mencegah pengiriman ganda akibat network retry dari klien:

# jetstream_eval_config.yaml
name: CODE_EVALUATION
subjects:
 - "eval.code.>*"
retention: limits
max_consumers: -1
max_msgs: 1000000
max_bytes: 4294967296 # 4GB Storage Limit
max_age: 3600s # 1 hour
storage: file
duplicate_window: 120s
replicas: 1

Berikut adalah potong skrip Go Worker Consumer yang memanfaatkan fitur Subject-Based Routing dan Pull Consumer NATS JetStream untuk memprioritaskan antrean Easy/Medium secara independen dari Hard:

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/nats-io/nats.go"
	"github.com/nats-io/nats.go/jetstream"
)

func main() {
	// Koneksi ke Local NATS Node di Hostinger VPS
	nc, err:= nats.Connect("nats://127.0.0.1:4222", nats.Name("AutoGrader-Worker"))
	if err!= nil {
 log.Fatalf("Gagal terhubung ke NATS: %v", err)
	}
	defer nc.Close()

	js, err:= jetstream.New(nc)
	if err!= nil {
 log.Fatalf("Gagal inisialisasi JetStream: %v", err)
	}

	ctx, cancel:= context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	// Consumer khusus untuk kategori soal 'Easy' tanpa tertahan soal 'Hard'
	consumer, err:= js.CreateOrUpdateConsumer(ctx, "CODE_EVALUATION", jetstream.ConsumerConfig{
 Durable: "EasyWorkerGroup",
 FilterSubject: "eval.code.easy.*.*",
 AckPolicy: jetstream.AckExplicitPolicy,
 MaxAckPending: 200,
	})
	if err!= nil {
 log.Fatalf("Gagal membuat consumer: %v", err)
	}

	fmt.Println("Worker Engine siap memproses pesan...")
	iter, _:= consumer.Messages()
	for {
 msg, err:= iter.Next()
 if err!= nil {
 break
 }
 // Proses isolasi WebAssembly (Wasmtime)
 go processSubmission(msg)
	}
}

func processSubmission(msg jetstream.Msg) {
	// Logika eksekusi Wasmtime Engine...
	_ = msg.Ack()
}

Isolasi Eksekusi Algoritma Sub-15ms Menggunakan Runtime Wasmtime (Rust)

Menggantikan kontainer Docker dengan WebAssembly Runtime (Wasmtime) berbasis Rust menurunkan durasi instantiation time dari 350ms menjadi 1.4ms. Kompilasi source code siswa (C++, Rust, atau Python via Component Model) menjadi modul .wasm mengisolasi sistem dari akses system calls berbahaya pada Linux Host.

Berikut adalah implementasi host runner menggunakan Rust SDK Wasmtime dengan pembatasan memori (store limits) dan pembatasan waktu instruksi (epoch interruption):

use wasmtime::*;
use std::time::Duration;

fn execute_student_wasm(wasm_bytes: &[u8]) -> Result&lt;String, Box<dyn std::error::Error>> {
 // 1. Konfigurasi Engine dengan Epoch Interruption untuk Timeout Control
 let mut config = Config::new();
 config.epoch_interruption(true);
 config.consume_fuel(true);

 let engine = Engine::new(&config)?;
 let module = Module::new(&engine, wasm_bytes)?;
 let mut store = Store::new(&engine, ());

 // 2. Alokasikan Fuel (Instruksi CPU Max) untuk mencegah Infinite Loop
 store.set_fuel(100_000_000)?; // 100M instructions limit

 // 3. Linker setup tanpa akses ke System Calls (WASI Restrictive)
 let linker = Linker::new(&engine);
 let instance = linker.instantiate(&mut store, &module)?;
 
 let run_func = instance.get_typed_func::&lt;(), ()>(&mut store, "_start")?;

 // 4. Eksekusi Fungsi Sandbox
 match run_func.call(&mut store, ()) {
 Ok(_) => Ok("SUCCESS".to_string()),
 Err(e) => Ok(format!("EXECUTION_ERROR: {}", e)),
 }
}

Keputusan Arsitektur Final & Analisis Implikasi Infrastruktur

Berdasarkan pengujian beban teoretis dan observasi log produksi, Bijak Technology menetapkan NATS JetStream + Wasmtime Execution Engine sebagai standar resmi platform code judge 2026.

Keputusan Berkas Arsitektur (ADR Summary):

  1. Broker Layer: NATS JetStream menggantikan RabbitMQ. Konsumsi RAM broker berkurang dari 380MB menjadi 28MB, membebaskan 90% kapasitas memori untuk pemroses kode.
  2. Execution Layer: Wasmtime menggantikan Docker Engine. Latensi inisialisasi turun 99.4%, memungkinkan 1 node Hostinger Cloud VPS KVM 4 menangani hingga 12.000 submissions per menit tanpa memicu disk swap.
  3. Trade-off Arsitektur: Kode siswa yang memerlukan library C/C++ spesifik atau sistem multithreading kompleks harus dikompilasi ke target WASI (WebAssembly System Interface) terlebih dahulu sebelum dikirimkan ke antrean stream NATS.

Transparansi: Beberapa tautan di artikel ini adalah tautan afiliasi yang mendukung kelangsungan publikasi riset kami tanpa biaya tambahan bagi Anda.

Topik Terkait:#Sains Komputasi#EduTech#NATS JetStream#Code Judge#Algoritma#Wasmtime#Generasi Muda
IP

Iswan Putera

Principal Software Architect

Software Architect & Pengembang Sistem Senior dengan pengalaman lebih dari satu dekade dalam rekayasa sistem terdistribusi, private cloud, dan implementasi ERP korporasi. Bertindak sebagai Lead Technology Writer di Bijak Technology.

Bagikan