Slik bruker du Docker Compose til applikasjoner med flere containere

Compose forenkler skalering og distribusjon av applikasjoner i Docker ved å automatisere containeradministrasjonen. I denne veiledningen går vi grundig gjennom hvordan du konfigurerer og bruker Docker Compose for å effektivisere distribusjonsprosessen for applikasjonene dine.

Hva er Docker Compose?

Docker Compose brukes til å administrere applikasjoner og øke effektiviteten i containerutvikling. Konfigurasjonene defineres i én enkelt YAML-fil, noe som gjør det enkelt å bygge og skalere applikasjoner. Docker Compose brukes ofte til å sette opp et lokalt miljø. Det kan imidlertid også inngå i en arbeidsflyt for kontinuerlig integrasjon og kontinuerlig levering (CI/CD). Utviklere kan definere en spesifikk containerversjon for testing eller bestemte faser i rørledningen. Dette gjør det enklere å identifisere problemer og fikse feil før applikasjonen settes i produksjon.

Krav til Docker Compose

For containerorkestrering trenger du både Docker Engine og Docker Compose. Sørg for at du har installert ett av følgende på systemet ditt:

• Docker Engine og Docker Compose: Kan installeres som frittstående binærfiler.
• Docker Desktop: Utviklingsmiljø med grafisk brukergrensesnitt som inkluderer Docker Engine og Docker Compose.

Trinnvis veiledning i bruk av Docker Compose

Nedenfor viser vi hvordan du bruker Docker Compose med en enkel Python-webapplikasjon som benytter en besøksteller. Til dette bruker vi Python-rammeverket Flask og minnedatabasen Redis. Du trenger ikke å installere Python eller Redis, da disse leveres som Docker-bilder.

Trinn 1: Opprett prosjektfiler

Start terminalen og opprett en ny mappe for prosjektet.

$ mkdir composedemo

Gå til katalogen.

$ cd composedemo

Opprett filen app.py i denne mappen, og legg til følgende kode i den:

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)

I vårt oppsett bruker vi redis som vertsnavn og standardporten 6379 for å koble til Redis-tjenesten. I tillegg angir vi at funksjonen get_hit_count() skal foreta flere tilkoblingsforsøk til tjenesten. Dette anbefales dersom Redis ikke er umiddelbart tilgjengelig når applikasjonen starter, eller dersom det kan oppstå sporadiske tilkoblingsproblemer under kjøring.

Opprett filen requirements.txt med avhengighetene:

flask
redis

Trinn 2: Opprett Dockerfile

Dockerfilen brukes til Docker-bildet. Den angir alle avhengighetene som Python-applikasjonen trenger.

# 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"]

Vi ber Docker om å bruke Python 3.7-bildet. Videre angir vi de nødvendige miljøvariablene for flask-kommandoen. Ved å bruke apk add installerer vi viktige avhengigheter, blant annet gcc. For at containeren skal kunne overvåke port 5000, angir vi EXPOSE. Ved hjelp av COPY overfører vi innholdet i den gjeldende mappen til arbeidskatalogen /code inne i containeren. Til slutt velger vi flask run som standardkommando for containeren.

Kontroller at Dockerfile-filen er lagret uten filtype, da enkelte tekstredigeringsprogrammer automatisk legger til filtypen .txt.

Trinn 3: Opprett en YAML-fil

I docker-compose.yml konfigurerer vi tjenestene «redis» og «web».

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

Nettjenesten er bygget ved hjelp av Docker-bildet som er opprettet av Dockerfile. Den knytter containeren og vertsdatamaskinen til port 8000, mens Flask-nettserveren kjører på port 5000. Redis-bildet hentes derimot direkte fra den offisielle Docker Hub.

Trinn 4: Kjør applikasjonen med Compose

Start programmet fra prosjektmappen din.

docker compose up

Gå til http://localhost:8000 i nettleseren din. Du kan også skrive inn http://127.0.0.1:8000.

Du bør se følgende melding:

Close

Oppdater siden. Antall visninger bør nå ha økt med 1.

Close

Avslutt programmet ved å bruke:

$ docker compose down

For å avslutte programmet kan du ganske enkelt trykke på Ctrl + C i terminalen.

Trinn 5: Opprett en bind-montering

Hvis du vil legge til en bind-mount for webtjenesten, kan du gjøre dette i docker-compose.yml.

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

Under delen «Volumes» angir vi at den gjeldende prosjektmappen skal kobles til katalogen /code inne i containeren. Dette gjør det mulig å foreta endringer i koden uten å måtte opprette bildet på nytt. Variabelen FLASK_DEBUG angir at flask run skal kjøres i utviklingsmodus.

Trinn 6: Kompiler og kjør applikasjonen

Skriv inn følgende kommando i terminalen for å kompilere Compose-filen på nytt:

docker compose up

Trinn 7: Oppdater applikasjonen

Nå som du bruker en bind-mount for applikasjonen din, kan du endre koden og automatisk se endringene uten å måtte bygge bildet på nytt.

Skriv en ny velkomsttest i app.py.

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

Oppdater nettleseren for å sjekke om endringene er tatt i bruk.

Close

Trinn 8: andre kommandoer

De --help alternativene viser tilgjengelige Docker Compose-kommandoer:

docker compose --help

For å kjøre Docker Compose i bakgrunnen kan du legge til argumentet -d:

docker compose up -d

Bruk down for å fjerne alle containere. Alternativet --volumes sletter volumene som brukes av Redis-containeren.

docker compose down --volumes