MariaDB puede ejecutarse en Kubernetes con alta disponibilidad y de manera escalable. En esta guía se explica cómo desplegar MariaDB creando un StatefulSet, asociando un volumen persistente y configurando el acceso al servicio de base de datos. De este modo, MariaDB se integra en tu clúster de Kubernetes de forma estable, segura y controlada.

¿Por qué desplegar MariaDB en Kubernetes?

Kubernetes facilita el despliegue, la escalabilidad y la supervisión de MariaDB. Se encarga de distribuir cargas de trabajo de forma inteligente y reinicia automáticamente el contenedor de la base de datos en caso de fallos. Con Kubernetes es posible aprovechar mejor los recursos y simplificar la gestión de la infraestructura, tanto en la nube como en un centro de datos local.

Requisitos previos

Antes de empezar, asegúrate de que cumples las siguientes condiciones:

  • Un clúster de Kubernetes en funcionamiento (por ejemplo, Minikube, AKS, EKS o VKE)
  • kubectl instalado y correctamente configurado en tu máquina local
  • Acceso a un terminal con permisos de administrador en el clúster
  • Opcional: una StorageClass o un HostPath configurado localmente para garantizar la persistencia de los datos
Compute Engine
La solución IaaS ideal para tus cargas de trabajo
  • vCPU económico con núcleos dedicados
  • Flexible y sin periodo mínimo contractual
  • Soporte experto 24/7

Instalar MariaDB en Kubernetes: paso a paso

A continuación, se muestra cómo desplegar MariaDB en tu clúster y garantizar que los datos se almacenen de forma persistente.

Paso 1: configurar PersistentVolume (PV) y PersistentVolumeClaim (PVC)

MariaDB en Kubernetes necesita almacenamiento persistente para los datos. Para que se conserven tras reinicios o nuevos despliegues, se define un PersistentVolume (PV) y una PersistentVolumeClaim (PVC).

El PV especifica 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 almacenamiento 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 configuración:

kubectl apply -f mariadb-pvc.yaml
bash

Verifica si el almacenamiento está correctamente vinculado:

kubectl get pvc mariadb-pvc
bash

Si aparece el estado Bound, todo está configurado correctamente.

Paso 2: crear una ConfigMap con my.cnf

Para ajustar la configuración de MariaDB, crea un archivo de configuración personalizado con una ConfigMap, que se montará más tarde en el contenedor.

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 externamente (bind-address), usará InnoDB como motor de almacenamiento por defecto y admitirá hasta 1000 conexiones.

Aplica la configuración:

kubectl apply -f mariadb-config.yaml
bash
Managed Kubernetes
Gestiona las cargas de trabajo de los contenedores con total seguridad

La plataforma ideal para aplicaciones de contenedores de alto rendimiento y gran escalabilidad, integrada en el ecosistema de IONOS Cloud con soporte experto 24/7.

Paso 3: crear un StatefulSet para MariaDB

Un StatefulSet garantiza que cada pod del clúster tenga una identidad fija y un almacenamiento estable. De este modo, todas las instancias de la base de datos mantienen su asociació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 StatefulSet:

kubectl apply -f mariadb-statefulset.yaml
bash

Comprueba el despliegue:

kubectl get statefulset mariadb
bash

Cuando veas READY 1/1, el primer pod de MariaDB se habrá desplegado correctamente en el clúster.

Paso 4: configurar el acceso con un Service

Para que otras aplicaciones 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 configuración:

kubectl apply -f mariadb-service.yaml
bash

Verifica su disponibilidad:

kubectl get svc mariadb
bash

Verás una IP interna y el puerto 3306, necesarios para conectarte.

Paso 5: comprobar la conexión a MariaDB en Kubernetes

Para confirmar que el servicio funciona correctamente, inicia un pod temporal como cliente:

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

Tras introducir la contraseña, accederás a la consola SQL. Comprueba las bases de datos disponibles:

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 StatefulSet

Una de las grandes ventajas de Kubernetes es la facilidad de escalado. Si tu aplicación genera más carga o requiere varias conexiones simultáneas, puedes ampliar MariaDB con más instancias. 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 Kubernetes que cree dos pods adicionales junto al existente. Cada pod recibe una identidad propia (por ejemplo, mariadb-0, mariadb-1, mariadb-2) y un volumen independiente.

Verifica el estado de la escalabilidad 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

Kubernetes eliminará los pods extra y mantendrá solo mariadb-0. Los datos permanecen en los volúmenes de los pods eliminados hasta que se borren manualmente

¿Le ha resultado útil este artículo?
Ir al menú principal