# MariaDB en Kubernetes: guía paso a paso

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](https://www.ionos.es/digitalguide/servidores/know-how/que-es-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](https://www.ionos.es/digitalguide/servidores/know-how/cluster-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

## 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`:

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

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

```bash
kubectl apply -f mariadb-pv.yaml
```

La PVC solicita almacenamiento del PV para ser utilizado por el pod. Crea el archivo `mariadb-pvc.yaml`:

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

Aplica esta configuración:

```bash
kubectl apply -f mariadb-pvc.yaml
```

Verifica si el almacenamiento está correctamente vinculado:

```bash
kubectl get pvc mariadb-pvc
```

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`:

```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
```

Con estas opciones, MariaDB será accesible externamente (`bind-address`), usará [InnoDB](https://www.ionos.es/digitalguide/hosting/cuestiones-tecnicas/que-es-innodb/) como motor de almacenamiento por defecto y admitirá hasta 1000 conexiones.

Aplica la configuración:

```bash
kubectl apply -f mariadb-config.yaml
```

### 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`:

```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
```

Aplica el StatefulSet:

```bash
kubectl apply -f mariadb-statefulset.yaml
```

Comprueba el despliegue:

```bash
kubectl get statefulset mariadb
```

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`:

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

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

Aplica la configuración:

```bash
kubectl apply -f mariadb-service.yaml
```

Verifica su disponibilidad:

```bash
kubectl get svc mariadb
```

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:

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

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

```sql
SHOW DATABASES;
```

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:

```bash
kubectl scale statefulset mariadb --replicas=3
```

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:

```bash
kubectl get statefulset mariadb
```

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

```bash
kubectl get pods -l app=mariadb
```

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

```bash
kubectl scale statefulset mariadb --replicas=1
```

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


This is a markdown version of: [https://www.ionos.es/digitalguide/hosting/cuestiones-tecnicas/mariadb-en-kubernetes/](https://www.ionos.es/digitalguide/hosting/cuestiones-tecnicas/mariadb-en-kubernetes/) for AI/LLM consumption.