Tutorial Docker Compose Development Environment Multi-Container

Setup development environment yang konsisten sering jadi masalah klasik bagi developer. Beda OS, beda versi dependency, dan konfigurasi manual yang tidak terekam membuat onboarding anggota tim baru jadi mimpi buruk. Docker Compose hadir sebagai solusi praktis: satu file YAML untuk mendefinisikan seluruh stack aplikasi mulai dari database, cache, hingga web server. Artikel ini akan membahas cara membangun multi-container environment menggunakan Docker Compose dengan stack Nginx, PostgreSQL, dan Redis.

Mengapa Docker Compose?

Docker Compose memungkinkan kamu menjalankan beberapa container sekaligus dengan satu perintah. Dibandingkan menjalankan docker run secara manual untuk setiap service, Compose memberikan beberapa keuntungan:

Reproducible environment: Satu file docker-compose.yml bisa dijalankan di laptop, staging, maupun production dengan hasil identik.
Service discovery otomatis: Container bisa saling berkomunikasi menggunakan nama service sebagai hostname.
Volume persistensi: Data database tetap aman meski container dihapus dan dibuat ulang.

Jika kamu belum menginstall Docker, ikuti panduan resmi dari Docker Documentation sesuai sistem operasi yang digunakan.

Langkah 1: Inisialisasi Project Structure

Buat direktori project baru dan siapkan struktur folder seperti berikut:

myapp/
├── docker-compose.yml
├── nginx/
│   └── default.conf
├── backend/
│   ├── Dockerfile
│   └── src/
└── postgres_data/ (auto-generated)

Struktur ini memisahkan konfigurasi web server, aplikasi backend, dan volume data. Pendekatan modular memudahkan maintenance jika suatu saat ingin menambahkan service baru seperti Elasticsearch atau Kafka.

Langkah 2: Konfigurasi PostgreSQL dan Redis

Buka file docker-compose.yml dan tambahkan definisi untuk database dan cache:

version: '3.8'
services:
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: devuser
      POSTGRES_PASSWORD: devpass
      POSTGRES_DB: myapp_db
    volumes:
      - ./postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U devuser -d myapp_db"]
      interval: 5s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    command: redis-server --appendonly yes

volumes:
  redis_data:

PostgreSQL versi 16 Alpine dipilih karena ukuran image ringan namun stabil. Healthcheck pada service db memastikan container backend tidak dijalankan sebelum database siap menerima koneksi. Redis menggunakan volume bernama agar data persisten meski container direstart.

Langkah 3: Build Backend dengan Dockerfile

Buat file backend/Dockerfile untuk aplikasi Node.js:

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY src/ ./src/
EXPOSE 3000
CMD ["node", "src/index.js"]

Tambahkan service backend ke docker-compose.yml:

  backend:
    build: ./backend
    environment:
      DATABASE_URL: postgres://devuser:devpass@db:5432/myapp_db
      REDIS_URL: redis://redis:6379
    ports:
      - "3000:3000"
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    volumes:
      - ./backend/src:/app/src
      - /app/node_modules

Mount volume ./backend/src:/app/src memungkinkan hot-reload selama development tanpa rebuild image. Docker bind mount ini adalah pola umum yang direkomendasikan dalam Docker Compose documentation.

Langkah 4: Setup Reverse Proxy dengan Nginx

Buat file nginx/default.conf:

server {
    listen 80;
    server_name localhost;

    location / {
        proxy_pass http://backend:3000;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Tambahkan service nginx ke Compose:

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx/default.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - backend

Nginx berfungsi sebagai reverse proxy dan load balancer. Dengan setup ini, traffic dari port 80 akan diteruskan ke backend port 3000. Konfigurasi read-only (:ro) pada volume mencegah modifikasi file konfigurasi dari dalam container.

Langkah 5: Jalankan dan Verifikasi Stack

Di root project, jalankan:

docker compose up --build -d

Flag -d menjalankan container di background. Tunggu beberapa detik, lalu verifikasi status:

docker compose ps
docker compose logs -f backend

Cek koneksi PostgreSQL dari host:

psql postgresql://devuser:devpass@localhost:5432/myapp_db -c "\\dt"

Dan tes Redis CLI:

docker compose exec redis redis-cli ping

Jika semua merespons dengan benar, environment multi-container kamu sudah berjalan. Untuk menghentikan semua service:

docker compose down

Tambahkan flag -v jika ingin menghapus volume bersamaan, atau gunakan --rmi local untuk membersihkan image hasil build.

Kesimpulan

Docker Compose menyederhanakan orchestration untuk development environment. Dengan satu file konfigurasi, seluruh tim bisa menjalankan stack yang identik tanpa konflik dependency. Pola yang sama juga bisa diadaptasi untuk production dengan menambahkan environment variables terpisah, TLS termination, dan monitoring via Prometheus atau Datadog.

Sumber referensi: Docker Compose Official Docs, PostgreSQL Docker Hub, Redis Docker Hub

Tips Optimasi untuk Production

Setelah environment development berjalan lancar, ada beberapa optimasi yang perlu dipertimbangkan sebelum deploy ke production:

Gunakan .env file: Jangan hardcode credential di docker-compose.yml. Gunakan file .env dan referensikan dengan syntax ${VAR_NAME}.
Resource limits: Tentukan deploy.resources.limits untuk mencegah satu container menghabiskan seluruh RAM server.
Healthcheck menyeluruh: Pastikan semua service memiliki healthcheck agar Docker Swarm atau orchestrator lain bisa melakukan auto-restart.
Logging driver: Konfigurasi log rotation dengan logging.driver: json-file dan max-size: 10m agar disk tidak penuh.

Troubleshooting Umum

Berikut masalah yang sering dijumpai dan cara mengatasinya:

Port sudah digunakan: Jika port 5432 atau 6379 sudah dipakai service lain, ubah mapping port di docker-compose.yml atau hentikan service yang conflict.
Permission denied pada volume: PostgreSQL container sering mengalami permission issue saat pertama kali mounting volume. Pastikan direktori kosong atau gunakan named volume daripada bind mount untuk data persisten.
Container exit sebelum healthy: Periksa urutan depends_on. Gunakan condition: service_healthy agar backend menunggu database benar-benar siap.

Dengan memahami pola-pola di atas, kamu sudah memiliki fondasi solid untuk mengelola development environment modern berbasis container.

Tim yang mengadopsi Docker Compose sejak awal development biasanya mengalami penurunan waktu onboarding hingga 70 persen. Developer baru cukup menjalankan satu perintah dan stack langsung berjalan persis seperti di mesin developer senior. Ini adalah investasi kecil dengan dampak besar terhadap produktivitas tim jangka panjang.

Tutorial Docker Compose untuk Development Environment: Setup Multi-Container dengan Nginx, PostgreSQL, dan Redis