Installare MariaDB su Kubernetes: una guida

MariaDB può essere eseguito in modo scalabile e affidabile con Kubernetes. In questa guida, creerai uno StatefulSet, collegherai un volume persistente e configurerai l’accesso al servizio di database. In questo modo, integrerai MariaDB in modo permanente e controllato nel tuo cluster Kubernetes.

Perché la combinazione di MariaDB e Kubernetes è vantaggiosa?

Kubernetes aiuta ad avviare, scalare e monitorare MariaDB in modo affidabile. Distribuisce intelligentemente i carichi di lavoro e garantisce il riavvio automatico della banca dati in caso di guasti. Con Kubernetes, puoi utilizzare le risorse in modo efficiente e gestire più facilmente la tua infrastruttura, sia nel cloud che in locale nel data center.

I requisiti

Prima di iniziare, verifica che siano soddisfatti i seguenti requisiti:

• È presente un cluster Kubernetes funzionante (ad esempio Minikube, AKS, EKS o VKE)
• kubectl è configurato sulla tua macchina locale
• Hai accesso a un terminale con permessi di amministrazione nel cluster
• Opzionale: StorageClass o HostPath locale configurato per la persistenza

Installare MariaDB su Kubernetes: guida

Ti mostriamo di seguito come distribuire MariaDB nel cluster e conservare i dati in modo permanente.

Primo passaggio: configurare PersistentVolume (PV) e PVC

MariaDB su Kubernetes necessita di una memoria persistente per i contenuti del database. Affinché questi siano conservati anche in caso di riavvio o re-deployment, configuriamo un PersistentVolume (PV) e un relativo PersistentVolumeClaim (PVC).

Il PV definisce una posizione di memoria fisica nel cluster, in questo caso /mnt/data/mariadb. Per farlo, crea un file YAML chiamato mariadb-pv.yaml:

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

La voce Retain assicura che i dati siano conservati dopo l’eliminazione del PVC. Applica il PV:

kubectl apply -f mariadb-pv.yaml

Il PVC riserva spazio di archiviazione dal PV per il pod. Crea il file mariadb-pvc.yaml con il seguente contenuto:

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

Applica questa configurazione:

kubectl apply -f mariadb-pvc.yaml

Verifica successivamente se lo spazio di archiviazione è stato associato con successo:

kubectl get pvc mariadb-pvc

Se viene visualizzato lo stato Bound, tutto è collegato correttamente.

Secondo passaggio: creare ConfigMap con my.cnf

Per configurare al meglio MariaDB, crea un file di configurazione personalizzato tramite ConfigMap, che sarà successivamente integrato nel container.

Crea il file mariadb-config.yaml con queste impostazioni:

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

Queste opzioni garantiscono che MariaDB sia accessibile dall’esterno (bind-address), consentono di utilizzare opzioni di archiviazione moderne come InnoDB e supportano fino a 1.000 connessioni.

Attiva la configurazione:

kubectl apply -f mariadb-config.yaml

Terzo passaggio: creare uno StatefulSet per MariaDB

Uno StatefulSet assicura che ogni pod nel cluster riceva un’identità fissa e una memoria stabile. In questo modo, tutte le istanze del database mantengono la loro associazione a un determinato volume anche dopo un riavvio. Per fare ciò, crea prima il file 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

Applica lo StatefulSet:

kubectl apply -f mariadb-statefulset.yaml

Verifica che l’operazione sia andata a buon fine con:

kubectl get statefulset mariadb

Una volta visualizzato READY 1/1, il tuo primo pod di MariaDB su Kubernetes è in esecuzione nel cluster.

Quarto passaggio: configurare l’accesso tramite un servizio Kubernetes

Per permettere ad altre applicazioni all’interno del cluster di accedere a MariaDB, abbiamo bisogno di un servizio Kubernetes. Crea il file mariadb-service.yaml con la seguente configurazione:

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

Grazie a questo servizio, il pod di MariaDB su Kubernetes è raggiungibile con un nome DNS fisso (mariadb).

Attiva la configurazione:

kubectl apply -f mariadb-service.yaml

Verifica se il servizio è disponibile:

kubectl get svc mariadb

Dovresti vedere un indirizzo IP interno e la porta 3306. Queste informazioni sono importanti per il passaggio successivo.

Quinto passaggio: connessione all’istanza di MariaDB su Kubernetes

Per controllare se il servizio di database funziona correttamente, puoi avviare un pod temporaneo che funge da client MySQL. Esegui il seguente comando:

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

Dopo aver inserito la password, accederai alla console SQL. Lì, ad esempio, puoi testare la visualizzazione dei database:

SHOW DATABASES;

Dovresti vedere database standard come mysql, information_schema o performance_schema. Per uscire, digita exit.

Sesto passaggio: scalare lo StatefulSet

Un grande vantaggio di Kubernetes è la facilità di scalare. Se la tua applicazione genera più carico o richiede più connessioni simultanee, puoi espandere MariaDB con ulteriori istanze. In pratica, questo avviene regolando le repliche.

Esegui questo comando per avviare tre pod:

kubectl scale statefulset mariadb --replicas=3

Questa istruzione ordina a Kubernetes di creare altri due pod oltre a quello esistente. Ogni pod riceve un’identità propria (ad esempio, mariadb-0, mariadb-1, mariadb-2) e un volume personale.

Verifica lo stato della scalabilità con:

kubectl get statefulset mariadb

Dovresti ora vedere READY 3/3. Controlla i pod in esecuzione:

kubectl get pods -l app=mariadb

Quando il carico aumentato è terminato o vuoi risparmiare sulle risorse di test, puoi ridurre di nuovo il numero di pod:

kubectl scale statefulset mariadb --replicas=1

Dopo un breve periodo, Kubernetes rimuove i pod aggiuntivi. Solo mariadb-0 rimane attivo. I dati nei volumi dei pod eliminati vengono conservati grazie all’architettura StatefulSet, finché non elimini manualmente il volume.