Cara Memasang dan Menggunakan Docker Compose di Ubuntu

Pengenalan

Docker mempermudahkan proses menguruskan proses aplikasi dalam kontena. Walaupun kontena serupa dengan mesin maya dalam beberapa cara, ia lebih ringan dan mesra sumber. Ini membolehkan pembangun memecahkan persekitaran aplikasi kepada beberapa perkhidmatan yang terasing.

Bagi aplikasi yang bergantung pada beberapa perkhidmatan, mengatur semua bekas untuk memulakan, berkomunikasi, dan dimatikan bersama-sama boleh menjadi sukar dengan cepat. Docker Compose adalah alat yang membolehkan anda menjalankan persekitaran aplikasi pelbagai bekas berdasarkan definisi yang ditetapkan dalam fail YAML. Ia menggunakan definisi perkhidmatan untuk membina persekitaran yang boleh disesuaikan sepenuhnya dengan pelbagai bekas yang boleh berkongsi rangkaian dan volum data.

Panduan ini akan membimbing anda melalui pemasangan Docker Compose pada server Ubuntu dan menjalankan sebuah kontena mudah. Dari situ, anda akan belajar membina persekitaran berbilang perkhidmatan menggunakan aplikasi WordPress dan pangkalan data MySQL. Kami juga akan membincangkan topik yang lebih lanjutan, termasuk skala perkhidmatan, mentakrifkan rangkaian tersuai, dan menggunakan arahan termasuk modular. Akhir sekali, artikel ini menyediakan panduan migrasi daripada docker-compose lama (v1) ke docker compose moden (v2) serta bahagian terperinci mengenai penyelesaian masalah isu biasa seperti konflik port dan ralat kebenaran.

Prasyarat

Untuk mengikuti artikel ini, anda akan memerlukan:

• Akses kepada mesin tempatan Ubuntu atau pelayan pembangunan sebagai pengguna bukan root dengan keistimewaan sudo. Jika anda menggunakan pelayan jarak jauh, adalah disyorkan untuk memasang firewall yang aktif. Untuk menetapkan ini, sila rujuk Panduan Persediaan Pelayan Awal kami untuk Ubuntu.
• Docker dipasang di pelayan atau mesin tempatan anda, mengikut Langkah 1 dan 2 Panduan Pemasangan Docker di Ubuntu – Panduan Langkah demi Langkah.

Langkah 1 — Memasang Docker Compose

Terdapat dua cara untuk memasang Docker Compose di Ubuntu:

• Pasang menggunakan repositori
• Pasang secara manual

Kita akan membincangkan kedua-dua cara dalam bahagian ini.

Memasang Docker Compose menggunakan repositori apt

Pertama, mari kita tetapkan repositori apt Docker.

# Add Docker's official GPG key:

sudo apt-get update

sudo apt-get install ca-certificates curl

sudo install -m 0755 -d /etc/apt/keyrings

sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc

sudo chmod a+r /etc/apt/keyrings/docker.asc



# Add the repository to Apt sources:

echo \

  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \

  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \

  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update

Sekarang, anda boleh memasang Docker Compose menggunakan arahan berikut:

sudo apt install docker-compose-plugin

Docker Compose kini telah berjaya dipasang pada sistem anda. Untuk mengesahkan bahawa pemasangan berjaya, anda boleh menjalankan:

docker compose version

Anda akan melihat output yang serupa dengan ini:

Docker Compose version v2.3.3

Memasang Docker Compose secara manual

Untuk memastikan anda memperoleh versi stabil Docker Compose yang paling terkini, anda akan memuat turun perisian ini dari repositori Github rasmi.

Pertama, sahkan versi terkini yang tersedia di halaman pelepasan mereka. Pada masa penulisan ini, versi stabil yang paling terkini ialah v2.40.2.

Gunakan arahan berikut untuk memuat turun:

mkdir -p ~/.docker/cli-plugins/

curl -SL https://github.com/docker/compose/releases/download/v2.40.2/docker-compose-linux-x86_64 -o ~/.docker/cli-plugins/docker-compose

Seterusnya, tetapkan kebenaran yang betul supaya arahan docker compose boleh dijalankan:

chmod +x ~/.docker/cli-plugins/docker-compose

Dalam bahagian seterusnya, anda akan melihat cara untuk menyediakan fail docker-compose.yml dan menjalankan persekitaran berkontena menggunakan alat ini.

Langkah 2 — Menyediakan Fail docker-compose.yml

Untuk menunjukkan cara menyediakan fail docker-compose.yml dan bekerja dengan Docker Compose, anda akan mencipta persekitaran pelayan web menggunakan imej rasmi Nginx dari Docker Hub, registri Docker awam. Persekitaran bercontainer ini akan menyajikan satu fail HTML statik.

Mulakan dengan mencipta direktori baru dalam folder rumah anda, dan kemudian masuk ke dalamnya:

mkdir ~/compose-demo

cd ~/compose-demo

Dalam direktori ini, sediakan folder aplikasi untuk dijadikan sebagai akar dokumen bagi persekitaran Nginx anda:

mkdir app

Menggunakan penyunting teks pilihan anda, buat fail index.html baru dalam folder app:

nano app/index.html

Letakkan kandungan berikut ke dalam fail ini:

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Docker Compose Demo</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kognise/water.css@latest/dist/dark.min.css">
</head>
<body>

    <h1>This is a Docker Compose Demo Page.</h1>
    <p>This content is being served by an Nginx container.</p>

</body>
</html>

Simpan dan tutup fail apabila anda selesai. Jika anda menggunakan nano, anda boleh melakukannya dengan menekan CTRL+X, kemudian Y dan ENTER untuk mengesahkan.

Seterusnya, buat fail docker-compose.yml:

nano docker-compose.yml

Masukkan kandungan berikut dalam fail docker-compose.yml anda:

services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html

Dalam Docker Compose moden, medan version adalah pilihan dan sering diabaikan, kerana Compose boleh mengesan versi konfigurasi secara automatik. Contoh di atas tidak termasuk medan version, yang merupakan pendekatan yang disyorkan untuk kebanyakan projek baru. Anda hanya perlu menyatakan version untuk keserasian lama.

Kemudian anda mempunyai blok services, di mana anda menyiapkan perkhidmatan yang merupakan sebahagian daripada persekitaran ini. Dalam kes anda, anda mempunyai satu perkhidmatan yang dipanggil web. Perkhidmatan ini menggunakan imej nginx:alpine dan menyediakan pengalihan port dengan arahan ports. Semua permintaan pada port 8000 mesin host (sistem dari mana anda menjalankan Docker Compose) akan dialihkan ke kontena web pada port 80, di mana Nginx akan berjalan.

Arahan volumes akan mencipta volum perkongsian antara mesin hos dan bekas. Ini akan berkongsi folder app tempatan dengan bekas, dan volum tersebut akan terletak di /usr/share/nginx/html di dalam bekas, yang kemudiannya akan menimpa akar dokumen lalai untuk Nginx.

Simpan dan tutup fail itu.

Anda telah menyediakan halaman demo dan fail docker-compose.yml untuk membuat persekitaran pelayan web yang dikontena yang akan menayangkannya. Dalam langkah seterusnya, anda akan menjalankan persekitaran ini dengan Docker Compose.

Langkah 3 — Menjalankan Docker Compose

Dengan fail docker-compose.yml yang telah tersedia, anda kini boleh menjalankan Docker Compose untuk menghidupkan persekitaran anda. Arahan berikut akan memuat turun imej Docker yang diperlukan, mencipta bekas untuk perkhidmatan web, dan menjalankan persekitaran yang dibekaskan dalam mod latar belakang:

docker compose up -d

Docker Compose akan mula mencari imej yang ditakrifkan pada sistem tempatan anda, dan jika ia tidak dapat mencari imej tersebut, ia akan memuat turun imej itu dari Docker Hub. Anda akan melihat output seperti ini:

Creating network "compose-demo_default" with the default driver
Pulling web (nginx:alpine)...
alpine: Pulling from library/nginx
cbdbe7a5bc2a: Pull complete
10c113fb0c77: Pull complete
9ba64393807b: Pull complete
c829a9c40ab2: Pull complete
61d685417b2f: Pull complete
Digest: sha256:57254039c6313fe8c53f1acbf15657ec9616a813397b74b063e32443427c5502
Status: Downloaded newer image for nginx:alpine
Creating compose-demo_web_1 ... done

sudo usermod -aG docker ${USER}

Selepas menjalankan arahan ini, anda perlu log keluar dan log masuk semula supaya perubahan kumpulan berkuat kuasa. Anda juga boleh mengaktifkan perubahan untuk sesi terminal semasa dengan menaip:

newgrp docker

Arahan ini sepatutnya menyelesaikan sebarang ralat kebenaran yang berkaitan dengan soket Docker. Untuk panduan penuh, sila rujuk Langkah 2 dalam Cara Memasang Docker di Ubuntu – Panduan Langkah demi Langkah.

Persekitaran anda kini sedang berjalan di latar belakang. Untuk mengesahkan bahawa kontena aktif, anda boleh jalankan:

docker compose ps

Arahan ini akan menunjukkan maklumat tentang bekas yang sedang berjalan dan keadaannya, serta sebarang penyaluran port yang sedang berlaku:

       Name                     Command               State          Ports        
----------------------------------------------------------------------------------
compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:8000->80/tcp

Anda kini boleh mengakses aplikasi demo dengan membuka pelayar anda ke localhost:8000 jika anda menjalankan demo ini pada mesin tempatan anda, atau domain_atau_IP_pelayan_anda:8000 jika anda menjalankan demo ini pada pelayan jauh.

Anda akan melihat halaman seperti ini:

Volume perkongsian yang anda tetapkan dalam fail docker-compose.yml menyimpan fail dalam folder app anda selaras dengan akar dokumen kontena. Jika anda membuat sebarang perubahan pada fail index.html, perubahan tersebut akan secara automatik diambil oleh kontena dan seterusnya dipaparkan pada pelayar anda apabila anda memuat semula halaman.

Dalam langkah seterusnya, anda akan melihat cara mengurus persekitaran berbekas anda dengan arahan Docker Compose.

Langkah 4 — Membiasakan Diri dengan Arahan Docker Compose

Anda telah melihat cara untuk menyediakan fail docker-compose.yml dan menghidupkan persekitaran anda dengan docker compose up. Kini anda akan melihat cara menggunakan arahan Docker Compose untuk mengurus dan berinteraksi dengan persekitaran berasaskan kontena anda.

Untuk menyemak log yang dihasilkan oleh kontena Nginx anda, anda boleh menggunakan perintah logs:

docker compose logs

Anda akan melihat output yang serupa dengan ini:

Attaching to compose-demo_web_1
web_1  | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
web_1  | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
web_1  | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf
web_1  | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
web_1  | /docker-entrypoint.sh: Configuration complete; ready for start up
web_1  | 172.22.0.1 - - [02/Jun/2020:10:47:13 +0000] "GET / HTTP/1.1" 200 353 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" "-"

Jika anda ingin menjeda pelaksanaan persekitaran tanpa mengubah keadaan semasa kontena anda, anda boleh menggunakan:

docker compose pause

Pausing compose-demo_web_1 ... done

Untuk menyambung semula pelaksanaan selepas mengeluarkan jeda:

docker compose unpause

Unpausing compose-demo_web_1 ... done

Perintah stop akan menghentikan pelaksanaan kontena, tetapi ia tidak akan memusnahkan sebarang data yang berkaitan dengan kontena anda:

docker compose stop

Stopping compose-demo_web_1 ... done

Jika anda ingin menghapuskan kontena, rangkaian, dan volum yang berkaitan dengan persekitaran berasaskan kontena ini, gunakan arahan down:

docker compose down

Removing compose-demo_web_1 ... done
Removing network compose-demo_default

Perhatikan bahawa ini tidak akan mengeluarkan imej asas yang digunakan oleh Docker Compose untuk memulakan persekitaran anda (dalam kes anda, nginx:alpine). Dengan cara ini, setiap kali anda memulakan kembali persekitaran anda dengan docker compose up, prosesnya akan menjadi lebih pantas kerana imej tersebut sudah ada dalam sistem anda.

Sekiranya anda juga ingin mengeluarkan imej asas daripada sistem anda, anda boleh menggunakan:

docker image rm nginx:alpine

Untagged: nginx:alpine
Untagged: nginx@sha256:b89a6ccbda39576ad23fd079978c967cecc6b170db6e7ff8a769bf2259a71912
Deleted: sha256:7d0cdcc60a96a5124763fddf5d534d058ad7d0d8d4c3b8be2aefedf4267d0270
Deleted: sha256:05a0eaca15d731e0029a7604ef54f0dda3b736d4e987e6ac87b91ac7aac03ab1
Deleted: sha256:c6bbc4bdac396583641cb44cd35126b2c195be8fe1ac5e6c577c14752bbe9157
Deleted: sha256:35789b1e1a362b0da8392ca7d5759ef08b9a6b7141cc1521570f984dc7905eb6
Deleted: sha256:a3efaa65ec344c882fe5d543a392a54c4ceacd1efd91662d06964211b1be4c08
Deleted: sha256:3e207b409db364b595ba862cdc12be96dcdad8e36c59a03b7b3b61c946a5741a

Langkah 5 — Membangunkan Aplikasi Pelbagai Perkhidmatan

Kekuatan sebenar Docker Compose terletak pada pengurusan pelbagai perkhidmatan yang bekerjasama. Contoh Nginx adalah satu perkhidmatan sahaja. Mari kita buat aplikasi yang lebih praktikal dengan pelbagai perkhidmatan: sebuah laman web WordPress yang disambungkan ke pangkalan data MySQL.

Tetapan ini melibatkan dua perkhidmatan: wordpress (menjalankan aplikasi) dan db (menjalankan pangkalan data). Kami juga akan menggunakan volum Docker untuk memastikan data pangkalan data kekal walaupun bekas dipadamkan.

Mari kita buat direktori baru untuk aplikasi ini:

mkdir -p ~/compose-demo/wordpressapp

cd ~/compose-demo/wordpressapp

Untuk contoh ini, kita tidak memerlukan sebarang fail tempatan, kerana imej-imej tersebut akan mengandungi semua perisian yang diperlukan.

Buat fail docker-compose.yml baru:

nano docker-compose.yml

Tampalkan konfigurasi berikut. Fail ini lebih kompleks, jadi kita akan meneliti setiap bahagiannya.

services:
  db:
    image: mysql:8.0
    container_name: mysql_db
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: <^your_root_password_here<^>
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: <^your_wordpress_password_here<^>
    restart: unless-stopped

  wordpress:
    image: wordpress:latest
    container_name: wordpress_app
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: <^your_wordpress_password_here<^>
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp_content:/var/www/html/wp-content
    depends_on:
      - db
    restart: unless-stopped

volumes:
  db_data:

Simpan dan tutup fail tersebut. Ingat untuk menggantikan pemegang tempat <^...^> dengan kata laluan yang kuat dan selamat.

Mari kita huraikan arahan baru dalam fail ini:

• services: Blok ini masih menentukan kontena kita. Kini kita mempunyai dua: db dan wordpress.
• image: Kami menggunakan mysql:8.0 untuk pangkalan data dan imej wordpress:latest untuk aplikasi.
• container_name: Ini menetapkan nama tertentu yang boleh dibaca manusia untuk kontena, yang lebih mudah dirujuk berbanding nama yang dihasilkan secara automatik.
• environment: Ini adalah senarai pembolehubah persekitaran yang disalurkan ke dalam bekas. Imej mysql menggunakan ini untuk menetapkan kata laluan root dan mencipta pangkalan data dan pengguna awal. Imej wordpress menggunakannya untuk mengetahui cara menyambung ke pangkalan datanya.

• volum (peringkat perkhidmatan):

  • Untuk perkhidmatan db, db_data:/var/lib/mysql memetakan volum yang diurus oleh Docker bernama db_data ke direktori data MySQL di dalam kontena. Ini memastikan data anda selamat.
  • Untuk perkhidmatan wordpress, ./wp_content:/var/www/html/wp-content memetakan direktori tempatan (wp_content) ke direktori kandungan WordPress. Ini membolehkan anda mengedit tema dan pemalam terus dari mesin hos anda.
• depends_on: Ini memberitahu Compose untuk memulakan perkhidmatan db sebelum ia memulakan perkhidmatan wordpress. Ini adalah penting, kerana WordPress akan gagal jika ia tidak dapat menemui pangkalan datanya semasa permulaan.
• volumes (peringkat atas): Blok ini menetapkan volume yang dinamakan. db_data: mencipta volume yang diurus oleh Docker, yang merupakan cara yang digalakkan untuk mengendalikan data yang kekal.

Sekarang, jalankan aplikasi pelbagai perkhidmatan ini:

docker compose up -d

Compose akan memuat turun kedua-dua imej mysql dan wordpress dan kemudian mencipta kontena, dengan memulakan perkhidmatan db terlebih dahulu.

Creating network "compose-demo_default" with the default driver
Creating volume "compose-demo_db_data" with default driver
Pulling db (mysql:8.0)...
...
Pulling wordpress (wordpress:latest)...
...
Creating mysql_db        ... done
Creating wordpress_app ... done

Anda kini boleh mengakses laman WordPress baru anda dengan melayari localhost:8001 atau <^domain_atau_IP_server_anda<^>:8001 dalam pelayar web anda. Anda sepatutnya akan melihat skrin pemasangan WordPress. Untuk contoh yang lebih terperinci, lihat artikel kami tentang Cara Memasang WordPress Dengan Docker Compose

Langkah 6 — Menggunakan Docker Compose untuk Pembangunan AI/ML

Selain aplikasi web, Docker Compose adalah alat yang sangat berguna untuk mencipta persekitaran sains data dan pembelajaran mesin (AI/ML) yang boleh dihasilkan semula. Projek AI/ML terkenal dengan kebergantungan yang kompleks, termasuk versi Python tertentu, perpustakaan seperti TensorFlow atau PyTorch, dan pemacu tahap sistem seperti NVIDIA CUDA Toolkit. Docker Compose menangkap seluruh persekitaran ini dalam fail konfigurasi, menyelesaikan masalah “ia berfungsi di mesin saya”, yang kritikal untuk penyelidikan yang boleh dihasilkan semula.

Dalam contoh ini, anda akan mencipta persekitaran AI/ML pelbagai perkhidmatan yang terdiri daripada:

• JupyterLab: Sebuah kontena untuk pembangunan interaktif, dibina daripada Dockerfile tersuai.
• PostgreSQL: Sebuah bekas pangkalan data untuk menyimpan keputusan eksperimen dan metadata.
• Akses GPU: Kontena JupyterLab akan dikonfigurasikan untuk mengakses GPU NVIDIA mesin hos, yang merupakan keperluan biasa untuk latihan model.

Struktur Fail

Pertama, buat direktori untuk projek anda. Di dalamnya, anda akan membuat fail docker-compose.yml, direktori jupyter, fail Dockerfile untuk Jupyter, dan fail requirements.txt. Struktur sepatutnya kelihatan seperti ini:

ai-project/
├── docker-compose.yml
└── jupyter/
    ├── Dockerfile
    └── requirements.txt

Mencipta Fail Komponen

1. Fail requirements.txt

Fail ini menyenaraikan pakej Python untuk persekitaran sains data anda.

nano jupyter/requirements.txt

Tambah pakej yang diperlukan. Untuk contoh ini, kita akan termasuk perpustakaan untuk manipulasi data, sambungan pangkalan data, dan rangka kerja pembelajaran mendalam.

pandas
scikit-learn
tensorflow
jupyterlab
psycopg2-binary

Simpan dan tutup fail itu.

2. Dockerfile

Fail ini mentakrifkan perkhidmatan JupyterLab tersuai anda. Ia menggunakan imej Jupyter rasmi sebagai asasnya dan memasang pakej dari requirements.txt.

nano jupyter/Dockerfile

Tampalkan kandungan berikut:

# Start from a base image that includes Jupyter and scientific libraries
FROM jupyter/scipy-notebook:latest

# Copy our local requirements file into the container
COPY requirements.txt /tmp/requirements.txt

# Install the Python packages
RUN pip install --no-cache-dir -r /tmp/requirements.txt

Fail ini mengarahkan Docker untuk menggunakan jupyter/scipy-notebook sebagai titik permulaan, menyalin requirements.txt anda ke dalam kontena, dan kemudian menggunakan pip untuk memasang pakej-pakej tersebut.

Menentukan Persekitaran dengan docker-compose.yml

Sekarang, buat fail utama docker-compose.yml. Fail ini akan mengatur kedua-dua perkhidmatan db dan perkhidmatan jupyter tersuai anda.

nano docker-compose.yml

Tampal konfigurasi berikut, gantikan tempat letak <^...^> dengan maklumat kelayakan selamat anda sendiri.

services:
  db:
    image: postgres:15-alpine
    container_name: ai_postgres_db
    environment:
      POSTGRES_USER: <^your_db_user^>
      POSTGRES_PASSWORD: <^your_db_pass^>
      POSTGRES_DB: experiments
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U <^your_db_user^> -d experiments"]
      interval: 10s
      timeout: 5s
      retries: 5
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    networks:
      - ai_net

  jupyter:
    build: ./jupyter
    container_name: ai_jupyter_lab
    ports:
      - "8888:8888"
    volumes:
      - ./notebooks:/home/jovyan/work
    environment:
      - POSTGRES_HOST=db
      - POSTGRES_USER=<^your_db_user^>
      - POSTGRES_PASSWORD=<^your_db_pass^>
      - POSTGRES_DB=experiments
    restart: unless-stopped
    networks:
      - ai_net
    depends_on:
      db:
        condition: service_healthy
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

volumes:
  postgres_data:
    name: ai_project_data

networks:
  ai_net:
    driver: bridge

Fail konfigurasi ini memperkenalkan beberapa konsep penting:

• build: ./jupyter: Ini memberitahu Docker Compose untuk membina imej khusus bagi perkhidmatan jupyter. Ia mencari Dockerfile di dalam direktori ./jupyter yang ditetapkan.
• volumes: - ./notebooks:/home/jovyan/work: Ini memautkan direktori tempatan bernama notebooks ke dalam kontena. Ini memastikan semua nota Jupyter yang anda buat disimpan terus pada mesin hos anda, mengekalkannya walaupun selepas kontena tersebut dipadamkan.
• healthcheck: Seperti yang dilihat dalam bahagian penyelesaian masalah, pemeriksaan ini mengesahkan bahawa perkhidmatan db bukan sahaja berjalan, tetapi sedia untuk menerima sambungan sebelum perkhidmatan lain bermula.
• depends_on: ... condition: service_healthy: Ini memberitahu perkhidmatan jupyter untuk menunggu sehingga pemeriksaan kesihatan db lulus sebelum mula berjalan.

• deploy.resources.reservations.devices: Ini adalah blok yang meminta akses GPU.

  • driver: nvidia: Menentukan pemacu hos yang akan digunakan.
  • count: 1: Meminta satu GPU.
  • capabilities: [gpu]: Menjamin kontena mempunyai kebolehan yang diperlukan untuk menggunakan GPU.

Menjalankan Persekitaran AI/ML

Dengan fail anda berada di tempatnya, anda sudah bersedia untuk membina dan menjalankan perkhidmatan.

1. Dari direktori ai-project anda, jalankan perintah docker compose up. Anda mesti menambah bendera --build pada kali pertama untuk memberitahu Compose membina imej jupyter khusus anda.

   docker compose up -d --build

2. Compose akan terlebih dahulu membina imej jupyter (yang mungkin mengambil masa beberapa minit kerana ia memuat turun TensorFlow), kemudian menarik imej postgres, dan akhirnya memulakan kedua-dua kontena.

   [+] Building 5.8s (9/9) FINISHED
    => [internal] load build definition from Dockerfile
   ...
   [+] Running 3/3
    ✔ Network ai-project_ai_net        Created
    ✔ Container ai_postgres_db         Started
    ✔ Container ai_jupyter_lab         Started

3. Anda kini boleh mengakses antara muka JupyterLab dengan pergi ke http://localhost:8888 (atau <^your_server_ip^>:8888) dalam pelayar anda. Anda akan diminta token, yang boleh anda dapatkan daripada log bekas:

   docker compose logs jupyter

   Cari baris yang serupa dengan http://127.0.0.1:8888/lab?token=a1b2c3d4e5f6...

4. Di dalam notebook Jupyter, anda kini boleh menyambung ke pangkalan data anda menggunakan nama hos db dan kelayakan yang anda sediakan. Persekitaran anda juga mempunyai akses kepada GPU hos untuk latihan model.

Menjalankan Skala Perkhidmatan dan Menggunakan Rangkaian Tersuai

Docker Compose termasuk ciri untuk menyesuaikan perkhidmatan dan mengurus rangkaian yang mereka gunakan untuk berkomunikasi.

Skala Perkhidmatan dengan Replika

Bayangkan server web Nginx anda dari Langkah 2 menerima terlalu banyak trafik. Anda boleh menambah skala perkhidmatan web untuk menjalankan beberapa contoh kontena. Docker Compose boleh mengurus ini secara automatik.

Terdapat dua cara utama untuk meningkatkan skala sesebuah perkhidmatan.

1. Menggunakan kekunci replicas (Disyorkan dalam v2)

Anda boleh menentukan bilangan instans yang dikehendaki secara langsung dalam fail docker-compose.yml anda menggunakan kunci deploy dan replicas. Ciri ini pada asalnya adalah sebahagian daripada Docker Swarm tetapi kini tersedia untuk penyebaran Compose standard.

Ubahsuai docker-compose.yml Nginx anda dari Langkah 2:

services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html
    deploy:
      replicas: 3

Apabila anda menjalankan docker compose up -d, Compose akan mencipta tiga kontena web. Walau bagaimanapun, anda akan menghadapi masalah: ketiga-tiga kontena akan cuba untuk mengikat ke port hos 8000. Ini akan menyebabkan ralat “port is already allocated” untuk kontena kedua dan ketiga. Untuk menyelesaikan ini dalam konfigurasi produksi, anda perlu menghapus pemetaan ports daripada perkhidmatan web. Dengan cara ini, kontena web hanya boleh diakses dalam rangkaian Docker. Perkhidmatan pengimbang beban yang berasingan akan menjadi satu-satunya dengan port awam. Ia kemudian akan mengagihkan trafik ke tiga replika web tersebut.

Contoh konfigurasi akan kelihatan seperti ini (ini adalah contoh lanjutan):

services:
  web:
    image: nginx:alpine
    # No 'ports' mapping here.
    # The service is only accessible inside the 'web-net' network.
    volumes:
      - ./app:/usr/share/nginx/html
    deploy:
      replicas: 3
    networks:
      - web-net

  load_balancer:
    image: nginx:latest
    ports:
      - "80:80" # The load_balancer is the only service with a public port.
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf # A config file that load balances to 'web'.
    networks:
      - web-net
    depends_on:
      - web

networks:
  web-net:

Dalam susunan ini, load_balancer mendengar pada port 80 dan menghala permintaan ke web_1, web_2, dan web_3 secara dalaman.

Kunci replicas ini paling berguna apabila digunakan bersama proksi terbalik (seperti Traefik atau instans Nginx lain) yang boleh mengimbangi beban permintaan antara replika dalam rangkaian Docker, tanpa setiap replika perlu mendedahkan port pada hos.

2. Menggunakan bendera --scale

Kaedah biasa untuk penskalaan adalah bendera --scale, yang dibawa daripada Compose v1. Bendera ini digunakan semasa runtime dan menimpa sebarang kunci replicas.

Walau bagaimanapun, anda mesti berhati-hati dengan definisi port. Jika servis anda menentukan pemetaan port hos tetap (contohnya, "8000:80"), menjalankan docker compose up --scale akan menyebabkan ralat untuk bekas kedua dan ketiga kerana kesemuanya cuba untuk mengikat pada port hos yang sama.

Untuk menggunakan --scale bagi perkhidmatan yang mendedahkan port, anda tidak boleh menggunakan pemetaan port hos tetap.

• Pilihan 1: Peta ke Port Hos Rawak (Baik untuk Pembangunan)

  Anda boleh mengubahsuai docker-compose.yml anda untuk menetapkan hanya port kontena. Ini memberitahu Docker untuk memetakan port 80 dalam setiap kontena ke port rawak yang tersedia pada mesin hos anda.

  services:
    web:
      image: nginx:alpine
      ports:
        - "80" # No fixed host port
      volumes:
        - ./app:/usr/share/nginx/html

  Sekarang, apabila anda menjalankan arahan skala:

  docker compose up -d --scale web=3

  Jalankan docker compose ps untuk melihat hasilnya. Setiap kontena akan berjalan pada port hos yang berbeza dan ditetapkan secara rawak:

        Name                     Command               State          Ports        
  ----------------------------------------------------------------------------------
  compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49154->80/tcp
  compose-demo-web_2   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49155->80/tcp
  compose-demo-web_3   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:49156->80/tcp

docker-compose.yml - Betul untuk --scale

• Pilihan 2: Gunakan Proksi Terbalik (Baik untuk Pengeluaran)

  Penyelesaian lain, seperti yang disebutkan dalam bahagian replicas, adalah untuk mengeluarkan arahan ports daripada perkhidmatan web sepenuhnya. Anda kemudiannya akan menggunakan bekas penyeimbang beban berasingan (yang mempunyai satu-satunya port awam) untuk mengurus dan mengagihkan trafik kepada replika berskala dalam rangkaian Docker.

  Untuk menghentikan dan mengalih keluar ketiga-tiga bekas, arahan tetap sama:

  docker compose down

Konfigurasi Rangkaian Tersuai

Secara lalai, Docker Compose mencipta satu rangkaian bridge untuk aplikasi anda. Setiap perkhidmatan dalam fail tersebut dilampirkan kepadanya, inilah sebabnya kontena wordpress dapat mencari kontena db hanya dengan menggunakan nama perkhidmatannya (db).

Walau bagaimanapun, anda boleh menentukan rangkaian khas anda sendiri untuk pengasingan dan kawalan yang lebih baik.

Mari ubah contoh WordPress untuk menggunakan rangkaian bridge tersuai.

services:
  db:
    image: mysql:8.0
    ...
    networks:
      - app_net

  wordpress:
    image: wordpress:latest
    ...
    ports:
      - "8001:80"
    depends_on:
      - db
    networks:
      - app_net

volumes:
  db_data:

networks:
  app_net:
    driver: bridge

Berikut adalah apa yang kami tambah:

• rangkaian (peringkat atas): Ini menentukan rangkaian baru bernama app_net dan menyatakan bahawa ia harus menggunakan pemacu standard bridge.
• rangkaian (tahap perkhidmatan): Di bawah kedua-dua db dan wordpress, kunci ini menghubungkan mereka ke rangkaian app_net kami.

Jika anda mempunyai perkhidmatan ketiga (seperti alat analitik) yang anda tidak sambungkan ke app_net, ia akan sepenuhnya terasing dan tidak dapat berkomunikasi dengan bekas db atau wordpress.

Untuk kluster pelbagai hos dengan Docker Swarm, anda perlu menukar driver daripada bridge kepada overlay. bridge driver adalah untuk komunikasi antara kontena pada satu hos sahaja, yang merupakan standard bagi kebanyakan kes penggunaan Docker Compose.

Menggunakan Fail Konfigurasi Modular

Apabila aplikasi anda berkembang, fail docker-compose.yml anda boleh menjadi besar dan sukar diurus. Docker Compose menyokong arahan include, membolehkan anda memecahkan konfigurasi anda merentasi berbilang fail.

Bayangkan anda ingin memisahkan definisi WordPress dan pangkalan data anda, dan mungkin mempunyai docker-compose.override.yml biasa untuk tetapan khusus pembangunan (seperti mengikat port pada pangkalan data).

Struktur direktori anda mungkin kelihatan seperti ini:

compose-demo/
├── docker-compose.yml
├── docker-compose.db.yml
├── docker-compose.web.yml

Fail ini akan hanya mentakrifkan perkhidmatan db.

services:
  db:
    image: mysql:8.0
    container_name: mysql_db
    volumes:
      - db_data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: <^your_root_password_here<^>
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress_user
      MYSQL_PASSWORD: <^your_wordpress_password_here<^>
    restart: unless-stopped

volumes:
  db_data:

Fail ini akan hanya mentakrifkan perkhidmatan wordpress.

services:
  wordpress:
    image: wordpress:latest
    container_name: wordpress_app
    ports:
      - "8001:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress_user
      WORDPRESS_DB_PASSWORD: <^your_wordpress_password_here<^>
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - ./wp_content:/var/www/html/wp-content
    depends_on:
      - db
    restart: unless-stopped

Sekarang, fail utama docker-compose.yml anda menjadi sangat mudah. Ia hanya menggunakan include untuk memasukkan fail-fail lain.

include:
  - docker-compose.db.yml
  - docker-compose.web.yml

Apabila anda menjalankan docker compose up -d, Compose akan membaca ketiga-tiga fail, menggabungkan konfigurasi, dan memulakan perkhidmatan db serta wordpress seolah-olah ia ditakrifkan dalam satu fail sahaja. Pendekatan ini menjadikan konfigurasi anda lebih modular dan boleh digunakan semula.

Beralih dari docker-compose (v1) ke docker compose (v2)

Perintah docker compose yang anda pasang dalam Langkah 1 ialah “Compose v2.” Ia ialah plugin berasaskan Go yang dibina terus ke dalam CLI Docker.

Versi asal, “Compose v1,” ialah alat Python yang berasingan yang dipanggil dengan docker-compose (dengan sengkang). Sehingga Julai 2023, Compose v1 tidak lagi disokong dan telah dihentikan.

Perubahan Utama dan Keserasian Terbalik

• Perintah: Perubahan yang paling ketara ialah perintah itu sendiri. Tanda hubung (docker-compose) kini digantikan dengan ruang (docker compose).
• Pemasangan: v1 dipasang menggunakan pip. v2 disertakan bersama Docker Desktop atau dipasang sebagai plugin CLI, seperti yang anda lakukan dalam Langkah 1.
• Fail YAML: Fail docker-compose.yml anda hampir 100% serasi ke belakang. Compose v2 sepenuhnya menyokong versi fail 3.x. Anda tidak perlu menukar fail YAML anda untuk migrasi, hanya arahan anda sahaja.
• --project-name bendera: Bendera -p masih berfungsi, tetapi bendera penuh kini adalah --project-name dan bukannya --project_name.

Panduan Migrasi Perintah

Kebanyakan arahan adalah sama, cuma tanda sempang dikeluarkan. Berikut ialah jadual yang membandingkan arahan v1 yang biasa dengan setara v2 mereka.

docker-compose up -d

docker compose up -d

docker-compose down

docker compose down

docker-compose ps

docker compose ps

docker-compose logs

docker compose logs

docker-compose stop

docker compose stop

docker-compose build

docker compose build

docker-compose exec web bash

docker compose exec web bash

docker-compose run web bash

docker compose run web bash

docker-compose up --scale web=3

docker compose up --scale web=3

Seperti yang anda boleh lihat, untuk kebanyakan penggunaan harian, satu-satunya perubahan adalah docker-compose -> docker compose. Jika anda menggunakan skrip, anda boleh mengemaskininya dengan hanya membuang tanda sengkang.

Jika anda masih mempunyai docker-compose v1 lama yang dipasang, anda boleh mengeluarkannya untuk mengelakkan kekeliruan:

sudo pip3 uninstall docker-compose

Atau, jika ia dipasang oleh apt:

sudo apt remove docker-compose

Menangani Masalah Biasa Docker Compose

Apabila anda bekerja dengan Docker Compose, anda mungkin menghadapi isu berkaitan dengan sintaks fail, kebenaran, atau konflik masa jalan kontena. Kebanyakan masalah boleh didiagnosis dan diselesaikan dengan memeriksa konfigurasi, kebenaran, dan log kontena anda secara sistematik.

Mari kita lihat beberapa kesilapan yang paling biasa dan penyelesaiannya.

Kebenaran Ditolak (Soket Docker)

Ini adalah salah satu ralat yang paling biasa bagi pengguna Docker baru. Anda menjalankan docker compose up dan melihat mesej ralat mengenai soket daemon Docker.

permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock

• Masalah: Pengguna bukan root anda tidak mempunyai kebenaran untuk berkomunikasi dengan Docker daemon, yang dijalankan sebagai root.

• Penyelesaian: Anda mesti menambah pengguna anda ke dalam kumpulan docker, yang telah dicipta semasa pemasangan Docker.

  1. Tambah pengguna anda ke dalam kumpulan docker:

     sudo usermod -aG docker ${USER}

  2. Untuk keanggotaan kumpulan baru berkuat kuasa, anda mesti log keluar dan log masuk semula.

  3. Sebagai alternatif, anda boleh mengaktifkan perubahan kumpulan untuk sesi terminal anda semasa dengan menaip:

     newgrp docker

  Ini sepatutnya menyelesaikan sebarang ralat kebenaran yang berkaitan dengan soket Docker.

Ralat Sintaks dan Indentasi YAML

Docker Compose gagal dijalankan dan melaporkan bahawa fail docker-compose.yml anda tidak sah.

ERROR: The Compose file './docker-compose.yml' is invalid because:
services.web.ports contains an invalid type, it should be a list

Atau :

mapping values are not allowed in this context at line 5

• Masalah: Fail docker-compose.yml bergantung kepada sintaks YAML yang ketat. Kesilapan yang paling biasa adalah indentasi yang tidak betul. YAML menggunakan ruang, bukan tab, untuk menentukan struktur.

• Penyelesaian: Periksa dengan teliti penjajaran dalam fail docker-compose.yml anda.

  • Standardnya adalah dua ruang untuk setiap tahap penjorokan.
  • Pastikan semua kunci pada tahap yang sama (seperti version, services, volumes) bermula di lajur yang sama.
  • Pastikan semua sub-kunci (seperti image, ports, volumes di bawah sesuatu perkhidmatan) diindentkan dua ruang lebih daripada perkhidmatan induknya (contohnya, web).
  • Gunakan penyunting kod dengan pemeriksa YAML untuk menonjolkan ralat sintaks secara automatik.

Pertembungan Port

Anda cuba untuk memulakan persekitaran anda, tetapi arahan gagal dengan mesej ralat bahawa alamat tersebut sudah digunakan.

Error starting userland proxy: listen tcp 0.0.0.0:8000: bind: address already in use

• Masalah: Proses lain pada mesin hos anda sudah menggunakan port yang anda cuba peta (dalam kes ini, port 8000). Ini selalunya merupakan bekas Docker lain atau pelayan pembangunan tempatan.

• Penyelesaian: Anda mempunyai dua pilihan:

  1. Hentikan proses lain. Anda boleh mencari proses yang menggunakan port dengan arahan ini:

     sudo lsof -i :8000

     Jika ia adalah bekas Docker lain, hentikannya dengan docker stop <container_id>.

  2. Tukar port hos dalam fail docker-compose.yml anda. Ini selalunya merupakan penyelesaian yang paling mudah. Tukar pemetaan ports daripada "8000:80" kepada port yang lain, seperti "8001:80".

     ...
     ports:
       - "8001:80" # Changed from 8000
     ...

  docker-compose.yml

Perkhidmatan Gagal dengan Connection Refused (depends_on)

Dalam aplikasi berbilang perkhidmatan (seperti contoh WordPress dan MySQL), bekas wordpress akan mula berjalan tetapi lognya menunjukkan Connection refused atau MySQL server has gone away apabila cuba menyambung ke perkhidmatan db.

• Masalah: Anda telah menggunakan depends_on, tetapi arahan ini hanya menunggu bekas db untuk mulai. Ia tidak menunggu aplikasi MySQL di dalam bekas untuk sepenuhnya dimulakan dan bersedia menerima sambungan.

• Penyelesaian: Aplikasi (dalam kes ini, WordPress) mesti dikonfigurasikan untuk mencuba semula sambungannya. Kebanyakan imej moden mempunyai logik cubaan semula ini terbina dalam. Bagi imej yang tidak mempunyai logik ini, anda mesti melaksanakan pemeriksaan kesihatan.

  Anda boleh menambah healthcheck pada perkhidmatan db anda. Perkhidmatan wordpress dengan depends_on kemudian boleh dikonfigurasikan untuk menunggu pangkalan data menjadi "sihat," bukan hanya "dimulakan."

Contoh Pemeriksaan Kesihatan untuk MySQL:

services:
  db:
    image: mysql:8.0
    ...
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p<^your_root_password_here<^>"]
      interval: 10s
      timeout: 5s
      retries: 5

  wordpress:
    image: wordpress:latest
    ...
    depends_on:
      db:
        condition: service_healthy # This now waits for the healthcheck
    ...

Ralat dengan Isipadu dan Pemasangan Ikatan

Anda mungkin menghadapi ralat kebenaran dalam log bekas anda, atau mendapati bahawa direktori data bekas anda kosong.

Kebenaran Fail/Directory

• Masalah: Kontena berjalan sebagai pengguna tertentu (contohnya, www-data dengan ID Pengguna 33), tetapi direktori tuan rumah yang anda pautkan dimiliki oleh pengguna anda (contohnya, ubuntu dengan ID Pengguna 1000). Pengguna dalam kontena tidak mempunyai kebenaran untuk menulis ke direktori tuan rumah.

• Penyelesaian: Tukar pemilikan direktori hos supaya sepadan dengan ID pengguna di dalam bekas. Anda boleh mengetahui ID pengguna bekas dengan menjalankan docker compose exec <service_name> id. Sebagai contoh, jika ID ialah 33 (biasa untuk www-data):

  sudo chown -R 33:33 ./wp_content

Isu Laluan Berkaitan

• Masalah: docker-compose.yml anda menggunakan laluan relatif seperti ./app, tetapi fail index.html anda tidak dihidangkan.

• Penyelesaian: Docker Compose mentafsir laluan relatif dari direktori di mana anda menjalankan perintah docker compose up. Sentiasa jalankan perintah Compose dari direktori yang sama yang mengandungi fail docker-compose.yml anda.

Rangkaian dan Penemuan Perkhidmatan

Log bekas aplikasi anda menunjukkan Hos tidak ditemui atau Tidak dapat menyelesaikan hos: db.

• Masalah: wordpress container anda tidak dapat mencari db container pada rangkaian.

• Penyelesaian: Secara lalai, Docker Compose akan mencipta rangkaian dan menyambungkan semua perkhidmatan kepadanya. Perkhidmatan boleh mencari satu sama lain menggunakan nama perkhidmatan mereka.

  1. Semak Nama Perkhidmatan: Pastikan nama hos dalam konfigurasi aplikasi anda (contohnya, pembolehubah persekitaran WORDPRESS_DB_HOST) adalah tepat sama dengan nama perkhidmatan dalam docker-compose.yml anda (contohnya, db).

  2. Periksa Rangkaian: Gunakan docker compose ps untuk mencari nama projek anda (contohnya, compose-demo). Kemudian, periksa rangkaian lalai:

     docker network inspect compose-demo_default

     Output JSON akan menyenaraikan semua kontena yang disambungkan ke rangkaian ini. Jika salah satu perkhidmatan anda tiada, semak docker-compose.yml anda untuk sebarang konfigurasi networks tersuai yang mungkin mengasingkannya.

Ketidakpadanan Arahan (v1 vs. v2)

Anda taip docker-compose up (dengan tanda sempang) dan melihat ralat “perintah tidak ditemui”.

docker-compose: command not found

• Masalah: Anda sedang cuba menggunakan arahan untuk Compose v1, yang merupakan alat Python yang tidak lagi dikembangkan. Panduan ini memasang Compose v2, yang merupakan plugin yang disepadukan terus ke dalam Docker CLI.
• Penyelesaian: Gunakan arahan yang betul dengan menggantikan tanda sempang (-) dengan ruang.

Sentiasa gunakan docker compose (ruang) apabila mengikuti panduan ini.

Soalan Lazim

1. Apa kegunaan Docker Compose?

Docker Compose ialah alat untuk mentakrif dan menjalankan aplikasi Docker berbilang kontena.

Ia menggunakan satu fail YAML (secara lalai, docker-compose.yml) untuk mengkonfigurasi semua komponen aplikasi anda, yang dipanggil perkhidmatan. Fail ini juga menentukan rangkaian yang membolehkan perkhidmatan berkomunikasi antara satu sama lain dan volume yang digunakan untuk data yang kekal.

Dengan satu fail ini, anda boleh mengurus keseluruhan tumpukan aplikasi anda dengan arahan yang mudah:

• docker compose up memulakan dan menjalankan keseluruhan aplikasi anda, termasuk semua bekas, rangkaian, dan volum yang ditetapkan.
• docker compose down menghentikan dan membuang semua kontena, rangkaian, dan volum yang dicipta oleh aplikasi anda.

Ia sangat berguna untuk mengurus aplikasi yang memerlukan pelbagai komponen, seperti laman web yang memerlukan pelayan web (seperti Nginx), backend aplikasi (seperti WordPress), dan pangkalan data (seperti MySQL).

2. Bagaimana saya memasang Docker Compose di Ubuntu?

Kaedah yang disyorkan adalah memasang Docker Compose sebagai plugin untuk Docker CLI. Ini dilakukan dengan memasang pakej docker-compose-plugin daripada repositori rasmi apt Docker.

1. Pertama, pastikan anda telah mengikuti dokumentasi rasmi Docker untuk menyediakan repositori apt Docker pada sistem Ubuntu anda.

2. Kemas kini senarai pakej anda:

   sudo apt update

3. Pasang pemalam Docker Compose:

   sudo apt install docker-compose-plugin

4. Sahkan pemasangan dengan memeriksa versi. Arahan menggunakan ruang, bukan tanda sempang.

   docker compose version

3. Bagaimana saya boleh mengemas kini Docker Compose ke versi terkini?

Kerana Docker Compose (v2) dipasang sebagai pakej sistem menggunakan apt, anda boleh mengemas kini ia menggunakan proses kemas kini perisian standard Ubuntu.

1. Segarkan indeks pakej tempatan anda:

   sudo apt update

2. Jalankan peningkatan sistem keseluruhan, yang akan termasuk plugin Compose:

   sudo apt upgrade

   Sebaliknya, jika anda hanya mahu mengemas kini plugin itu sendiri, anda boleh jalankan:

   sudo apt install --only-upgrade docker-compose-plugin

4. Bolehkah Docker Compose digunakan dalam persekitaran pengeluaran?

Ya, Docker Compose sering digunakan dalam pengeluaran, terutamanya untuk aplikasi yang dijalankan pada hos tunggal.

Ia menyediakan cara yang mudah untuk mentakrifkan, menyebarkan, dan mengurus kitar hayat perkhidmatan, rangkaian, dan volum aplikasi anda. Untuk penyebaran pelayan tunggal, ia adalah penyelesaian yang sangat berkesan dan mudah diurus.

Untuk senario yang lebih kompleks yang memerlukan penyelarasan bekas merentasi pelbagai hos (satu kluster), alat lain lebih biasa digunakan. Ini termasuk Docker Swarm (yang menggunakan sintaks fail Compose yang serupa) dan Kubernetes (yang merupakan piawaian industri untuk orkestrasi bekas skala besar).

5. Apakah perbezaan antara Docker dan Docker Compose?

Jadual ini menggambarkan perbezaan utama antara Docker CLI dan Docker Compose CLI.

Ringkasnya, anda menggunakan docker untuk berinteraksi dengan satu kontena. Anda menggunakan docker compose untuk mengurus seluruh tumpukan aplikasi anda (contohnya, web, app, db) sekaligus.

6. Bagaimana saya menjalankan pelbagai kontena dengan Docker Compose?

Anda menjalankan pelbagai kontena dengan mentakrifkannya sebagai perkhidmatan dalam fail docker-compose.yml anda.

1. Buat fail bernama docker-compose.yml.

2. Di dalam fail ini, gunakan kekunci services: untuk mendefinisikan setiap kontena yang anda ingin jalankan.

   Berikut adalah contoh praktikal yang mentakrif dan menjalankan dua kontena: sebuah laman WordPress dan pangkalan data MySQL.

   services:
     db:
       # This is the first service (container)
       image: mysql:8.0
       environment:
         MYSQL_ROOT_PASSWORD: <^your_password_here<^>
         MYSQL_DATABASE: wordpress
       volumes:
         - db_data:/var/lib/mysql
   
     wordpress:
       # This is the second service (container)
       image: wordpress:latest
       ports:
         - "8001:80"
       environment:
         WORDPRESS_DB_HOST: db
         WORDPRESS_DB_PASSWORD: <^your_password_here<^>
       depends_on:
         - db
   
   volumes:
     db_data:

docker-compose.yml

3. Simpan fail dan buka terminal di direktori yang sama.

4. Jalankan satu arahan untuk memulakan kedua-dua kontena:

   docker compose up -d

Docker Compose akan membaca fail tersebut, mencipta rangkaian kongsi untuk perkhidmatan, memuat turun kedua-dua imej mysql dan wordpress, dan memulakan sebuah kontena untuk setiap perkhidmatan.

7. Mengapa menggunakan Docker Compose untuk pembangunan?

Docker Compose adalah alat standard untuk persekitaran pembangunan kerana ia menyelesaikan beberapa masalah biasa.

• Persekitaran Konsisten: Ia memastikan setiap pembangun dalam satu pasukan menjalankan perkhidmatan yang sama tepat (pangkalan data, cache, pelayan web) dengan versi dan konfigurasi yang sama tepat. Ini ditakrifkan dalam fail docker-compose.yml, yang disimpan dalam kawalan versi. Ini menghapuskan masalah “ia berfungsi di komputer saya”.

• Kepelbagaian: Ia menggantikan skrip penetapan yang kompleks dan arahan docker run yang panjang. Seorang pembangun hanya perlu menjalankan docker compose up untuk memulakan seluruh tumpukan aplikasi dan docker compose down untuk menghentikannya.

• Pemisahan Perkhidmatan: Pembangun boleh bekerja pada pelbagai projek pada mesin yang sama tanpa konflik kebergantungan. Projek A boleh menggunakan PostgreSQL 9.6 dan Projek B boleh menggunakan PostgreSQL 14, kerana setiap pangkalan data dijalankan dalam bekas yang terasing yang diuruskan oleh fail Compose masing-masing.

• Ujian Integrasi Mudah: Kerana Compose memulakan semua kebergantungan aplikasi sekaligus, ia mewujudkan persekitaran tempatan yang sempurna untuk menjalankan ujian integrasi yang mengesahkan bagaimana perkhidmatan berinteraksi antara satu sama lain.

Kesimpulan

Dalam panduan ini, anda telah memasang Docker Compose dan mengkonfigurasi aplikasi multi-container yang lengkap. Anda bermula dengan fail docker-compose.yml asas untuk pelayan web Nginx dan berkembang ke susunan yang lebih kompleks dan realistik yang melibatkan aplikasi WordPress dan pangkalan data MySQL. Anda telah mempelajari cara mengurus keseluruhan kitaran hayat aplikasi, daripada membina dan menjalankan perkhidmatan hingga memberhentikan dan menghapusnya.

Anda kini sudah biasa dengan konsep utama untuk mengurus aplikasi dengan berkesan, termasuk skala perkhidmatan, definisi rangkaian tersuai, dan membahagikan konfigurasi anda ke dalam fail modul menggunakan arahan include. Dengan mengikuti panduan migrasi dan langkah-langkah penyelesaian masalah, anda juga boleh menyelesaikan masalah biasa seperti konflik port, ralat “Permission denied”, dan kesilapan sintaks YAML. Kemahiran yang dibincangkan di sini akan membolehkan anda membina persekitaran pembangunan yang konsisten dan boleh diulang serta melancarkan aplikasi satu hos dengan yakin.

Untuk rujukan lengkap bagi semua arahan docker compose yang tersedia, semak dokumentasi rasmi.

Untuk lebih banyak tutorial berkaitan Docker, sila lihat artikel-artikel berikut:

• Cara Memasang Docker pada Ubuntu – Panduan Langkah demi Langkah
• Cara Memasang WordPress Dengan Docker Compose

Terima kasih kerana belajar bersama Komuniti Linux-Console.net.