Hur man använder Docker Compose för applikationer med flera containrar

Compose förenklar skalning och distribution av applikationer i Docker genom att automatisera containerhanteringen. Vår handledning ger en djupgående inblick i hur du konfigurerar och använder Docker Compose för att effektivisera din applikationsdistributionsprocess.

Vad är Docker Compose?

Docker Compose används för att hantera applikationer och öka effektiviteten i containerutveckling. Konfigurationer definieras i en enda YAML-fil, vilket gör applikationer lätta att bygga och skala. Docker Compose används ofta för att konfigurera en lokal miljö. Det kan dock också ingå i ett arbetsflöde för kontinuerlig integration/kontinuerlig leverans (CI/CD). Utvecklare kan definiera en specifik container-version för testning eller specifika pipeline-faser. Detta gör det enklare att identifiera problem och åtgärda buggar innan applikationen går i produktion.

Krav för Docker Compose

För containerorkestrering behöver du både Docker Engine och Docker Compose. Se till att du har något av följande installerat på ditt system:

• Docker Engine och Docker Compose: Kan installeras som fristående binärfiler.
• Docker Desktop: Utvecklingsmiljö med grafiskt användargränssnitt inklusive Docker Engine och Docker Compose.

Steg-för-steg-guide för hur man använder Docker Compose

Nedan visar vi hur man använder Docker Compose med en enkel Python-webbapplikation som använder en träffräknare. För detta använder vi Python Flask-ramverket och Redis-databasen i minnet. Du behöver inte installera Python eller Redis, eftersom de tillhandahålls som Docker-bilder.

Steg 1: Skapa projektfiler

Starta terminalen och skapa en ny mapp för projektet.

$ mkdir composedemo

Byt till katalogen.

$ cd composedemo

Skapa filen app.py i den här mappen och lägg till följande kod 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år konfiguration använder vi redis som värdnamn och standardporten 6379 för anslutning till Redis-tjänsten. Dessutom anger vi att funktionen get_hit_count() ska göra flera anslutningsförsök till tjänsten. Detta rekommenderas om Redis inte är omedelbart tillgängligt när applikationen startar eller om det kan uppstå tillfälliga anslutningsproblem under körning.

Skapa filen requirements.txt med beroenden:

flask
redis

Steg 2: Konfigurera Dockerfile

Dockerfile används för Docker-bilden. Den specificerar alla beroenden som Python-applikationen kräver.

# 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 instruerar Docker att använda Python 3.7-bilden. Dessutom ställer vi in nödvändiga miljövariabler för flask-kommandot. Med hjälp av apk add installerar vi viktiga beroenden, inklusive gcc. För att containern ska kunna övervaka port 5000 anger vi EXPOSE. Med hjälp av COPY överför vi innehållet i den aktuella mappen till arbetskatalogen /code i containern. Slutligen väljer vi flask run som standardkommando för containern.

Kontrollera att Dockerfile har sparats utan filändelse, eftersom vissa redigeringsprogram automatiskt lägger till suffixet .txt.

Steg 3: Skapa YAML-fil

I docker-compose.yml konfigurerar vi tjänsterna ”redis” och ”web”.

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

Webbtjänsten är byggd med hjälp av Docker-bilden som skapats av Dockerfile. Den kopplar samman containern och värddatorn med port 8000, medan Flask-webbservern körs på port 5000. Redis-bilden hämtas däremot direkt från den officiella Docker Hub.

Steg 4: Kör applikationen med Compose

Starta applikationen från din projektmapp.

docker compose up

Öppna http://localhost:8000 i din webbläsare. Du kan också ange http://127.0.0.1:8000.

Du bör se följande meddelande:

Close

Uppdatera sidan. Antalet visningar bör nu ha ökat med 1.

Close

Avsluta programmet med:

$ docker compose down

För att avsluta programmet trycker du bara på Ctrl + C i terminalen.

Steg 5: Lägg till en bindmount

Om du vill lägga till en bindningsmontering för webbtjänsten kan du göra det i docker-compose.yml.

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

Under avsnittet Volumes anger vi att den aktuella projektmappen ska kopplas till katalogen /code i containern. Detta möjliggör smidiga kodändringar utan att bilden behöver skapas om. Variabeln FLASK_DEBUG anger att flask run ska köras i utvecklingsläge.

Steg 6: Bygg om och kör applikationen

Ange följande kommando i terminalen för att återskapa Compose-filen:

docker compose up

Steg 7: Uppdatera applikationen

Nu när du använder en bind-mount för din applikation kan du ändra din kod och automatiskt se ändringarna utan att behöva bygga om bilden.

Skriv ett nytt välkomsttest i app.py.

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

Uppdatera webbläsaren för att testa om ändringarna har tillämpats.

Close

Steg 8: andra kommandon

Alternativet --help listar tillgängliga Docker Compose-kommandon:

docker compose --help

För att köra Docker Compose i bakgrunden kan du lägga till argumentet -d:

docker compose up -d

Använd down för att ta bort alla behållare. Alternativet --volumes raderar de volymer som används av Redis-behållaren.

docker compose down --volumes