„Compose“ su­pa­pras­ti­na programų mastelio keitimą ir diegimą „Docker“ aplinkoje, au­to­ma­ti­zuo­da­ma kon­t­ei­ne­rių valdymą. Mūsų pamoka išsamiai nagrinėja „Docker Compose“ nustatymą ir naudojimą, siekiant op­ti­mi­zuo­ti jūsų programų diegimo procesą.

Kas yra „Docker Compose“?

„Docker Compose“ nau­do­ja­mas prog­ra­moms valdyti ir kon­t­ei­ne­rių kūrimo efek­ty­vu­mui didinti. Kon­fi­gū­ra­ci­jos api­brė­žia­mos viename YAML faile, todėl programas lengva kurti ir mas­te­lin­ti. „Docker Compose“ dažnai nau­do­ja­mas vietinei aplinkai su­kon­fi­gū­ruo­ti. Tačiau jis taip pat gali būti nuo­la­ti­nės in­te­g­ra­ci­jos ir nuo­la­ti­nio pri­sta­ty­mo (CI/CD) darbo eigos dalis. Kūrėjai gali apibrėžti konkrečią kon­t­ei­ne­rio versiją te­sta­vi­mui arba konk­re­čioms procesų grandinės fazėms. Tai leidžia lengviau nustatyti problemas ir ištaisyti klaidas prieš programai patekant į gamybą.

„Docker Compose“ rei­ka­la­vi­mai

Kon­t­ei­ne­rių ko­or­di­na­vi­mui rei­ka­lin­gi tiek „Docker Engine“, tiek „Docker Compose“. Įsi­ti­kin­ki­te, kad jūsų sistemoje yra įdiegta viena iš šių programų:

  • „Docker Engine“ ir „Docker Compose“: galima įdiegti kaip atskirus vyk­do­muo­sius failus.
  • „Docker Desktop“: kūrimo aplinka su grafinė vartotojo sąsaja, įskaitant „Docker Engine“ ir „Docker Compose“.
Tip

Mūsų pamokose su­ži­no­si­te, kaip įdiegti „Docker Compose“ įvairiose ope­ra­ci­nė­se sistemose:

Išsamus vadovas, kaip naudoti „Docker Compose“

Toliau pa­ro­dy­si­me, kaip naudoti „Docker Compose“ su paprasta „Python“ ži­nia­tink­lio programa, kurioje nau­do­ja­mas ap­si­lan­ky­mų skai­tik­lis. Tam pa­si­telk­si­me „Python Flask“ sistemą ir atminties duomenų bazę „Redis“. „Python“ ar „Redis“ diegti nereikia, nes jie pa­tei­kia­mi kaip „Docker“ atvaizdai.

1 žingsnis: Sukurkite projekto failus

Pa­lei­s­ki­te terminalą ir sukurkite naują aplanką projektui.

$ mkdir composedemo
shell

Pereikite į tą katalogą.

$ cd composedemo
shell

Šiame aplanke sukurkite failą „app.py“ ir į jį įterpkite šį kodą:

import time
import redis
from flask import Flask
app = Flask(__name__)
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 World! I was here {} times.\n'.format(count)
python

Mūsų kon­fi­gū­ra­ci­jo­je naudojame redis kaip kom­piu­te­rio vardą ir nu­ma­ty­tą­jį 6379 prievadą pri­si­jun­gi­mui prie „Redis“ paslaugos. Be to, nurodome, kad funkcija get_hit_count() turėtų atlikti kelis pri­si­jun­gi­mo prie paslaugos bandymus. Tai re­ko­men­duo­ja­ma tais atvejais, kai „Redis“ gali būti ne iš karto pa­sie­kia­ma paleidus programą arba kai vykdymo metu gali kilti laikini ryšio su­tri­ki­mai.

Sukurkite failą „require­ments.txt“ su pri­klau­so­my­bė­mis:

flask
redis
plaintext

2 žingsnis: Sukurkite „Doc­ker­fi­le“ failą

„Doc­ker­fi­le“ nau­do­ja­mas Docker atvaizdui sukurti. Jame nurodomos visos Python programai rei­ka­lin­gos pri­klau­so­my­bės.

# syntax=docker/dockerfile:1
FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
RUN apk add --no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
EXPOSE 5000
COPY . .
CMD ["flask", "run"]
shell

Nurodome „Docker“ naudoti „Python 3.7“ atvaizdą. Be to, nustatome reikiamas aplinkos kin­ta­muo­sius komandai „flask“. Naudodami apk add, įdiegiame būtinas pri­klau­so­my­bes, įskaitant „gcc“. Kad kon­t­ei­ne­ris galėtų stebėti 5000 prievadą, nurodome EXPOSE. Naudodami COPY, per­ke­lia­me da­bar­ti­nio aplanko turinį į darbo katalogą /code kon­t­ei­ne­rio viduje. Ga­liau­siai kaip nu­ma­ty­tą­ją komandą kon­t­ei­ne­riui pa­si­ren­ka­me flask run.

Pa­tik­rin­ki­te, ar failas „Doc­ker­fi­le“ buvo iš­sau­go­tas be failo plėtinio, nes kai kurie re­dak­to­riai au­to­ma­tiš­kai prideda plėtinį .txt.

3 žingsnis: Sukurkite YAML failą

Failo „docker-compose.yml“ kon­fi­gū­ruo­ja­me paslaugas „redis“ ir „web“.

version: "3.9"
services:
    web:
        build: .
        ports:
            - "8000:5000"
    redis:
        image: "redis:alpine"
yaml

Ši ži­nia­tink­lio paslauga sukurta naudojant „Doc­ker­fi­le“ sukurtą „Docker“ atvaizdą. Ji susieja kon­t­ei­ne­rį ir pag­rin­di­nį kom­piu­te­rį su 8000 prievadu, o „Flask“ ži­nia­tink­lio serveris veikia 5000 prievade. Tuo tarpu „Redis“ atvaizdas gaunamas tie­sio­giai iš ofi­cia­laus „Docker Hub“.

4 žingsnis: Pa­lei­s­ki­te programą naudodami „Compose“

Pa­lei­s­ki­te programą iš savo projekto aplanko.

docker compose up
shell

Nar­šyk­lė­je ati­da­ry­ki­te puslapį http://localhost:8000. Taip pat galite įvesti adresą http://127.0.0.1:8000.

Tu­rė­tu­mė­te pamatyti tokį pranešimą:

Image: Docker Compose Application: Output the number of visits in the browser
You’ll see the number of times you have visited the browser.

At­nau­jin­ki­te puslapį. Peržiūrų skaičius dabar turėtų būti padidėjęs 1.

Image: Calling the Docker Compose application again
The number of visits increased by 1.

Už­da­ry­ki­te programą naudodami:

$ docker compose down
shell

Norėdami su­stab­dy­ti programos veikimą, terminale tiesiog įveskite Ctrl + C.

5 žingsnis: Pridėkite „bind“ montavimą

Jei norite pridėti pri­ri­ša­mą­jį montavimą ži­nia­tink­lio paslaugai, tai galite padaryti faile „docker-compose.yml“.

version: "3.9"
services:
    web:
        build: .
        ports:
            - "8000:5000"
        volumes:
            - .:/code
        environment:
            FLASK_DEBUG: "true"
    redis:
        image: "redis:alpine"
yaml

Skyriuje „Volumes“ nurodome, kad da­bar­ti­nis projekto aplankas turi būti pri­skir­tas kon­t­ei­ne­rio viduje esančiam katalogui /code. Tai leidžia sklan­džiai keisti kodą be būtinybės iš naujo kurti atvaizdą. Kin­ta­ma­sis FLASK_DEBUG nurodo flask run veikti kūrimo režimu.

6 žingsnis: Atkurti ir paleisti programą

Terminale įveskite šią komandą, kad per­kom­pi­liuo­tu­mė­te „Compose“ failą:

docker compose up
shell

7 žingsnis: At­nau­jin­ki­te programą

Dabar, kai savo prog­ra­mo­je naudojate „bind mount“, galite keisti kodą ir au­to­ma­tiš­kai matyti pa­kei­ti­mus be būtinybės iš naujo kurti atvaizdą.

Pa­ra­šy­ki­te naują „welcome“ testą faile „app.py“.

return 'Hello from Docker! I was here {} times.\n'.format(count)
python

At­nau­jin­ki­te naršyklę, kad pa­tik­rin­tu­mė­te, ar pa­kei­ti­mai įsi­ga­lio­jo.

Image: Docker Compose application: modified welcome text
The welcome text in the Python ap­p­li­ca­tion has been modified

8 žingsnis: kitos komandos

--help parinkčių sąraše pa­tei­kia­mos „Docker Compose“ komandos:

docker compose --help
shell

Norėdami paleisti „Docker Compose“ fone, galite nurodyti argumentą -d “:

docker compose up -d
shell

Naudokite down, kad pa­ša­lin­tu­mė­te visus kon­t­ei­ne­rius. Komanda --volumes ištrina „Redis“ kon­t­ei­ne­riui nau­do­ja­mus tomus.

docker compose down --volumes
shell
Go to Main Menu