MariaDB lässt sich mit Kubernetes skalierbar und betriebssicher betreiben. In dieser Anleitung erstellen Sie ein StatefulSet, binden ein persistentes Volume ein und konfigurieren den Zugriff auf den Datenbankdienst. So integrieren Sie MariaDB dauerhaft und kontrolliert in Ihr Kubernetes-Cluster.

Warum ist die Kombination MariaDB und Kubernetes sinnvoll?

Kubernetes hilft dabei, MariaDB zuverlässig zu starten, zu skalieren und zu überwachen. Es verteilt Arbeitslasten intelligent und sorgt dafür, dass die Datenbank bei Ausfällen automatisch neu startet. Mit Kubernetes können Sie Ressourcen effizient nutzen und Ihre Infrastruktur leichter verwalten – und das sowohl in der Cloud als auch lokal im Rechenzentrum.

Das sind die Anforderungen

Bevor Sie beginnen, überprüfen Sie, ob folgende Voraussetzungen erfüllt sind:

  • Ein laufender Kubernetes-Cluster ist vorhanden (zum Beispiel Minikube, AKS, EKS oder VKE)
  • kubectl ist auf Ihrer lokalen Maschine eingerichtet
  • Sie haben Zugriff auf ein Terminal mit Admin-Rechten im Cluster
  • Optional: eine StorageClass oder lokal konfigurierter HostPath für die Persistenz
Compute Engine
Die ideale IaaS für Ihre Workloads
  • Kostengünstige vCPUs und leistungsstarke dedizierte Cores
  • Höchste Flexibilität ohne Mindestvertragslaufzeit
  • Inklusive 24/7 Experten-Support

MariaDB via Kubernetes installieren: Schritt für Schritt

Wir zeigen Ihnen im Folgenden, wie Sie MariaDB im Cluster ausrollen und die Daten dauerhaft speichern. Ausführliche Informationen zu Kubernetes finden Sie in unserem Kubernetes-Tutorial.

Schritt 1: PersistentVolume (PV) und PVC einrichten

MariaDB in Kubernetes benötigt persistenten Speicher für die Datenbankinhalte. Damit diese auch bei einem Neustart oder Re-Deployment erhalten bleiben, konfigurieren wir ein PersistentVolume (PV) und eine passende PersistentVolumeClaim (PVC).

Das PV definiert einen physischen Speicherort im Cluster, in diesem Fall /mnt/data/mariadb. Erstellen Sie dazu eine YAML-Datei namens mariadb-pv.yaml:

apiVersion: v1
kind: PersistentVolume
metadata:
    name: mariadb-pv
spec:
    capacity:
        storage: 10Gi
    accessModes:
        - ReadWriteOnce
    persistentVolumeReclaimPolicy: Retain
    hostPath:
        path: /mnt/data/mariadb
yaml

Der Eintrag Retain stellt sicher, dass die Daten nach dem Löschen der PVC erhalten bleiben. Wenden Sie das PV an:

kubectl apply -f mariadb-pv.yaml
bash

Die PVC reserviert Speicherplatz vom PV für den Pod. Legen Sie die Datei mariadb-pvc.yaml mit folgendem Inhalt an:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
    name: mariadb-pvc
spec:
    accessModes:
        - ReadWriteOnce
    resources:
        requests:
            storage: 10Gi
yaml

Wenden Sie diese Konfiguration an:

kubectl apply -f mariadb-pvc.yaml
bash

Prüfen Sie anschließend, ob der Speicher erfolgreich gebunden wurde:

kubectl get pvc mariadb-pvc
bash

Wenn der Status Bound angezeigt wird, ist alles korrekt verbunden.

Schritt 2: ConfigMap mit my.cnf erstellen

Damit MariaDB optimal konfiguriert ist, legen Sie eine benutzerdefinierte Konfigurationsdatei über eine ConfigMap an. Diese wird später in den Container eingebunden.

Erstellen Sie die Datei mariadb-config.yaml mit diesen Einstellungen:

apiVersion: v1
kind: ConfigMap
metadata:
    name: mariadb-config
    labels:
        app: mariadb
data:
    my.cnf: |
        [mysqld]
        bind-address=0.0.0.0
        default_storage_engine=InnoDB
        innodb_file_per_table=1
        max_connections=1000
yaml

Diese Optionen stellen sicher, dass MariaDB von außen erreichbar ist (bind-address), Sie moderne Speicheroptionen wie InnoDB nutzen und bis zu 1000 Verbindungen möglich sind.

Aktivieren Sie die Konfiguration:

kubectl apply -f mariadb-config.yaml
bash
Managed Kubernetes
Kubernetes als Managed Service von IONOS Cloud

Die ideale Plattform für performante und hochskalierbare Container-Anwendungen. Umfassend ins IONOS Cloud Ökosystem integriert und rund um die Uhr professionell betreut.

Schritt 3: StatefulSet für MariaDB erstellen

Ein StatefulSet sorgt dafür, dass jeder Pod im Cluster eine feste Identität und einen stabilen Speicher erhält. Damit behalten alle Datenbankinstanzen auch nach einem Neustart ihre Zuordnung zu einem bestimmten Volume. Erstellen Sie dafür zunächst die Datei mariadb-statefulset.yaml.

apiVersion: apps/v1
kind: StatefulSet
metadata:
    name: mariadb
spec:
    serviceName: "mariadb"
    replicas: 1
    selector:
        matchLabels:
            app: mariadb
    template:
        metadata:
            labels:
                app: mariadb
        spec:
            containers:
            - name: mariadb
                image: mariadb:latest
                ports:
                - containerPort: 3306
                    name: mariadb
                env:
                - name: MYSQL_ROOT_PASSWORD
                    value: "strong_password"
                volumeMounts:
                - name: mariadb-storage
                    mountPath: /var/lib/mysql
                - name: config-volume
                    mountPath: /etc/mysql/conf.d
            volumes:
            - name: config-volume
                configMap:
                    name: mariadb-config
    volumeClaimTemplates:
    - metadata:
            name: mariadb-storage
        spec:
            accessModes: ["ReadWriteOnce"]
            resources:
                requests:
                    storage: 10Gi
yaml

Wenden Sie das StatefulSet an:

kubectl apply -f mariadb-statefulset.yaml
bash

Prüfen Sie den Erfolg mit:

kubectl get statefulset mariadb
bash

Sobald READY 1/1 angezeigt wird, läuft Ihr erster MariaDB-Kubernetes-Pod erfolgreich im Cluster.

Schritt 4: Zugriff über einen Kubernetes-Service einrichten

Damit andere Anwendungen innerhalb des Clusters auf MariaDB zugreifen können, benötigen wir einen Kubernetes-Service. Erstellen Sie die Datei mariadb-service.yaml mit folgender Konfiguration:

apiVersion: v1
kind: Service
metadata:
    name: mariadb
spec:
    ports:
    - port: 3306
        targetPort: 3306
    selector:
        app: mariadb
yaml

Durch diesen Service ist der MariaDB-Kubernetes-Pod unter einem festen DNS-Namen (mariadb) erreichbar.

Aktivieren Sie die Konfiguration:

kubectl apply -f mariadb-service.yaml
bash

Prüfen Sie, ob der Service verfügbar ist:

kubectl get svc mariadb
bash

Sie sollten eine interne IP-Adresse und den Port 3306 sehen. Diese Informationen sind wichtig für den nächsten Schritt.

Schritt 5: Verbindung zur MariaDB-Kubernetes-Instanz

Um zu kontrollieren, ob der Datenbankdienst korrekt funktioniert, können Sie einen temporären Pod starten, der als MySQL-Client fungiert. Führen Sie folgenden Befehl aus:

kubectl run -it --rm --image=mariadb mariadb-client -h mariadb -u root -p strong_password
bash

Nach Eingabe des Passworts gelangen Sie in die SQL-Konsole. Testen Sie dort beispielsweise die Anzeige der Datenbanken:

SHOW DATABASES;
sql

Sie sollten Standarddatenbanken wie mysql, information_schema oder performance_schema sehen. Geben Sie zum Beenden exit ein.

Schritt 6: StatefulSet skalieren

Ein großer Vorteil von Kubernetes ist die einfache Skalierung. Wenn Ihre Anwendung mehr Last erzeugt oder mehrere Verbindungen gleichzeitig benötigt, können Sie MariaDB durch weitere Instanzen erweitern. In der Praxis geschieht das über das Anpassen der Replikate.

Führen Sie diesen Befehl aus, um drei Pods zu starten:

kubectl scale statefulset mariadb --replicas=3
bash

Dieser Ausdruck weist Kubernetes an, zusätzlich zum bestehenden Pod zwei weitere zu erstellen. Jeder Pod erhält dabei eine eigene Identität (zum Beispiel mariadb-0, mariadb-1, mariadb-2) sowie ein eigenes Volume.

Überprüfen Sie den Status der Skalierung mit:

kubectl get statefulset mariadb
bash

Sie sollten nun READY 3/3 sehen. Kontrollieren Sie die laufenden Pods:

kubectl get pods -l app=mariadb
bash

Wenn die erhöhte Last vorbei ist oder Sie Testressourcen einsparen möchten, können Sie die Anzahl der Pods wieder reduzieren:

kubectl scale statefulset mariadb --replicas=1
bash

Nach kurzer Zeit entfernt Kubernetes die zusätzlichen Pods. Nur mariadb-0 bleibt bestehen. Daten in den Volumes von gelöschten Pods bleiben durch die StatefulSet-Architektur erhalten, solange Sie das Volume nicht manuell löschen.

Tipp

Mehr Anleitungen zu MariaDB finden Sie in den Tutorials „MariaDB via Docker installieren“ und „MariaDB auf Proxmox installieren“.

War dieser Artikel hilfreich?
Zum Hauptmenü