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:
- 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.
- Overhead CPU & Memory Container: Proses
docker runatau pembuatan ephemeral container memakan overhead pembuatan namespace/cgroups rata-rata 180msโ450ms dan konsumsi RAM minimal 128MB per eksekusi. - 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<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::<(), ()>(&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):
- Broker Layer: NATS JetStream menggantikan RabbitMQ. Konsumsi RAM broker berkurang dari 380MB menjadi 28MB, membebaskan 90% kapasitas memori untuk pemroses kode.
- 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.
- 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.

Bagikan ke Media Sosial
Salin draf atau langsung buka platform pilihan Anda
1/3 Ketika 10.000 submisi kode masuk serentak, RabbitMQ + Docker konvensional sering tumbang akibat Head-of-Line Blocking dan cold-start latency >1.200ms. ๐งต #SystemDesign #WebAssembly
2/3 Dengan beralih ke NATS JetStream & Wasmtime (WebAssembly) di Hostinger VPS KVM 4, jejak memori terpangkas drastis dan latensi eksekusi turun ke sub-15ms. #CloudFinOps #DevOps
3/3 Pelajari Architectural Decision Record (ADR) lengkap & tabel komparasi parameternya di tengah artikel kami: https://bijaktechnology.com/blog/arsitektur-code-judge-nats-jetstream-edutech-wasmtime/
๐ก Cara tayang rapi di Medium.com: