Panduan Docker Compose: Mempermudah Pengembangan Multi-Container

Docker Compose menyederhanakan pengelolaan aplikasi Docker multi-container, memungkinkan pengembang menulis dan menjalankan aplikasi kompleks dengan mudah.

Engineer DevOps tingkat menengah, pengembang backend, dan pengembang cloud-native, khususnya yang mengerjakan arsitektur microservices atau multi-layanan, sering menghadapi tantangan mengelola banyak container yang saling terhubung. Docker Compose mengatasi kompleksitas ini, mempermudah alur kerja pengembangan dan pengujian.

Dalam artikel ini, Anda akan mempelajari semua yang Anda perlukan untuk menggunakan Docker Compose. Lihat Panduan Docker untuk Pemula jika Anda baru memulai dengan Docker.

Apa itu Docker Compose?

Docker Compose adalah alat yang dirancang untuk mendefinisikan dan mengorkestrasi aplikasi Docker multi-container melalui satu file konfigurasi YAML.

Dengan Compose, Anda dapat dengan mudah menentukan layanan, jaringan, volume, pengaturan lingkungan, dan dependensi. Ini ideal untuk pengembangan lokal, pengaturan pengujian, pembuatan prototipe cepat, dan lingkungan produksi skala kecil.

Kasus penggunaan umum Docker Compose mencakup pembuatan lingkungan lokal yang mencerminkan sistem dunia nyata, seperti arsitektur microservices. Dengan mendefinisikan interaksi komponen secara jelas, Compose memberikan konsistensi, kemudahan penggunaan, dan siklus iterasi yang lebih cepat.

Anda mungkin bertanya mengapa tidak langsung menggunakan Kubernetes. Pertama, itu berlebihan untuk proyek kecil dan pengujian lokal. Seperti yang akan Anda temukan di tutorial Kubernetes vs. Docker kami, Kubernetes lebih cocok untuk mengelola banyak container di seluruh klaster. Kursus Containerization and Virtualization with Docker and Kubernetes kami membahas lebih dalam cara membangun dan menerapkan aplikasi dengan Docker dan Kubernetes.

Mengapa Menggunakan Docker Compose vs. Perintah Docker Manual?

Mengelola banyak container secara individual dapat dengan cepat menjadi kacau karena:

• Urutan dependensi yang kompleks,
• Lingkungan yang tidak konsisten, dan
• Masalah skalabilitas.

Dengan perintah manual, Anda berisiko melakukan kesalahan manusia, penyimpangan konfigurasi, dan alur kerja yang tidak efisien.

Docker Compose membantu menyelesaikan masalah ini dengan mendefinisikan semua layanan aplikasi dan dependensinya dalam satu file YAML. Ini menghadirkan konsistensi, skalabilitas, dan kemudahan pengelolaan dependensi, secara signifikan mengurangi kesalahan dan meningkatkan produktivitas.

Compose lebih cepat daripada membuat container secara manual dan menghubungkannya. Selain itu, Compose membuat jaringan bawaan untuk komunikasi antar semua container. Di samping itu, Compose mengelola volume, memastikan penyambungan ulang otomatis saat layanan diganti atau dimulai ulang.

Anda dapat mempelajari cara melakukan containerization aplikasi machine learning dengan Docker dan Kubernetes di tutorial How to Containerize an Application Using Docker kami.

Apa Perbedaan antara Docker dan Docker Compose?

Sementara Docker adalah platform untuk membangun, menjalankan, dan mengelola container, Docker Compose adalah alat yang memudahkan pendefinisian dan pengelolaan banyak container menggunakan file YAML, umumnya docker-compose.yml.

Docker menangani container tunggal, tetapi Docker Compose memungkinkan Anda menumpuknya menjadi satu layanan. Misalnya, sebuah aplikasi dengan backend, frontend, basis data, caching, dan sebagainya.

Anda dapat membangun dan menjalankan container tanpa Docker Compose. Namun, mengemas semuanya ke dalam satu file docker-compose.yml memudahkan pengelolaan banyak container. Ini juga memungkinkan Anda menyalakan aplikasi di lingkungan mana pun dengan satu perintah.

Memahami Docker dan Docker Compose sangat penting untuk sukses dalam wawancara Anda berikutnya. Pastikan Anda siap dengan menjelajahi 26 Pertanyaan dan Jawaban Wawancara Docker Teratas untuk 2025.

Dasar-Dasar Docker Compose

Sebelum masuk ke detail praktis, memahami prinsip inti dan sintaks Docker Compose sangat penting. Sebelum menggunakan Compose, pastikan Anda telah memasang Docker dengan mengikuti petunjuk dalam panduan Install Docker on Ubuntu: From Setup to First Container kami.

Kerangka konseptual

Docker Compose mengabstraksi kompleksitas orkestrasi container untuk pengembangan lokal dan penerapan yang lebih sederhana. Dengan file compose berformat YAML, Anda menyatakan layanan yang dibutuhkan, mendefinisikan dependensinya, menentukan jaringan, volume, variabel lingkungan, dan lainnya. Compose secara efisien mengelola memulai, menghentikan, menskalakan, dan menghubungkan antar layanan ini.

Sintaks Compose inti

Docker Compose berpusat pada sintaks YAML yang lugas. Komponen inti meliputi:

• services untuk mendefinisikan aplikasi yang dikontainerisasi
• images atau konteks build untuk menentukan container
• ports untuk mengekspos layanan
• volumes untuk penyimpanan data persisten
• networks untuk komunikasi antar layanan

Definisi Layanan dan Arsitektur Aplikasi

File Compose merepresentasikan layanan aplikasi dan koneksinya.

Mendefinisikan layanan

Layanan adalah inti dari file Compose. Anda dapat dengan jelas mendefinisikan dan menamai banyak layanan (seperti frontend web, basis data, dan layanan caching), menentukan dependensi melalui kata kunci sederhana seperti depends_on untuk mengontrol urutan startup container.

Dasar-dasar jaringan

Docker Compose secara otomatis membuat jaringan default untuk memfasilitasi komunikasi antar layanan yang didefinisikan. Pengembang juga dapat menentukan jaringan kustom jika diperlukan untuk isolasi yang lebih baik atau kebutuhan jaringan yang lebih terperinci.

Manajemen volume

Volume memungkinkan persistensi data di luar siklus hidup container. Anda dapat menentukan volume bernama atau me-mount direktori host ke container, memastikan basis data, log, atau data stateful lainnya tetap konsisten.

Variabel lingkungan

Compose menyederhanakan penerusan variabel lingkungan dan secret secara aman ke dalam container. Compose mendukung deklarasi langsung di bawah layanan dan referensi variabel yang disimpan dalam file env di samping file compose untuk menjaga nilai sensitif tetap aman dan terpisah dari definisi Docker.

Penskalaan dan Orkestrasi Docker Compose

Docker Compose juga mempermudah penskalaan dan orkestrasi dasar, yang sangat berguna untuk skenario uji beban cepat atau evaluasi layanan paralel.

Menskalakan layanan

Flag Compose "--scale" memudahkan Anda menyalakan banyak salinan layanan dengan cepat. Ini membuat pengujian skenario seperti evaluasi load balancing atau penanganan permintaan konkuren menjadi sederhana.

Sebagai contoh, men-skala container aplikasi Flask dapat dilakukan hanya dengan satu perintah:

docker-compose up --scale flaskapp=4

Docker Compose vs Docker Swarm dan Kubernetes

Walau Docker Compose unggul untuk pengembangan lokal dan pengaturan skala kecil, Compose terbatas untuk orkestrasi skala produksi multi-host. Untuk skenario kompleks dan tingkat produksi di banyak host, orkestrator yang lebih andal seperti Docker Swarm atau Kubernetes lebih tepat, karena menawarkan load balancing yang kuat, self-healing, jaringan canggih, dan skalabilitas besar yang tidak tersedia di Compose.

Postingan blog Docker Compose vs. Kubernetes kami membahas lebih detail perbedaan utama antara Docker Compose dan Kubernetes.

Teknik Optimasi untuk Penggunaan Compose yang Efisien

Pemanfaatan Docker Compose yang efisien mencakup pengoptimalan build, penambahan health check, dan pengelolaan sumber daya layanan. Pada bagian ini, Anda akan mempelajari lebih lanjut teknik optimasi tersebut.

Strategi build yang efisien

Menggunakan multi-stage build dalam Dockerfile membantu mengurangi ukuran image Docker, sementara memanfaatkan cache build secara eksplisit mempercepat proses pengembangan dan CI secara signifikan.

Health check dan kebijakan restart

Compose memungkinkan Anda mendefinisikan health check container secara eksplisit untuk menjaga keandalan aplikasi. Kebijakan restart membantu memastikan container yang gagal otomatis dimulai ulang, meningkatkan ketangguhan.

Mengelola batas sumber daya

Menetapkan batas CPU dan memori langsung dalam definisi YAML Compose membantu Anda mengontrol alokasi sumber daya, meningkatkan prediktabilitas dan efisiensi pemakaian.

Contoh potongan untuk batas sumber daya:

services:
  flaskapp:
    image: flask
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 512M

Contoh Praktis: Aplikasi Multi-Container

Berikut contoh dunia nyata yang disederhanakan melibatkan aplikasi Python Flask dipasangkan dengan Redis:

services:
  redis:
    image: redis:7
    container_name: redis
    ports:
      - "6379:6379"
    restart: always
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 5s
      retries: 3
  web:
    build: .
    container_name: flask_app
    command: gunicorn app:app --worker-class gevent --bind 0.0.0.0:5000 --timeout 3000
    ports:
      - "5000:5000"
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

  worker:
    build: .
    container_name: celery_worker
    command: celery -A celery_worker.celery worker --loglevel=info
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

File Docker Compose tersebut mendefinisikan aplikasi multi-container dengan tiga layanan:

1. redis
2. web (aplikasi Flask dengan Gunicorn)
3. worker (pekerja Celery)

Untuk layanan redis:

• Menggunakan image resmi Redis 7.
• Menetapkan nama container menjadi redis.
• Memetakan port 6379 di dalam container ke 6379 di host.
• Selalu restart jika crash (restart: always).
• Mendefinisikan healthcheck yang menjalankan ping redis-cli setiap 30 detik, timeout setelah 5 detik, dan mencoba ulang 3 kali sebelum menyatakan container tidak sehat.

Untuk layanan web:

• Membangun image dari direktori saat ini (build: .).
• Menamai container flask_app.
• Menjalankan perintah gunicorn app:app menggunakan worker gevent, bind ke 0.0.0.0:5000, dengan timeout panjang 3000 detik
• Memetakan port 5000 container ke 5000 di host.
• Mendeklarasikan dependensi pada layanan redis, memastikan Redis mulai lebih dulu.
• Menetapkan variabel lingkungan REDIS_URL yang mengarah ke container Redis internal.
• Memuat variabel lingkungan tambahan dari file .env.
• Me-mount tiga folder lokal ke dalam container:
• ./shorts ke /app/shorts,
• ./temp_uploads ke /app/temp_uploads
• ./uploads ke /app/uploads
• Dikonfigurasi untuk selalu restart jika crash.

Untuk layanan worker:

• Juga membangun image dari direktori saat ini (build: .), menggunakan kembali Dockerfile yang sama seperti layanan web.
• Menamai container: celery_worker.
• Menjalankan perintah celery -A celery_worker.celery worker --loglevel=info yang memulai pekerja Celery untuk memproses tugas latar belakang.
• Mendeklarasikan dependensi pada layanan redis, memastikan Redis mulai lebih dulu.
• Menetapkan variabel lingkungan REDIS_URL yang sama untuk terhubung ke broker Redis.
• Memuat variabel lingkungan lain dari file .env.
• Me-mount tiga folder yang sama seperti layanan web, memungkinkan aplikasi web dan worker berbagi file dan unggahan.
• Dikonfigurasi untuk selalu restart jika crash.

Jelajahi lebih banyak ide proyek Docker dari tutorial 10 Ide Proyek Docker kami.

Membangun dan Menjalankan Aplikasi Multi-Container

Docker Compose menawarkan seperangkat alat yang lugas untuk tugas container rutin:

Membangun image

Gunakan docker compose build untuk menghasilkan image container sesuai Dockerfile yang Anda definisikan. Kami membahas lebih banyak informasi tentang membangun image Docker di tutorial How to Learn Docker from Scratch: A Guide for Data Professionals kami.

Menjalankan layanan

Menggunakan docker compose up memulai semua layanan yang didefinisikan dalam file compose. Untuk mode detached, gunakan docker compose up -d. Kursus Introduction to Docker kami membahas lebih detail tentang menjalankan container di latar belakang.

Melihat container yang berjalan

Untuk melihat container aktif dan statusnya, gunakan docker compose ps untuk menampilkan semua layanan yang berjalan.

Menghentikan layanan

Gunakan docker compose down untuk menghentikan layanan yang berjalan.

Melihat log

Gunakan docker compose logs untuk memeriksa log. Anda dapat menentukan container untuk memeriksa log menggunakan docker logs container_name. Untuk streaming log, gunakan docker compose -f container_name.

Panduan 18 Perintah Docker Teratas untuk Membangun, Menjalankan, dan Mengelola Container kami menguraikan lebih banyak perintah Docker agar Anda dapat mengelola aplikasi lintas lingkungan dengan percaya diri.

Penggunaan Lanjutan Docker Compose

Alur kerja Compose beradaptasi untuk pengaturan pengembangan yang lebih kompleks atau konfigurasi lingkungan yang berbeda.

Konfigurasi multi-lingkungan

Banyak file Compose atau file override memfasilitasi pengaturan lingkungan berbeda (pengembangan, pengujian, produksi). Ini menjaga definisi tetap terpelihara dan mudah dibaca, memungkinkan modifikasi cepat tanpa konfigurasi yang berantakan.

Manajemen dependensi

Sementara depends_on menangani pengurutan startup dasar, skenario kompleks dapat memasukkan skrip inisialisasi (seperti "wait-for-it"), memastikan container hanya mulai setelah kondisi tertentu terpenuhi, misalnya kesiapan basis data.

Integrasi dengan CI/CD

Compose terintegrasi dengan mudah ke dalam alur kerja continuous integration, mengotomatiskan penyiapan lingkungan lengkap untuk pengujian. Platform seperti GitLab CI dan GitHub Actions menawarkan pendekatan native atau sederhana untuk integrasi Compose, mempermudah pengujian otomatis.

Praktik Terbaik dan Tantangan Umum

Anda dapat menghindari jebakan umum dan membangun konfigurasi yang mudah dirawat dengan menata dan menyusun definisi Compose secara cermat.

Organisasi File Compose

Jaga file Compose Anda tetap jelas dan modular. Untuk proyek yang lebih sederhana, satu file mungkin cukup, tetapi untuk aplikasi yang lebih besar, pertimbangkan memecah konfigurasi menjadi beberapa file Compose menggunakan fitur override. Ini memungkinkan:

• Pemisahan logis komponen (mis., docker-compose.backend.yml, docker-compose.frontend.yml)
• Kustomisasi lingkungan lokal vs. produksi yang lebih mudah
• Alur kontrol versi dan kolaborasi yang lebih ringkas, karena perubahan pada satu layanan tidak memengaruhi seluruh file

Gunakan nama layanan yang bermakna dan indentasi yang konsisten untuk membuat file lebih mudah dibaca dan dinavigasi.

Potensi Jebakan

Waspadai kekeliruan umum berikut:

• Menggunakan tag latest untuk image: Ini memperkenalkan ketidakpastian, karena versi image aktual dapat berubah seiring waktu. Selalu tetapkan versi image secara eksplisit (mis., postgres:15.1) untuk memastikan konsistensi lintas lingkungan.
• Hard-code secret: Jangan pernah menyertakan data sensitif (mis., kunci API, kata sandi) langsung dalam file Compose. Gunakan variabel lingkungan, file .env (dikecualikan dari kontrol versi), atau alat manajemen secret seperti Docker Secrets untuk penanganan yang aman.
• Definisi layanan yang terlalu kompleks: Tahan godaan untuk menjejalkan terlalu banyak logika atau tanggung jawab ke dalam satu container. Ikuti prinsip tanggung jawab tunggal, dan utamakan kesederhanaan bila memungkinkan.
• Mengabaikan jaringan eksplisit: Definisikan jaringan kustom di Compose alih-alih mengandalkan perilaku default. Ini menawarkan kontrol yang lebih baik atas komunikasi layanan, mengurangi konflik port, dan meningkatkan batas keamanan.

Dengan menerapkan praktik ini, alur kerja berbasis Compose Anda akan lebih tangguh, aman, dan lebih mudah dirawat dalam lingkungan kolaboratif atau yang terus berkembang.

Kesimpulan

Docker Compose secara signifikan menyederhanakan pembuatan, pengelolaan, dan menjalankan aplikasi multi-container bagi pengembang. Definisi berbasis YAML yang jelas, kemudahan orkestrasi, dan penskalaan yang lugas menjadikannya sangat berharga untuk skenario pengembangan lokal dan arsitektur penerapan yang lebih sederhana. Meskipun orkestrator tingkat lanjut seperti Docker Swarm dan Kubernetes lebih cocok untuk beban kerja produksi skala besar, Compose tetap merupakan titik masuk penting untuk memahami dasar-dasar orkestrasi container dan meningkatkan alur kerja pengembang.

Lihat kursus Docker kami untuk mempelajari:

• Containerization and Virtualization with Docker and Kubernetes
• Intermediate Docker