MariaDB via Ku­ber­netes in­stal­lie­ren: Schritt-für-Schritt-Anleitung

MariaDB lässt sich mit Ku­ber­netes ska­lier­bar und be­triebs­si­cher betreiben. In dieser Anleitung erstellen Sie ein Sta­teful­Set, binden ein per­sis­ten­tes Volume ein und kon­fi­gu­rie­ren den Zugriff auf den Da­ten­bank­dienst. So in­te­grie­ren Sie MariaDB dauerhaft und kon­trol­liert in Ihr Ku­ber­netes-Cluster.

Warum ist die Kom­bi­na­ti­on MariaDB und Ku­ber­netes sinnvoll?

Ku­ber­netes hilft dabei, MariaDB zu­ver­läs­sig zu starten, zu skalieren und zu über­wa­chen. Es verteilt Ar­beits­las­ten in­tel­li­gent und sorgt dafür, dass die Datenbank bei Ausfällen au­to­ma­tisch neu startet. Mit Ku­ber­netes können Sie Res­sour­cen effizient nutzen und Ihre In­fra­struk­tur leichter verwalten – und das sowohl in der Cloud als auch lokal im Re­chen­zen­trum.

Das sind die An­for­de­run­gen

Bevor Sie beginnen, über­prü­fen Sie, ob folgende Vor­aus­set­zun­gen erfüllt sind:

• Ein laufender Ku­ber­netes-Cluster ist vorhanden (zum Beispiel Minikube, AKS, EKS oder VKE)
• kubectl ist auf Ihrer lokalen Maschine ein­ge­rich­tet
• Sie haben Zugriff auf ein Terminal mit Admin-Rechten im Cluster
• Optional: eine Sto­rage­Class oder lokal kon­fi­gu­rier­ter HostPath für die Per­sis­tenz

MariaDB via Ku­ber­netes in­stal­lie­ren: Schritt für Schritt

Wir zeigen Ihnen im Folgenden, wie Sie MariaDB im Cluster ausrollen und die Daten dauerhaft speichern. Aus­führ­li­che In­for­ma­tio­nen zu Ku­ber­netes finden Sie in unserem Ku­ber­netes-Tutorial.

Schritt 1: Per­sis­tent­Vo­lu­me (PV) und PVC ein­rich­ten

MariaDB in Ku­ber­netes benötigt per­sis­ten­ten Speicher für die Da­ten­bank­in­hal­te. Damit diese auch bei einem Neustart oder Re-De­ploy­ment erhalten bleiben, kon­fi­gu­rie­ren wir ein Per­sis­tent­Vo­lu­me (PV) und eine passende Per­sis­tent­Vo­lu­meCla­im (PVC).

Das PV definiert einen phy­si­schen Spei­cher­ort 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

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

Die PVC re­ser­viert Spei­cher­platz 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

Wenden Sie diese Kon­fi­gu­ra­ti­on an:

kubectl apply -f mariadb-pvc.yaml

Prüfen Sie an­schlie­ßend, ob der Speicher er­folg­reich gebunden wurde:

kubectl get pvc mariadb-pvc

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

Schritt 2: ConfigMap mit my.cnf erstellen

Damit MariaDB optimal kon­fi­gu­riert ist, legen Sie eine be­nut­zer­de­fi­nier­te Kon­fi­gu­ra­ti­ons­da­tei über eine ConfigMap an. Diese wird später in den Container ein­ge­bun­den.

Erstellen Sie die Datei mariadb-config.yaml mit diesen Ein­stel­lun­gen:

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

Diese Optionen stellen sicher, dass MariaDB von außen er­reich­bar ist (bind-address), Sie moderne Spei­cher­op­tio­nen wie InnoDB nutzen und bis zu 1000 Ver­bin­dun­gen möglich sind.

Ak­ti­vie­ren Sie die Kon­fi­gu­ra­ti­on:

kubectl apply -f mariadb-config.yaml

Schritt 3: Sta­teful­Set für MariaDB erstellen

Ein Sta­teful­Set sorgt dafür, dass jeder Pod im Cluster eine feste Identität und einen stabilen Speicher erhält. Damit behalten alle Da­ten­bank­in­stan­zen auch nach einem Neustart ihre Zuordnung zu einem be­stimm­ten 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

Wenden Sie das Sta­teful­Set an:

kubectl apply -f mariadb-statefulset.yaml

Prüfen Sie den Erfolg mit:

kubectl get statefulset mariadb

Sobald READY 1/1 angezeigt wird, läuft Ihr erster MariaDB-Ku­ber­netes-Pod er­folg­reich im Cluster.

Schritt 4: Zugriff über einen Ku­ber­netes-Service ein­rich­ten

Damit andere An­wen­dun­gen innerhalb des Clusters auf MariaDB zugreifen können, benötigen wir einen Ku­ber­netes-Service. Erstellen Sie die Datei mariadb-service.yaml mit folgender Kon­fi­gu­ra­ti­on:

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

Durch diesen Service ist der MariaDB-Ku­ber­netes-Pod unter einem festen DNS-Namen (mariadb) er­reich­bar.

Ak­ti­vie­ren Sie die Kon­fi­gu­ra­ti­on:

kubectl apply -f mariadb-service.yaml

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

kubectl get svc mariadb

Sie sollten eine interne IP-Adresse und den Port 3306 sehen. Diese In­for­ma­tio­nen sind wichtig für den nächsten Schritt.

Schritt 5: Ver­bin­dung zur MariaDB-Ku­ber­netes-Instanz

Um zu kon­trol­lie­ren, ob der Da­ten­bank­dienst korrekt funk­tio­niert, können Sie einen tem­po­rä­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

Nach Eingabe des Passworts gelangen Sie in die SQL-Konsole. Testen Sie dort bei­spiels­wei­se die Anzeige der Da­ten­ban­ken:

SHOW DATABASES;

Sie sollten Stan­dard­da­ten­ban­ken wie mysql, information_schema oder performance_schema sehen. Geben Sie zum Beenden exit ein.

Schritt 6: Sta­teful­Set skalieren

Ein großer Vorteil von Ku­ber­netes ist die einfache Ska­lie­rung. Wenn Ihre Anwendung mehr Last erzeugt oder mehrere Ver­bin­dun­gen gleich­zei­tig 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

Dieser Ausdruck weist Ku­ber­netes an, zu­sätz­lich zum be­stehen­den 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.

Über­prü­fen Sie den Status der Ska­lie­rung mit:

kubectl get statefulset mariadb

Sie sollten nun READY 3/3 sehen. Kon­trol­lie­ren Sie die laufenden Pods:

kubectl get pods -l app=mariadb

Wenn die erhöhte Last vorbei ist oder Sie Test­res­sour­cen einsparen möchten, können Sie die Anzahl der Pods wieder re­du­zie­ren:

kubectl scale statefulset mariadb --replicas=1

Nach kurzer Zeit entfernt Ku­ber­netes die zu­sätz­li­chen Pods. Nur mariadb-0 bleibt bestehen. Daten in den Volumes von ge­lösch­ten Pods bleiben durch die Sta­teful­Set-Ar­chi­tek­tur erhalten, solange Sie das Volume nicht manuell löschen.