# Docker Compose 2026: Aplikasi Multi-Container, Jaringan, dan Pertanyaan Interview DevOps

> Pelajari Docker Compose untuk aplikasi multi-container dengan networking, volumes, dan deployment produksi. Dilengkapi pertanyaan interview DevOps.

- Published: 2026-08-03
- Updated: 2026-08-03
- Author: SharpSkill
- Reading time: 5 min

---

Docker Compose tetap menjadi alat utama untuk mendefinisikan dan menjalankan aplikasi Docker multi-container pada tahun 2026. Baik untuk mengorkestrasi stack development lokal maupun mempersiapkan interview DevOps, pemahaman tentang networking Compose, dependency service, dan pola produksi membedakan engineer junior dari praktisi senior.

> **Poin Penting**
>
> Docker Compose menggunakan format YAML deklaratif untuk mendefinisikan services, networks, dan volumes dalam satu file. Menjalankan `docker compose up` akan memulai seluruh stack aplikasi dengan jaringan terisolasi dan penyimpanan persisten.

## Memahami Arsitektur Docker Compose

Docker Compose beroperasi berdasarkan prinsip sederhana: definisikan services aplikasi dalam file `compose.yaml` (konvensi penamaan modern menggantikan `docker-compose.yml`), dan Compose menangani pembuatan container, networking, dan manajemen lifecycle.

[Spesifikasi Docker Compose](https://docs.docker.com/compose/compose-file/) mendefinisikan tiga konsep inti:

- **Services**: Konfigurasi container termasuk image, build context, environment variables, dan resource limits
- **Networks**: Channel komunikasi terisolasi antar services
- **Volumes**: Penyimpanan data persisten yang bertahan setelah container restart

```yaml
# compose.yaml
services:
  api:
    build: ./api
    ports:
      - "3000:3000"
    environment:
      - DATABASE_URL=postgres://db:5432/app
    depends_on:
      db:
        condition: service_healthy
    networks:
      - backend

  db:
    image: postgres:16
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=app
      - POSTGRES_PASSWORD_FILE=/run/secrets/db_password
    secrets:
      - db_password
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5
    networks:
      - backend

networks:
  backend:
    driver: bridge

volumes:
  postgres_data:

secrets:
  db_password:
    file: ./secrets/db_password.txt
```

Konfigurasi ini mendemonstrasikan beberapa pola production-ready: health checks untuk dependency ordering, Docker secrets untuk data sensitif, named volumes untuk persistensi, dan definisi network eksplisit.

## Mendalami Docker Compose Networking

Secara default, Compose membuat satu network untuk aplikasi. Semua services bergabung ke network ini dan dapat saling menjangkau menggunakan nama service sebagai hostname. Memahami model networking ini fundamental untuk [migrasi Kubernetes](/blog/devops/kubernetes-deploying-first-application) nantinya.

```yaml
# compose.yaml
services:
  frontend:
    build: ./frontend
    ports:
      - "80:80"
    networks:
      - frontend-net
      - backend-net

  api:
    build: ./api
    networks:
      - backend-net

  cache:
    image: redis:7-alpine
    networks:
      - backend-net

  db:
    image: postgres:16
    networks:
      - backend-net

networks:
  frontend-net:
    driver: bridge
  backend-net:
    driver: bridge
    internal: true
```

Flag `internal: true` mencegah backend network mengakses internet eksternal. Service frontend menjembatani kedua network, bertindak sebagai satu-satunya titik masuk. Segmentasi network ini mencerminkan praktik keamanan produksi.

> **Resolusi DNS**
>
> Server DNS embedded Docker menyelesaikan nama service secara otomatis. Service `api` dapat menjangkau database di `db:5432` tanpa konfigurasi IP manual.

## Multi-Stage Builds dengan Compose

Image produksi harus minimal. Multi-stage builds dikombinasikan dengan Compose profiles memungkinkan konfigurasi berbeda untuk development dan produksi.

```dockerfile
# api/Dockerfile
# Stage 1: Build
FROM node:22-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production
FROM node:22-alpine AS production
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package*.json ./
USER node
EXPOSE 3000
CMD ["node", "dist/index.js"]

# Stage 3: Development
FROM node:22-alpine AS development
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
USER node
CMD ["npm", "run", "dev"]
```

```yaml
# compose.yaml
services:
  api:
    build:
      context: ./api
      target: ${BUILD_TARGET:-production}
    volumes:
      - ${API_VOLUMES:-./api/dist:/app/dist:ro}
    profiles:
      - ${COMPOSE_PROFILES:-prod}
```

Menjalankan `BUILD_TARGET=development COMPOSE_PROFILES=dev docker compose up` memulai konfigurasi development dengan hot reload.

## Service Dependencies dan Health Checks

Direktif `depends_on` mengontrol urutan startup, tetapi container yang dimulai tidak berarti service sudah siap. Health checks menyelesaikan masalah timing ini—pola yang sering ditanyakan dalam [interview DevOps](/blog/devops/essential-devops-interview-questions).

```yaml
# compose.yaml
services:
  api:
    build: ./api
    depends_on:
      db:
        condition: service_healthy
      cache:
        condition: service_started
      migrations:
        condition: service_completed_successfully

  migrations:
    build: ./api
    command: npm run migrate
    depends_on:
      db:
        condition: service_healthy

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

  cache:
    image: redis:7-alpine
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 3
```

Tiga kondisi dependency tersedia:
- `service_started`: Default, container telah dimulai
- `service_healthy`: Health check berhasil
- `service_completed_successfully`: Container exit dengan kode 0 (untuk init containers)

## Docker Compose untuk Development Lokal

Lingkungan development mendapat manfaat dari bind mounts, environment overrides, dan debugging tools. File `compose.override.yaml` secara otomatis digabungkan dengan `compose.yaml`.

```yaml
# compose.yaml (konfigurasi dasar)
services:
  api:
    build: ./api
    environment:
      - NODE_ENV=production

  db:
    image: postgres:16
```

```yaml
# compose.override.yaml (override development)
services:
  api:
    build:
      target: development
    volumes:
      - ./api:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
      - DEBUG=app:*
    ports:
      - "9229:9229"

  db:
    ports:
      - "5432:5432"
```

Anonymous volume `/app/node_modules` mencegah node_modules host menimpa dependencies yang terinstall di container.

## Pola Deployment Produksi

Docker Compose cocok untuk deployment produksi single-host. Untuk orkestrasi multi-host, [Kubernetes dengan Helm](/blog/devops/kubernetes-helm-charts-2026-packaging-deployment-interview-questions) menyediakan scaling lebih baik, tetapi Compose tetap viable untuk aplikasi kecil.

```yaml
# compose.prod.yaml
services:
  api:
    image: registry.example.com/api:${VERSION:-latest}
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: "0.5"
          memory: 512M
        reservations:
          cpus: "0.25"
          memory: 256M
      restart_policy:
        condition: on-failure
        delay: 5s
        max_attempts: 3
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./certs:/etc/nginx/certs:ro
    depends_on:
      - api
```

Key `deploy` mengkonfigurasi resource limits, jumlah replika, dan restart policies. Menjalankan `docker compose -f compose.prod.yaml up -d` memulai stack produksi dalam mode detached.

## Environment Variables dan Manajemen Secrets

Konfigurasi sensitif memerlukan penanganan yang tepat. Docker Compose mendukung beberapa pendekatan, dari file `.env` hingga Docker secrets.

```bash
# .env
POSTGRES_PASSWORD=dev_password_only
API_SECRET_KEY=local_dev_key
```

```yaml
# compose.yaml
services:
  api:
    environment:
      - API_SECRET_KEY  # Mewarisi dari shell atau .env
      - DATABASE_URL=postgres://user:${POSTGRES_PASSWORD}@db:5432/app
    env_file:
      - ./config/api.env
```

Untuk produksi, Docker secrets menyediakan keamanan lebih baik dengan mounting data sensitif sebagai file daripada environment variables:

```yaml
# compose.prod.yaml
services:
  api:
    secrets:
      - api_key
      - db_password
    environment:
      - API_KEY_FILE=/run/secrets/api_key

secrets:
  api_key:
    external: true
  db_password:
    file: ./secrets/db_password.txt
```

> **Catatan Keamanan**
>
> Jangan pernah commit file `.env` yang berisi secrets produksi ke version control. Gunakan manajemen secret eksternal seperti HashiCorp Vault atau solusi cloud provider untuk deployment produksi.

## Pertanyaan Interview DevOps Umum tentang Docker Compose

Pewawancara menguji pemahaman konsep Compose melalui skenario praktis. Pertanyaan-pertanyaan ini sering muncul dalam interview DevOps dan platform engineering.

**T: Bagaimana container dalam network Compose berkomunikasi?**

Docker membuat dedicated bridge network untuk setiap project Compose. Services berkomunikasi menggunakan nama service sebagai hostname. Server DNS embedded menyelesaikan nama-nama ini ke alamat IP container. Traffic eksternal hanya dapat menjangkau services melalui port yang dipublikasikan secara eksplisit.

**T: Apa yang terjadi ketika menjalankan `docker compose up` dengan container yang sudah ada?**

Compose membandingkan konfigurasi saat ini dengan container yang sedang berjalan. Services yang tidak berubah tetap berjalan. Services yang dimodifikasi dibuat ulang dengan pengaturan baru. Services baru dimulai dari awal. Services yang dihapus dihentikan dan dihapus.

**T: Bagaimana menangani migrasi database di Compose?**

Dua pola tersedia. Pertama, gunakan init container dengan dependency `service_completed_successfully`:

```yaml
services:
  migrate:
    image: api:latest
    command: npm run migrate
    depends_on:
      db:
        condition: service_healthy

  api:
    depends_on:
      migrate:
        condition: service_completed_successfully
```

Kedua, sertakan logika migrasi dalam script startup aplikasi, memeriksa dan menerapkan migrasi pending sebelum menerima traffic.

**T: Apa perbedaan volumes dan bind mounts?**

Named volumes dikelola oleh Docker, disimpan di `/var/lib/docker/volumes`, dan portable antar host. Bind mounts memetakan direktori host langsung ke dalam container, berguna untuk development tetapi tergantung environment. Volumes mendukung driver untuk penyimpanan remote seperti NFS atau cloud block storage.

**T: Apa perbedaan `docker-compose` dan `docker compose`?**

`docker-compose` dengan tanda hubung adalah tool standalone berbasis Python V1, sekarang deprecated. `docker compose` dengan spasi adalah implementasi V2 berbasis Go yang terintegrasi ke Docker CLI. V2 lebih cepat, mendukung Compose Specification sepenuhnya, dan menerima pengembangan aktif.

## Debugging Aplikasi Compose

Troubleshooting aplikasi containerized memerlukan teknik spesifik. Perintah-perintah ini mengungkap apa yang terjadi di dalam stack Compose:

```bash
# Lihat logs dari semua services
docker compose logs -f

# Logs dari service spesifik dengan timestamps
docker compose logs -f --timestamps api

# Eksekusi command di container yang berjalan
docker compose exec api sh

# Jalankan command sekali (memulai container baru)
docker compose run --rm api npm test

# Lihat penggunaan resource
docker compose top
docker stats

# Inspeksi konfigurasi network
docker network inspect project_backend

# Validasi compose file
docker compose config
```

Perintah `docker compose config` menggabungkan semua compose files dan menampilkan konfigurasi final—sangat berharga untuk debugging masalah interpolasi variabel.

## Kesimpulan

- Docker Compose mendefinisikan aplikasi multi-container dalam satu file YAML dengan services, networks, dan volumes
- Services berkomunikasi via DNS menggunakan nama service sebagai hostname dalam default bridge network
- Health checks dengan kondisi `service_healthy` memastikan urutan startup yang tepat
- Gunakan `compose.override.yaml` untuk pengaturan khusus development seperti bind mounts dan debug ports
- Deployment produksi mendapat manfaat dari resource limits, restart policies, dan Docker secrets untuk data sensitif
- CLI `docker compose` (V2) menggantikan `docker-compose` (V1) yang deprecated dengan performa dan fitur lebih baik

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/id/blog/devops/docker-compose-2026-multi-container-networking-devops-interview