Tutorial Bun Runtime: API Server Production-Ready

Bun hadir sebagai runtime JavaScript all-in-one yang menjanjikan kecepatan eksekusi lebih cepat dari Node.js dan Deno. Selain runtime, Bun menyertakan bundler, test runner, dan package manager dalam satu binary. Artikel ini fokus pada praktik membangun API server production-ready menggunakan Bun dengan framework Hono.

Banyak developer masih ragu beralih dari Node.js karena khawatir ecosystem belum matang. Faktanya, Bun sudah kompatibel dengan sebagian besar NPM package dan mendukung Web API standar seperti Request, Response, dan ReadableStream. Mari kita buktikan dengan membangun REST API lengkap.

Mengapa Bun untuk Backend?

Performa adalah alasan utama developer memilih Bun. Benchmark internal menunjukkan throughput HTTP bisa 3-4x lebih tinggi dibanding Node.js dalam skenario tertentu. Selain itu, cold start Bun jauh lebih cepat karena menggunakan JavaScriptCore dibanding V8 yang lebih berat.

Bun juga menyederhanakan toolchain. Tidak perlu lagi memasang Jest untuk testing, esbuild untuk bundling, atau nodemon untuk hot reload. Semua sudah built-in. Hal ini mengurangi kompleksitas projek dan ukuran dependency tree secara signifikan.

Persiapan Proyek

Pastikan Bun sudah terinstall. Jika belum, jalankan perintah install dari official website:

curl -fsSL https://bun.sh/install | bash

Buat direktori projek baru dan inisialisasi dengan bun init. Pilih template blank agar kita punya kontrol penuh atas struktur folder:

mkdir bun-api-server
cd bun-api-server
bun init -y

Install framework Hono dan driver PostgreSQL. Hono dipilih karena ringan, cepat, dan didesain khusus untuk edge runtime termasuk Bun:

bun add hono pg
bun add -d @types/bun

Tambahkan file .env untuk konfigurasi database dan port server:

DATABASE_URL=postgresql://user:password@localhost:5432/bun_api
PORT=3000
JWT_SECRET=supersecretkey_change_in_production

Langkah 1: Struktur Folder dan Entry Point

Organisasi kode yang baik memudahkan maintenance di masa depan. Gunakan struktur berikut:

src/
  index.ts       // Entry point
  routes/
    users.ts     // Route handlers
  db/
    client.ts    // Database connection
  middleware/
    auth.ts      // Auth middleware

File src/index.ts menjadi entry point utama. Di sini kita inisialisasi Hono app, mount middleware global, dan daftarkan route:

import { Hono } from "hono";
import { logger } from "hono/logger";
import { cors } from "hono/cors";
import { userRoutes } from "./routes/users";

const app = new Hono();

app.use("*", logger());
app.use("*", cors({ origin: process.env.ALLOWED_ORIGIN || "*" }));

app.route("/api/users", userRoutes);

app.get("/health", (c) => c.json({ status: "ok", timestamp: new Date().toISOString() }));

export default {
  port: process.env.PORT || 3000,
  fetch: app.fetch
};

Langkah 2: Koneksi Database dengan Pooling

Bun mendukung native async dan await secara optimal. Gunakan connection pooling dari library pg untuk menangani concurrent requests dengan efisien:

import { Pool } from "pg";

export const db = new Pool({
  connectionString: process.env.DATABASE_URL,
  max: 20,
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000
});

db.on("error", (err) => {
  console.error("Unexpected database error", err);
});

Pool size 20 cukup untuk aplikasi skala menengah. Sesuaikan dengan kapasitas VPS dan beban traffic. Selalu handle error event agar aplikasi tidak crash saat database sementara tidak tersedia.

Langkah 3: Implementasi CRUD Route

Buat file src/routes/users.ts dengan operasi CRUD lengkap. Hono memudahkan parsing body JSON dan parameter URL:

import { Hono } from "hono";
import { db } from "../db/client";

export const userRoutes = new Hono();

userRoutes.get("/", async (c) => {
  const result = await db.query("SELECT id, email, created_at FROM users ORDER BY created_at DESC LIMIT 100");
  return c.json(result.rows);
});

userRoutes.get("/:id", async (c) => {
  const id = c.req.param("id");
  const result = await db.query("SELECT * FROM users WHERE id = $1", [id]);
  if (result.rows.length === 0) return c.json({ error: "User not found" }, 404);
  return c.json(result.rows[0]);
});

userRoutes.post("/", async (c) => {
  const body = await c.req.json();
  const { email, name } = body;
  const result = await db.query(
    "INSERT INTO users (email, name) VALUES ($1, $2) RETURNING *",
    [email, name]
  );
  return c.json(result.rows[0], 201);
});

Validasi input bisa ditambahkan dengan library Zod sebelum query dieksekusi. Untuk tutorial ini, kita fokus pada alur dasar agar kode tetap readable.

Langkah 4: Environment dan Konfigurasi Production

Sebelum deploy, pastikan variabel environment terpisah antara development dan production. Bun secara native membaca file .env, tapi di server production sebaiknya gunakan secret management atau systemd environment file:

[Service]
Environment=DATABASE_URL=postgresql://prod_user:secure_pass@db.internal/api_prod
Environment=PORT=3000
Environment=JWT_SECRET=very_long_random_string

Untuk logging, gunakan format JSON agar mudah di-parse oleh log aggregator seperti Grafana Loki atau Datadog. Hono logger bisa diganti dengan custom middleware yang menulis ke stdout dalam format JSON.

Langkah 5: Deployment dengan Systemd

Bun menghasilkan single binary yang bisa dijalankan langsung. Buat service file systemd di VPS production:

[Unit]
Description=Bun API Server
After=network.target

[Service]
Type=simple
User=deploy
WorkingDirectory=/var/www/bun-api
ExecStart=/usr/local/bin/bun run src/index.ts
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Jalankan sudo systemctl enable bun-api dan sudo systemctl start bun-api. Pastikan firewall membuka port 3000, atau lebih baik gunakan reverse proxy Nginx/Caddy untuk menangani TLS termination.

Testing dan Benchmark

Bun menyertakan test runner bawaan yang kompatibel dengan Jest-style describe dan it. Contoh test sederhana:

import { describe, it, expect } from "bun:test";

describe("Health Endpoint", () => {
  it("should return status ok", async () => {
    const res = await fetch("http://localhost:3000/health");
    const json = await res.json();
    expect(json.status).toBe("ok");
  });
});

Jalankan dengan bun test. Untuk benchmark HTTP, gunakan wrk atau autocannon dan bandingkan hasilnya dengan implementasi serupa di Node.js.

Kesimpulan

Bun menawarkan alternatif runtime yang menarik untuk backend JavaScript. Dengan Hono sebagai framework, kita bisa membangun API server yang ringan dan cepat tanpa meninggalkan kemudahan ekosistem NPM.

Sebelum migrasi production sepenuhnya, lakukan stress test dan verifikasi kompatibilitas library kritis yang digunakan. Dokumentasi resmi Bun tersedia di bun.sh/docs. Source code tutorial ini bisa diadaptasi untuk kebutuhan spesifik proyekmu.

Tutorial Bun Runtime untuk API Server Production-Ready