Installer MariaDB via Ku­ber­netes : guide étape par étape

MariaDB peut être déployée de manière évolutive et fiable avec Ku­ber­netes. Dans ce guide, vous ap­pren­drez à créer un Sta­te­ful­Set, intégrer un volume per­sis­tant et con­fi­gu­rer 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 Ku­ber­netes.

Pourquoi combiner MariaDB à Ku­ber­netes ?

Ku­ber­netes aide à démarrer, à mettre à l’échelle et à sur­veil­ler MariaDB de manière fiable. Il répartit in­tel­li­gem­ment les charges de travail et s’assure que la base de données redémarre au­to­ma­ti­que­ment en cas de panne. Avec Ku­ber­netes, vous pouvez utiliser les res­sources ef­fi­ca­ce­ment et gérer plus fa­ci­le­ment votre in­fras­truc­ture, que ce soit dans le Cloud ou lo­ca­le­ment dans un data center.

Prérequis

Avant de commencer, vérifiez que les con­di­tions suivantes sont remplies :

• Un cluster Ku­ber­netes opé­ra­tion­nel est dis­po­nible (comme Minikube, AKS, EKS ou VKE)
• kubectl est configuré sur votre machine locale
• Vous avez accès à un terminal avec des droits ad­mi­nis­tra­teur dans le cluster
• Optionnel : une Sto­ra­ge­Class ou un HostPath configuré lo­ca­le­ment pour la per­sis­tance

Installer MariaDB via Ku­ber­netes : étape par étape

Découvrez ci-dessous comment déployer MariaDB dans le cluster et stocker les données de manière per­ma­nente. Vous trouverez des in­for­ma­tions dé­tail­lées sur Ku­ber­netes dans notre tutoriel Ku­ber­netes.

Étape 1 : con­fi­gu­rer Per­sis­tent­Vo­lume (PV) et PVC

MariaDB nécessite un stockage per­sis­tant pour les données de la base au sein de Ku­ber­netes. Pour que celui-ci soit préservé lors d’un re­dé­mar­rage ou d’un re­dé­ploie­ment, nous con­fi­gu­rons un Per­sis­tent­Vo­lume (PV) et une Per­sis­tent­Vo­lu­me­Claim (PVC) ap­pro­priée.

Le PV définit un em­pla­ce­ment 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 con­ser­vées après la sup­pres­sion 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 con­fi­gu­ra­tion :

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 cor­rec­te­ment connecté.

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

Pour que MariaDB soit configuré de manière optimale, créez un fichier de con­fi­gu­ra­tion per­son­na­lisé via un ConfigMap. Celui-ci sera ensuite intégré dans le conteneur.

Créez le fichier mariadb-config.yaml avec ces pa­ra­mè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 ga­ran­tis­sent que MariaDB est ac­ces­sible de l’extérieur (bind-address), vous per­met­tent d’utiliser des options de stockage modernes telles que InnoDB et au­to­ri­sent jusqu’à 1000 con­nexions.

Appliquez la con­fi­gu­ra­tion avec :

kubectl apply -f mariadb-config.yaml

Étape 3 : créer un Sta­te­ful­Set pour MariaDB

Un Sta­te­ful­Set 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 con­ser­vent leur as­so­cia­tion à un volume spé­ci­fique, même après un re­dé­mar­rage. 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 Sta­te­ful­Set :

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 Ku­ber­netes fonc­tionne avec succès dans le cluster.

Étape 4 : con­fi­gu­rer l’accès via un service Ku­ber­netes

Pour que d’autres ap­pli­ca­tions au sein du cluster puissent accéder à MariaDB, un service Ku­ber­netes est né­ces­saire. Créez le fichier mariadb-service.yaml avec la con­fi­gu­ra­tion suivante :

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

Grâce à ce service, le pod MariaDB Ku­ber­netes est ac­ces­sible sous un nom DNS fixe (mariadb).

Appliquez alors la con­fi­gu­ra­tion :

kubectl apply -f mariadb-service.yaml

Puis vérifiez si le service est dis­po­nible :

kubectl get svc mariadb

Vous devriez voir une adresse IP interne et le port 3306. Ces in­for­ma­tions sont im­por­tantes pour l’étape suivante.

Étape 5 : connexion à l’instance MariaDB Ku­ber­netes

Pour vérifier si le service de base de données fonc­tionne cor­rec­te­ment, vous pouvez démarrer un pod tem­po­raire 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 Sta­te­ful­Set

Un grand avantage de Ku­ber­netes est la mise à l’échelle facile. Si votre ap­pli­ca­tion génère plus de charge ou nécessite plusieurs con­nexions si­mul­ta­né­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 ex­pres­sion demande à Ku­ber­netes de créer deux pods sup­plé­men­taires 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 main­te­nant 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 éco­no­mi­ser des res­sources de test, vous pouvez réduire à nouveau le nombre de pods :

kubectl scale statefulset mariadb --replicas=1

Ku­ber­netes supprime alors ra­pi­de­ment les pods sup­plé­men­taires et seul le pod mariadb-0 reste. Les données dans les volumes des pods supprimés sont con­ser­vées grâce à l’ar­chi­tec­ture Sta­te­ful­Set, tant que vous ne supprimez pas le volume ma­nuel­le­ment.