Apa itu Docker Compose? #

Docker Compose adalah tool yang melengkapi Docker untuk mengelola aplikasi multi-container. Saat aplikasimu tumbuh dari satu service menjadi beberapa service yang saling tergantung, menjalankan container satu per satu dengan docker run menjadi tidak praktis. Docker Compose menjawab kebutuhan itu dengan satu file deklaratif yang mendefinisikan seluruh stack aplikasi.

Artikel ini membahas konsep dasar Docker Compose — apa itu, bagaimana cara kerjanya, kapan harus dipakai, dan perbedaannya dengan pendekatan docker run manual. Setelah memahami ini, kamu akan siap masuk ke pembahasan struktur file docker-compose.yml dan konfigurasi lanjutan.

Masalah yang Diselesaikan Docker Compose #

Pada aplikasi sederhana, satu container mungkin cukup. Tapi hampir semua aplikasi production modern terdiri dari banyak service: web app, database, cache, message broker, reverse proxy, monitoring agent, dan lain-lain. Mengelola semua itu dengan docker run di command line sangat menyakitkan.

Bayangkan setup seperti ini dengan docker run:

docker network create app-network
docker volume create pg-data
docker run -d --name postgres --network app-network -v pg-data:/var/lib/postgresql/data -e POSTGRES_PASSWORD=secret postgres:16
docker run -d --name redis --network app-network redis:7
docker run -d --name api --network app-network -e DATABASE_URL=postgres://postgres:secret@postgres:5432/myapp -e REDIS_URL=redis://redis:6379 -p 8080:8080 myapi:latest
docker run -d --name web --network app-network -p 3000:3000 myweb:latest

Empat baris perintah, masing-masing panjang, harus dijalankan dalam urutan tertentu, banyak parameter yang harus diingat. Kalau satu gagal, kamu harus rollback manual. Kalau ada developer baru yang mau menjalankan stack ini, mereka harus mencatat semua perintah itu.

Dengan Docker Compose, semua itu jadi satu file:

# docker-compose.yml
services:
  postgres:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: secret
    volumes:
      - pg-data:/var/lib/postgresql/data

  redis:
    image: redis:7

  api:
    image: myapi:latest
    environment:
      DATABASE_URL: postgres://postgres:secret@postgres:5432/myapp
      REDIS_URL: redis://redis:6379
    ports:
      - "8080:8080"
    depends_on:
      - postgres
      - redis

  web:
    image: myweb:latest
    ports:
      - "3000:3000"
    depends_on:
      - api

volumes:
  pg-data:

Dan untuk menjalankan semuanya:

docker compose up

Satu perintah. Stack aplikasi lengkap berdiri dalam hitungan detik. Developer baru cukup git clone lalu docker compose up — selesai.

Definisi Docker Compose #

Docker Compose adalah tool untuk mendefinisikan dan menjalankan aplikasi Docker multi-container. Dengan Compose, kamu menggunakan file YAML untuk mengkonfigurasi service aplikasi. Lalu, dengan satu perintah, kamu membuat dan menjalankan semua service dari konfigurasi itu.

Karakteristik utama:

• File tunggal sebagai source of truth — semua konfigurasi di satu tempat.
• Deklaratif — kamu deklarasikan apa yang kamu mau, Compose yang memikirkan bagaimana caranya.
• Idempotent — menjalankan docker compose up beberapa kali menghasilkan state akhir yang sama.
• Lifecycle management — start, stop, restart, scale, logs, semua tersedia via command line yang konsisten.
• Environment-specific — bisa punya beberapa file (default, development, production) yang digabung sesuai kebutuhan.

Docker Compose adalah project official dari Docker Inc. dan tersedia di semua instalasi Docker modern. Sejak Docker Compose V2, tool ini terintegrasi langsung dengan Docker CLI (docker compose) — bukan sebagai binary terpisah lagi.

Sejarah Singkat #

Docker Compose pertama kali diperkenalkan tahun 2014 sebagai project terpisah (docker-compose dengan dash). Awalnya ia adalah Python script yang berkomunikasi dengan Docker daemon via Docker Remote API.

Tonggak penting:

• 2014 — Compose v1 dirilis sebagai project terpisah.
• 2017 — Compose Specification dipindahkan ke basis Go.
• 2020 — Compose V2 (docker compose dengan spasi) diumumkan, ditulis ulang dalam Go dan terintegrasi dengan Docker CLI.
• 2023 — Compose V2 menjadi default; V1 di-deprecate.

Pada Compose V2, docker compose adalah bagian dari Docker CLI itu sendiri (bukan binary terpisah). Ini membuat pengalaman lebih konsisten dan menghilangkan overhead parsing YAML yang dulu ada di V1.

Catatan migrasi: Jika kamu punya script lama yang menggunakan docker-compose (dengan dash), instalasi Docker modern biasanya menyediakannya sebagai wrapper. Tapi untuk kode baru, selalu gunakan docker compose (dengan spasi). Perintah V1 sudah di-deprecate.

Cara Kerja Docker Compose #

Docker Compose bekerja dalam tiga langkah: baca file, buat resource, jalankan.

flowchart LR
    A[docker-compose.yml] -->|compose parse| B[In-memory spec]
    B -->|compose convert| C[Container, Network, Volume]
    C -->|compose up| D[Running Stack]
    D -->|compose down| E[Removed Stack]
    A2[.env file] --> A
    A3[override.yml] --> A

1. Parse — docker compose membaca file docker-compose.yml (dan file-file tambahan seperti .env atau docker-compose.override.yml), lalu mengubahnya menjadi representasi internal.

2. Convert — representasi internal diterjemahkan menjadi resource Docker konkret: container, network, volume, dan lain-lain.

3. Run — resource dijalankan. Untuk setiap service, Compose membuat container dengan konfigurasi yang sesuai. Service yang punya depends_on menunggu dependency-nya siap dulu.

File docker-compose.yml tidak menggantikan Dockerfile. Keduanya saling melengkapi:

• Dockerfile mendefinisikan image (apa yang dijalankan di dalam container).
• docker-compose.yml mendefinisikan stack (container apa saja yang dijalankan, network, volume, environment).

flowchart TB
    subgraph Compose["docker-compose.yml"]
        S1[Service 1: image apa? port? env?]
        S2[Service 2: image apa? port? env?]
        S3[Service 3: image apa? port? env?]
    end
    subgraph Dockerfile["Dockerfile"]
        I[Image: OS + runtime + app code]
    end
    S1 --> I

Pada prakteknya, service di Compose bisa menggunakan image dari registry (Postgres, Redis, nginx) atau image yang di-build lokal dari Dockerfile (build: ./path/to/Dockerfile).

Perbedaan dengan docker run #

docker run dan Compose bukan lawan — mereka saling melengkapi. docker run adalah perintah untuk menjalankan satu container. Compose adalah cara mengorkestrasi banyak container sekaligus.

Kapan pakai docker run:

• Eksperimen singkat (test satu image).
• Production deployment yang sudah di-orchestrasi oleh Kubernetes atau platform lain.
• Script sekali pakai.

Kapan pakai Docker Compose:

• Multi-container application.
• Local development environment.
• Small-to-medium production deployment.
• CI/CD pipeline yang butuh spin up/down environment.
• Demo dan prototyping.

Use Case Docker Compose #

Local Development #

Paling umum. Developer menjalankan stack lengkap (app, database, cache, message broker) dengan satu perintah. Identik dengan production (atau sedekat mungkin), sehingga bug yang muncul di local akan muncul juga di production.

# Developer clone repo, lalu:
docker compose up

Seluruh stack jalan di laptop mereka. Tidak perlu install Postgres, Redis, atau service lain secara manual.

Automated Testing #

CI/CD pipeline menjalankan test yang butuh environment terisolasi. Docker Compose memungkinkan setup yang cepat dan cleanup otomatis.

# docker-compose.test.yml
services:
  app:
    build: .
    environment:
      DATABASE_URL: postgres://test:test@db:5432/test
    depends_on:
      - db

  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: test

CI script: docker compose -f docker-compose.test.yml up --abort-on-container-exit. Container app menjalankan test, lalu otomatis exit. CI baca exit code.

Demo dan Prototyping #

Untuk demo ke stakeholder atau eksperimen singkat, Compose memungkinkan setup yang cepat dan reproducible. Hapus folder, run docker compose up, dan demo environment kembali berdiri.

Small Production Deployment #

Untuk traffic rendah sampai menengah, Compose bisa langsung dipakai di production. Dengan reverse proxy (Traefik, Caddy) di depan dan image yang baik, ini cukup untuk banyak use case.

Tapi untuk traffic tinggi, multi-host, atau high availability, kamu butuh orchestrator yang lebih powerful (Kubernetes, Docker Swarm, atau platform managed seperti ECS/GKE/AKS).

CI/CD Ephemeral Environment #

Beberapa platform CI/CD (GitLab CI, GitHub Actions dengan self-hosted runner) mendukung Docker Compose untuk membuat ephemeral environment per branch atau per merge request. Container berdiri saat pipeline jalan, dihapus saat selesai.

Lifecycle Commands #

Docker Compose menyediakan beberapa perintah untuk mengelola lifecycle stack.

Untuk task tertentu:

# Lihat log dengan follow
docker compose logs -f --tail 100

# Eksekusi di container yang jalan
docker compose exec db psql -U postgres

# Scale service tertentu
docker compose up -d --scale worker=3

# Validasi docker-compose.yml tanpa menjalankan
docker compose config

Struktur File docker-compose.yml #

File docker-compose.yml adalah inti dari Docker Compose. Ia menggunakan format YAML dengan struktur hierarkis.

# Versi schema (opsional di Compose V2, dihilangkan untuk kompatibilitas)
version: "3.8"

# Daftar service
services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html:ro
    depends_on:
      - api

  api:
    build: ./api
    environment:
      DATABASE_URL: postgres://user:pass@db:5432/myapp
    depends_on:
      - db

  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: secret
    volumes:
      - db-data:/var/lib/postgresql/data

# Volume yang digunakan
volumes:
  db-data:

# Network yang digunakan (jika perlu custom)
networks:
  backend:

Setiap service punya konfigurasi: image (atau build), port, environment, volume, dependency, dan lain-lain. Top-level keys juga termasuk volumes dan networks untuk deklarasi resource yang dipakai service.

Artikel selanjutnya di section ini akan membahas setiap bagian secara detail: cara mendefinisikan service, menggunakan variable, mengatur network, healthcheck, dan best practice penulisan docker-compose.yml.

Keterbatasan Docker Compose #

Walau powerful, Docker Compose punya keterbatasan yang perlu dipahami:

• Single host only — Compose menjalankan semua service di satu host. Untuk multi-host, kamu butuh orchestrator (Kubernetes, Swarm).
• Tidak ada auto-scaling bawaan — --scale flag menskalakan jumlah container, tapi tidak ada autoscaling berdasarkan metric (CPU, traffic).
• Tidak ada self-healing — kalau container crash, Compose tidak otomatis restart (kecuali diset restart: always).
• Tidak ada rolling update — docker compose up recreate container sekaligus, tidak ada zero-downtime deploy.
• Tidak ada service discovery antar host — semua service harus reachable di network yang sama.

Untuk kebutuhan yang lebih advanced, pertimbangkan:

• Docker Swarm — orchestrator bawaan Docker, sederhana tapi jarang dipakai di industri.
• Kubernetes — standar industri, paling powerful, paling kompleks.
• AWS ECS / Fargate — managed container service dari AWS.
• Google Cloud Run — serverless container, auto-scale ke 0.

Kapan TIDAK Perlu Docker Compose #

Docker Compose bukan jawaban universal. Ada situasi di mana ia berlebihan atau kurang tepat.

• Single-container aplikasi — kalau aplikasimu benar-benar satu service tanpa dependency, cukup docker run atau bahkan tanpa Docker sama sekali.
• Multi-host production — Compose jalan di satu host. Untuk multi-host, kamu butuh Kubernetes, Swarm, atau platform managed.
• Autoscaling berdasarkan metric — Compose tidak punya mekanisme untuk auto-scale berdasarkan CPU atau traffic. Butuh Kubernetes HPA atau platform equivalent.
• Rolling update — Compose recreate container sekaligus. Untuk zero-downtime deploy, butuh orchestrator dengan rolling update support.

Kapan Compose tepat? Stack aplikasi yang berjalan di satu host, dengan beberapa service yang saling tergantung. Itu sweet spot Compose. Untuk skala dan kompleksitas yang lebih besar, naik ke Kubernetes atau platform managed.

Migrasi dari docker run ke Compose #

Jika kamu sudah punya setup berbasis docker run dan ingin migrate ke Compose, prosesnya mudah. Ambil setiap perintah docker run dan ubah menjadi service di YAML.

Contoh migrasi:

# Perintah docker run
docker run -d \
  --name postgres \
  -e POSTGRES_USER=app \
  -e POSTGRES_PASSWORD=secret \
  -e POSTGRES_DB=myapp \
  -v pg-data:/var/lib/postgresql/data \
  --network app-net \
  --restart unless-stopped \
  postgres:16-alpine

Menjadi service di Compose:

services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: secret
      POSTGRES_DB: myapp
    volumes:
      - pg-data:/var/lib/postgresql/data
    networks:
      - app-net
    restart: unless-stopped

Mapping flag docker run → field Compose:

Setelah migrasi, bandingkan behavior — jalankan docker compose up dan pastikan semua service jalan seperti sebelumnya. Cek port yang di-expose, volume yang di-mount, environment variable, dan network connectivity antar service.

Interaksi dengan Docker Lainnya #

Docker Compose bukan tool terpisah — ia bagian dari ekosistem Docker. Beberapa interaksi penting:

• docker context — Compose menghormati context Docker yang aktif. Gunakan docker context use production sebelum docker compose up untuk deploy ke remote host.
• docker buildx — Build cache dan multi-platform build via buildx bisa dipakai oleh Compose lewat field builder (eksperimental).
• docker scan — Security scanning per image masih dilakukan per service. Tidak ada docker compose scan built-in (per workflow di V2).
• docker system — docker compose tidak menghapus image yang di-build. Gunakan docker image prune atau docker system prune untuk cleanup.

Best Practice Ringkas #

• Satu file docker-compose.yml per project — tidak perlu banyak file kecuali untuk environment berbeda.
• Gunakan .env untuk secret dan konfigurasi — jangan hardcode di YAML.
• Naming convention — gunakan nama service yang menjelaskan fungsinya, mis. web, api, db, redis, bukan container1.
• Image tag eksplisit — postgres:16-alpine, bukan postgres:latest. Hindari surprise saat update.
• Healthcheck di service critical — agar dependency-aware startup bisa berfungsi dengan benar.
• Volume untuk data persisten — selalu, untuk database, upload, log penting.
• .dockerignore di context build — exclude node_modules, .git, dll agar build context kecil.

Ringkasan #

• Docker Compose adalah tool untuk mendefinisikan dan menjalankan aplikasi multi-container via satu file YAML (docker-compose.yml).
• Masalah yang dipecahkan — mengelola banyak container dengan docker run itu tidak praktis. Compose membawa reproducibility, dokumentasi built-in, dan lifecycle management.
• Cara kerja — Compose parse file YAML → convert ke resource Docker → jalankan container dengan dependency yang benar. Sejak V2, Compose terintegrasi dengan Docker CLI (docker compose).
• File docker-compose.yml ≠ Dockerfile — Dockerfile mendefinisikan image, Compose mendefinisikan stack. Mereka saling melengkapi.
• Use case paling umum — local development, automated testing, demo, dan small-to-medium production deployment.
• Lifecycle commands — up, down, ps, logs, exec, build, pull, restart, stop, start, dan top.
• Keterbatasan — single host only, tidak ada autoscaling/self-healing bawaan, tidak ada rolling update. Untuk multi-host dan high availability, butuh Kubernetes atau platform managed.
• Compose bukan pengganti orchestrator — untuk production serius, Compose cukup untuk dev/test/small prod, tapi Kubernetes atau ECS untuk skala besar.

← Sebelumnya: Best Practice Dockerfile   Berikutnya: Struktur File →