Docker/Compose

Docker/Compose

Compose

Docker Compose verwenden

Docker Compose — Werkzeug zur Definition und Verwaltung mehrerer Container, die gemeinsam eine Anwendung bilden. Die gesamte Umgebung wird in einer compose.yaml-Datei beschrieben und kann mit einem einzigen Befehl gestartet oder gestoppt werden.

Der große Vorteil von Compose besteht darin, dass Sie Ihren Anwendungsstack in einer Datei definieren können, diese im Stammverzeichnis Ihres Projekt-Repositorys aufbewahren können (es ist jetzt versionskontrolliert) und es anderen Personen leicht ermöglichen, zu Ihrem Projekt beizutragen. Jemand müsste nur Ihr Repository klonen und die Anwendung mit Compose starten. Tatsächlich gibt es auf GitHub/GitLab eine ganze Reihe von Projekten, die genau das tun

Vorteile

• Deklarative, versionskontrollierbare Konfiguration in compose.yaml.
• Start, Stopp und Bereinigung des gesamten Stacks mit einem Befehl.
• Isolierung und Service-Discovery über benannte Netzwerke und Volumes.
• Skalierung und gemeinsame Log-Sicht pro Dienst.

Erstellen Sie die Compose-Datei

Erstellen Sie im Verzeichnis getting-started-app eine Datei namens compose.yaml

├── getting-started-app/

│ ├── Dockerdatei

│ ├── compose.yaml

│ ├── node_modules/

│ ├── package.json

│ ├── spec/

│ ├── src/

│ └── yarn.lock

Definieren Sie den Anwendungsdienst

In Teil 6 haben Sie den folgenden Befehl verwendet, um den Anwendungsdienst zu starten

docker run -dp 127.0.0.1:3000:3000 \
  -w /app -v "$(pwd):/app" \
  --network todo-app \
  -e MYSQL_HOST=mysql \
  -e MYSQL_USER=root \
  -e MYSQL_PASSWORD=secret \
  -e MYSQL_DB=todos \
  node:lts-alpine \
  sh -c "yarn install && yarn run dev"

Nun definieren Sie diesen Dienst in der Datei compose.yaml.# Öffnen Sie compose.yaml in einem Text- oder Code-Editor und beginnen Sie damit, den Namen und das Image des ersten Dienstes (oder Containers) zu definieren, den Sie als Teil Ihrer Anwendung ausführen möchten. Der Name wird automatisch zu einem Netzwerk-Alias, der bei der Definition Ihres MySQL-Dienstes nützlich sein wird

services:
  app:
    image: node:18-alpine

• Normalerweise sehen Sie den Befehl in der Nähe der Image-Definition, obwohl die Reihenfolge nicht vorgeschrieben ist. Fügen Sie den Befehl in Ihre compose.yaml-Datei ein

services:
  app:
    image: node:18-alpine
    command: sh -c "yarn install && yarn run dev"

• Nun migrieren Sie den -p 127.0.0.1:3000:3000 Teil des Befehls, indem Sie die Ports für den Dienst definieren

services:
  app:
    image: node:18-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 127.0.0.1:3000:3000

• Als Nächstes migrieren Sie sowohl das Arbeitsverzeichnis (-w /app) als auch die Volume-Zuordnung (-v "$(pwd):/app") mit Hilfe der working_dir- und volumes-Definitionen

Ein Vorteil der Volume-Definitionen von Docker Compose ist, dass Sie relative Pfade zum aktuellen Verzeichnis verwenden können.

services:
  app:
    image: node:18-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 127.0.0.1:3000:3000
    working_dir: /app
    volumes:
      - ./:/app

• Schließlich müssen Sie die Definitionen der Umgebungsvariablen mithilfe des Umgebungsschlüssels migrieren

services:
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 127.0.0.1:3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: secret
      MYSQL_DB: todos

Definieren Sie den MySQL-Dienst

Nun ist es an der Zeit, den MySQL-Dienst zu definieren. Der Befehl, den Sie für diesen Container verwendet haben, war der folgende:

docker run -d \
  --network todo-app --network-alias mysql \
  -v todo-mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=secret \
  -e MYSQL_DATABASE=todos \
  mysql:8.0

1. Definieren Sie zunächst den neuen Dienst und nennen Sie ihn mysql, damit er automatisch den Netzwerk-Alias erhält. Geben Sie auch das zu verwendende Image an

services:
  app:
    # Die Definition des app-Dienstes
  mysql:
    image: mysql:8.0

• Als Nächstes definieren Sie die Volume-Zuordnung. Wenn Sie den Container mit docker run ausgeführt haben, hat Docker das benannte Volume automatisch erstellt. Dies geschieht jedoch nicht, wenn Sie den Container mit Compose ausführen. Sie müssen das Volume im Abschnitt volumes: der obersten Ebene definieren und dann den Einhängepunkt in der Dienstkonfiguration angeben. Wenn Sie nur den Namen des Volumes angeben, werden die Standardoptionen verwendet

services:
  app:
    # The app service definition
  mysql:
    image: mysql:8.0
    volumes:
      - todo-mysql-data:/var/lib/mysql

volumes:
  todo-mysql-data:

• Schließlich müssen Sie noch die Umgebungsvariablen angeben

services:
  app:
    # The app service definition
  mysql:
    image: mysql:8.0
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

Zu diesem Zeitpunkt sollte Ihre komplette compose.yaml wie folgt aussehen:

services:
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 127.0.0.1:3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: secret
      MYSQL_DB: todos

  mysql:
    image: mysql:8.0
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

Starten Sie den Anwendungsstack

Nun, da Sie Ihre compose.yaml-Datei haben, können Sie Ihre Anwendung starten.

• Vergewissern Sie sich zunächst, dass keine anderen Kopien der Container ausgeführt werden. Verwenden Sie docker ps, um die Container aufzulisten und docker rm -f <ids>, um sie zu entfernen
• Starten Sie den Anwendungsstapel mit dem Befehl docker compose up. Fügen Sie das Flag -d hinzu, um alles im Hintergrund laufen zu lassen

docker compose up -d

• Wenn Sie den vorherigen Befehl ausführen, sollten Sie eine Ausgabe wie die folgende sehen

✔ Network getting-started-app_default         Created                                                                                                                                                        0.1s
✔ Volume getting-started-app_todo-mysql-data  Created                                                                                                                                                        0.0s
✔ Container getting-started-app-mysql-1       Started                                                                                                                                                        0.3s
✔ Container getting-started-app-app-1         Started

Sie werden feststellen, dass Docker Compose sowohl das Volume als auch ein Netzwerk erstellt hat. Standardmäßig erstellt Docker Compose automatisch ein Netzwerk speziell für den Anwendungsstapel (deshalb haben Sie kein Netzwerk in der Compose-Datei definiert).

• Sehen Sie sich die Protokolle mit dem Befehl docker compose logs -f an. Sie werden sehen, dass die Protokolle der einzelnen Dienste in einen einzigen Stream verschachtelt sind. Dies ist sehr nützlich, wenn Sie auf zeitliche Probleme achten wollen. Die Markierung -f folgt dem Protokoll, so dass Sie eine Live-Ausgabe erhalten, während es erzeugt wird

Wenn Sie den Befehl bereits ausgeführt haben, werden Sie eine Ausgabe sehen, die wie folgt aussieht:

mysql_1 | 2019-10-03T03:07:16.083639Z 0 [Hinweis] mysqld: bereit für Verbindungen

mysql_1 | Version: '8.0.31' socket: '/var/run/mysqld/mysqld.sock' port: 3306 MySQL Gemeinschaftsserver (GPL)

app_1 | Verbunden mit mysql db auf dem Host mysql

app_1 | Lauschen auf Port 3000

• Der Name des Dienstes wird am Anfang der Zeile angezeigt (oft farbig), um die Unterscheidung der Meldungen zu erleichtern.
• Wenn Sie die Protokolle für einen bestimmten Dienst anzeigen möchten, können Sie den Namen des Dienstes an das Ende des Befehls logs anhängen (z. B. docker compose logs -f app).
• Zu diesem Zeitpunkt sollten Sie in der Lage sein, Ihre App in Ihrem Browser auf http://localhost:3000 zu öffnen und zu sehen, dass sie läuft

Sehen Sie den App-Stack im Docker Desktop Dashboard

Im Docker Desktop Dashboard sehen Sie, dass es eine Gruppe namens getting-started-app gibt. Dies ist der Projektname von Docker Compose und wird verwendet, um die Container zusammenzufassen. Standardmäßig ist der Projektname einfach der Name des Verzeichnisses, in dem sich die compose.yaml befand

Wenn Sie den Stack erweitern, sehen Sie die beiden Container, die Sie in der Compose-Datei definiert haben. Die Namen sind auch etwas aussagekräftiger, da sie dem Muster <Service-Name>-<Replikat-Nummer> folgen. So ist es sehr einfach, schnell zu erkennen, welcher Container Ihre Anwendung und welcher Container die mysql-Datenbank ist

Alles abreißen

Wenn Sie bereit sind, alles abzubauen, führen Sie einfach docker compose down aus oder drücken Sie den Mülleimer im Docker Desktop Dashboard für die gesamte Anwendung. Die Container werden gestoppt und das Netzwerk wird entfernt

Warnung

Standardmäßig werden benannte Volumes in Ihrer Compose-Datei nicht entfernt, wenn Sie docker compose down ausführen. Wenn Sie die Volumes entfernen möchten, müssen Sie das Flag --volumes hinzufügen

Das Docker Desktop Dashboard entfernt die Volumes nicht, wenn Sie den Anwendungsstapel löschen

Zusammenfassung

In diesem Abschnitt haben Sie Docker Compose kennengelernt und erfahren, wie Sie damit die Definition und Freigabe von Multi-Service-Anwendungen vereinfachen können

Nächste Schritte

Als Nächstes werden Sie einige bewährte Verfahren kennenlernen, mit denen Sie Ihr Dockerfile verbessern können

Anhang

Siehe auch

Kategorie Docker/Workshop wurde nicht gefunden

---

Links

Weblinks

1. Compose-Übersicht
2. Compose-Dateireferenz
3. Compose CLI-Referenz