Docker dan Kubernetes untuk Pembangun · Pelajaran

Aplikasi Berbilang Kontena dengan Compose

Orkestrasikan berbilang kontena Docker seperti aplikasi web dan pangkalan data menggunakan Docker Compose untuk pembangunan setempat.

Pelajaran 3 daripada 412 langkah

Aplikasi Berbilang Kontena dengan Compose ialah pelajaran Docker dan Kubernetes untuk Pembangun percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Docker dan Kubernetes untuk Pembangun, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Docker dan Kubernetes untuk Pembangun merangkumi sejumlah 4 pelajaran.

Mengapa Aplikasi Berbilang Bekas?

Dalam aplikasi dunia sebenar, anda jarang hanya mempunyai satu komponen. Bayangkan aplikasi web: anda memerlukan pelayan web (seperti Nginx), aplikasi bahagian belakang (seperti Python Flask), dan pangkalan data (seperti Redis atau PostgreSQL).

Setiap komponen ini mempunyai kebergantungan dan konfigurasi tersendiri. Mengurusnya secara berasingan serta memastikan semuanya berkomunikasi dengan betul boleh menjadi rumit dengan cepat.

Kenali Docker Compose

Docker Compose ialah alat yang direka untuk memudahkan proses mentakrifkan dan menjalankan aplikasi Docker berbilang bekas.

Anda mentakrifkan semua perkhidmatan aplikasi anda (bekas) dalam satu fail YAML.
Kemudian, dengan satu arahan mudah, Compose mencipta dan memulakan semua perkhidmatan untuk anda.
Ia amat berguna untuk persekitaran pembangunan dan pengujian setempat.

Fail YAML Compose

Teras Docker Compose ialah fail docker-compose.yml. Fail YAML ini menerangkan perkhidmatan, rangkaian dan volum aplikasi anda.

Fail ini biasanya bermula dengan kunci version, diikuti bahagian utama services yang digunakan untuk mentakrifkan setiap bekas yang membentuk aplikasi anda.

Mentakrifkan Perkhidmatan

Di bawah bahagian services, anda menyenaraikan setiap komponen aplikasi anda. Setiap perkhidmatan sepadan dengan satu bekas Docker.

Sifat utama untuk mentakrifkan perkhidmatan termasuk:

image: Menentukan imej Docker yang hendak digunakan (contohnya, nginx:latest).
build: Menyediakan laluan ke direktori yang mengandungi Dockerfile untuk membina imej tersuai.
container_name: Nama tetap pilihan untuk bekas anda supaya lebih mudah dirujuk.

Mendedahkan dan Mengkonfigurasi Perkhidmatan

Anda biasanya perlu mendedahkan perkhidmatan kepada mesin hos atau mengkonfigurasikannya dengan pemboleh ubah persekitaran.

ports: Memetakan port daripada hos kepada bekas (contohnya, "8080:80" memetakan port hos 8080 kepada port bekas 80).
environment: Menghantar pemboleh ubah persekitaran ke dalam bekas (contohnya, DB_HOST: "database").

Tetapan ini penting untuk komunikasi dan penyesuaian.

Menyambungkan Perkhidmatan Anda

Apabila anda menggunakan Docker Compose, ia secara automatik mencipta rangkaian lalai untuk aplikasi anda. Semua perkhidmatan yang ditakrifkan dalam fail docker-compose.yml anda menyertai rangkaian ini.

Hal ini membolehkan perkhidmatan berkomunikasi antara satu sama lain menggunakan nama perkhidmatan sebagai nama hos. Contohnya, perkhidmatan aplikasi web boleh bersambung kepada perkhidmatan pangkalan data bernama redis dengan hanya menggunakan redis sebagai nama hos.

Contoh: Python + Redis

Mari bina aplikasi berbilang bekas yang ringkas: aplikasi web Python Flask yang mengira bilangan kali aplikasi itu dilawati, sambil menyimpan kiraan tersebut dalam pangkalan data Redis.

Persediaan ini menunjukkan dengan jelas cara perkhidmatan 'web' boleh berinteraksi dengan perkhidmatan 'database' dalam satu aplikasi Compose.

Kod Aplikasi Web dan Dockerfile

Berikut ialah aplikasi Python Flask ringkas kita (app.py) dan Dockerfilenya. Aplikasi Flask bersambung kepada perkhidmatan redis, manakala Dockerfile membungkus semuanya.

# app.py
import time
import redis
from flask import Flask

app = Flask(__name__)
# Connects to 'redis' service in Compose network
cache = redis.Redis(host='redis', port=6379)

def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)

@app.route('/')
def hello():
    count = get_hit_count()
    return 'Hello from CoddyKit! I have been seen {} times.\n'.format(count)

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)

# requirements.txt
# flask
# redis

# Dockerfile
FROM python:3.9-slim-buster
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app.py"]

Fail Compose Pertama Anda

docker-compose.yml ini menggabungkan semuanya. Ia mentakrifkan dua perkhidmatan: web (aplikasi Python kita, dibina daripada direktori semasa) dan redis (menggunakan imej Redis rasmi).

Cuba jalankan contoh ini!

version: '3.8'
services:
  web:
    build: .
    ports:
      - "5000:5000"
  redis:
    image: "redis:alpine"

Mengurus Aplikasi Compose Anda

Untuk memulakan aplikasi berbilang bekas dalam mod terpisah (di latar belakang), pergi ke direktori yang mengandungi docker-compose.yml dan fail sokongan anda, kemudian jalankan:

docker compose up -d

Untuk melihat perkhidmatan yang sedang berjalan dan statusnya:

docker compose ps

Untuk menghentikan dan mengalih keluar bekas, rangkaian serta volum yang dicipta oleh Compose:

docker compose down

Semakan Konfigurasi Compose

Pertimbangkan petikan docker-compose.yml berikut:

version: '3.8'
services:
  app:
    build: .
    ports:
      - "8080:80"
  database:
    image: "postgres:13"

Pernyataan manakah yang TRUE tentang konfigurasi ini?

Jawab dalam pelajaran interaktif

Imbas Kembali: Docker Compose

Anda telah mempelajari cara Docker Compose memudahkan pengurusan aplikasi berbilang bekas untuk pembangunan setempat!

Ia menggunakan fail docker-compose.yml untuk mentakrifkan semua perkhidmatan anda.
Perkhidmatan boleh berkomunikasi antara satu sama lain menggunakan nama perkhidmatan pada rangkaian lalai.
Arahan seperti docker compose up dan docker compose down mengurus seluruh susunan aplikasi anda dengan mudah.

Docker Compose ialah alat penting untuk persediaan pembangunan setempat yang melibatkan berbilang bekas Docker.

Percuma untuk bermula

Pelajari Docker dan Kubernetes untuk Pembangun dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 12
Pelajaran: 48

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Aplikasi Berbilang Kontena dengan Compose” percuma?

Ya — teks penuh “Aplikasi Berbilang Kontena dengan Compose” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Docker dan Kubernetes untuk Pembangun, tingkat taraf kepada CoddyKit PRO. Kursus Docker dan Kubernetes untuk Pembangun merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Aplikasi Berbilang Kontena dengan Compose”?

Orkestrasikan berbilang kontena Docker seperti aplikasi web dan pangkalan data menggunakan Docker Compose untuk pembangunan setempat. Anda berlatih Docker dan Kubernetes untuk Pembangun menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Docker dan Kubernetes untuk Pembangun?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Docker dan Kubernetes untuk Pembangun di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Aplikasi Berbilang Kontena dengan Compose” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Docker dan Kubernetes untuk Pembangun ini?

Ya. Setiap pelajaran Docker dan Kubernetes untuk Pembangun menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Membina Dockerfile untuk Imej
Membina Imej Docker Tersuai
Aplikasi Berbilang Kontena dengan Compose
Mengekalkan Data dengan Volume Docker

← Kembali ke Docker dan Kubernetes untuk Pembangun