Or­ches­trie­re deine Docker-An­wen­dun­gen

Compose er­leich­tert die Ska­lie­rung und Be­reit­stel­lung von An­wen­dun­gen in Docker, indem es die Ver­wal­tung von Con­tai­nern au­to­ma­ti­siert. In diesem Tutorial werfen wir einen de­tail­lier­ten Blick auf die Ein­rich­tung und Nutzung von Docker Compose, damit du es in deiner eigenen Pro­duk­ti­ons­um­ge­bung anwenden kannst.

Was ist Docker Compose?

Docker Compose dient dem Ma­nage­ment von An­wen­dun­gen und erhöht die Effizienz bei der Ent­wick­lung von Con­tai­nern. Kon­fi­gu­ra­tio­nen werden in einer einzigen YAML-Datei fest­ge­legt, wodurch Ap­pli­ka­tio­nen einfach zu erstellen und zu skalieren sind. Docker Compose wird häufig verwendet, um eine lokale Umgebung ein­zu­rich­ten. Es kann aber auch Teil eines Con­ti­nuous In­te­gra­ti­on / Con­ti­nuous Delivery (CI/CD) Workflows sein. Ent­wick­ler:innen können eine spe­zi­fi­sche Version von Con­tai­nern für Tests oder für eine bestimmte Phase der Pipeline de­fi­nie­ren. Dies er­leich­tert die Iden­ti­fi­zie­rung von Problemen und die Behebung von Fehlern, bevor sie online gehen.

Docker Compose: Das sind die Vor­aus­set­zun­gen

Für die Container-Or­ches­trie­rung benötigst du sowohl die Docker-Engine als auch Docker Compose. Du musst daher eine der folgenden Mög­lich­kei­ten auf deinem System ein­ge­rich­tet haben:

• Docker Engine und Docker Compose: können als Stan­da­lo­ne Binaries in­stal­liert werden
• Docker Desktop: Ent­wick­lungs­um­ge­bung mit gra­fi­scher Be­nut­zer­ober­flä­che, die die Docker-Engine und Docker Compose bereits be­inhal­tet

Schritt-für-Schritt-Anleitung: So nutzt du Docker Compose

Im Folgenden de­mons­trie­ren wir die Konzepte von Docker Compose mit einer einfachen Python-Web-Ap­pli­ka­ti­on, deren Aufrufe in einem Hit-Counter gezählt werden. Dazu verwenden wir das Python Flask Framework und die In-Memory-Datenbank Redis. Du musst weder Python noch Redis in­stal­lie­ren, da diese als Docker Images be­reit­ge­stellt werden.

Schritt 1: Pro­jekt­da­tei­en erstellen

Öffne das Terminal und lege einen neuen Ordner für das Projekt an.

$ mkdir composedemo

Wechsle daraufhin in das Ver­zeich­nis.

$ cd composedemo

Erstelle in diesem Ordner die Datei app.py und füge ihr folgenden Code hinzu:

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)

Wir verwenden als Hostname „Redis“ und den Stan­dard­port „6379“. Des Weiteren legen wir fest, dass die Funktion get_hit_count() mehrere Versuche un­ter­neh­men soll, sich mit dem Dienst zu verbinden. Dies ist emp­feh­lens­wert, da es sein kann, dass Redis beim Start der Anwendung noch nicht verfügbar ist oder es im Betrieb zu Ver­bin­dungs­pro­ble­men kommt.

Lege noch die Datei re­qui­re­ments.txt mit den Ab­hän­gig­kei­ten an:

flask
redis

Schritt 2: Do­cker­file ein­rich­ten

Das Do­cker­file wird für das Docker Image benutzt. Hierin werden alle Ab­hän­gig­kei­ten angegeben, die die Python-Anwendung benötigt.

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

Docker wird damit an­ge­wie­sen, das Python 3.7 Image zu verwenden. Zudem haben wir die Um­ge­bungs­va­ria­blen für das Flask-Kommando fest­ge­legt. Mit apk add in­stal­lie­ren wir gcc und andere Ab­hän­gig­kei­ten. EXPOSE gibt an, dass der Container Port 5000 über­wa­chen soll. Mit COPY wird der Inhalt des aktuellen Ordners in das Ar­beits­ver­zeich­nis /code kopiert. Als Stan­dard­be­fehl für den Container wählen wir flask run.

Überprüfe, dass das Do­cker­file ohne Da­tei­endung ge­spei­chert wurde, da manche Editoren au­to­ma­tisch das Suffix .txt anhängen.

Schritt 3: YAML-Datei anlegen

In docker-compose.yml kon­fi­gu­rie­ren wir die Dienste „redis“ und „web“.

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

Der Web-Dienst nutzt das Image, das vom Do­cker­file erstellt wird. Es verknüpft den Container und den Host-Computer mit Port 8000, während der Flask-Webserver auf Port 5000 läuft. Das Redis-Image wird hingegen direkt aus dem of­fi­zi­el­len Docker Hub bezogen.

Schritt 4: Die Anwendung mit Compose ausführen

Starte die Ap­pli­ka­ti­on von deinem Pro­jekt­ord­ner aus.

docker compose up

Rufe ‘http://localhost:8000’ in deinem Browser auf. Du kannst auch ‘http://127.0.0.1:8000’ eingeben.

Dir sollte folgende Nachricht angezeigt werden:

Close

Ak­tua­li­sie­re die Seite. Die Anzahl deiner Aufrufe sollte nun um 1 gestiegen sein.

Close

Stoppe die Anwendung mit:

$ docker compose down

Du kannst aber auch in dem Terminal, in dem du die Ap­pli­ka­ti­on gestartet hast, Ctrl + C drücken.

Schritt 5: Ein Bind Mount hin­zu­fü­gen

Wenn du ein Bind Mount für den Web-Dienst hin­zu­fü­gen möchtest, kannst du dies in docker-compose.yml vornehmen.

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

Unter Volumes geben wir an, dass der aktuelle Pro­jekt­ord­ner an das Ver­zeich­nis /code innerhalb des Con­tai­ners an­ge­bun­den werden soll. Damit kannst du den Code ändern, ohne das Image neu erstellen zu müssen. Die Um­ge­bungs­va­ria­ble FLASK_DEBUG ordnet flask run dabei an, im Ent­wick­lungs­mo­dus aus­ge­führt zu werden.

Schritt 6: Ap­pli­ka­ti­on neu erstellen und ausführen

Gib folgenden Befehl in das Terminal ein, um die Compose-Datei neu auf­zu­set­zen:

docker compose up

Schritt 7: Die Anwendung ak­tua­li­sie­ren

Da du jetzt einen Bind Mount für deine Ap­pli­ka­ti­on ver­wen­dest, kannst du deinen Code mo­di­fi­zie­ren und au­to­ma­tisch die Än­de­run­gen sehen, ohne das Image neu zu erstellen.

Schreibe einen neuen Be­grü­ßungs­test in app.py.

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

Ak­tua­li­sie­re den Browser, um zu testen, ob die Än­de­run­gen über­nom­men wurden.

Close

Schritt 8: Weitere Kommandos

Die Option --help zeigt dir eine Liste an ver­füg­ba­ren Kommandos für Docker Compose an:

docker compose --help

Um Docker Compose im Hin­ter­grund laufen zu lassen, kannst du das Argument -d hin­zu­fü­gen:

docker compose up -d

Mit down werden alle Container entfernt. Die Option --volumes löscht dabei auch die vom Redis-Container ver­wen­de­ten Volumes.

docker compose down --volumes