Lernprogramm: Erstellen von Multicontainer-Apps mit MySQL und Docker Compose

2025-02-03

In diesem Artikel wird beschrieben, wie Sie Multicontainer-Apps mit MySQL- und Docker Composeerstellen. Mit einer App mit mehreren Containern können Sie Container für spezielle Aufgaben zuweisen, sodass sich jeder Container auf eine einzelne Aufgabe konzentrieren kann. Es gibt viele Vorteile bei der Verwendung von Multicontainer-Apps:

Mit separaten Containern können Sie APIs und Front-End-Ressourcen anders verwalten als Datenbanken.
Mit mehreren Containern können Sie Versionen isoliert versions- und aktualisieren.
Lokale Datenbanken können in Containern und verwalteten Diensten verwaltet werden, die für Datenbanken in der Produktion verwendet werden.
Multi-Container-Apps sind effizienter als das Ausführen mehrerer Prozesse mit einem Prozess-Manager, was dem Start/Herunterfahren von Containern Komplexität hinzufügt.

In diesem Tutorial:

MySQL starten
Ausführen Ihrer Multi-Container-App mit MySQL
Erstellen einer Docker Compose-Datei für Ihre App
Ausführen des Anwendungsstapels mit Docker Compose

Voraussetzungen

Dieser Artikel ist Teil einer Lernprogrammreihe. Die Verfahren basieren auf einem etablierten Beispiel, das Docker Desktop- für Linux-Container erfordert.

Der empfohlene Ansatz besteht darin, das erste Lernprogramm, Erstellen Sie eine Container-App, einschließlich der Erfüllung der Voraussetzungen, sowie das Lernprogramm Daten in Ihrer App speichern abzuschließen. Nachdem Sie diese Tutorials durchgearbeitet haben, fahren Sie mit den in diesem Artikel beschriebenen Prozeduren fort.
Im Beispiel in diesem Artikel wird Docker Composeverwendet.
- Fenster
- Linux
Docker Desktop für Windows enthält Docker Compose.

Führen Sie den folgenden Befehl aus, um Ihre Docker-Installation zu überprüfen:
```
docker-compose version
```
Folgen Sie für Linux den Anweisungen, um Docker Compose zu installieren.

Visual Studio Code

In dieser Lernprogrammreihe werden Prozeduren für Visual Studio Code (VS Code) beschrieben. Überprüfen Sie die folgenden Überlegungen für die Arbeit in dieser Umgebung:

Verwenden Sie das linke Menü, um zwischen dem CONTAINER-EXPLORER oder der EXPLORER-Ansicht (Datei und Ordner) zu wechseln:
Öffnen Sie ein Befehlszeilenfenster in VS Code, indem Sie Terminal>Neues Terminalauswählen. Sie können auch die Tastenkombination STRG+UMSCHALTTASTE+` (Graviszeichen) verwenden.
Wenn nicht anders angegeben, führen Sie Befehle in einem Bash-Fenster aus. Die meisten Befehle, die für Bash markiert sind, werden in einem Bash-Fenster oder im Befehlszeilenfenster von VS Code ausgeführt.

MySQL-Datenbankverwaltungssystem starten

Standardmäßig werden Container isoliert ausgeführt. Ein Container kennt andere Prozesse oder Container auf demselben Computer nicht.

Um die Kommunikation zwischen Containern zu ermöglichen, müssen sie an dasselbe Netzwerk angefügt werden. Mehrere Container im selben Netzwerk können Daten freigeben und Informationen miteinander verarbeiten.

Es gibt zwei Möglichkeiten, einen Container an ein Netzwerk anzufügen. Sie können einen Container während der Erstellung an ein Netzwerk anfügen oder einen vorhandenen Container zu einem späteren Zeitpunkt an ein Netzwerk anfügen.

In diesem Beispiel erstellen Sie das Netzwerk und fügen den MySQL-Container beim Start an.

Erstellen Eines Netzwerks mit dem Namen todo-app:
```
docker network create todo-app
```
Starten Sie einen MySQL-Container mit dem Namen todo-mysql-data, und fügen Sie ihn an das todo-app Netzwerk an. Der Befehl erstellt einen Netzwerkalias mysql für die MySQL-Datenbank todos.

Wenn Sie den Befehl ausführen, geben Sie Ihr MySQL-Stammkennwort für den <your-password> Platzhalter ein.
```
docker run -d --network todo-app --network-alias mysql -v todo-mysql-data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=<your-password> -e MYSQL_DATABASE=todos mysql:lts
```
Mit diesem Befehl werden auch die MYSQL_ROOT_PASSWORD- und MYSQL_DATABASE Umgebungsvariablen definiert. Weitere Informationen finden Sie unter MySQL Docker Hub listing.

Warnung

In diesem Lernprogramm werden Kennwortanmeldeinformationen zum Authentifizieren mit einer MySQL-Datenbank veranschaulicht, was nicht die sicherste Methode ist. Weitere Informationen zu sichereren Authentifizierungsmethoden finden Sie in der MySQL-Dokumentation.
Holen Sie sich die Container-ID, um sie im nächsten Schritt zu verwenden.
```
docker ps
```
Vergewissern Sie sich, dass Sie eine Verbindung mit dem Container im mysql Netzwerk herstellen können.

Wenn Sie den Befehl ausführen, geben Sie Ihre Container-ID für den <mysql-container-id> Platzhalter ein.
```
docker exec -it <mysql-container-id> mysql -p
```
Geben Sie an der Eingabeaufforderung das Kennwort ein, das Sie beim Erstellen des todo-mysql-data-Containers angegeben haben.

Listen Sie in der MySQL-Shell die Datenbanken auf, und überprüfen Sie, ob die todos Datenbank angezeigt wird.

SHOW DATABASES;

Die folgende Ausgabe wird angezeigt:

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
| todos              |
+--------------------+
5 rows in set (0.00 sec)

Um die Verbindung zu beenden und zur Befehlszeilenaufforderung zurückzukehren, geben Sie exitein.

Ausführen Ihrer App mit MySQL

Die todo-App unterstützt das Festlegen bestimmter Umgebungsvariablen, um Ihre MySQL-Verbindungseinstellungen anzugeben. In der folgenden Tabelle sind die unterstützten Variablen und die werte aufgeführt, die im in diesem Abschnitt dargestellten Beispiel verwendet werden.

Variablenname	Beispielwert	Beschreibung
`MYSQL_HOST`	`mysql`	Der Hostname für den MySQL-Server.
`MYSQL_USER`	`root`	Der Benutzername, der für die Verbindung verwendet werden soll.
`MYSQL_PASSWORD`	`<your-password>`	Das Kennwort, das für die Verbindung verwendet werden soll. Ersetzen Sie in diesem Beispiel Ihr Stammkennwort durch den Platzhalter `<your-password>`.
`MYSQL_DATABASE`	`todos`	Der Name der Datenbank, die nach dem Herstellen der Verbindung verwendet werden soll.

Warnung

Die Verwendung von Umgebungsvariablen zum Festlegen von Verbindungseinstellungen ist für die Entwicklung akzeptabel, diese Vorgehensweise wird jedoch nicht für die Ausführung von Anwendungen in der Produktion empfohlen. Weitere Informationen finden Sie unter Warum Sie Umgebungsvariablen nicht für geheime Datenverwenden sollten.

Ein sichererer Mechanismus besteht darin, die geheime Unterstützung ihres Container-Orchestrierungsframeworks zu verwenden. In den meisten Fällen werden diese Geheimnisse als Dateien im laufenden Container bereitgestellt.

Im folgenden Beispiel starten Sie Ihre App und verbinden Ihren App-Container mit Ihrem MySQL-Container.

Führen Sie den folgenden docker Befehl aus. Beachten Sie, wie der Befehl die zuvor beschriebenen Umgebungsvariablen angibt.

Denken Sie beim Ausführen des Befehls daran, Ihr MySQL-Stammkennwort für den <your-password> Platzhalter einzugeben.
```
docker run -dp 3000:3000 -w /app -v ${PWD}:/app --network todo-app -e MYSQL_HOST=mysql -e MYSQL_USER=root -e MYSQL_PASSWORD=<your-password> -e MYSQL_DB=todos node:lts-alpine sh -c "yarn install && yarn run dev"
```
Öffnen Sie im VS Code-Editor den Container-Explorer, klicken Sie mit der rechten Maustaste auf Ihren App-Container, und wählen Sie "Protokolle anzeigen" aus.

Sie können die Protokolle auch über die Befehlszeile anzeigen, indem Sie den Befehl docker logs verwenden.

Überprüfen Sie die Protokollausgabe. Beachten Sie die Zeile, die angibt, dass die App mit der MySQL-Datenbank verbunden ist: Connected to mysql db at host mysql.

# Previous log messages omitted
$ nodemon src/index.js
[nodemon] 1.19.2
[nodemon] to restart at any time, enter `rs`
[nodemon] watching dir(s): *.*
[nodemon] starting `node src/index.js`
Connected to mysql db at host mysql
Listening on port 3000

Wechseln Sie in Ihrem Internetbrowser zu Ihrer ausgeführten Anwendung: http://localhost:3000.
Fügen Sie in Ihrer ausgeführten Anwendung Ihrer Aufgabenliste einige Elemente hinzu.
Stellen Sie eine Verbindung mit der MySQL-Containerdatenbank im mysql Netzwerk her, damit Sie die Datenbank überprüfen können.

Wenn Sie den Befehl ausführen, geben Sie Ihre Container-ID für den <mysql-container-id> Platzhalter ein.
```
docker exec -ti <mysql-container-id> mysql -p todos
```
Geben Sie an der Eingabeaufforderung das Kennwort ein, das Sie beim Erstellen des todo-mysql-data-Containers angegeben haben.

Überprüfen Sie in der MySQL-Shell, ob die von Ihnen hinzugefügten todo_items in die todos-Datenbank geschrieben wurden.

use todos;
select * from todo_items;

Die Ausgabe sollte ähnlich wie das folgende Beispiel aussehen:

+--------------------------------------+--------------------+-----------+
| id                                   | name               | completed |
+--------------------------------------+--------------------+-----------+
| c906ff08-60e6-44e6-8f49-ed56a0853e85 | Do amazing things! |         0 |
| 2912a79e-8486-4bc3-a4c5-460793a575ab | Be awesome!        |         0 |
+--------------------------------------+--------------------+-----------+

Sie verfügen jetzt über eine Anwendung, die Daten in einer externen Datenbank speichert, die in einem separaten Container ausgeführt wird. Dieses Verfahren veranschaulicht, wie Sie die Kommunikation zwischen Containern mithilfe von Netzwerken aktivieren können.

Erstellen einer Docker Compose-Datei

Docker Compose hilft Ihnen beim Definieren und Freigeben von Anwendungen mit mehreren Containern. Eine Docker Compose-Datei kann alle erforderlichen Dienste angeben, sodass Sie alle zugehörigen Prozesse mit einem einzigen Befehl starten oder beenden können. Sie können Ihren Anwendungsstapel in einer Docker Compose-Datei im Stammverzeichnis Ihres Projekt-Repositorys definieren und Ihre Konfiguration unter Versionssteuerung verwalten. Mit diesem Ansatz können andere Personen zu Ihrem Projekt beitragen, wenn sie Ihr Repository klonen.

Im folgenden Beispiel konfigurieren Sie eine Docker Compose-Datei für Ihre Multicontaineranwendung todo.

Erstellen Sie im Stammverzeichnis Ihres todo-App-Projekts eine Docker Compose-Datei mit dem Namen docker-compose.yml.

Anmerkung

Standardmäßig ist die YAML-Schemaversion auf die neueste Version festgelegt. Wenn Die Schemaversion veraltet ist, wird beim Ausführen der App eine Warnmeldung angezeigt. Informationen zum Überprüfen der aktuellen Schemaversionen und der Kompatibilitätsmatrix finden Sie unter Übersicht (Compose file).
Fügen Sie in der datei docker-compose.yml die folgenden Elemente hinzu. Geben Sie Ihre App name an, und erstellen Sie die Liste von services (oder Containern), die Sie als Teil Ihrer Anwendung ausführen möchten.
```
name: todo

services:
```
Die Liste der Dienste ist für Ihre App eindeutig. Beispiele sind app, web, db, proxyusw. Sie erweitern die Definition für das services-Element in einem späteren Schritt.

Tipp

Einzüge sind in YML-Dateien von Bedeutung. Wenn Sie in VS Code bearbeiten, weist IntelliSense auf Fehler im Format oder in der Syntax hin.
Kehren Sie zur services Definition in der datei docker-compose.yml zurück. Erweitern Sie die Definition, indem Sie einen Eintrag hinzufügen, um das app Dienstelement zu definieren, das das Image für den Container enthält.
```
services:
  app:
    image: node:lts-alpine
```
Sie können einen beliebigen Namen für den Dienst auswählen. Der Name wird automatisch zu einem Netzwerkalias, der nützlich ist, wenn Sie den MySQL-Dienst definieren.
Erweitern Sie die Definition des app-Elements, um anzugeben, welcher command ausgeführt werden soll.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
```
Definieren Sie ports zur Verwendung mit dem app-Dienst. Beachten Sie, dass diese Ports dem argument -p 3000:3000 für den Befehl entsprechen, der zum Ausführen der App mit MySQL verwendet wird.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
```
Identifizieren Sie das Arbeitsverzeichnis working_dir für den Dienst app und auch die zugeordneten volumes.
```
  app:
    image: node:lts-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
```
Wenn Sie Docker Compose-Volumes definieren, können Sie relative Pfade basierend auf dem aktuellen Verzeichnis verwenden.

Geben Sie environment Variablendefinitionen an, die beim Ausführen von Befehlen für den app Dienst verwendet werden sollen.

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

Denken Sie daran, Ihr MySQL-Stammkennwort für den <your-password> Platzhalter einzugeben.

Fügen Sie die Definition für den MySQL-Dienst mysql nach der app Dienstdefinition hinzu. Geben Sie die Elementnamen und -werte wie dargestellt und mit demselben Einzug an.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
```
Die mysql-Dienstdefinition entspricht dem Befehl, den Sie zuvor genutzt haben, um MySQL zu starten. Wenn Sie den Dienst definieren, empfängt er automatisch den Netzwerkalias.

Identifizieren Sie die volumes, die dem mysql-Service zugeordnet sind.

services:
  app:
    ...
  mysql:
    image: mysql:lts
    volumes:
      - todo-mysql-data:/var/lib/mysql

Geben Sie environment Variablendefinitionen an, die beim Ausführen von Befehlen für den mysql Dienst verwendet werden sollen.
```
services:
  app:
    ...
  mysql:
    image: mysql:lts
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: <your-password>
      MYSQL_DATABASE: todos
```
Denken Sie daran, Ihr MySQL-Stammkennwort für den <your-password> Platzhalter einzugeben.
Definieren Sie die Volumezuordnung für die gesamte App. Fügen Sie einen volumes:-Abschnitt nach dem services:-Abschnitt mit dem gleichen Einzug hinzu.
```
services:
   ...

volumes:
  todo-mysql-data:
```

Vergewissern Sie sich, dass die abgeschlossene docker-compose.yml Datei wie im folgenden Beispiel aussieht. Ihr MySQL-Stammkennwort sollte für den <your-password> Platzhalter angezeigt werden.

name: todo

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

  mysql:
    image: mysql:lts
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: <your-password>
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

Ausführen des Anwendungsstapels mit Docker Compose

Jetzt können Sie versuchen, ihre docker-compose.yml Datei auszuführen.

Beenden Sie alle ausgeführten Instanzen Ihrer Anwendung und Datenbank.
- Visual Studio Code
- Befehlszeile
Führen Sie die folgenden Schritte in VS Code aus:
1. Öffnen Sie den CONTAINER-EXPLORER (Erweiterung "Containertools").
2. Für jeden laufenden Container: Klicken Sie mit der rechten Maustaste auf den Container und wählen Sie Entfernenaus.
Führen Sie die folgenden Befehle in einem Befehlszeilenfenster oder Terminal aus:
1. Rufen Sie die Liste der ausgeführten Container und ihrer Bezeichner <container-id> ab:
```
docker ps
```
2. Beenden und entfernen Sie alle laufenden Container.
```
docker stop <container-id>
docker rm <container-id>
```
Starten Sie Ihre Multicontainer-App und alle Dienste.
- Visual Studio Code
- Befehlszeile
Führen Sie die folgenden Schritte in VS Code aus:
1. Öffnen Sie die Ansicht EXPLORER (Datei und Ordner).
2. Klicken Sie mit der rechten Maustaste auf die docker-compose.yml Datei und wählen Sie Compose Upaus.
Führen Sie den folgenden Befehl mit dem argument -d aus, der den Befehl als Hintergrundprozess ausführt:
```
docker-compose up -d
```
Die Ausgabe sollte ähnlich wie das folgende Beispiel aussehen:
```
[+] Building 0.0s (0/0)
[+] Running 2/2
✔ Container app-app-1    Started  0.9s 
✔ Container app-mysql-1  Running
```
Mit diesem Vorgang wird das zugeordnete Volume für die App und das Netzwerk erstellt. Standardmäßig erstellt Docker Compose ein Netzwerk speziell für den Anwendungsstapel.
Überprüfen Sie die Protokolle für den laufenden Container.
- Visual Studio Code
- Befehlszeile
Führen Sie die folgenden Schritte in VS Code aus:
1. Öffnen Sie den CONTAINER-EXPLORER (Erweiterung "Containertools").
2. Klicken Sie mit der rechten Maustaste auf den App-Container, und wählen Sie Protokoll anzeigenaus.
Führen Sie den folgenden Befehl aus:
```
docker logs
```
Sie können Protokolle für einen bestimmten Dienst anzeigen, indem Sie den Dienstnamen hinzufügen, z. B. app am Ende des befehls logs:
```
docker logs <service-name>
```
Die Ausgabe sollte ähnlich wie das folgende Beispiel aussehen:
```
mysql_1  | 2019-10-03T03:07:16.083639Z 0 [Note] mysqld: ready for connections.
mysql_1  | Version: '5.7.27'  socket: '/var/run/mysqld/mysqld.sock'  port: 3306  MySQL Community Server (GPL)
app_1    | Connected to mysql db at host mysql
app_1    | Listening on port 3000
```
Die Protokolle zeigen den Dienstnamen und die Instanznummer an, z. B. app_1 am Anfang jeder Zeile. Mit diesem Format können Sie Nachrichten nach Dienst und Instanz unterscheiden. Die Protokolle der einzelnen Dienste werden in einen einzelnen Datenstrom interleaviert. Mit diesem Ansatz können Sie auf zeitbezogene Probleme achten.
Sie können jetzt zu Ihrer ausgeführten Anwendung in Ihrem Internetbrowser wechseln: http://localhost:3000.

Beenden von Docker Compose und ausgeführten Containern

Wenn Sie mit der App und den Containern fertig sind, können Sie sie entfernen.

Visual Studio Code
Befehlszeile

Führen Sie die folgenden Schritte in VS Code aus:

Öffnen Sie die Ansicht EXPLORER (Datei und Ordner).
Klicken Sie mit der rechten Maustaste auf die docker-compose.yml Datei, und wählen Sie Compose Downaus.

Führen Sie den folgenden Befehl aus, um die ausgeführte App und Container zu beenden:

docker-compose down

Dieser Vorgang beendet alle ausgeführten Container und entfernt das Netzwerk.

Standardmäßig werden benannte Volumes in Ihrer Compose-Datei nicht entfernt. Wenn Sie diese Volumes entfernen möchten, können Sie den Befehl docker-compose down --volumes verwenden.

Bereinigen von Ressourcen

Wenn Sie die Komponenten der Voraussetzungen in dieser Tutorialreihe auf Ihrer Installation angewendet haben, können Sie die Konfiguration für die zukünftige Docker-Entwicklung wiederverwenden. Es ist nicht wichtig, komponenten zu löschen oder zu deinstallieren.

Freigeben über