Installer MariaDB via Kubernetes : guide étape par étape

MariaDB peut être déployée de manière évolutive et fiable avec Kubernetes. Dans ce guide, vous apprendrez à créer un StatefulSet, intégrer un volume persistant et configurer l’accès au service de base de données. Ainsi, vous intégrez MariaDB de manière stable et contrôlée dans votre cluster Kubernetes.

Pourquoi combiner MariaDB à Kubernetes ?

Kubernetes aide à démarrer, à mettre à l’échelle et à surveiller MariaDB de manière fiable. Il répartit intelligemment les charges de travail et s’assure que la base de données redémarre automatiquement en cas de panne. Avec Kubernetes, vous pouvez utiliser les ressources efficacement et gérer plus facilement votre infrastructure, que ce soit dans le Cloud ou localement dans un data center.

Prérequis

Avant de commencer, vérifiez que les conditions suivantes sont remplies :

• Un cluster Kubernetes opérationnel est disponible (comme Minikube, AKS, EKS ou VKE)
• kubectl est configuré sur votre machine locale
• Vous avez accès à un terminal avec des droits administrateur dans le cluster
• Optionnel : une StorageClass ou un HostPath configuré localement pour la persistance

Installer MariaDB via Kubernetes : étape par étape

Découvrez ci-dessous comment déployer MariaDB dans le cluster et stocker les données de manière permanente. Vous trouverez des informations détaillées sur Kubernetes dans notre tutoriel Kubernetes.

Étape 1 : configurer PersistentVolume (PV) et PVC

MariaDB nécessite un stockage persistant pour les données de la base au sein de Kubernetes. Pour que celui-ci soit préservé lors d’un redémarrage ou d’un redéploiement, nous configurons un PersistentVolume (PV) et une PersistentVolumeClaim (PVC) appropriée.

Le PV définit un emplacement de stockage physique dans le cluster, dans le cas présent /mnt/data/mariadb. Créez un fichier YAML nommé mariadb-pv.yaml :

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

L’entrée Retain garantit que les données sont conservées après la suppression de la PVC. Appliquez le PV :

kubectl apply -f mariadb-pv.yaml

La PVC réserve de l’espace de stockage du PV pour le pod. Créez le fichier mariadb-pvc.yaml de la manière suivante :

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

Appliquez cette configuration :

kubectl apply -f mariadb-pvc.yaml

Vérifiez ensuite si le stockage a été lié avec succès :

kubectl get pvc mariadb-pvc

Si le statut Bound s’affiche, tout est correctement connecté.

Étape 2 : créer un ConfigMap avec my.cnf

Pour que MariaDB soit configuré de manière optimale, créez un fichier de configuration personnalisé via un ConfigMap. Celui-ci sera ensuite intégré dans le conteneur.

Créez le fichier mariadb-config.yaml avec ces paramètres :

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

Ces options garantissent que MariaDB est accessible de l’extérieur (bind-address), vous permettent d’utiliser des options de stockage modernes telles que InnoDB et autorisent jusqu’à 1000 connexions.

Appliquez la configuration avec :

kubectl apply -f mariadb-config.yaml

Étape 3 : créer un StatefulSet pour MariaDB

Un StatefulSet garantit que chaque pod dans le cluster reçoit une identité fixe et un stockage stable. Ainsi, toutes les instances de la base de données conservent leur association à un volume spécifique, même après un redémarrage. Commencez par créer le fichier 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

Appliquez le StatefulSet :

kubectl apply -f mariadb-statefulset.yaml

Vérifiez le succès de l’opération avec :

kubectl get statefulset mariadb

Une fois que READY 1/1 s’affiche, votre premier pod MariaDB Kubernetes fonctionne avec succès dans le cluster.

Étape 4 : configurer l’accès via un service Kubernetes

Pour que d’autres applications au sein du cluster puissent accéder à MariaDB, un service Kubernetes est nécessaire. Créez le fichier mariadb-service.yaml avec la configuration suivante :

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

Grâce à ce service, le pod MariaDB Kubernetes est accessible sous un nom DNS fixe (mariadb).

Appliquez alors la configuration :

kubectl apply -f mariadb-service.yaml

Puis vérifiez si le service est disponible :

kubectl get svc mariadb

Vous devriez voir une adresse IP interne et le port 3306. Ces informations sont importantes pour l’étape suivante.

Étape 5 : connexion à l’instance MariaDB Kubernetes

Pour vérifier si le service de base de données fonctionne correctement, vous pouvez démarrer un pod temporaire qui agit comme un client MySQL. Exécutez la commande suivante :

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

Après avoir saisi le mot de passe, vous accédez à la console SQL. Testez par exemple l’affichage des bases de données :

SHOW DATABASES;

Vous devriez voir des bases de données standard telles que mysql, information_schema ou performance_schema. Pour quitter, tapez exit.

Étape 6 : mettre à l’échelle le StatefulSet

Un grand avantage de Kubernetes est la mise à l’échelle facile. Si votre application génère plus de charge ou nécessite plusieurs connexions simultanément, vous pouvez étendre MariaDB avec d’autres instances. En pratique, cela se fait en ajustant les réplicas.

Exécutez cette commande pour démarrer trois pods :

kubectl scale statefulset mariadb --replicas=3

Cette expression demande à Kubernetes de créer deux pods supplémentaires en plus du pod existant. Chaque pod reçoit ainsi une identité propre (par exemple mariadb-0, mariadb-1, mariadb-2) ainsi qu’un volume propre.

Vérifiez l’état de la mise à l’échelle avec :

kubectl get statefulset mariadb

Vous devriez maintenant voir READY 3/3. Vérifiez les pods en cours d’exécution :

kubectl get pods -l app=mariadb

Lorsque la charge accrue est terminée ou si vous souhaitez économiser des ressources de test, vous pouvez réduire à nouveau le nombre de pods :

kubectl scale statefulset mariadb --replicas=1

Kubernetes supprime alors rapidement les pods supplémentaires et seul le pod mariadb-0 reste. Les données dans les volumes des pods supprimés sont conservées grâce à l’architecture StatefulSet, tant que vous ne supprimez pas le volume manuellement.