Belajar Echo - Production-Ready Architecture

#Pendahuluan

Kode yang benar di mesin kalian hanyalah langkah pertama. Arsitektur production-ready menentukan apakah aplikasi bisa di-deploy, diskalakan, dan dipulihkan dengan andal. Episode ini menyatukan seluruh pelajaran series menjadi blueprint deployment nyata.

Episode 21 ini membahas modular monolith dan microservices, config environment, centralized logging, Docker multi-stage, CI/CD dengan GitHub Actions, deployment ke Kubernetes dan VM, serta strategi zero-downtime.

#Memilih Bentuk Arsitektur

#Modular Monolith versus Microservices

Bukan semua aplikasi butuh microservices. Modular monolith — satu deployable dengan modul internal yang terpisah tegas — sering menjadi pilihan terbaik:

• Lebih sederhana untuk transaksi dan konsistensi data.
• Satu deployment pipeline dan satu tempat debugging.
• Tetap scalable horizontal lewat banyak instance.

Microservices baru masuk akal ketika tim besar bekerja independen, atau beban kerja butuh scaling terpisah. Mulai dari modular monolith; pecah ketika tim dan beban benar-benar menuntut.

cmd/api/main.go
internal/
  user/
  order/
  notification/
  platform/echo.go

#Config Environment dan Centralized Logging

#Config dan Log untuk Semua Environment

Seluruh konfigurasi sudah dikelola episode 10: struct Config, environment sebagai sumber nilai, dan slog sebagai satu logger. Di production, lengkapi dengan:

level := slog.LevelInfo
if cfg.Environment == "development" {
	level = slog.LevelDebug
}
slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
	Level: level,
})))

Log JSON di stdout, dikumpulkan aggregator (episode 11), dan dihubungkan dengan trace (episode 18). Tidak ada file log lokal di dalam kontainer.

#Containerization dengan Docker

#Dockerfile Multi-Stage

Docker multi-stage menghasilkan image kecil dan aman: build di satu stage, hasil binary disalin ke stage runtime yang ramping:

FROM golang:1.24-alpine AS build
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o /app/server ./cmd/api
 
FROM alpine:3.20
RUN adduser -D appuser
COPY --from=build /app/server /server
USER appuser
EXPOSE 8080
ENTRYPOINT ["/server"]

Stage build memakai Go penuh; stage runtime hanya alpine ramping dengan binary statis dan user non-root. CGO_ENABLED=0 menghasilkan binary tanpa dependency C.

docker build -t belajar-echo:latest .
docker run --rm -p 8080:8080 belajar-echo:latest

#CI/CD dengan GitHub Actions

#Pipeline Build, Test, dan Release

Pipeline CI/CD otomatis: setiap push ke main di-build, diuji, dan dirilis:

name: deploy
on:
  push:
    branches: [main]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: "1.24"
      - run: go mod download
      - run: go build ./...
      - run: go test ./... -race
      - run: go vet ./...

Langkah berikutnya dalam pipeline: build image Docker, push ke registry, dan trigger deployment. Setiap commit yang lulus menjadi kandidat rilis.

#Deployment ke Kubernetes dan VM

#Kubernetes dan Strategi Zero-Downtime

Deployment Kubernetes memakai strategi rolling update agar tidak ada downtime:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: belajar-echo
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
      maxSurge: 1
  template:
    spec:
      containers:
        - name: api
          image: registry.example.com/belajar-echo:v1.0.0
          ports:
            - containerPort: 8080
          readinessProbe:
            httpGet:
              path: /health/ready
              port: 8080

Tiga kunci zero-downtime: replicas lebih dari satu, readinessProbe ke /health/ready dari episode 18, dan rolling update yang mengganti instance secara bertahap. Kombinasi ini memastikan traffic hanya diarahkan ke instance yang siap.

#Penutup

Episode 21 menyusun blueprint production: modular monolith sebagai titik awal yang pragmatis, config dan centralized logging yang konsisten, Docker multi-stage dengan binary statis dan user non-root, CI/CD GitHub Actions, deployment Kubernetes dengan rolling update, dan readiness probe untuk zero-downtime.

Inti yang harus dibawa pulang:

• Modular monolith adalah titik awal; microservices saat tim dan beban menuntut.
• Config selalu dari environment; log JSON di stdout.
• Docker multi-stage menghasilkan image ramping dan aman.
• Binary statis dengan CGO_ENABLED=0 dan user non-root.
• CI/CD mengotomatisasi build, test, dan rilis.
• Rolling update plus readiness probe menghasilkan zero-downtime.
• Seluruh pilar saling bergantung: config, log, trace, dan health.

Di episode 22 selanjutnya kita akan membahas ekosistem alternatif & refleksi akhir — perbandingan mendalam Echo dengan Gin, Fiber, chi, dan net/http polos, kapan memilih masing-masing, rekap perjalanan 22 episode, checklist REST API production-grade, dan masa depan Echo di ekosistem Go.