# Dari Lokal ke Produksi: Modern Backend dengan Bun, Hono, dan Podman

*Memahami Peran Podman-Compose untuk Development dan Kubernetes untuk Produksi*

Dunia pengembangan backend terus bergerak cepat. Munculnya runtime seperti **Bun** dan framework minimalis seperti **Hono** menjanjikan kecepatan development yang luar biasa. Namun, kecepatan development harus diimbangi dengan alur kerja yang solid dari mesin lokal hingga ke server produksi.

Artikel ini akan memandu Anda membangun API sederhana menggunakan Bun, Hono, dan PostgreSQL. Kita akan menggunakan **Podman** sebagai container engine, dan yang terpenting, kita akan mengupas tuntas mengapa `podman-compose` adalah teman terbaik Anda saat development, dan mengapa **Kubernetes** adalah pilihan yang tepat untuk produksi.

---

### \## Sekilas Tentang Stack Modern Kita

Sebelum kita mulai, mari kita kenali para pemain utamanya:

* **Bun**: Sebuah *toolkit* dan *runtime* JavaScript all-in-one yang super cepat. Ia berfungsi sebagai package manager, bundler, dan runner.
    
* **Hono**: Framework web yang sangat ringan dan cepat, dapat berjalan di berbagai runtime JavaScript, termasuk Bun.
    
* **PostgreSQL**: Database relasional open-source yang andal dan kaya fitur.
    
* **Podman**: Alternatif untuk Docker yang lebih aman karena arsitekturnya yang *daemonless*. Sepenuhnya kompatibel dengan perintah Docker.
    

---

### \## Development Lokal dengan `podman-compose`: Cepat & Praktis 🚀

Saat melakukan development, kita butuh cara cepat untuk menjalankan seluruh lingkungan (aplikasi, database, dll.) dengan satu perintah. Di sinilah `podman-compose` bersinar.

#### **Langkah 1: Setup Proyek Bun & Hono**

Pertama, buat aplikasi Hono sederhana.

Bash

```typescript
# Buat direktori proyek
mkdir hono-api && cd hono-api

# Inisialisasi proyek Bun dan install Hono
bun init -y
bun install hono
```

Buat file `index.ts` dengan kode berikut:

TypeScript

```typescript
// index.ts
import { Hono } from 'hono'

const app = new Hono()

app.get('/', (c) => {
  return c.json({ message: 'Hello from Bun, Hono, and Podman!' })
})

export default app
```

#### **Langkah 2: Membuat** `Containerfile`

Selanjutnya, kita bungkus aplikasi kita dalam sebuah image kontainer. Buat file bernama `Containerfile` (mirip seperti Dockerfile).

Dockerfile

```typescript
# Containerfile
FROM oven/bun:1

WORKDIR /app

# Salin package.json dan bun.lockb
COPY package.json bun.lockb ./
# Install dependencies
RUN bun install --frozen-lockfile

# Salin sisa kode
COPY . .

# Expose port dan jalankan aplikasi
EXPOSE 3000
CMD ["bun", "run", "index.ts"]
```

#### **Langkah 3: Orkestrasi Lokal dengan** `compose.yaml`

Inilah bagian intinya. Kita akan membuat file `compose.yaml` untuk mendefinisikan dua layanan: aplikasi Hono kita (`app`) dan database PostgreSQL (`db`).

YAML

```typescript
# compose.yaml
services:
  app:
    build: .
    ports:
      - "3000:3000"
    depends_on:
      - db
    # Environment variables untuk koneksi ke database
    environment:
      - DB_HOST=db
      - DB_PORT=5432
      - DB_USER=myuser
      - DB_PASSWORD=mypassword
      - DB_NAME=mydb

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=myuser
      - POSTGRES_PASSWORD=mypassword
      - POSTGRES_DB=mydb
    volumes:
      # Menyimpan data postgres secara persisten di mesin lokal
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:
```

#### **Langkah 4: Jalankan Semuanya!**

Sekarang, dengan satu perintah sederhana, seluruh lingkungan development Anda akan aktif.

Bash

```typescript
podman-compose up --build
```

Podman akan membangun image aplikasi Anda, menarik image PostgreSQL, membuat network di antara keduanya, dan menjalankannya. Anda bisa langsung mengakses [`http://localhost:3000`](http://localhost:3000) dan mulai *coding*. **Praktis, bukan?**

---

### \## Jembatan Menuju Produksi: Kenapa `podman-compose` Tidak Cukup?

Lingkungan lokal sudah berjalan mulus. Lalu, mengapa kita tidak bisa langsung menggunakan file `compose.yaml` ini di server produksi?

`podman-compose` dirancang untuk **satu host/mesin**. Ia tidak memiliki fitur-fitur krusial yang dibutuhkan oleh lingkungan produksi, seperti:

* **High Availability & Self-Healing**: Jika kontainer database Anda mati, `podman-compose` tidak akan secara otomatis me-restartnya. Aplikasi Anda akan *down*.
    
* **Scaling (Penskalaan)**: Jika traffic ke API Anda melonjak, Anda tidak bisa secara otomatis menambah jumlah kontainer aplikasi.
    
* **Advanced Networking**: Tidak ada *load balancing* bawaan atau manajemen lalu lintas yang canggih.
    
* **Zero-Downtime Deployment**: Melakukan update aplikasi tanpa membuat layanan berhenti (downtime) sangat sulit dilakukan.
    

---

### \## Kubernetes untuk Produksi: Skalabilitas & Keandalan 🛡️

Di sinilah **Kubernetes** mengambil alih. Kubernetes adalah platform orkestrasi yang dirancang untuk menjalankan aplikasi terdistribusi dalam skala besar dengan keandalan tinggi.

Ia menjawab semua kekurangan `podman-compose` untuk produksi:

* **Orkestrasi Terdistribusi**: Kubernetes menjalankan kontainer Anda di sebuah klaster (kumpulan mesin), bukan hanya satu.
    
* **Self-Healing**: Jika sebuah kontainer atau bahkan satu mesin mati, Kubernetes akan secara otomatis memindahkan dan me-restart kontainer tersebut di mesin lain yang sehat.
    
* **Penskalaan Otomatis**: Anda bisa mengaturnya untuk menambah atau mengurangi jumlah kontainer aplikasi secara otomatis berdasarkan beban CPU atau memori.
    
* **Manajemen Konfigurasi & Rahasia**: Menyediakan cara yang aman dan terpusat untuk mengelola konfigurasi dan data sensitif seperti password database menggunakan `ConfigMaps` dan `Secrets`.
    
* **Rolling Updates**: Memungkinkan Anda memperbarui aplikasi ke versi baru secara bertahap tanpa menyebabkan downtime.
    

#### **Seperti Apa Konfigurasinya di Kubernetes?**

Anda tidak lagi menggunakan `compose.yaml`. Sebagai gantinya, Anda mendefinisikan *state* atau keadaan yang Anda inginkan dalam file manifest YAML Kubernetes. Secara konseptual, Anda akan membuat:

1. Sebuah `Deployment` untuk aplikasi Hono Anda, yang mendefinisikan image kontainer dan jumlah replika yang diinginkan.
    
2. Sebuah `Deployment` untuk database PostgreSQL.
    
3. Sebuah `PersistentVolumeClaim` untuk memastikan data database disimpan secara permanen, bahkan jika kontainernya di-restart.
    
4. Sebuah `Service` untuk memberikan alamat jaringan yang stabil bagi aplikasi dan database agar bisa saling berkomunikasi.
    
5. `Secrets` untuk menyimpan kredensial database dengan aman.
    

Prosesnya adalah: bangun image dengan `podman build`, unggah ke *image registry*, lalu terapkan file manifest YAML Anda ke klaster Kubernetes dengan `kubectl apply`.

---

### \## Kesimpulan: Alat yang Tepat untuk Tugas yang Tepat

Memahami alur kerja ini sangat penting bagi developer modern.

* Gunakan `podman-compose` untuk mempercepat siklus development Anda. Ia sempurna untuk menciptakan lingkungan lokal yang konsisten dan mudah dikelola dengan satu perintah.
    
* Ketika aplikasi Anda siap untuk "go public", adopsi **Kubernetes** untuk mendapatkan keandalan, skalabilitas, dan ketangguhan yang dibutuhkan oleh lingkungan produksi.
    

Dengan memahami peran masing-masing alat, Anda dapat membangun dan mengirimkan aplikasi dengan lebih cepat dan lebih percaya diri. Selamat mencoba!