How to install MariaDB via Ku­ber­netes

MariaDB can run in a scalable and reliable way on Ku­ber­netes. In this guide, you’ll create a State­fulSet, add per­sis­tent storage and configure access to the database service. This ensures MariaDB is per­ma­nent­ly in­te­grat­ed into your Ku­ber­netes cluster in a stable, con­trolled way.

Why should you use MariaDB with Ku­ber­netes?

Ku­ber­netes makes it easy to start, scale and monitor MariaDB. It dis­trib­utes workloads in­tel­li­gent­ly and au­to­mat­i­cal­ly restarts the database if something goes wrong. Whether you run in the cloud or on-premises, Ku­ber­netes helps you use resources ef­fi­cient­ly and manage your in­fra­struc­ture more easily.

What do you need before in­stalling MariaDB on Ku­ber­netes?

Before you begin make sure you have:

• A running Ku­ber­netes cluster (e.g. Minikube, AKS, EKS or VKE)
• kubectl is set up on your local machine
• Terminal access with admin rights in the cluster
• Optional: a Stor­age­Class or locally con­fig­ured HostPath for storing data

How to install MariaDB via Ku­ber­netes

Below you’ll learn how to deploy MariaDB in the cluster and store data so it’s not lost after restarts. For more details on Ku­ber­netes basics, see our Ku­ber­netes tutorial.

Step 1: Set up Per­sis­tentVol­ume (PV) and PVC

MariaDB in Ku­ber­netes needs per­sis­tent storage so your data isn’t lost if the pod restarts or is re­de­ployed. We’ll configure a Per­sis­tentVol­ume (PV) and a Per­sis­tentVol­ume­Claim (PVC). The PV defines where the data is stored phys­i­cal­ly in the cluster — in this example /mnt/data/mariadb. Save the following YAML to a file named mariadb-pv.yaml:

apiVersion: v1

kind: PersistentVolume

metadata:

  name: mariadb-pv

spec:

  capacity:

    storage: 10Gi

  accessModes:

    - ReadWriteOnce

  persistentVolumeReclaimPolicy: Retain

  hostPath:

    path: /mnt/data/mariadb

The Retain policy makes sure the data remains even if the PVC is deleted. Create the Per­sis­tentVol­ume by running:

kubectl apply -f mariadb-pv.yaml

You should receive con­fir­ma­tion that the Per­sis­tentVol­ume was created. Next the PVC reserves space from the PV for the MariaDB pod. Save the following to a file named mariadb-pvc.yaml:

apiVersion: v1

kind: PersistentVolumeClaim

metadata:

  name: mariadb-pvc

spec:

  accessModes:

    - ReadWriteOnce

  resources:

    requests:

      storage: 10Gi

Create the Per­sis­tentVol­ume­Claim by running:

kubectl apply -f mariadb-pvc.yaml

You should receive con­fir­ma­tion that the PVC was created. Verify the PVC is bound by running:

kubectl get pvc mariadb-pvc

If the status column shows Bound every­thing is correctly connected.

Step 2: Create ConfigMap with my.cnf

To fine-tune MariaDB create a custom con­fig­u­ra­tion file using a ConfigMap. This will be mounted into the container later.

Save the following to a file named 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

These settings make MariaDB ac­ces­si­ble from outside the container (bind-address), enable modern storage features like InnoDB and allow up to 1,000 si­mul­ta­ne­ous con­nec­tions.

Create the ConfigMap by running:

kubectl apply -f mariadb-config.yaml

Step 3: Create State­fulSet for MariaDB

A State­fulSet ensures each pod keeps a con­sis­tent identity and storage. This means your database stays linked to its storage even after it restarts. Save the following to a file named 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

Create the State­fulSet by running:

kubectl apply -f mariadb-statefulset.yaml

Verify it’s running with:

kubectl get statefulset mariadb

Wait until READY 1/1 is displayed, which means the MariaDB pod is up and running.

Step 4: Set up access via a Ku­ber­netes service

To let other apps in the cluster access MariaDB create a Ku­ber­netes Service. Save the following to a file named mariadb-service.yaml:

apiVersion: v1

kind: Service

metadata:

  name: mariadb

spec:

  ports:

  - port: 3306

    targetPort: 3306

  selector:

    app: mariadb

Through this service, the MariaDB-Ku­ber­netes pod is ac­ces­si­ble under a fixed DNS name (mariadb).

Create the Service by running:

kubectl apply -f mariadb-service.yaml

Check that it’s available with:

kubectl get svc mariadb

You should see an internal IP address and port 3306. This in­for­ma­tion is important for the next step.

Step 5: Connect to the MariaDB Ku­ber­netes instance

You can test the service by starting a temporary pod that acts as a MySQL client. Run the following command:

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

When prompted enter the root password you set earlier. At the SQL prompt run:

SHOW DATABASES;

You should see default databases like mysql, information_schema or performance_schema. Type exit to leave the SQL console. The temporary client pod will be deleted au­to­mat­i­cal­ly.

Step 6: Scale State­fulSet

One benefit of Ku­ber­netes is easy scaling. If you need more capacity, you can add more MariaDB pods by in­creas­ing the number of replicas.

Execute the following command to run three pods:

kubectl scale statefulset mariadb --replicas=3

This command instructs Ku­ber­netes to create two ad­di­tion­al pods alongside the existing one. Each pod has its own name (for example, mariadb-0, mariadb-1, mariadb-2) and its own storage.

Verify the scaling by running:

kubectl get statefulset mariadb

You should now see READY 3/3. Then, list the pods:

kubectl get pods -l app=mariadb

When extra capacity isn’t needed, you can scale back:

kubectl scale statefulset mariadb --replicas=1

After a short while only mariadb-0 will remain. The volumes from removed pods are kept until they are deleted manually.