# 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](https://www.ionos.it/digitalguide/server/know-how/cose-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](https://www.ionos.it/digitalguide/server/know-how/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`: ```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: ```bash 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: ```yaml apiVersion: v1 kind: PersistentVolumeClaim metadata: name: mariadb-pvc spec: accessModes: - ReadWriteOnce resources: requests: storage: 10Gi ``` Applica questa configurazione: ```bash kubectl apply -f mariadb-pvc.yaml ``` Verifica successivamente se lo spazio di archiviazione è stato associato con successo: ```bash 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: ```yaml 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](https://www.ionos.it/digitalguide/hosting/tecniche-hosting/che-cose-innodb/) e supportano fino a 1.000 connessioni. Attiva la configurazione: ```bash 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`. ```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: ```bash kubectl apply -f mariadb-statefulset.yaml ``` Verifica che l’operazione sia andata a buon fine con: ```bash 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: ```yaml 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: ```bash kubectl apply -f mariadb-service.yaml ``` Verifica se il servizio è disponibile: ```bash 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: ```bash 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: ```sql 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: ```bash 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: ```bash kubectl get statefulset mariadb ``` Dovresti ora vedere `READY 3/3`. Controlla i pod in esecuzione: ```bash 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: ```bash 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. This is a markdown version of: [https://www.ionos.it/digitalguide/hosting/tecniche-hosting/mariadb-in-kubernetes/](https://www.ionos.it/digitalguide/hosting/tecniche-hosting/mariadb-in-kubernetes/) for AI/LLM consumption.