Docker Compose Cheatsheet - Perintah paling berguna dengan contoh

Berikut adalah Docker Compose cheatsheet dengan contoh yang dilengkapi untuk membantu Anda menguasai file dan perintah Compose dengan cepat.

Referensi File Compose: docker-compose.yml

Struktur inti:

version: '3'       # Versi format file Compose

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Port host 8080:Port kontainer 80
  db:
    image: postgres
    environment:            # Variabel lingkungan
      POSTGRES_PASSWORD: example
    volumes:
      - db_data:/var/lib/postgresql/data

networks:          # Jaringan khusus
  appnet:
    driver: bridge

volumes:           # Volume bernama
  db_data:

• services: Setiap kontainer dalam aplikasi multi-kontainer Anda. Dalam contoh di atas, kita memiliki dua layanan: web dan db.
• networks & volumes: Mendefinisikan jaringan terisolasi dan penyimpanan berkelanjutan - di sini kita memiliki jaringan appnet dan volume bernama db_data.

Contoh

Layanan tunggal dengan pemetaan port

services:
  app:
    build: .
    ports:
      - "8000:80"   # Port host 8000:Port kontainer 80

Menampilkan aplikasi pada port host 8000 dan membangun dari Dockerfile di direktori saat ini.

Multi-layanan dengan volume bersama dan jaringan khusus

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - type: bind
        source: ./app
        target: /app
    networks:
      - mynet
  db:
    image: postgres
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - mynet

networks:
  mynet:

volumes:
  db_data:

Web dan DB berada dalam jaringan yang sama; DB menggunakan volume bernama yang dipertahankan - db_data.

Menggunakan konteks pembangunan dan jalur Dockerfile

Anda dapat membangun gambar docker sesuai permintaan dari Dockerfile yang ditentukan dalam docker-compose.yml.

services:
  app:
    build:
      context: .
      dockerfile: docker/MyDockerfile

Berbagi data antar layanan

services:
  web:
    image: nginx
    volumes:
      - shared_data:/usr/share/nginx/html
  worker:
    image: myworker
    volumes:
      - shared_data:/usr/src/app/data

volumes:
  shared_data:

Kedua layanan mengakses volume yang sama (untuk file statis atau pertukaran data) - shared_data.

Opsi File Compose Lanjutan

• environment: Tetapkan variabel lingkungan untuk kontainer.
• depends_on: Kontrol urutan startup layanan.
• deploy.replicas: Skala layanan dalam mode Swarm.

Contoh:

services:
  web:
    image: nginx
    deploy:
      replicas: 3
    depends_on:
      - db

Menginisialisasi 3 instance web; hanya mengontrol urutan startup (tidak mengontrol kesiapan).

Perintah Docker Compose Penting

Pola Compose Umum

• Database dengan data yang bertahan lama

  services:
    mysql:
      image: mysql
      environment:
        MYSQL_ROOT_PASSWORD: password
      volumes:
        - mysql_data:/var/lib/mysql
  
  volumes:
    mysql_data:
  

  Data DB bertahan di volume mysql_data selama restart kontainer.

• Pemetaan kode untuk pengembangan

  services:
    app:
      build: .
      volumes:
        - .:/app
  

  Edit kode secara langsung di host, otomatis direfleksikan di kontainer.

Flag yang Berguna

• -d: Mode detach (jalankan di latar belakang).
• --build: Paksa rebuild gambar sebelum memulai.
• --force-recreate: Buat ulang kontainer meskipun tidak berubah.
• --remove-orphans: Hapus kontainer yang tidak didefinisikan dalam file Compose.

Mendefinisikan dan Menyesuaikan Layanan

Anda dapat mendefinisikan dan menyesuaikan layanan, jaringan, dan volume dalam Docker Compose dengan memanfaatkan file docker-compose.yml, yang memusatkan semua konfigurasi dan kebutuhan orkestrasi aplikasi Anda.

• Layanan didefinisikan di bawah kunci services.
• Setiap layanan mewakili konfigurasi kontainer, di mana Anda dapat mengatur:
  • Image: Pilih gambar dari Docker Hub atau registry lain.
  • Ports: Peta port kontainer ke port host.
  • Variabel lingkungan: Kirim nilai konfigurasi.
  • Volume: Pertahankan data atau berbagi file/folder dengan host atau layanan lain.
  • Jaringan: Kontrol jaringan mana yang dapat diakses oleh layanan.

Contoh:

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Port host 8080:Port kontainer 80
    environment:
      - NGINX_HOST=localhost
    volumes:
      - web_data:/usr/share/nginx/html
    networks:
      - frontend

  db:
    image: postgres:13
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - backend

• Di sini, layanan web menggunakan gambar nginx, mengatur variabel lingkungan, menghubungkan volume, membuka port 80 sebagai 8080 di host, dan terhubung ke jaringan frontend. Layanan db melakukan hal serupa untuk PostgreSQL.

Menyesuaikan Jaringan

• Jaringan mengontrol layanan mana yang dapat berkomunikasi. Compose membuat jaringan default, tetapi Anda dapat mendefinisikan lebih banyak, menentukan pengemudi khusus, mengatur opsi, dan menentukan layanan mana yang bergabung dengan jaringan mana untuk isolasi yang lebih halus.
• Definisikan jaringan di tingkat atas di bawah networks, dan daftar jaringan mana yang harus dihubungkan dengan kunci networks di tingkat layanan.

Contoh:

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    driver_opts:
      com.docker.network.bridge.host_binding_ipv4: "127.0.0.1"

• Hubungkan jaringan ke layanan:

services:
  app:
    networks:
      - frontend
      - backend
  db:
    networks:
      - backend

• Pengaturan ini memungkinkan layanan app mengakses pengguna di jaringan frontend dan backend, sementara db hanya dapat diakses dalam backend.

Menyesuaikan Volume

• Volume didefinisikan di bawah kunci volumes di tingkat atas. Pasang volume ke kontainer menggunakan kunci volumes di bawah layanan.
• Volume dapat diberi nama, menggunakan pengemudi khusus, dan dibagikan di antara beberapa layanan untuk penyimpanan berkelanjutan dan berbagi data.

Contoh:

volumes:
  web_data:                # Volume bernama untuk konten web
  db_data:                 # Volume bernama untuk database

services:
  web:
    volumes:
      - web_data:/usr/share/nginx/html

  db:
    volumes:
      - db_data:/var/lib/postgresql/data

• Dalam contoh ini, web_data dipertahankan dan tersedia untuk setiap kontainer yang memasangnya. db_data memastikan data database tidak hilang saat kontainer dibuat ulang.
• Anda dapat mendefinisikan bind-mount dengan opsi pengemudi khusus untuk kasus lanjutan:

volumes:
  db_data:
    driver: local
    driver_opts:
      type: none
      device: /data/db_data
      o: bind

• Konfigurasi ini mengatur bind-mount dari jalur host /data/db_data ke dalam kontainer.

Ringkasan Praktik Terbaik:

• Gunakan nama layanan sebagai nama host DNS untuk komunikasi antar layanan.
• Hubungkan layanan ke beberapa jaringan sesuai kebutuhan untuk mengontrol akses.
• Gunakan volume bernama untuk penyimpanan berkelanjutan dan berbagi data.
• Definisikan semuanya menggunakan YAML, memungkinkan kontrol versi dan skrip deployment yang mudah.

File Compose Berjumlah Banyak

Untuk mengorganisasi pengaturan multi-layanan yang kompleks dalam Docker Compose, Anda dapat menggunakan beberapa file Compose dan file override, memungkinkan konfigurasi modular, spesifik lingkungan, dan skalabel. Berikut cara kerjanya:

1. Struktur File Dasar dan Override

• Buat file dasar (compose.yaml atau docker-compose.yml) yang berisi semua definisi layanan umum dan default.
• Tambahkan file override spesifik lingkungan (misalnya, docker-compose.override.yml, docker-compose.dev.yml, docker-compose.prod.yml).

Contoh struktur file:

/project-directory
|-- docker-compose.yml           # Konfigurasi dasar
|-- docker-compose.override.yml  # Override lokal/dev (diproses secara otomatis)
|-- docker-compose.prod.yml      # Override produksi
|-- docker-compose.test.yml      # Override pengujian (jika diperlukan)

Konfigurasi dasar mendefinisikan layanan inti, sementara setiap override menyesuaikan pengaturan untuk lingkungan atau kasus tertentu.

2. Bagaimana File Override Bekerja

• Menggabungkan: Saat Anda menjalankan docker compose up, Docker Compose menggabungkan file dasar dengan setiap override dalam urutan tertentu; file berikutnya mengganti, memperluas, atau menambahkan pengaturan dari file sebelumnya.
• Mengganti Bidang: Jika layanan atau bidang didefinisikan dalam beberapa file, nilai dari file terakhir yang ditentukan digunakan. Bidang baru ditambahkan.

Contoh penggabungan:

• docker-compose.yml:

  services:
    web:
      image: myapp
      ports:
        - "8000:80"
  

• docker-compose.override.yml:

  services:
    web:
      environment:
        - DEBUG=true
  

• Hasil: Layanan web menggunakan gambar dan port dasar serta variabel lingkungan yang diubah DEBUG.

3. Penggunaan Perintah untuk Banyak File

• Perilaku default: Jika tersedia, Docker Compose secara otomatis memuat docker-compose.override.yml bersama dengan docker-compose.yml saat Anda menjalankan perintah apa pun.
• Menentukan file secara manual: Gunakan flag -f untuk mengontrol file mana yang digabungkan dan dalam urutan apa:

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

  • Ini mengabaikan override default dan menggunakan pengaturan spesifik produksi.

4. Strategi Organisasi Praktis

• Pemisahan lingkungan: Gunakan satu override per lingkungan: dev, test, prod, dll.
• Microservices dan tim: Pecah konfigurasi menjadi file terpisah untuk layanan atau tim berbeda, dan gabungkan sesuai kebutuhan.
• Toggle fitur: File tambahan dapat memperkenalkan atau menghilangkan layanan atau konfigurasi opsional untuk kebutuhan sementara (misalnya, compose.debug.yml untuk log tambahan).

5. Manfaat

• Klarifikasi: Menjaga file individu kecil dan fokus.
• Skalabilitas: Mudah menambahkan layanan, lingkungan, atau pengaturan baru.
• Pemeliharaan: Hanya ubah atau tinjau bagian yang relevan untuk deployment tertentu.

6. Contoh: Beralih Lingkungan

Pengembangan:

docker compose -f docker-compose.yml -f docker-compose.dev.yml up

Produksi:

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

Setiap lingkungan hanya mendapatkan konfigurasi yang diperlukan untuknya, dengan semua konfigurasi bersama dalam file dasar.

Mengatur pengaturan Compose yang kompleks dengan beberapa file - dan memanfaatkan sistem override/merge - memastikan modularitas, penyesuaian spesifik lingkungan, dan skalabilitas mudah untuk aplikasi Docker multi-layanan besar.

Tautan yang Berguna

• https://docs.docker.com/compose/
• Docker Cheatsheet
• Kubernetes Cheatsheet
• Dockerising Flutter Web app dengan dockerised Flutter build dan Nginx
• Install Portainer di Linux