Compose helpottaa so­vel­lus­ten skaa­laus­ta ja käyt­töön­ot­toa Doc­ke­ris­sa au­to­ma­ti­soi­mal­la konttien hallinnan. Op­paas­sam­me kä­si­tel­lään pe­rus­teel­li­ses­ti Docker Compose -työkalun asennusta ja käyttöä, jotta voit tehostaa so­vel­lus­ten käyt­töön­ot­topro­ses­sia.

Mikä on Docker Compose?

Docker Composea käytetään so­vel­lus­ten hal­lin­taan ja kont­ti­ke­hi­tyk­sen te­hos­ta­mi­seen. Mää­ri­tyk­set mää­ri­tel­lään yhdessä YAML-tie­dos­tos­sa, mikä helpottaa so­vel­lus­ten ra­ken­ta­mis­ta ja skaa­laa­mis­ta. Docker Composea käytetään usein pai­kal­li­sen ym­pä­ris­tön mää­rit­tä­mi­seen. Se voi kuitenkin olla myös osa jatkuvan in­tegroin­nin ja jatkuvan toi­mi­tuk­sen (CI/CD) työn­kul­kua. Ke­hit­tä­jät voivat määrittää tietyn kont­ti­ver­sion testausta tai tiettyjä pro­ses­si­vai­hei­ta varten. Tämä helpottaa ongelmien tun­nis­ta­mis­ta ja virheiden kor­jaa­mis­ta ennen so­vel­luk­sen siir­tä­mis­tä tuo­tan­toon.

Docker Compose -vaa­ti­muk­set

Konttien hal­lin­taan tarvitset sekä Docker Engine -oh­jel­mis­ton että Docker Compose -työkalun. Varmista, että jär­jes­tel­mäs­sä­si on asen­net­tu­na jokin seu­raa­vis­ta:

  • Docker Engine ja Docker Compose: Voidaan asentaa eril­li­si­nä suo­ri­tus­tie­dos­toi­na.
  • Docker Desktop: Ke­hi­ty­sym­pä­ris­tö, jossa on graafinen käyt­tö­liit­ty­mä ja joka sisältää Docker Engine- ja Docker Compose -oh­jel­mis­tot.
Vinkki

Tutustu op­pai­siim­me ja lue, miten Docker Compose asen­ne­taan eri käyt­tö­jär­jes­tel­mil­le:

Vai­heit­tai­nen opas Docker Composen käyttöön

Seu­raa­vas­sa esit­te­lem­me, miten Docker Composea käytetään yk­sin­ker­tai­sen Python-verk­ko­so­vel­luk­sen kanssa, jossa hyö­dyn­ne­tään kä­vi­jä­las­ku­ria. Tätä varten käytämme Pythonin Flask-kehystä ja Redis-muis­ti­tie­to­kan­taa. Sinun ei tarvitse asentaa Pythonia tai Redisiä, sillä ne toi­mi­te­taan Docker-kuvina.

Vaihe 1: Luo pro­jek­ti­tie­dos­tot

Käynnistä ko­men­to­ri­vi ja luo pro­jek­tiin uusi kansio.

$ mkdir composedemo
shell

Siirry kyseiseen kansioon.

$ cd composedemo
shell

Luo tähän kansioon tiedosto app.py ja lisää siihen seuraava koodi:

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

Tässä ko­koon­pa­nos­sa käytämme isän­tä­ni­mek­si redis ja ole­tus­port­ti­na 6379 yhteyden muo­dos­ta­mi­seen Redis-palveluun. Lisäksi mää­ri­täm­me, että get_hit_count() tulee yrittää muodostaa yhteys palveluun useita kertoja. Tätä suo­si­tel­laan ti­lan­teis­sa, joissa Redis ei vält­tä­mät­tä ole heti käy­tet­tä­vis­sä so­vel­luk­sen käyn­nis­tyes­sä tai jos yh­tey­son­gel­mia esiintyy ajoittain so­vel­luk­sen ollessa käynnissä.

Luo tiedosto requi­re­ments.txt, joka sisältää riip­pu­vuu­det:

flask
redis
plaintext

Vaihe 2: Määritä Doc­ker­fi­le

Doc­ker­fi­le- tiedostoa käytetään Docker-kuvan luomiseen. Siinä mää­ri­tel­lään kaikki Python-so­vel­luk­sen tar­vit­se­mat riip­pu­vuu­det.

# 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

Käskemme Dockeria käyt­tä­mään Python 3.7 -kuvaa. Lisäksi mää­ri­täm­me tar­vit­ta­vat ym­pä­ris­tö­muut­tu­jat flask-komentoa varten. Ko­men­nol­la apk add asennamme vält­tä­mät­tö­mät riip­pu­vuu­det, kuten gcc:n. Jotta kontti voi kuunnella porttia 5000, mää­ri­täm­me EXPOSE. Ko­men­nol­la COPY siirrämme nykyisen kansion sisällön kontin sisällä olevaan työ­kan­sioon /code. Lopuksi va­lit­sem­me kontin ole­tus­ko­men­nok­si flask run.

Tarkista, että Doc­ker­fi­le-tiedosto on tal­len­net­tu ilman tie­dos­to­tun­nis­tet­ta, sillä jotkut teks­tie­di­to­rit lisäävät siihen au­to­maat­ti­ses­ti .txt -päätteen.

Vaihe 3: Luo YAML-tiedosto

Mää­ri­täm­me tie­dos­tos­sa docker-compose.yml palvelut ”redis” ja ”web”.

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

Verk­ko­pal­ve­lu on ra­ken­net­tu Doc­ker­fi­le-tiedoston avulla luodun Docker-kuvan pohjalta. Se yhdistää kontin ja isän­tä­ko­neen porttiin 8000, kun taas Flask-verk­ko­pal­ve­lin toimii portissa 5000. Redis-kuva puo­les­taan ladataan suoraan vi­ral­li­ses­ta Docker Hubista.

Vaihe 4: Suorita sovellus Compose-ym­pä­ris­tös­sä

Käynnistä sovellus pro­jek­ti­kan­sios­ta.

docker compose up
shell

Avaa se­lai­mes­sa­si osoite http://localhost:8000. Voit myös kir­joit­taa osoitteen http://127.0.0.1:8000.

Näet seuraavan viestin:

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

Päivitä sivu. Kat­se­lu­ker­to­jen määrän pitäisi nyt olla kasvanut yhdellä.

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

Sulje sovellus seu­raa­vas­ti:

$ docker compose down
shell

Voit lopettaa so­vel­luk­sen toiminnan pai­na­mal­la ter­mi­naa­lis­sa yk­sin­ker­tai­ses­ti Ctrl + C.

Vaihe 5: Lisää bind-kiinnitys

Jos haluat lisätä web-pal­ve­lul­le bind-kiin­ni­tyk­sen, voit tehdä sen tie­dos­tos­sa docker-compose.yml.

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

”Volumes”-osiossa mää­ri­täm­me, että nykyisen pro­jek­ti­kan­sion liitetään kontin sisällä olevaan /code-ha­ke­mis­toon. Tämä mah­dol­lis­taa sau­mat­to­mat koo­di­muu­tok­set ilman, että kuvaa tarvitsee luoda uudelleen. Muuttuja FLASK_DEBUG ohjaa flask run toimimaan ke­hi­tys­ti­las­sa.

Vaihe 6: Kokoa sovellus uudelleen ja suorita se

Kirjoita seuraava komento ter­mi­naa­liin Compose-tiedoston uu­del­leen­ra­ken­ta­mi­sek­si:

docker compose up
shell

Vaihe 7: Päivitä sovellus

Nyt kun käytät so­vel­luk­ses­sa­si bind-mountia, voit muokata koodiasi ja nähdä muutokset au­to­maat­ti­ses­ti ilman, että kuvan tarvitsee koota uudelleen.

Kirjoita uusi ter­ve­tu­lo­tes­ti tie­dos­toon app.py.

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

Päivitä selain tar­kis­taak­se­si, ovatko muutokset tulleet voimaan.

Kuva: Docker Compose application: modified welcome text
The welcome text in the Python applica­tion has been modified

Vaihe 8: muut komennot

Kohdassa --help lue­tel­laan käy­tet­tä­vis­sä olevat Docker Compose -komennot:

docker compose --help
shell

Jos haluat suorittaa Docker Compose -komennon taustalla, voit lisätä ar­gu­men­tin -d:

docker compose up -d
shell

Käytä down pois­taak­se­si kaikki kontit. Komento --volumes poistaa Redis-kontin käyttämät levyt.

docker compose down --volumes
shell
Siirry pää­va­lik­koon