Arsitektur High-Throughput REST API Menggunakan Go dan SQLite di Environment Edge

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap arsitektur web modern, pergeseran paradigma dari centralized cloud computing menuju edge computing menuntut efisiensi operasional yang ekstrem. Layanan backend dituntut untuk berjalan sedekat mungkin dengan pengguna akhir demi memangkas latensi jaringan (Network Latency). Namun, pendekatan tradisional yang mengandalkan database klien-server terpusat seperti PostgreSQL atau MySQL di setiap node edge seringkali menemui jalan buntu. Latency antar-region, kompleksitas replikasi, dan konsumsi memori yang tinggi membuat database relasional konvensional tidak efisien untuk dijalankan pada infrastruktur edge dengan spesifikasi sumber daya yang terbatas.

Di sinilah SQLite hadir sebagai solusi transformatif. Sebagai database berbasis embedded, SQLite menghilangkan overhead jaringan antara aplikasi dan penyimpanan data, karena database berjalan di dalam proses yang sama atau melalui shared memory lokal. Kendati demikian, penggunaan SQLite dalam lingkungan high-throughput dan concurrent write sering kali terbentur oleh arsitektur locking bawaannya yang bersifat exclusive writer. Tanpa konfigurasi yang tepat, aplikasi backend akan mengalami database is locked error yang melumpuhkan performa.

[!WARNING] Secara default, SQLite menggunakan mode journaling rollback tradisional yang mengunci seluruh file database selama operasi tulis (write). Hal ini menyebabkan performa aplikasi high-concurrency anjlok drastis akibat terjadinya antrean panjang pada thread eksekusi.

Untuk mengatasi hal ini, kombinasi antara bahasa Go (Golang) dan SQLite dengan konfigurasi Write-Ahead Logging (WAL) Mode menjadi standar emas baru. Go menawarkan model konkurensi berbasis goroutine yang sangat ringan, manajemen memori efisien melalui garbage collector yang dioptimalkan, serta kompilasi biner mandiri tanpa runtime dependency. Ketika Go dipadukan dengan SQLite WAL mode, aplikasi dapat melakukan proses concurrent reads tanpa batas waktu yang sama saat operasi write sedang berlangsung, menghasilkan throughput ribuan request per detik (RPS) pada perangkat keras berdaya rendah.

Perbandingan Kondisi: Sebelum vs Sesudah Penerapan

2. Konsep Inti & Deep Dive Arsitektur

Arsitektur High-Throughput API di edge menuntut pemahaman mendalam mengenai siklus hidup koneksi, penanganan I/O, dan mekanisme penulisan disk. Berikut adalah visualisasi alur eksekusi data dari klien HTTP hingga penyimpanan fisik di disk:

+--------------------------------------------------------------------------+
|                         EDGE CLIENT / BROWSER                            |
+--------------------------------------------------------------------------+
                                     |
                                     v (HTTP/2 REST API)
+--------------------------------------------------------------------------+
|                   GO HTTP SERVER (Gorilla Mux / Chi)                     |+
|  +--------------------------------------------------------------------+  |
|  |                       Go Concurrency Engine                        |  |
|  |   [Goroutine 1]   [Goroutine 2]   [Goroutine 3]   ...   [Goroutine N]  |
|  +--------------------------------------------------------------------+  |
+--------------------------------------------------------------------------+
                                     |
                                     v (Connection Pool: SetMaxOpenConns(1))
+--------------------------------------------------------------------------+
|                      GO-SQLITE3 / MODERNCS DRIVER                        |
+--------------------------------------------------------------------------+
                                     |
                                     v (OS System Calls)
+--------------------------------------------------------------------------+
|                     SQLITE ENGINE (WAL MODE ENABLED)                     |
|                                                                          ||
|  +---------------------------+       +--------------------------------+  |
|  |     Shared Memory (SHM)   | <---> |   Write-Ahead Log (.db-wal)    |  |
|  +---------------------------+       +--------------------------------+  |
|                ^                                     ^                   |
|                | (Checkpointing)                     | (Sequential Append||
|                v                                     v                   |
|  +--------------------------------------------------------------------+  |
|  |                       Main Database (.db)                          |  |
|  +--------------------------------------------------------------------+  |
+--------------------------------------------------------------------------+
                                     |
                                     v (NVMe / SSD Storage)
+--------------------------------------------------------------------------+
|                         PHYSICAL STORAGE LAYER                           |+
+--------------------------------------------------------------------------+

Mekanisme Kerja Write-Ahead Logging (WAL)

Dalam mode WAL, perubahan pada database tidak langsung ditulis ke file utama database (.db). Sebaliknya, perubahan tersebut dicatat secara berurutan (append-only) ke dalam file log terpisah yang disebut file WAL (.db-wal). Sebuah file memori bersama (shared memory file atau .db-shm) digunakan untuk mengoordinasikan pembaca dan penulis lintas proses secara efisien menggunakan instruksi memory barrier dan atomic operations.

1. Operasi Baca (Read): Pembaca memeriksa file WAL dan file utama secara bersamaan. Pembaca tidak perlu menunggu penulis selesai, karena snapshot data saat transaksi pembacaan dimulai dijamin konsisten.
2. Operasi Tulis (Write): Penulis menambahkan data baru ke akhir file WAL. Operasi ini sangat cepat karena berupa penulisan sekuensial (sequential I/O) tanpa perlu mengubah struktur B-Tree kompleks di file utama.
3. Checkpointing: Proses pemindahan data dari file WAL kembali ke file utama database dilakukan secara asinkron (otomatis ketika file WAL mencapai ukuran tertentu, atau dipicu secara manual). Hal ini memastikan ukuran file WAL tetap terkendali tanpa membebani thread utama API.

3. Perbandingan Komparatif / Analisis Pendekatan

Memilih tumpukan teknologi untuk arsitektur edge memerlukan analisis mendalam terhadap trade-off sumber daya komputasi. Berikut perbandingan arsitektur penyimpanan data di edge:

[!TIP] Untuk environment edge (seperti AWS Outposts, Cloudflare Workers dengan Durable Objects, atau VPS minimalis berkapasitas 512MB RAM), kombinasi Go + SQLite WAL memberikan rasio cost-to-performance terbaik di industri saat ini.

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum mulai menulis kode, pastikan sistem operasi dan perangkat lunak pendukung telah terinstal dengan benar pada environment produksi atau development (disarankan menggunakan Linux Ubuntu 22.04 LTS / Debian 12 atau Alpine Linux).

Instalasi Go dan Dependensi Sistem

Jalankan perintah berikut pada terminal untuk menyiapkan lingkungan:

# Perbarui daftar paket sistem
sudo apt-get update && sudo apt-get upgrade -y

# Instal tool esensial, build-essential (diperlukan jika menggunakan CGO), dan Git
sudo apt-get install -y curl build-essential git wrk

# Unduh dan instal Go (Versi 1.22 atau terbaru)
export GO_VERSION="1.22.2"
curl -OL https://golang.org/dl/go${GO_VERSION}.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go${GO_VERSION}.linux-amd64.tar.gz

# Konfigurasi Environment PATH
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile
echo 'export PATH=$PATH:$(go env GOPATH)/bin' >> ~/.profile
source ~/.profile

# Verifikasi instalasi Go
go version

5. Panduan Implementasi Langkah demi Langkah

Berikut adalah implementasi penuh dari REST API berkecepatan tinggi menggunakan Go standar, router berkinerja tinggi, dan driver SQLite dengan konfigurasi WAL mode serta connection pooling optimal.

Langkah 1: Inisialisasi Modul Go

mkdir -p edge-api-go
cd edge-api-go
go mod init edge-api-go

Langkah 2: Instalasi Driver SQLite & Router

Kita akan menggunakan pustaka modernc.org/sqlite karena ditulis murni dalam bahasa Go (Pure Go) tanpa ketergantungan pada CGO, sehingga memudahkan kompilasi silang (cross-compilation) ke berbagai arsitektur edge.

go get modernc.org/sqlite@latest
go get github.com/julienschmidt/httprouter@v1.3.0

Langkah 3: Kode Sumber Utama (main.go)

Buat file main.go dan isi dengan kode lengkap berikut:

package main

import (
	"database/sql"
	"encoding/json"
	"log"
	"net/http"
	"time"

	"github.com/julienschmidt/httprouter"
	_ "modernc.org/sqlite"
)

type App struct {
	DB *sql.DB
}

type LogEntry struct {
	ID        int64     `json:"id"`
	Level     string    `json:"level"`
	Message   string    `json:"message"`
	Timestamp time.Time `json:"timestamp"`
}

func main()
{
	// Inisialisasi koneksi database SQLite dengan DSN (Data Source Name) yang dioptimalkan untuk WAL mode
	// Parameter cache=shared dan _busy_timeout krusial untuk konkurensi tinggi
	dsn := "file:edge_logs.db?cache=shared&_journal_mode=WAL&_sync=NORMAL&_busy_timeout=5000"
	
	db, err := sql.Open("sqlite", dsn)
	if err != nil {
		log.Fatalf("Gagal membuka database: %v", err)
	}
	defer db.Close()

	// ATURAN CONNECTION POOLING UNTUK SQLITE:
	// SQLite hanya mendukung 1 penulis aktif pada satu waktu.
	// SetMaxOpenConns(1) mencegah race condition pada layer aplikasi, sementara goroutine pool
	// tetap dapat melakukan query baca secara paralel berkat fitur thread-safe driver modernc.
	db.SetMaxOpenConns(1)
	db.SetMaxIdleConns(1)
	db.SetConnMaxLifetime(0)

	// Verifikasi koneksi
	if err := db.Ping(); err != nil {
		log.Fatalf("Database tidak merespons: %v", err)
	}

	// Buat tabel jika belum ada
	createTableSQL := `
	CREATE TABLE IF NOT EXISTS system_logs (
		id INTEGER PRIMARY KEY AUTOINCREMENT,
		level TEXT NOT NULL,
		message TEXT NOT NULL,
		timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
	);
	CREATE INDEX IF NOT EXISTS idx_logs_level ON system_logs(level);
	`

	_, err = db.Exec(createTableSQL)
	if err != nil {
		log.Fatalf("Gagal membuat skema tabel: %v", err)
	}

	app := &App{DB: db}

	// Inisialisasi Router HTTP
	router := httprouter.New()
	router.POST("/api/v1/logs", app.CreateLogHandler)
	router.GET("/api/v1/logs", app.GetLogsHandler)

	log.Println("Edge API berjalan pada port :8080...")
	log.Fatal(http.ListenAndServe(":8080", router))
}

// Handler untuk menyimpan log baru (Write)
func (app *App) CreateLogHandler(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
	var entry LogEntry
	decoder := json.NewDecoder(r.Body)
	if err := decoder.Decode(&entry); err != nil {
		http.Error(w, "Payload JSON tidak valid", http.StatusBadRequest)
		return
	}

	if entry.Level == "" || entry.Message == "" {
		http.Error(w, "Field 'level' dan 'message' wajib diisi", http.StatusBadRequest)
		return
	}

	query := `INSERT INTO system_logs (level, message, timestamp) VALUES (?, ?, ?)`
	now := time.Now()

	_, err := app.DB.Exec(query, entry.Level, entry.Message, now)
	if err != nil {
		http.Error(w, "Gagal menyimpan data ke database", http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(map[string]interface{}{_ "status": "success", "message": "Log berhasil dicatat\