Erstellen von Anwendungen mit mehreren Containern mit Docker Compose

Da die Softwareentwicklung zunehmend die Microservices-Architektur übernimmt, ist die Notwendigkeit, komplexe Anwendungen mit mehreren Diensten zu verwalten, von größter Bedeutung. Docker Compose erweist sich als ein entscheidendes Werkzeug, das die Steuerung von Multi-Container-Anwendungen vereinfacht. Dieser Artikel möchte tiefer in die erweiterten Funktionen von Docker Compose eintauchen, Einblicke in seine Fähigkeiten bieten und praktische Beispiele zur Veranschaulichung seiner Anwendung liefern.

Docker Compose verstehen

Docker Compose is a tool designed to define and manage multi-container Docker applications. It allows developers to specify the services, networks, and volumes that their application requires in a single YAML file, typically named docker-compose.yml. With a few commands, developers can build, start, scale, and stop multiple containers, facilitating a streamlined workflow.

Kernkonzepte

Bevor wir uns mit Docker Compose befassen, ist es wichtig, einige grundlegende Konzepte zu verstehen:

• DienstleistungenEin Dienst ist definiert in der docker-compose.yml file and represents a single container or a group of containers running the same image.

• NetzwerkeDocker Compose ermöglicht es Ihnen, benutzerdefinierte Netzwerke für eine bessere Kommunikation zwischen Diensten zu erstellen. Jeder Dienst kann über ein privates Netzwerk kommunizieren, was die Sicherheit erhöht und die Komplexität reduziert.

• Bände: Volumes are used to persist data generated by and used by Docker containers. Docker Compose makes it easy to define and manage volumes for your services.

Setting Up Docker Compose

Um unsere Erkundung von Docker Compose zu beginnen, werden wir zunächst die Umgebung einrichten. Stellen Sie sicher, dass Docker auf Ihrem Computer installiert ist. Docker Compose ist in Docker Desktop enthalten; wenn Sie jedoch eine Linux-Distribution verwenden, müssen Sie es möglicherweise separat installieren.

Installation

On Ubuntu, for instance, you can install Docker Compose using the following commands:

sudo apt-get update
sudo apt-get install docker-compose

Once installed, you can verify the installation by checking the version:

docker-compose --version

Erstellen einer einfachen Anwendung

Erstellen wir eine einfache Multi-Container-Anwendung mit Docker Compose. Für unser Beispiel werden wir einen Web-Anwendungsstack erstellen, der aus einer Flask-API, einem Redis-Cache und einer PostgreSQL-Datenbank besteht.

Project Structure

Zuerst die folgende Verzeichnisstruktur erstellen:

myapp/
├── Dockerfile
├── app.py
├── requirements.txt
└── docker-compose.yml

Schreiben des Anwendungscodes

In requirements.txt, werden wir die Abhängigkeiten definieren, die für unsere Flask-Anwendung erforderlich sind:

Flask==2.0.2
redis==4.0.2
psycopg2==2.9.1

In app.py, werden wir eine einfache Flask-Anwendung schreiben, die mit Redis und PostgreSQL interagiert:

from flask import Flask
import redis
import psycopg2

app = Flask(__name__)

# Configure Redis
redis_client = redis.StrictRedis(host='redis', port=6379, decode_responses=True)

# Configure PostgreSQL
def get_db_connection():
    conn = psycopg2.connect(host='db', database='mydb', user='myuser', password='mypassword')
    return conn

@app.route('/')
def index():
    redis_client.incr('hits')
    return f'Hello World! This page has been viewed {redis_client.get("hits")} times.'

@app.route('/db')
def db():
    conn = get_db_connection()
    cur = conn.cursor()
    cur.execute('SELECT message FROM messages;')
    message = cur.fetchone()
    cur.close()
    conn.close()
    return message[0] if message else 'No messages found.'

if __name__ == '__main__':
    app.run(host='0.0.0.0')

Das Schreiben der Dockerfile

Now, we will create a Dockerfile for our Flask application:

# Use the official Python image from the Docker Hub
FROM python:3.9-slim

# Set the working directory
WORKDIR /app

# Copy the requirements file and install dependencies
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

# Copy the application code
COPY app.py ./

# Expose the application port
EXPOSE 5000

# Command to run the application
CMD ["python", "app.py"]

Creating the Docker Compose Configuration

Now, let’s define the services in the docker-compose.yml:

version: '3.8'

services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - redis
      - db
    environment:
      REDIS_HOST: redis
      POSTGRES_HOST: db

  redis:
    image: redis:alpine

  db:
    image: postgres:13
    restart: always
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Explanation of the Configuration

Der eingegebene Text ist unvollständig. Bitte geben Sie den vollständigen Text zur Übersetzung an. docker-compose.yml Datei haben wir drei Dienste definiert: Netz, Redis, and db.

• NetzDieser Dienst wird aus der Dockerfile im aktuellen Verzeichnis erstellt. Er macht Port 5000 verfügbar, um Zugriff auf die Flask-Anwendung zu ermöglichen. depends_on directive ensures that the Redis and db services are started before the Netz Service.

• Redis: This service uses the official Redis image from Docker Hub.

• db: Dieser Dienst betreibt eine PostgreSQL-Datenbank. Er verwendet Umgebungsvariablen, um die Datenbank, den Benutzer und das Passwort einzurichten. Ein Volume (db-Daten) wird definiert, um die Datenbankdaten zu speichern.

Running the Application

Wenn alles eingerichtet ist, können Sie Ihre Multi-Container-Anwendung starten, indem Sie Folgendes ausführen:

docker-compose up

Dieser Befehl erstellt die Dienste und startet die Anwendung. Sobald die Anwendung läuft, können Sie darauf zugreifen unter http://localhost:5000. You should see the message indicating how many times the page has been viewed.

Scaling the Services

One of the powerful features of Docker Compose is the ability to scale services. For instance, to scale the Netz Wenn Sie den Dienst auf 3 Instanzen ausführen möchten, können Sie den folgenden Befehl ausführen:

docker-compose up --scale web=3

Dieser Befehl startet drei Instanzen des Netz Service, der die Lastverteilung zwischen ihnen ermöglicht.

Erweiterte Konfiguration

Wenn Ihre Anwendung an Komplexität zunimmt, möchten Sie möglicherweise fortgeschrittene Funktionen von Docker Compose integrieren.

Custom Networks

By default, Docker Compose creates a single network for your application. You can define multiple networks in your docker-compose.yml file:

networks:
  frontend:
  backend:

Sie können Dienste bestimmten Netzwerken zuweisen.

services:
  web:
    networks:
      - frontend
  redis:
    networks:
      - backend
  db:
    networks:
      - backend

Health Checks

Die Definition von Gesundheitsprüfungen ist entscheidend, um sicherzustellen, dass Ihre Dienste korrekt ausgeführt werden. Sie können Gesundheitsprüfungen mithilfe des Gesundheitscheck property:

services:
  web:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5000/"]
      interval: 30s
      timeout: 10s
      retries: 5

Environment Variables and Secrets

You can pass environment variables for configuration using the environment key:

Umgebung:
  - FLASK_ENV=production

Für sensible Informationen unterstützt Docker Compose Geheimnisse, die sicher innerhalb Ihrer Dienste definiert und verwendet werden können.

secrets:
  db_password:
    file: ./secrets/db_password.txt

services:
  db:
    environment:
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password

Verwendung externer Volumes

Anstatt Volumina innerhalb zu definieren docker-compose.yml, Sie können externe Volumes verwenden, die außerhalb Ihrer Compose-Anwendung verwaltet werden:

volumes:
  db_data:
    external: true

Debugging und Protokollierung

Docker Compose integriert sich nahtlos in Docker-Protokolle und ermöglicht es Ihnen, Protokolle aller Dienste anzuzeigen. Sie können die Protokolle mit folgendem Befehl anzeigen:

docker-compose logs -f

Dieser Befehl folgt den Logs und zeigt die Ausgabe aller Dienste an, was für die Fehlersuche unverzichtbar ist.

Fazit

Docker Compose ist ein leistungsstarkes Werkzeug zur Verwaltung von Multi-Container-Anwendungen, das durch seine YAML-Konfiguration Einfachheit und Flexibilität bietet. Indem es Entwicklern ermöglicht, Dienste, Netzwerke und Volumes in einer einzigen Datei zu definieren, rationalisiert Docker Compose den Entwicklungs- und Bereitstellungsprozess.

As applications become more complex, the advanced features discussed—such as custom networks, health checks, environment variables, and logging—become essential for maintaining robust and reliable applications. Whether you’re building microservices or simple web applications, understanding Docker Compose is a crucial skill in the modern development landscape.

Durch das Beherrschen dieser erweiterten Docker Compose-Funktionen sind Sie bestens gerüstet, um die Anforderungen bei der Bereitstellung und Verwaltung komplexer Anwendungen effektiv zu bewältigen. Viel Spaß beim Programmieren!