Chi #

Chi adalah router HTTP yang sangat ringan dan idiomatik di ekosistem Go. Chi tidak membawa banyak abstraksi seperti framework besar, sehingga sering dipilih untuk service yang:

Fokus pada kesederhanaan
Mengikuti standar net/http
Mudah di-maintain dalam jangka panjang

Namun, justru karena Chi minimalis, setup local development sering kali berbeda-beda antar developer:

Versi Go tidak seragam
Cara menjalankan service tidak konsisten
Tidak ada hot reload
Setup database dan dependency manual

Di sinilah Dockerfile dan Docker Compose berperan penting sebagai fondasi environment lokal yang konsisten, reproducible, dan cepat di-iterate.

Artikel ini membahas secara mendetail dan rinci:

Dockerfile khusus Go Chi local development
Docker Compose sebagai orkestrator environment lokal
Workflow development yang efisien
Best practice dan anti-pattern yang sering terjadi

Fokus utama artikel ini adalah Docker Compose untuk local development, bukan production.

Filosofi Docker Go Chi #

Tujuan utama penggunaan Docker di local development Go Chi:

Menyamakan versi Go dan OS
Menghilangkan masalah works on my machine
Mempercepat onboarding developer baru
Mendukung hot reload

Bukan tujuan utama:

Binary sekecil mungkin
Image production-grade
Hardening security ekstrem

Local development mengutamakan feedback loop cepat, bukan optimasi runtime.

Gambaran Arsitektur #

Arsitektur umum Go Chi lokal:

Developer
   |
   v
Docker Compose
   |
   +--> chi-app (hot reload)
   |
   +--> database (PostgreSQL / MySQL)

Struktur Project Go Chi #

Contoh struktur project Go Chi yang umum dan scalable:

.
├── cmd/
│   └── api/
│       └── main.go
├── internal/
│   ├── http/
│   │   ├── handler.go
│   │   └── router.go
│   ├── service/
│   └── repository/
├── pkg/
├── go.mod
├── go.sum
├── Dockerfile
├── docker-compose.yml
├── .env
├── .air.toml
└── .dockerignore

Chi sangat cocok dipadukan dengan struktur cmd/ dan internal/ yang idiomatik di Go.

Karakteristik Dockerfile Go Chi #

Aspek	Local Development	Production
Build	go build + air	go build static
Reload	Aktif	Tidak
Debug	Aktif	Minimal
Image size	Tidak kritis	Penting

Kesalahan umum: menggunakan Dockerfile production untuk local development.

Dockerfile Go Chi #

Prinsip Dasar #

Gunakan image Go resmi
Aktifkan hot reload
Cache dependency Go
Jalankan app via tool reload

Contoh Dockerfile #

FROM golang:1.22-alpine

WORKDIR /app

# Install OS dependency
RUN apk add --no-cache git curl bash

# Install air for hot reload
RUN go install github.com/air-verse/air@latest

# Cache Go dependencies
COPY go.mod go.sum ./
RUN go mod download

# Copy source code
COPY . .

EXPOSE 8080

CMD ["air", "-c", ".air.toml"]

Konfigurasi Hot Reload dengan Air #

root = "."

tmp_dir = "tmp"

[build]
  cmd = "go build -o ./tmp/main ./cmd/api"
  bin = "./tmp/main"
  include_ext = ["go", "tpl", "tmpl", "html"]
  exclude_dir = ["vendor", "tmp"]

[log]
  time = true

Tanpa hot reload, iterasi Go Chi akan terasa lambat.

Penjelasan Dockerfile #

1. Base Image #

FROM golang:1.22-alpine

Versi Go eksplisit
Image ringan
Cocok untuk local dev

2. Hot Reload Tool #

RUN go install github.com/air-verse/air@latest

Chi tidak menyediakan hot reload bawaan, sehingga tool eksternal sangat penting.

3. Dependency Cache #

COPY go.mod go.sum ./
RUN go mod download

Mencegah go mod download berulang kali saat rebuild.

4. Menjalankan Aplikasi #

CMD ["air", "-c", ".air.toml"]

Air akan memonitor perubahan file dan me-restart server otomatis.

Docker Compose #

Peran Docker Compose #

Docker Compose menyatukan:

Go Chi application
Database
Environment variable

Dalam satu perintah sederhana.

Contoh docker-compose.yml #

version: "3.9"

services:
  api:
    container_name: chi-app
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    volumes:
      - .:/app
    env_file:
      - .env
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    container_name: postgres-db
    environment:
      POSTGRES_DB: app_db
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Penjelasan docker-compose.yml #

1. Service Go Chi #

Volume Mount #

volumes:
  - .:/app

Sinkronisasi source code
Hot reload berjalan optimal

Port Mapping #

ports:
  - "8080:8080"

Akses API via http://localhost:8080.

2. Service Database #

Image resmi PostgreSQL
Data persisten via volume

Workflow Development #

Jalankan stack:
```
docker compose up --build
```
Edit kode Go
Air reload otomatis
Test endpoint

Anti-Pattern #

Menjalankan Go tanpa hot reload
Menggunakan Dockerfile production untuk local
Tidak cache go mod download
Logic bisnis bercampur di handler

Best Practice #

1. Gunakan `.dockerignore` #

.git
tmp
bin
.env

2. Pisahkan Config via ENV #

Gunakan os.Getenv atau library config ringan.

3. Jaga Chi Tetap Tipis #

Jangan memaksa Chi menjadi framework besar.

Penutup #

Dockerfile dan Docker Compose untuk local development Go Chi seharusnya dirancang untuk kesederhanaan, kecepatan iterasi, dan konsistensi environment.

Dengan setup yang tepat:

Developer experience meningkat
Setup lokal lebih bersih
Service lebih mudah dirawat