Docker Compose untuk Multi-Service: Menjalankan Aplikasi dan Database secara Bersamaan

Menjalankan satu container Docker untuk aplikasi sederhana adalah langkah awal. Namun, aplikasi production nyata membutuhkan kombinasi service: web server, database, cache, message queue, dan lainnya. Mengelola container-container ini secara manual dengan docker run menjadi tidak praktis dan rentan error. Docker Compose adalah tool yang memungkinkan kita mendefinisikan dan menjalankan multi-container application dalam satu file konfigurasi.

Mengapa Multi-Service Orchestration Penting

Aplikasi modern terdiri dari komponen terpisah yang saling berkomunikasi. Sebuah web app memerlukan database untuk persistence, Redis untuk caching, dan mungkin Elasticsearch untuk search. Menjalankan masing-masing dengan command terpisah menyebabkan beberapa masalah: dependency harus dijalankan dalam urutan tertentu, environment variables tersebar di berbagai tempat, dan cleanup menjadi rumit.

Docker Compose menyederhanakan ini dengan declarative configuration. Kita definisikan semua service, network, dan volume dalam satu docker-compose.yml. Satu command docker compose up menjalankan seluruh stack secara konsisten di semua environment.

Struktur File docker-compose.yml

File docker-compose.yml menggunakan format YAML dengan beberapa key komponen utama. Setiap service adalah container yang akan dijalankan. Network memungkinkan container saling berkomunikasi. Volume digunakan untuk persistent storage.

version: '3.8'

services:
  # Define individual services here

networks:
  # Define custom networks

volumes:
  # Define named volumes

Version directive menentukan format file. Services block berisi definisi container. Setiap service memiliki konfigurasi image, ports, environment variables, dan dependencies.

Contoh Stack: Node.js + PostgreSQL + Redis

Mari kita buat stack lengkap dengan tiga service: aplikasi Node.js sebagai backend, PostgreSQL sebagai database, dan Redis untuk caching. Konfigurasi ini merepresentasikan arsitektur common untuk web application.

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: node-app
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
      - DATABASE_URL=postgresql://postgres:password@db:5432/myapp
      - REDIS_URL=redis://cache:6379
    depends_on:
      - db
      - cache
    networks:
      - app-network
    volumes:
      - .:/app
      - /app/node_modules

  db:
    image: postgres:15-alpine
    container_name: postgres-db
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=myapp
    ports:
      - "5432:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - app-network

  cache:
    image: redis:7-alpine
    container_name: redis-cache
    ports:
      - "6379:6379"
    networks:
      - app-network

volumes:
  postgres-data:

networks:
  app-network:
    driver: bridge

Service app menggunakan build context untuk membangun image dari Dockerfile lokal. Port mapping 3000:3000 mengekspos aplikasi ke host. Environment variables menyediakan connection string ke database dan cache.

Service db menggunakan official PostgreSQL image dari Docker Hub. Environment variables mengkonfigurasi initial database credentials. Named volume postgres-data memastikan data tetap persisten meskipun container di-restart.

Service cache menggunakan Redis Alpine image yang lightweight. Tidak ada volume karena Redis dalam contoh ini hanya untuk cache yang boleh hilang saat restart.

Mengelola Service Dependencies

Container sering memiliki startup order requirements. Database harus ready sebelum aplikasi mencoba connect. Directive depends_on mengekspresikan dependency ini.

services:
  app:
    depends_on:
      - db
      - cache

Namun, depends_on hanya menunggu container start, bukan service ready. PostgreSQL container mungkin sudah berjalan, tetapi database belum siap menerima connection. Untuk production-grade dependency management, gunakan wait-for-it script atau health checks.

services:
  app:
    depends_on:
      db:
        condition: service_healthy

  db:
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5

Healthcheck memastikan Docker menunggu sampai database benar-benar ready sebelum menandai service sebagai healthy.

Environment Variables dan File .env

Hardcoding credentials dalam docker-compose.yml adalah bad practice untuk production. Docker Compose mendukung environment variable substitution dan file .env terpisah.

services:
  db:
    environment:
      - POSTGRES_USER=${DB_USER}
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_DB=${DB_NAME}

File .env di direktori yang sama:

DB_USER=postgres
DB_PASSWORD=securepassword123
DB_NAME=myapp

Docker Compose secara otomatis membaca file .env dan mensubstitusi variabel. File .env ditambahkan ke .gitignore untuk menjaga credential tetap private.

Networking Antar Service

Docker Compose secara otomatis membuat default network yang menghubungkan semua service. Setiap service dapat mengakses service lain menggunakan service name sebagai hostname.

Dalam contoh kita:

• Aplikasi Node.js connect ke database dengan hostname db
• Aplikasi connect ke Redis dengan hostname cache
• Port internal dapat diakses tanpa publish ke host

Custom network dengan driver bridge memberikan isolasi lebih baik. Service hanya dapat berkomunikasi jika berada dalam network yang sama.

Command untuk Mengelola Multi-Service Stack

Docker Compose CLI menyediakan command untuk lifecycle management lengkap.

# Build dan jalankan semua service dalam background
docker compose up -d

# Melihat status service yang berjalan
docker compose ps

# Melihat logs dari semua service
docker compose logs -f

# Melihat logs dari service spesifik
docker compose logs -f app

# Restart service tertentu
docker compose restart app

# Scale service ke multiple instance
docker compose up -d --scale app=3

# Stop dan hapus semua container
docker compose down

# Stop, hapus container dan volume
docker compose down -v

Command up -d membangun image jika diperlukan, membuat network dan volume, lalu menjalankan container dalam detached mode. Command down membersihkan semua resources yang dibuat Compose.

Development Workflow dengan Docker Compose

Untuk development, bind mount memungkinkan live reload. Source code di host di-mount ke dalam container. Perubahan file langsung terlihat tanpa rebuild image.

services:
  app:
    volumes:
      - .:/app
      - /app/node_modules

Volume kedua untuk node_modules adalah anonymous volume yang mencegah bind mount menimpa dependencies yang di-install dalam container.

Best Practices untuk Production

Konfigurasi development dan production berbeda. Gunakan multiple Compose file untuk environment-specific overrides.

# Base configuration
docker-compose.yml

# Production overrides
docker-compose.prod.yml

Command untuk production:

docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

File production dapat menonaktifkan bind mounts, menggunakan image pre-built dari registry, dan mengaktifkan restart policies.

services:
  app:
    image: myregistry.com/myapp:latest
    restart: unless-stopped
    deploy:
      replicas: 2

Kesimpulan

Docker Compose mengubah cara kita mengembangkan dan mendeploy multi-service application. Satu file konfigurasi mendefinisikan seluruh stack, memastikan consistency across environments. Service discovery otomatis melalui DNS, dependency management, dan networking built-in mengurangi complexity operational.

Ingin menguasai container orchestration dan modern DevOps practices? Bergabunglah di DevOps Engineering Bootcamp Rumah Coding. Program hands-on mencakup Docker, Kubernetes, CI/CD pipelines, dan cloud deployment untuk mempersiapkan karir di dunia DevOps.