MariaDB puede eje­cu­tar­se en Ku­be­r­ne­tes con alta di­s­po­ni­bi­li­dad y de manera escalable. En esta guía se explica cómo desplegar MariaDB creando un Sta­te­fu­l­Set, asociando un volumen pe­r­si­s­te­n­te y co­n­fi­gu­ra­n­do el acceso al servicio de base de datos. De este modo, MariaDB se integra en tu clúster de Ku­be­r­ne­tes de forma estable, segura y co­n­tro­la­da.

¿Por qué desplegar MariaDB en Ku­be­r­ne­tes?

Ku­be­r­ne­tes facilita el de­s­plie­gue, la es­ca­la­bi­li­dad y la su­pe­r­vi­sión de MariaDB. Se encarga de di­s­tri­buir cargas de trabajo de forma in­te­li­ge­n­te y reinicia au­to­má­ti­ca­me­n­te el co­n­te­ne­dor de la base de datos en caso de fallos. Con Ku­be­r­ne­tes es posible apro­ve­char mejor los recursos y si­m­pli­fi­car la gestión de la in­frae­s­tru­c­tu­ra, tanto en la nube como en un centro de datos local.

Re­qui­si­tos previos

Antes de empezar, asegúrate de que cumples las si­guie­n­tes co­n­di­cio­nes:

  • Un clúster de Ku­be­r­ne­tes en fu­n­cio­na­mie­n­to (por ejemplo, Minikube, AKS, EKS o VKE)
  • kubectl instalado y co­rre­c­ta­me­n­te co­n­fi­gu­ra­do en tu máquina local
  • Acceso a un terminal con permisos de ad­mi­ni­s­tra­dor en el clúster
  • Opcional: una Sto­ra­ge­Cla­ss o un HostPath co­n­fi­gu­ra­do lo­ca­l­me­n­te para ga­ra­n­ti­zar la pe­r­si­s­te­n­cia de los datos

Instalar MariaDB en Ku­be­r­ne­tes: paso a paso

A co­n­ti­nua­ción, se muestra cómo desplegar MariaDB en tu clúster y ga­ra­n­ti­zar que los datos se almacenen de forma pe­r­si­s­te­n­te.

Paso 1: co­n­fi­gu­rar Pe­r­si­s­te­n­t­Vo­lu­me (PV) y Pe­r­si­s­te­n­t­Vo­lu­me­Claim (PVC)

MariaDB en Ku­be­r­ne­tes necesita al­ma­ce­na­mie­n­to pe­r­si­s­te­n­te para los datos. Para que se conserven tras reinicios o nuevos de­s­plie­gues, se define un Pe­r­si­s­te­n­t­Vo­lu­me (PV) y una Pe­r­si­s­te­n­t­Vo­lu­me­Claim (PVC).

El PV es­pe­ci­fi­ca la ubicación física en el nodo del clúster, en este ejemplo /mnt/data/mariadb. Crea el archivo mariadb-pv.yaml:

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

La opción Retain garantiza que los datos se conserven aunque se elimine la PVC. Aplica el PV:

kubectl apply -f mariadb-pv.yaml
bash

La PVC solicita al­ma­ce­na­mie­n­to del PV para ser utilizado por el pod. Crea el archivo mariadb-pvc.yaml:

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

Aplica esta co­n­fi­gu­ra­ción:

kubectl apply -f mariadb-pvc.yaml
bash

Verifica si el al­ma­ce­na­mie­n­to está co­rre­c­ta­me­n­te vinculado:

kubectl get pvc mariadb-pvc
bash

Si aparece el estado Bound, todo está co­n­fi­gu­ra­do co­rre­c­ta­me­n­te.

Paso 2: crear una ConfigMap con my.cnf

Para ajustar la co­n­fi­gu­ra­ción de MariaDB, crea un archivo de co­n­fi­gu­ra­ción pe­r­so­na­li­za­do con una ConfigMap, que se montará más tarde en el co­n­te­ne­dor.

Archivo mariadb-config.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
yaml

Con estas opciones, MariaDB será accesible ex­te­r­na­me­n­te (bind-address), usará InnoDB como motor de al­ma­ce­na­mie­n­to por defecto y admitirá hasta 1000 co­ne­xio­nes.

Aplica la co­n­fi­gu­ra­ción:

kubectl apply -f mariadb-config.yaml
bash
Managed Ku­be­r­ne­tes de IONOS
La pla­ta­fo­r­ma ideal para gestionar apli­ca­cio­nes en co­n­te­ne­do­res.

Co­m­ple­ta­me­n­te escalable, seguro y con ac­tua­li­za­cio­nes au­to­má­ti­cas.

Paso 3: crear un Sta­te­fu­l­Set para MariaDB

Un Sta­te­fu­l­Set garantiza que cada pod del clúster tenga una identidad fija y un al­ma­ce­na­mie­n­to estable. De este modo, todas las in­s­ta­n­cias de la base de datos mantienen su aso­cia­ción con un volumen concreto incluso después de un reinicio. Para ello, crea primero el archivo mariadb-statefulset.yaml.

Archivo 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
yaml

Aplica el Sta­te­fu­l­Set:

kubectl apply -f mariadb-statefulset.yaml
bash

Comprueba el de­s­plie­gue:

kubectl get statefulset mariadb
bash

Cuando veas READY 1/1, el primer pod de MariaDB se habrá de­s­ple­ga­do co­rre­c­ta­me­n­te en el clúster.

Paso 4: co­n­fi­gu­rar el acceso con un Service

Para que otras apli­ca­cio­nes dentro del clúster accedan a MariaDB, es necesario crear un Service.

Archivo mariadb-service.yaml:

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

Este Service hace que MariaDB sea accesible bajo un nombre DNS fijo (mariadb).

Aplica la co­n­fi­gu­ra­ción:

kubectl apply -f mariadb-service.yaml
bash

Verifica su di­s­po­ni­bi­li­dad:

kubectl get svc mariadb
bash

Verás una IP interna y el puerto 3306, ne­ce­sa­rios para co­ne­c­tar­te.

Paso 5: comprobar la conexión a MariaDB en Ku­be­r­ne­tes

Para confirmar que el servicio funciona co­rre­c­ta­me­n­te, inicia un pod temporal como cliente:

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

Tras in­tro­du­cir la co­n­tra­se­ña, accederás a la consola SQL. Comprueba las bases de datos di­s­po­ni­bles:

SHOW DATABASES;
sql

Deberían aparecer las bases de datos estándar como mysql, information_schema o performance_schema. Sal con exit.

Paso 6: escalar el Sta­te­fu­l­Set

Una de las grandes ventajas de Ku­be­r­ne­tes es la facilidad de escalado. Si tu apli­ca­ción genera más carga o requiere varias co­ne­xio­nes si­mu­l­tá­neas, puedes ampliar MariaDB con más in­s­ta­n­cias. En la práctica, esto se consigue ajustando el número de réplicas.

Ejecuta este comando para iniciar tres pods:

kubectl scale statefulset mariadb --replicas=3
bash

Este comando indica a Ku­be­r­ne­tes que cree dos pods adi­cio­na­les junto al existente. Cada pod recibe una identidad propia (por ejemplo, mariadb-0, mariadb-1, mariadb-2) y un volumen in­de­pe­n­die­n­te.

Verifica el estado de la es­ca­la­bi­li­dad con:

kubectl get statefulset mariadb
bash

El valor READY 3/3 indica que todo funciona. Para listar los pods:

kubectl get pods -l app=mariadb
bash

Si ya no necesitas tanta capacidad, reduce de nuevo el número de réplicas:

kubectl scale statefulset mariadb --replicas=1
bash

Ku­be­r­ne­tes eliminará los pods extra y mantendrá solo mariadb-0. Los datos pe­r­ma­ne­cen en los volúmenes de los pods eli­mi­na­dos hasta que se borren ma­nua­l­me­n­te

Ir al menú principal