Mehrere Container-Docker-Apps bereitstellen

Einführung

Docker Compose ist ein unverzichtbares Werkzeug für Entwickler, die die Containerverwaltung und die Anwendungsbereitstellung optimieren möchten. Dieses umfassende Tutorial erforscht die Grundlagen von Docker Compose und bietet praktische Einblicke in die Konfiguration, Bereitstellung und Verwaltung komplexer Multi-Container-Umgebungen effizient und systematisch.

Docker Compose Grundlagen

Einführung in Docker Compose

Docker Compose ist ein leistungsstarkes Werkzeug zur Definition und Ausführung von Multi-Container-Docker-Anwendungen. Es ermöglicht Entwicklern, eine YAML-Datei zur Konfiguration von Anwendungsservices, Netzwerken und Volumes zu verwenden, wodurch der Prozess der Container-Orchestrierung und -verwaltung vereinfacht wird.

Kernkonzepte und Architektur

graph TD
    A[Docker Compose] --> B[Servicekonfiguration]
    A --> C[Multi-Container-Verwaltung]
    A --> D[Deklarative Infrastruktur]

Praktisches Beispiel: Einrichtung einer Webanwendung

Hier ist ein umfassendes Beispiel, das die Docker Compose-Konfiguration für eine typische Webanwendung demonstriert:

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./website:/usr/share/nginx/html
  database:
    image: postgres:13
    environment:
      POSTGRES_PASSWORD: mysecretpassword
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

Code-Aufschlüsselung

1. version: '3.8' gibt das Docker Compose-Dateiformat an
2. Der Abschnitt services definiert zwei Container: Webserver und Datenbank
3. Der nginx-Service ordnet den Hostport 80 dem Containerport 80 zu
4. Der postgres-Service richtet eine Datenbank mit persistentem Volume-Speicher ein

Installation und grundlegende Befehle

So installieren Sie Docker Compose unter Ubuntu 22.04:

sudo apt update
sudo apt install docker-compose-plugin
docker compose version

Wichtige Docker Compose-Befehle:

• docker compose up: Startet alle Services
• docker compose down: Stoppt und entfernt Container
• docker compose ps: Listet laufende Services
• docker compose logs: Zeigt Service-Logs an

Konfiguration und Bereitstellung

Struktur der Docker Compose-Datei

Die Docker Compose-Konfiguration basiert auf einer YAML-Datei, die die gesamte Anwendungsinfrastruktur definiert. Die Standarddatei heißt docker-compose.yml und enthält umfassende Servicedefinitionen.

graph TD
    A[docker-compose.yml] --> B[Services]
    A --> C[Netzwerke]
    A --> D[Volumes]
    A --> E[Umgebungsvariablen]

Detailliertes Beispiel für die Servicekonfiguration

version: "3.8"
services:
  backend:
    image: python:3.9
    build:
      context: ./backend
      dockerfile: Dockerfile
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=postgresql://user:password@database:5432/appdb
    depends_on:
      - database

  database:
    image: postgres:13
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: secretpassword

volumes:
  postgres_data:

Konfigurationsparameter

Bereitstellungsstrategien

graph LR
    A[Lokale Entwicklung] --> B[Staging-Umgebung]
    B --> C[Produktive Bereitstellung]
    C --> D[Skalierung von Services]

Bereitstellungsbefehle

Typischer Bereitstellungsablauf unter Ubuntu 22.04:

## Compose-Datei validieren
docker compose config

## Services erstellen
docker compose build

## Services starten
docker compose up -d

## Laufende Services prüfen
docker compose ps

## Logs anzeigen
docker compose logs backend

## Services stoppen
docker compose down

Erweiterte Konfigurationstechniken

services:
  webserver:
    restart: always
    healthcheck:
      test: ["CMD", "curl", "-f", "
      interval: 30s
      timeout: 10s
      retries: 3

Erweiterte Compose-Strategien

Mehrumgebungskonfiguration

Docker Compose unterstützt eine ausgereifte Umgebungsverwaltung durch mehrere Konfigurationsdateien und Überlagerungsmechanismen.

graph LR
    A[Basis-Konfiguration] --> B[Entwicklungs-Überlagerung]
    A --> C[Produktions-Überlagerung]
    A --> D[Staging-Überlagerung]

Umgebungsspezifische Konfiguration

version: "3.8"
services:
  application:
    image: myapp:latest
    environment:
      - APP_ENV=${DEPLOY_ENV:-development}
      - DATABASE_URL=${DATABASE_CONNECTION}

Dynamische Skalierung von Services

## Skalierung des Web-Services auf 3 Instanzen
docker compose up -d --scale web=3

Erweiterte Netzwerkkonfigurationen

Produktionsreife Compose-Beispiel

version: '3.8'
services:
  webserver:
    image: nginx:alpine
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
    healthcheck:
      test: ["CMD", "curl", "-f", "
      interval: 30s
      timeout: 10s
      retries: 3

  backend:
    image: myapp:${VERSION}
    secrets:
      - db_password
    configs:
      - source: app_config
        target: /app/config.json

secrets:
  db_password:
    external: true

configs:
  app_config:
    file: ./config.json

Container-Versionsstrategien

## Versionierte Images taggen und pushen
docker build -t myapp:v1.0 .
docker compose push

Bereitstellungsablauf

graph TD
    A[Images erstellen] --> B[Tests ausführen]
    B --> C[In Registry pushen]
    C --> D[Container bereitstellen]
    D --> E[Performance überwachen]

Sicherheits- und Compliance-Befehle

## Compose-Services auf Schwachstellen prüfen
docker compose config --resolve-env-vars
docker scan docker-compose.yml

Zusammenfassung

Durch die Beherrschung von Docker Compose können Entwickler die Container-Orchestrierung vereinfachen, die Infrastruktur als Code definieren und skalierbare, reproduzierbare Anwendungsumgebungen erstellen. Der Tutorial behandelt Kernkonzepte, Konfigurationsstrategien und praktische Implementierungsmethoden, die nahtlose Entwicklung und Bereitstellung von Multi-Container-Anwendungen in verschiedenen Infrastrukturszenarien ermöglichen.