In­stal­la­re MariaDB su Ku­ber­ne­tes: una guida

MariaDB può essere eseguito in modo scalabile e af­fi­da­bi­le con Ku­ber­ne­tes. In questa guida, creerai uno Sta­te­ful­Set, col­le­ghe­rai un volume per­si­sten­te e con­fi­gu­re­rai l’accesso al servizio di database. In questo modo, in­te­gre­rai MariaDB in modo per­ma­nen­te e con­trol­la­to nel tuo cluster Ku­ber­ne­tes.

Perché la com­bi­na­zio­ne di MariaDB e Ku­ber­ne­tes è van­tag­gio­sa?

Ku­ber­ne­tes aiuta ad avviare, scalare e mo­ni­to­ra­re MariaDB in modo af­fi­da­bi­le. Di­stri­bui­sce in­tel­li­gen­te­men­te i carichi di lavoro e ga­ran­ti­sce il riavvio au­to­ma­ti­co della banca dati in caso di guasti. Con Ku­ber­ne­tes, puoi uti­liz­za­re le risorse in modo ef­fi­cien­te e gestire più fa­cil­men­te la tua in­fra­strut­tu­ra, sia nel cloud che in locale nel data center.

I requisiti

Prima di iniziare, verifica che siano sod­di­sfat­ti i seguenti requisiti:

• È presente un cluster Ku­ber­ne­tes fun­zio­nan­te (ad esempio Minikube, AKS, EKS o VKE)
• kubectl è con­fi­gu­ra­to sulla tua macchina locale
• Hai accesso a un terminale con permessi di am­mi­ni­stra­zio­ne nel cluster
• Opzionale: Sto­ra­ge­Class o HostPath locale con­fi­gu­ra­to per la per­si­sten­za

In­stal­la­re MariaDB su Ku­ber­ne­tes: guida

Ti mostriamo di seguito come di­stri­bui­re MariaDB nel cluster e con­ser­va­re i dati in modo per­ma­nen­te.

Primo passaggio: con­fi­gu­ra­re Per­si­stent­Vo­lu­me (PV) e PVC

MariaDB su Ku­ber­ne­tes necessita di una memoria per­si­sten­te per i contenuti del database. Affinché questi siano con­ser­va­ti anche in caso di riavvio o re-de­ploy­ment, con­fi­gu­ria­mo un Per­si­stent­Vo­lu­me (PV) e un relativo Per­si­stent­Vo­lu­me­Claim (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 con­ser­va­ti dopo l’eli­mi­na­zio­ne del PVC. Applica il PV:

kubectl apply -f mariadb-pv.yaml

Il PVC riserva spazio di ar­chi­via­zio­ne 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 con­fi­gu­ra­zio­ne:

kubectl apply -f mariadb-pvc.yaml

Verifica suc­ces­si­va­men­te se lo spazio di ar­chi­via­zio­ne è stato associato con successo:

kubectl get pvc mariadb-pvc

Se viene vi­sua­liz­za­to lo stato Bound, tutto è collegato cor­ret­ta­men­te.

Secondo passaggio: creare ConfigMap con my.cnf

Per con­fi­gu­ra­re al meglio MariaDB, crea un file di con­fi­gu­ra­zio­ne per­so­na­liz­za­to tramite ConfigMap, che sarà suc­ces­si­va­men­te integrato nel container.

Crea il file mariadb-config.yaml con queste im­po­sta­zio­ni:

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 ga­ran­ti­sco­no che MariaDB sia ac­ces­si­bi­le dall’esterno (bind-address), con­sen­to­no di uti­liz­za­re opzioni di ar­chi­via­zio­ne moderne come InnoDB e sup­por­ta­no fino a 1.000 con­nes­sio­ni.

Attiva la con­fi­gu­ra­zio­ne:

kubectl apply -f mariadb-config.yaml

Terzo passaggio: creare uno Sta­te­ful­Set per MariaDB

Uno Sta­te­ful­Set assicura che ogni pod nel cluster riceva un’identità fissa e una memoria stabile. In questo modo, tutte le istanze del database man­ten­go­no la loro as­so­cia­zio­ne a un de­ter­mi­na­to 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 Sta­te­ful­Set:

kubectl apply -f mariadb-statefulset.yaml

Verifica che l’ope­ra­zio­ne sia andata a buon fine con:

kubectl get statefulset mariadb

Una volta vi­sua­liz­za­to READY 1/1, il tuo primo pod di MariaDB su Ku­ber­ne­tes è in ese­cu­zio­ne nel cluster.

Quarto passaggio: con­fi­gu­ra­re l’accesso tramite un servizio Ku­ber­ne­tes

Per per­met­te­re ad altre ap­pli­ca­zio­ni all’interno del cluster di accedere a MariaDB, abbiamo bisogno di un servizio Ku­ber­ne­tes. Crea il file mariadb-service.yaml con la seguente con­fi­gu­ra­zio­ne:

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 Ku­ber­ne­tes è rag­giun­gi­bi­le con un nome DNS fisso (mariadb).

Attiva la con­fi­gu­ra­zio­ne:

kubectl apply -f mariadb-service.yaml

Verifica se il servizio è di­spo­ni­bi­le:

kubectl get svc mariadb

Dovresti vedere un indirizzo IP interno e la porta 3306. Queste in­for­ma­zio­ni sono im­por­tan­ti per il passaggio suc­ces­si­vo.

Quinto passaggio: con­nes­sio­ne all’istanza di MariaDB su Ku­ber­ne­tes

Per con­trol­la­re se il servizio di database funziona cor­ret­ta­men­te, puoi avviare un pod tem­po­ra­neo 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 vi­sua­liz­za­zio­ne dei database:

SHOW DATABASES;

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

Sesto passaggio: scalare lo Sta­te­ful­Set

Un grande vantaggio di Ku­ber­ne­tes è la facilità di scalare. Se la tua ap­pli­ca­zio­ne genera più carico o richiede più con­nes­sio­ni si­mul­ta­nee, 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 istru­zio­ne ordina a Ku­ber­ne­tes 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 sca­la­bi­li­tà con:

kubectl get statefulset mariadb

Dovresti ora vedere READY 3/3. Controlla i pod in ese­cu­zio­ne:

kubectl get pods -l app=mariadb

Quando il carico aumentato è terminato o vuoi ri­spar­mia­re sulle risorse di test, puoi ridurre di nuovo il numero di pod:

kubectl scale statefulset mariadb --replicas=1

Dopo un breve periodo, Ku­ber­ne­tes rimuove i pod ag­giun­ti­vi. Solo mariadb-0 rimane attivo. I dati nei volumi dei pod eliminati vengono con­ser­va­ti grazie all’ar­chi­tet­tu­ra Sta­te­ful­Set, finché non elimini ma­nual­men­te il volume.