Docker/Multi-Container

Docker/Multi-Container - Multi-Container

Beschreibung

Mehrcontainer-Anwendungen

Die Mehrcontainer-Architektur trennt Zuständigkeiten, vereinfacht den Betrieb und ermöglicht gezieltes Skalieren. Datenbankkomponenten (z. B. MySQL) werden als separater Container ausgeführt.

Entwurfsprinzip. Ein Container = eine klar abgegrenzte Aufgabe.

Anwendungsteile bleiben lose gekoppelt, Images bleiben kompakt und wartbar.

Vorteile

API/Frontend und Datenbank haben unterschiedliche Lastprofile und werden unabhängig skaliert.
Anwendungs- und DB-Images werden getrennt gebaut, getestet und aktualisiert.
Lokal kann die Datenbank in einem Container laufen; in der Produktion kann dasselbe System einen verwalteten Datenbankdienst nutzen – ohne Änderungen am Anwendungs-Image.
Pro Container ein Hauptprozess. Mehrere Prozesse erfordern einen Prozessmanager und erhöhen die Komplexität von Start/Shutdown.

Empfehlung.

MySQL separat betreiben und die Anwendung als Verbund miteinander gekoppelter Container ausführen.
So bleibt die Architektur verständlich, betrieblich robust und leicht anpassbar (Skalierung, Updates, Umgebungswechsel).

Container-Vernetzung

Standardmäßig sind Container isoliert und sehen weder Prozesse noch andere Container auf demselben Host.
Damit Container Daten austauschen können, benötigen sie ein gemeinsames Netzwerk.
Dazu müssen die Container in dasselbe Netzwerk eingebunden werden.

MySQL starten

Es gibt zwei Möglichkeiten, einen Container in ein Netzwerk einzubinden

Netzwerk beim Start des Containers zuweisen
Bereits laufenden Container mit einem Netzwerk verbinden

In diesem Abschnitt wird zuerst ein Netzwerk erstellt und der MySQL-Container beim Start daran angeschlossen.

Erstellen Sie das Netzwerk

docker network create todo-app

MySQL-Container starten und mit dem Netzwerk verbinden. Dabei werden Umgebungsvariablen gesetzt, die MySQL für die Initialisierung verwendet.

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

Im vorherigen Befehl sehen Sie die --network-alias-Flagge. In einem späteren Abschnitt werden Sie mehr über dieses Flag erfahren.(!)

Hinweis: Der obige Befehl gibt das Volume todo-mysql-data an, das in /var/lib/mysql gemountet ist. Docker erstellt das Volume automatisch, falls es zuvor nicht mit docker volume create erstellt wurde.

Überprüfung der Verbindung zur Datenbank

docker exec -it <mysql-container-id> mysql -u root -p

Wenn die Passwortabfrage erscheint, geben Sie secret ein.

Führen Sie in der MySQL-Shell eine Liste der Datenbanken auf und überprüfen Sie, ob die Datenbank todos angezeigt wird

mysql> SHOW DATABASES;

+--------------------+
| Datenbank          |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
| todos              |
+--------------------+
5 Zeilen im Satz (0.00 sec)

Beenden Sie die MySQL-Shell, um zur Shell auf Ihrem Rechner zurückzukehren

mysql> exit

Sie haben jetzt eine todos-Datenbank und können sie benutzen

Verbindung zu MySQL herstellen

Nach dem Start des MySQL-Containers kann innerhalb desselben Docker-Netzwerks über DNS auf den Dienst zugegriffen werden (Hostname: mysql). Zur Überprüfung der Namensauflösung wird der Diagnose-Container nicolaka/netshoot verwendet.

Netshoot-Container im selben Netzwerk starten

docker run -it --network todo-app nicolaka/netshoot

Im Container DNS-Auflösung für den Hostnamen mysql testen

dig mysql

Das Ergebnis sollte in etwa wie folgt aussehen:

; <<>> DiG 9.18.8 <<>> mysql
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 32162
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0

;; QUESTION SECTION:
;mysql.				IN	A

;; ANSWER SECTION:
mysql.			600	IN	A	172.23.0.2

;; Query time: 0 msec
;; SERVER: 127.0.0.11#53(127.0.0.11)
;; WHEN: Tue Oct 01 23:47:24 UTC 2019
;; MSG SIZE  rcvd: 44

Im ANSWER SECTION erscheint ein A-Record für mysql, der auf 172.23.0.2 zeigt (die tatsächliche IP kann abweichen).
Die Auflösung erfolgt über den Docker-internen DNS-Resolver, weil dem MySQL-Container zuvor der Netzwerkalias --network-alias mysql zugewiesen wurde.

Docker-DNS läuft typischerweise unter 127.0.0.11 und löst Service-/Aliasnamen netzwerkintern.
mysql ist außerhalb des Docker-Netzwerks kein gültiger FQDN, innerhalb des Netzwerks jedoch als Alias nutzbar.

Anwendungen im selben Docker-Netzwerk verbinden sich daher einfach mit dem Hostnamen mysql.

Starten Sie Ihre Anwendung mit MySQL

Die todo-App unterstützt das Setzen einiger Umgebungsvariablen, um die MySQL-Verbindungseinstellungen festzulegen. Diese sind

Parameter	Beschreibung
MYSQL_HOST	der Hostname für den laufenden MySQL-Server
MYSQL_USER	der Benutzername, der für die Verbindung verwendet werden soll
MYSQL_PASSWORD	das Passwort, das für die Verbindung verwendet werden soll
MYSQL_DB	die zu verwendende Datenbank nach der Verbindung

Sicherheitshinweis

Während die Verwendung von env vars zur Festlegung von Verbindungseinstellungen für die Entwicklung allgemein akzeptiert wird, wird davon dringend abgeraten, wenn Anwendungen in Produktion laufen.
Ein sicherer Mechanismus besteht darin, die Unterstützung für Geheimnisse des Orchestrators zu nutzen (Docker Swarm Secrets, Kubernetes Secrets). In Laufzeit-Containern werden Geheimnisse i. d. R. als Dateien bereitgestellt. Viele Images/Apps (u. a. MySQL und die Todo-App) unterstützen dazu Umgebungsvariablen mit dem Suffix _FILE, die auf eine Datei mit dem Wert verweisen.
Docker wertet _FILE nicht aus; die Anwendung muss die Variable lesen und den Dateiinhalt verwenden.
Für MySQL: MYSQL_PASSWORD_FILE statt MYSQL_PASSWORD.

Erstellen eines MYSQL-Containers

Geben Sie jede der vorherigen Umgebungsvariablen an und verbinden Sie den Container mit Ihrem App-Netzwerk. Stellen Sie sicher, dass Sie sich im Verzeichnis getting-started-app befinden, wenn Sie diesen Befehl ausführen

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:18-alpine \
sh -c "yarn install && yarn run dev"

Wenn Sie sich die Logs für den Container ansehen (docker logs -f <container-id>), sollten Sie eine Meldung ähnlich der folgenden sehen, die anzeigt, dass die mysql-Datenbank verwendet wird

nodemon src/index.js
[nodemon] 2.0.20
[nodemon] um jederzeit neu zu starten, geben Sie `rs` ein
[nodemon] überwachte(s) Verzeichnis(e): *.*
[nodemon] startet `node src/index.js`
Verbunden mit der mysql db auf dem Host mysql
Überwacht auf Port 3000

Öffnen Sie die Anwendung in Ihrem Browser und fügen Sie Ihrer ToDo-Liste ein paar Einträge hinzu

Verbinden Sie sich mit der mysql-Datenbank und prüfen Sie, ob die Einträge in die Datenbank geschrieben werden. Denken Sie daran, dass das Passwort geheim ist

docker exec -it <mysql-container-id> mysql -p todos

Und in der mysql-Shell führen Sie Folgendes aus:

mysql> select * from todo_items;

+--------------------------------------+--------------------+-----------+

| id | name | completed |

+--------------------------------------+--------------------+-----------+

| c906ff08-60e6-44e6-8f49-ed56a0853e85 | Tue erstaunliche Dinge! | 0 |

| 2912a79e-8486-4bc3-a4c5-460793a575ab | Sei fantastisch! | 0 |

+--------------------------------------+--------------------+-----------+

Deine Tabelle sieht anders aus, weil sie deine Artikel enthält. Aber Sie sollten sie dort gespeichert sehen

Zusammenfassung

Jetzt haben Sie eine Anwendung, die ihre Daten in einer externen Datenbank speichert, die in einem separaten Container läuft. Sie haben ein wenig über Container-Netzwerke und die Erkennung von Diensten mithilfe von DNS gelernt

Nächste Schritte

Im nächsten Abschnitt wird eine etwas bequemere Methode zur Interaktion von Containern mit Docker Compose vorgestellt.

Anhang

Siehe auch

Kategorie Docker/Workshop wurde nicht gefunden

Dokumentation

Links

Projekt

Weblinks