Einführung in Docker Compose: Mehrere Container gleichzeitig verwalten

Was ist Docker Compose?

Docker Compose ist ein Tool, das es ermöglicht, Multi-Container-Docker-Anwendungen zu definieren und zu betreiben. Es verwendet eine einfache YAML-Datei, um die Dienste, Netzwerke und Volumes einer Anwendung zu konfigurieren und bietet eine einheitliche Möglichkeit, Container zu orchestrieren. Mit Docker Compose können Entwickler und Teams mehrere Container gleichzeitig starten, stoppen und verwalten, was besonders nützlich ist, wenn Anwendungen aus mehreren Microservices bestehen.

Vorteile von Docker Compose

• Einfachheit: Docker Compose vereinfacht die Verwaltung mehrerer Container, indem es eine zentrale Konfigurationsdatei bereitstellt.
• Konsistenz: Die Verwendung von YAML-Dateien stellt sicher, dass Umgebungen konsistent sind, was insbesondere bei der Zusammenarbeit in Teams wichtig ist.
• Skalierbarkeit: Docker Compose ermöglicht es, Container einfach zu skalieren, indem die Anzahl der Instanzen in der Konfigurationsdatei geändert wird.
• Integration in CI/CD-Pipelines: Docker Compose kann Teil von Continuous Integration und Continuous Delivery (CI/CD) Workflows sein, um Tests und Bereitstellungen zu automatisieren.

Voraussetzungen für die Verwendung von Docker Compose

Bevor Sie mit Docker Compose arbeiten können, müssen Sie sicherstellen, dass Sie sowohl die Docker Engine als auch Docker Compose auf Ihrem System installiert haben. Docker Compose kann als eigenständige Binärdatei installiert werden oder ist in Docker Desktop für Windows und Mac bereits enthalten. Für Linux-Nutzer ist eine separate Installation erforderlich.

Installation von Docker Compose

Um Docker Compose auf einem Linux-System zu installieren, können Sie die folgenden Befehle verwenden:

sudo curl -L "https://github.com/docker/compose/releases/download/1.26.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
docker-compose --version

Dies installiert Docker Compose und überprüft die Installation, indem die Version angezeigt wird.

Erste Schritte mit Docker Compose

Um ein grundlegendes Verständnis dafür zu bekommen, wie Docker Compose funktioniert, werden wir ein einfaches Beispiel durchgehen, in dem wir eine Python-Webanwendung mit Flask und einer Redis-Datenbank erstellen. Dieses Beispiel zeigt, wie einfach es ist, Container zu erstellen und zu verwalten.

Schritt 1: Projektverzeichnis erstellen

Erstellen Sie ein neues Verzeichnis für Ihr Projekt:

mkdir composedemo
cd composedemo

Schritt 2: Anwendungsdateien erstellen

Erstellen Sie eine Datei namens app.py und fügen Sie den folgenden Code ein:

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! Ich wurde {} mal gesehen.\n'.format(count)

In diesem Code verwenden wir Redis als Cache, um die Anzahl der Besuche zu zählen.

Schritt 3: Anforderungen definieren

Erstellen Sie eine Datei namens requirements.txt und fügen Sie die folgenden Zeilen ein:

flask
redis

Schritt 4: Dockerfile erstellen

Erstellen Sie eine Datei namens Dockerfile mit folgendem Inhalt:

# syntax=docker/dockerfile:1
FROM python:3.10-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", "--debug"]

Schritt 5: Docker Compose-Datei erstellen

Erstellen Sie eine Datei namens docker-compose.yml und fügen Sie die folgende Konfiguration ein:

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

Schritt 6: Anwendung starten

Um die Anwendung zu starten, führen Sie den folgenden Befehl im Terminal aus:

docker-compose up

Nach dem Start der Anwendung können Sie http://localhost:8000 in Ihrem Webbrowser öffnen, um die Anwendung zu sehen.

Schritt 7: Anwendung aktualisieren

Um die Anwendung während der Entwicklung einfach zu aktualisieren, können Sie einen Bind-Mount hinzufügen. Ändern Sie die docker-compose.yml wie folgt:

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

Mit dieser Konfiguration wird jede Änderung an Ihrem Code sofort im Container wirksam, ohne dass Sie den Container neu erstellen müssen.

Best Practices für Docker Compose

Hier sind einige Best Practices, die Sie bei der Verwendung von Docker Compose beachten sollten:

• Modularität: Verwenden Sie mehrere docker-compose.yml-Dateien, um verschiedene Umgebungen (z.B. Entwicklung, Test, Produktion) zu verwalten.
• Umgebungsvariablen: Nutzen Sie Umgebungsvariablen in .env-Dateien, um sensible Daten wie Passwörter und API-Keys zu speichern.
• Volumenverwaltung: Verwenden Sie Volumes, um Daten zwischen Containern und dem Host zu persistieren.
• Netzwerkmanagement: Definieren Sie benutzerdefinierte Netzwerke, um die Kommunikation zwischen Containern zu steuern.

Zusammenfassung

Docker Compose ist ein unverzichtbares Werkzeug für Entwickler, die mit Multi-Container-Anwendungen arbeiten. Es vereinfacht den Prozess der Containerverwaltung erheblich und ermöglicht eine effiziente Entwicklung, Tests und Bereitstellung von Anwendungen. Durch die Verwendung von YAML-Dateien zur Definition von Anwendungen können Teams konsistente und reproduzierbare Umgebungen schaffen.

Für weitere Informationen und Ressourcen zu Docker Compose besuchen Sie die offizielle Docker Dokumentation.