So richtest du MySQL in Docker ein und konfigurierst es

Was die Verwendung von MySQL in Docker-Containern angeht, so ist das einfach ein Match made in the Clouds. Wenn du bereits mit Docker gearbeitet hast, gelten alle Vorteile auch für MySQL-Docker-Container:

• Isolation und Beständigkeit: Die MySQL-Instanz wird von anderer Software und anderen Abhängigkeiten isoliert, um mögliche Konflikte zu vermeiden
• Versionskontrolle: Mit Docker kannst du deinen gesamten Software-Stack zusammen mit MySQL versionieren. Das bedeutet, dass du deine Umgebung jederzeit reproduzieren kannst, was die Entwicklung und das Testen erleichtert.
• Skalierbarkeit und Ressourcenmanagement: Mit Docker kannst du deine MySQL-Anwendung skalieren, indem du einfach mehr Ressourcen wie Speicher oder CPU zuweist.
• Abhängigkeitsmanagement: Docker kapselt deine MySQL-Instanz und ermöglicht es dir, verschiedene Versionen davon zu verwalten, ohne etwas auf deinem lokalen Rechner zu verändern.

Das Wichtigste ist aber, dass deine MySQL-Anwendung überall funktioniert, nicht nur auf deinem Computer.

Wenn du MySQL mit seinem zweitbeliebtesten Konkurrenten vergleichen möchtest, schau dir unseren ausführlichen PostgreSQL vs. PostgreSQL an. MySQL comparison.

Heute lernst du also die Grundlagen, wie du MySQL zusammen mit Docker einsetzen kannst. Lass uns loslegen!

Voraussetzungen

Da sich dieser Artikel auf MySQL-Docker-Container konzentriert, gibt es ein paar Voraussetzungen, denen du folgen kannst:

• Kommandozeile/Terminalzugang: Du brauchst eine lokale Umgebung mit Terminalzugang. Wenn du in einer Jupyter-Umgebung wie Colab arbeitest, solltest du jetzt umsteigen.
• Eine laufende Docker-Instanz: Du solltest Docker Desktop bereits installiert haben (Anleitung in unserem Docker for Data Science-Tutorial). Wenn er voll funktionsfähig ist, wird unten links auf der Benutzeroberfläche ein grünes Walbaby zu sehen sein:

und der Befehl docker --help funktioniert ohne Fehler auf dem Terminal.

• Grundlegende Vertrautheit mit Docker: Auch wenn ich alle im Artikel verwendeten Befehle erkläre, wird ein grundlegendes Verständnis von Docker den Nutzen, den du aus diesem Artikel ziehen kannst, deutlich erhöhen.
• SQL: Das Gleiche gilt für SQL - ich werde in diesem Artikel keine SQL-Befehle erklären, da dies vom Hauptthema ablenken würde. Wenn deine SQL-Kenntnisse etwas eingerostet sind, kannst du die wichtigsten Themen aus diesem SQL-Kurs wieder auffrischen .

Herunterladen des offiziellen MySQL Docker Image

Wir beginnen mit dem Herunterladen des offiziellen MySQL-Docker-Images mit dem folgenden Befehl:

$ docker pull mysql:latest

docker pull benötigt den Namen und die Version des Bildes mit der Syntax image:version. Mit dem Schlüsselwort latest kannst du die neueste stabile Version herunterladen.

Wenn du die offizielle MySQL-Image-Seite auf Docker Hub besuchst, kannst du viele andere Versionen für verschiedene Zwecke sehen.

Hier ist ein Beispiel für den Download von Version 8.2:

$ docker pull mysql:8.2

Sobald du das Image heruntergeladen hast, sollte es unter deinen bestehenden Docker-Images aufgelistet sein:

Das Auflisten von Docker-Images ist auch über das Terminal möglich:

$ docker images

Erinnere dich: Docker-Images sind Blaupausen für die Erstellung von Containern. So wie du mit einem Bauplan ein Haus bauen kannst, enthält ein Docker-Image alle notwendigen Anweisungen und Komponenten, um eine laufende Instanz einer Anwendung oder eines Dienstes zu erstellen.

Wenn du aus einem OOP-Hintergrund kommst, kannst du dir Docker-Images als Klassen vorstellen. So wie du mit einer einzigen Klasse mehrere Objekte erstellen kannst, kannst du mit Docker-Images mehrere Container erstellen.

Betrieb und Verwaltung eines MySQL Server Containers

Erstellen wir nun unseren ersten Container aus dem mysql Image. Hier ist der Befehl, den wir verwenden werden:

$ docker run --name test-mysql -e MYSQL_ROOT_PASSWORD=strong_password -d mysql

• runContainer: Erstellt einen neuen Container oder startet einen bestehenden.
• --name CONTAINER_NAME: gibt dem Container einen Namen. Der Name sollte lesbar und kurz sein. In unserem Fall lautet der Name test-mysql.
• -e ENV_VARIABLE=valueDas Tag -e erzeugt eine Umgebungsvariable, auf die du innerhalb des Containers zugreifen kannst. Es ist wichtig, MYSQL_ROOT_PASSWORD zu setzen, damit wir später SQL-Befehle aus dem Container heraus ausführen können. Achte darauf, dass du dein sicheres Passwort an einem sicheren Ort aufbewahrst (nicht in deinem Gehirn).
• -dDas -d Tag ist die Abkürzung für detached (abgetrennt) und lässt den Container im Hintergrund laufen. Wenn du diese Markierung entfernst, druckt der Befehl so lange Protokolle aus, bis der Container anhält.
• image_name: Das letzte Argument ist der Name des Bildes, aus dem der Container gebaut wird. In diesem Fall ist unser Bild mysql.

Wenn der Befehl eine lange Kauderwelsch-Zeichenkette (die Container-ID) zurückgibt, bedeutet das, dass der Container gestartet ist. Du kannst seinen Status mit docker ps überprüfen:

Denke daran: Ein Docker-Container ist ein leistungsstarker Emulator eines Betriebssystems. Abgesehen von der Ausführung von MySQL kannst du im Container alle Aufgaben erledigen, die du normalerweise mit dem Terminal deines Computers erledigen würdest.

Um auf das Terminal innerhalb deines Containers zuzugreifen, kannst du den folgenden Befehl verwenden:

$ docker exec -it container_name bash

Dadurch wird eine Bash-Sitzung gestartet.

Lokale Verbindung mit dem MySQL Server Container

Alle MySQL-Container starten einen MySQL-Server, der alles enthält, um Datenbanken mit SQL zu erstellen und zu verwalten. Um sich mit dem Server zu verbinden, enthalten Container auch einen MySQL-Client, mit dem wir SQL-Abfragen durchführen können. Der Client ist nur ein schicker Name für den Terminalbefehl mysql. Benutzen wir es im Terminal von test-mysql:

1. Öffne das Bash-Terminal von test-mysql:

$ docker exec -it test-mysql bash

2. Verbinde dich mit dem Client als Root-Benutzer:

$ mysql -u root -p
Enter password: ...
mysql>

Wir verwenden das -u Tag, um den Benutzernamen anzugeben (root) und fügen das -p Tag hinzu, um das Passwort einzugeben, wenn wir dazu aufgefordert werden.

Es ist auch möglich, sich mit dem MySQL-Server außerhalb des Containers zu verbinden. Wenn du dich zum Beispiel von deinem Host-Rechner aus verbinden willst, kannst du den MySQL-Client manuell auf deinem System installieren.

Um MySQL und seinen Client unter Windows zu installieren, kannst du den Anweisungen in der offiziellen MySQL-Installationsanleitung folgen.

Für Mac kannst du Homebrew verwenden:

$ brew install mysql

Für Linux oder WSL2 (meine Wahl), kannst du sudo verwenden:

$ sudo apt update
$ sudo apt install mysql-client

Wenn du den Container nach der Installation noch laufen lässt, halte ihn an und entferne ihn:

$ docker stop test-mysql
test-mysql
$ docker rm test-mysql

Als Nächstes starten wir den Container neu, indem wir einen Port des Containers einem Port auf unserem lokalen Rechner zuordnen:

$ docker run -d --name test-mysql -e MYSQL_ROOT_PASSWORD=strong_password -p 3307:3306 mysql

Dieser Befehl macht Folgendes:

• -p 3307:3306: Stellt den Port 3306 des Containers (den Standardport für MySQL) auf deinen lokalen Port 3307 um. Das bedeutet, dass jeder Datenverkehr, der an deinen lokalen Port 3307 gesendet wird, an den Port 3306 des Containers weitergeleitet wird und dein MySQL-Server über diesen Port erreichbar ist.
• -d: Lässt den Container wieder im losgelösten Modus laufen.
• --name test-mysql: Wiederverwendet den gleichen Containernamen "test-mysql".
• -e MYSQL_ROOT_PASSWORD=strong_password: Legt das Root-Passwort für den MySQL-Server neu fest.
• mysql: Gibt das auszuführende Docker-Image an, das das offizielle MySQL-Image ist.

Nachdem Terminal eine neue ID für den Container ausgegeben hat, können wir die Port-Zuordnungen überprüfen:

$ docker port test-mysql
3306/tcp -> 0.0.0.0:3307

Es war erfolgreich! Jetzt kannst du dich von deinem lokalen Rechner aus mit dem Server auf Port 3307 über den mysql Client verbinden:

$ mysql --host=127.0.0.1 --port=3307 -u root -p
Enter password:

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 8
Server version: 8.2.0 MySQL Community Server - GPL

Copyright (c) 2000, 2023, Oracle and/or its affiliates…

Den MySQL Container konfigurieren

Du kannst MySQL-Container für so viele Einstellungen mit einer Konfigurationsdatei konfigurieren. Normalerweise wird die Datei in einem der folgenden Verzeichnisse des Containers gespeichert:

• /etc/mysql/
• /etc/mysql/conf.d
• /etc/mysql/mysql.conf.d

Die Verzeichnisse ändern sich von Bild zu Bild. Der Standard-Dateiname und die Dateierweiterung für eine Konfigurationsdatei ist jedoch my.cnf. Wenn die Datei in keinem der oben genannten Verzeichnisse existiert, bedeutet das, dass der Container eine eigene Konfigurationsdatei benötigt. Das ist bei unserem Container test-mysql der Fall:

$ ls /etc/mysql/conf.d/ # Returns no output

In solchen Situationen müssen wir die folgenden vorsichtigen Schritte unternehmen:

1. Halte an und entferne den Behälter:

$ docker stop test-mysql; docker rm test-mysql

2. Erstelle lokal (auf deinem Rechner) eine leere Konfigurationsdatei:

$ sudo mkdir -p /etc/docker/test-mysql # Create a dir
$ sudo touch /etc/docker/test-mysql/my.cnf # Create a config file inside dir

3. Starte den Container neu, indem du die beiden leeren .cnf Dateien verknüpfst:

$ docker run \
   --name test-mysql \
   -v /etc/docker/test-mysql:/etc/mysql/conf.d \
   -e MYSQL_ROOT_PASSWORD=strong_password \
   -d mysql

Wir schreiben einen neuen Tag: -v, was die Abkürzung für Volumen ist. Das Tag kann verwendet werden, um Verzeichnisse zwischen dem Container und dem lokalen Rechner zu verknüpfen. Im Fachjargon der Informatik nennt man diesen Vorgang Montage.

Im obigen Befehl mounten wir also das lokale Verzeichnis /etc/docker/test-mysql in das Verzeichnis /etc/mysql/conf.d des Containers. Dadurch werden die Inhalte der beiden Verzeichnisse miteinander verknüpft. Alle Änderungen, die in einem der beiden Verzeichnisse vorgenommen werden, werden in beiden wiedergegeben.

Mit Mounting können wir die Datei my.cnf auf unserem lokalen Rechner bearbeiten, um die Konfigurationen der Docker-Container zu ändern. Und das Beste daran ist, dass die geänderten Konfigurationen auf unserem lokalen Rechner erhalten bleiben, auch wenn der Container gestoppt oder entfernt wird. Es wird wiederverwendbar sein.

Welche Konfigurationen können wir also nach diesem Schritt ändern? Die Antwort hängt von deinem Anwendungsfall ab. Wir werden sie im Folgenden behandeln.

Möchtest du dich für Docker zertifizieren lassen? Schau dir unseren Leitfaden für eine Docker-Zertifizierung an!

Welche Optionen solltest du konfigurieren?

Obwohl die Standardkonfiguration für MySQL Docker-Container für viele gängige Szenarien funktioniert, solltest du bestimmte Einstellungen ändern, um die Leistung, Sicherheit und Ressourcennutzung zu optimieren. Hier sind einige der am häufigsten geänderten Konfigurationsoptionen:

Leistung

• innodb_buffer_pool_size: Diese Einstellung bestimmt die Menge an Speicher, die dem InnoDB-Pufferpool zugewiesen wird, der häufig aufgerufene Daten für einen schnelleren Abruf zwischenspeichert. Eine Erhöhung dieses Wertes kann die Leistung bei leseintensiven Workloads verbessern, verbraucht aber auch mehr Speicher.
• query_cache_size: Diese Einstellung steuert die Größe des Abfrage-Caches, in dem bereits ausgeführte Abfragen gespeichert werden, um sie schneller erneut ausführen zu können. Eine Erhöhung dieses Wertes kann die Leistung bei sich wiederholenden Abfragen verbessern, verbraucht aber auch mehr Speicher und ist bei dynamischen Abfragen möglicherweise nicht effektiv.
• thread_pool_size: Diese Einstellung bestimmt die maximale Anzahl gleichzeitiger Verbindungen, die der Server verarbeiten kann. Wenn du diesen Wert an die erwartete Verkehrslast anpasst, kannst du die Ressourcenauslastung optimieren und Engpässe vermeiden.

Sicherheit

• bind-address: Diese Option schränkt den MySQL-Server so ein, dass er nur an bestimmten Netzwerkschnittstellen lauscht, um den Zugriff von nicht autorisierten Quellen zu begrenzen.
• mysql_bind_host: Diese Einstellung ermöglicht es, den MySQL-Server an bestimmte IP-Adressen zu binden, anstatt auf allen Schnittstellen zu lauschen.
• validate_password_policy: Diese Option ermöglicht strengere Passwortanforderungen für mehr Sicherheit.

Ressourcennutzung

• max_connections: Diese Einstellung regelt die maximale Anzahl der zulässigen gleichzeitigen Verbindungen. Die Anpassung dieses Wertes kann eine Erschöpfung der Ressourcen verhindern und einen effizienten Serverbetrieb sicherstellen.
• innodb_file_per_table: Diese Option speichert jede InnoDB-Tabelle in einer separaten Datei, was die Leistung verbessern kann, aber den Speicherplatzbedarf erhöht.
• innodb_io_capacity: Diese Option legt die geschätzten IOPS (Input/Output Operations Per Second) für das Speichersystem fest, damit die Engine die Nutzung des Pufferpools und die Festplattenoperationen optimieren kann.

Andere häufige Änderungen

• character_set_server: Diese Option legt den Standardzeichensatz für den Server fest und sorgt so für eine einheitliche Datenkodierung und -verarbeitung.
• collation_server: Diese Option legt die Standard-Sortierregeln fest, die für die Sortierung und den Vergleich von Zeichendaten verwendet werden.
• log_bin: Diese Option ermöglicht die binäre Protokollierung der Serveraktivitäten, was bei der Fehlersuche und Replikation hilfreich sein kann.

Um die vollständige Liste der Konfigurationsoptionen zu sehen, kannst du den folgenden Befehl ausführen:

$ docker run -it --rm mysql:tag --verbose --help

Du kannst die Datei .cnf mit einem beliebigen Texteditor bearbeiten. Hier ist die Syntax, die du befolgen solltest:

[mysqld]
max_connections=200
other_params=value
...

Wie man die im MySQL Docker Container gespeicherten Daten bewahrt

Die Persistenz der in deinen MySQL-Containern gespeicherten Daten ist aus vielen Gründen wichtig:

• Datenpersistenz: Wenn du einen Container stoppst oder entfernst, gehen alle Daten verloren, auch deine Datenbank. Die Entkopplung der Daten vom Container macht sie jederzeit zugänglich.
• Gemeinsame Nutzung von Daten zwischen Containern: Wenn du die Daten aus dem Container löst, können mehrere Container darauf zugreifen. Auf diese Weise kannst du Datendopplungen vermeiden und die Synchronisierung zwischen Projekten, die dieselben Daten verwenden, vereinfachen.
• Übertragbarkeit und Sicherung: Persistente Daten können leicht gesichert und unabhängig voneinander geteilt werden, so dass sie bei Datenverlust oder versehentlicher Löschung zuverlässig wiederhergestellt werden können.
• Verbesserte Leistung und Skalierbarkeit: Indem du Daten, auf die häufig zugegriffen wird, in persistenten Speichern wie SSDs speicherst, kannst du die Leistung deiner Anwendung verbessern, anstatt dich auf die beschreibbare Schicht des Containers zu verlassen, die normalerweise langsamer ist.

Der Prozess ist derselbe, den wir schon gesehen haben - wir erstellen ein Volume und mounten es dorthin, wo die Daten in unserem Container gespeichert sind. Hier sind die Schritte:

1. Erstelle ein Volumen:

$ docker volume create test-mysql-data

Der Befehl volume create erstellt einen eigenen Speicherplatz auf deinem lokalen Dateisystem für das Volume. Nachdem das Volume gemountet wurde, werden alle Containerdaten mit ihm verknüpft.

2. Starte den Container neu, wobei das Volume gemountet ist:

$ docker stop test-mysql; docker rm test-mysql
$ docker run \
   --name test-mysql \
   -v test-mysql-data:/var/lib/mysql \
   -e MYSQL_ROOT_PASSWORD=strong_password \
   -d mysql

Diesmal ist die Syntax in diesem Format: -v volume_name:directory_in_container. Alle erstellten Volumes sollten in das Verzeichnis /var/lib/mysql gemountet werden, wie in den MySQL-Image-Dokumenten angegeben.

Jetzt werden alle Datenbanken oder Tabellen, die innerhalb von test-mysql erstellt wurden, lokal gespeichert, auch wenn der Container gestoppt oder entfernt wird.

Das letzte Kommando

Im Laufe des Artikels hat sich unser docker run Befehl deutlich weiterentwickelt. Fassen wir also alle Varianten in einem einzigen Hauptbefehl zusammen. Wir müssen anhalten und den Container wieder entfernen. Wir werden auch den Datenträger entfernen, um ganz von vorne anzufangen:

$ docker stop test-mysql; docker rm test-mysql
$ docker volume rm test-mysql-data

Hier ist also der letzte Hauptbefehl:

$ docker run \
   --name final-mysql \
   -e MYSQL_ROOT_PASSWORD=strong_password \
   -p 3307:3306 \
   -v /etc/docker/test-mysql:/etc/mysql/conf.d \
   -v final-mysql-data:/var/lib/mysql \
   -d mysql

Mit diesem Befehl wird unsere vorherige lokale Datei my.cnf an den gewünschten Ort gemountet und ein neues Volume mit dem Namen final-mysql-data erstellt und gemountet.

Komplexe MySQL-Setups mit Docker Compose verwalten

Für fortgeschrittene Setups mit mehreren Containern, wie z. B. den Betrieb von MySQL neben anderen Diensten (z. B. Webserver oder Anwendungs-Backends), vereinfacht Docker Compose den Prozess, indem es dir ermöglicht, Anwendungen mit mehreren Containern mit einer einzigen Konfigurationsdatei zu definieren und zu verwalten.

Hier ist ein einfaches Beispiel für eine docker-compose.yml Datei für einen MySQL-Container:

version: '3.9'
services:
  db:
    image: mysql:8.3.0
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: strong_password
      MYSQL_DATABASE: example_db
      MYSQL_USER: user
      MYSQL_PASSWORD: user_password
    ports:
      - "3306:3306"
    volumes:
      - db_data:/var/lib/mysql
      - ./mysql-config:/etc/mysql/conf.d
volumes:
  db_data:

Schritte zur Verwendung von Docker Compose:

• Erstelle eine docker-compose.yml Datei: Speichere die Konfigurationsdatei in deinem Projektverzeichnis.
• Starte die Dienste: Führe den folgenden Befehl aus, um alle in der Datei definierten Dienste zu starten:

docker-compose up -d

• Halte die Dienste an: Schalte die Dienste ab, wenn du fertig bist:

docker-compose down

Vorteile von Docker Compose for MySQL:

• Vereinfachte Konfiguration: Verwalte MySQL-Konfigurationen, Ports und Volumes in einer einzigen Datei.
• Leichtere Skalierung: Skaliere die Datenbank ganz einfach oder integriere sie in andere Dienste in deinem Anwendungsstack.
• Dauerhafte Daten: Verwalte automatisch Volumes für die Datenpersistenz bei Container-Neustarts.

Der Einsatz von Docker Compose ist besonders hilfreich bei der Verwaltung mehrerer Umgebungen (z. B. Entwicklung, Staging und Produktion) oder bei der Zusammenarbeit mit Teams.

Fazit

In diesem Artikel wurden die wichtigsten Aspekte des Betriebs und der Verwaltung von MySQL-Datenbanken in Docker-Containern behandelt. Wir haben gelernt, wie man MySQL-Images herunterlädt und einrichtet, MySQL-Server innerhalb von Containern startet, wie man diese Container modifiziert und Volumes für die benutzerdefinierte Konfiguration und Datenpersistenz hinzufügt.

Um mehr über das Thema zu erfahren, empfehle ich die folgenden Ressourcen:

• Einführung in Docker für Data Science
• Einführung in den Docker-Kurs
• Docker und Kubernetes Containerisierung für maschinelles Lernen
• MySQL Docker Image Dokumentation
• MySQL-Referenzhandbuch

Danke fürs Lesen!