Multi Container #

Dalam dunia pengembangan aplikasi modern, sangat jarang sebuah aplikasi hanya terdiri dari satu komponen saja. Umumnya kita memiliki web/app server, database, cache, message broker, hingga background worker yang semuanya saling berinteraksi. Mengelola banyak container secara manual akan cepat menjadi rumit dan rawan error.

Di sinilah Docker Compose berperan penting. Docker Compose memungkinkan kita mendefinisikan, menjalankan, dan mengelola multi-container application menggunakan satu file deklaratif (docker-compose.yml). Dengan pendekatan ini, seluruh stack aplikasi dapat dijalankan secara konsisten di environment development, staging, maupun production (dengan batasan tertentu).

Artikel ini akan membahas konsep multi container, peran Docker Compose, struktur file Compose, hingga best practice yang umum digunakan di dunia nyata.

Apa Itu Multi Container Application? #

Multi container application adalah aplikasi yang terdiri dari lebih dari satu container, di mana setiap container biasanya memiliki single responsibility.

Contoh sederhana:

• Container web/app (Golang, Node.js, Ruby, dll)
• Container database (PostgreSQL, MySQL)
• Container cache (Redis)
• Container reverse proxy (Nginx)

Alih-alih menggabungkan semuanya ke dalam satu container besar (monolith container), pendekatan multi container menawarkan:

• Isolasi yang lebih baik
• Skalabilitas per komponen
• Kemudahan maintenance
• Arsitektur yang lebih dekat dengan production

Peran Docker Compose dalam Multi Container #

Docker Compose berfungsi sebagai orchestrator ringan untuk:

• Mendefinisikan service-container
• Mengatur network antar container
• Mengelola volume
• Mengatur dependency dan startup order

Semua konfigurasi ini dituliskan dalam satu file utama:

docker-compose.yml

Dengan satu perintah:

docker compose up

seluruh aplikasi multi container dapat dijalankan sekaligus.

Struktur Dasar docker-compose.yml #

Struktur umum Docker Compose:

version: "3.9"

services:
  app:
    image: my-app
    ports:
      - "8080:8080"

  db:
    image: postgres:16
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password

networks:
  default:
    driver: bridge

Komponen utama:

• services: daftar container yang akan dijalankan
• networks: jaringan virtual antar container
• volumes: penyimpanan data persisten

Contoh Arsitektur Multi Container Sederhana #

Studi Kasus: Web App + Database + Redis #

Arsitektur:

• app → aplikasi backend
• db → PostgreSQL
• redis → cache/session store

services:
  app:
    build: .
    ports:
      - "8080:8080"
    depends_on:
      - db
      - redis
    environment:
      DB_HOST: db
      REDIS_HOST: redis

  db:
    image: postgres:16
    environment:
      POSTGRES_DB: app_db
      POSTGRES_USER: app_user
      POSTGRES_PASSWORD: secret
    volumes:
      - db_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine

volumes:
  db_data:

Perhatikan:

• Nama service (db, redis) otomatis menjadi hostname
• Tidak perlu expose port database ke host

Networking Antar Container #

Secara default:

• Docker Compose membuat bridge network khusus
• Setiap service dapat saling berkomunikasi menggunakan service name

Contoh:

• App mengakses database via db:5432
• App mengakses Redis via redis:6379

Ini jauh lebih aman dibanding menggunakan localhost atau IP statis.

depends_on dan Startup Order #

depends_on membantu mengatur urutan startup container:

app:
  depends_on:
    - db

Catatan penting:

• depends_on tidak menjamin service siap digunakan
• Hanya memastikan container sudah dijalankan

Best practice:

• Gunakan healthcheck
• Atau retry logic di aplikasi

Healthcheck pada Multi Container #

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

Dengan healthcheck:

• Container lain bisa menunggu kondisi sehat
• Lebih mendekati perilaku production

Volume untuk Data Persisten #

Container bersifat ephemeral. Untuk data penting (database, upload file), gunakan volume:

volumes:
  db_data:

Keuntungan:

• Data tidak hilang saat container restart
• Mudah backup dan restore

Multi Container untuk Reverse Proxy #

Contoh arsitektur:

• nginx → reverse proxy
• app → backend service

services:
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - app

  app:
    image: my-app

Pendekatan ini umum digunakan untuk:

• SSL termination
• Load balancing
• Routing multiple service

Environment Variable & Configuration #

Best practice:

• Jangan hardcode konfigurasi sensitif
• Gunakan .env file

DB_USER=app_user
DB_PASSWORD=secret

environment:
  DB_USER: ${DB_USER}
  DB_PASSWORD: ${DB_PASSWORD}

Multi Container untuk Development vs Production #

Docker Compose sangat ideal untuk:

• Development
• Local testing
• CI pipeline

Namun untuk production:

• Docker Compose bukan full orchestrator
• Tidak memiliki auto-healing, auto-scaling bawaan

Biasanya Compose digunakan untuk:

• Single VM
• Small production setup

Sedangkan skala besar beralih ke:

• Kubernetes
• Nomad
• ECS

Best Practice #

1. Satu container = satu tanggung jawab

2. Jangan expose port yang tidak perlu

3. Gunakan volume untuk data penting

4. Gunakan service name sebagai hostname

5. Pisahkan konfigurasi via environment variable

6. Gunakan healthcheck

7. Buat file Compose terpisah per environment

   • docker-compose.yml
   • docker-compose.dev.yml
   • docker-compose.prod.yml

Penutup #

Docker Compose adalah solusi praktis dan elegan untuk mengelola multi container application, terutama pada fase development dan small-scale production. Dengan pendekatan deklaratif, arsitektur aplikasi menjadi lebih jelas, konsisten, dan mudah direproduksi di berbagai environment.

Memahami konsep multi container sejak awal akan mempermudah transisi ke orchestrator yang lebih kompleks seperti Kubernetes, karena prinsip dasarnya tetap sama: service terpisah, terisolasi, dan saling terhubung melalui network.