Setting up MariaDB Galera Cluster on Kubernetes for High Availability

Question

Pulumi · Accepted Answer

To set up a MariaDB Galera Cluster on a Kubernetes cluster for high availability, you will need to accomplish a few high-level tasks:

1. **Deploy a StatefulSet**: MariaDB instances should be managed via a StatefulSet in Kubernetes because StatefulSets provide stable and unique network identifiers, stable persistent storage, ordered deployment and scaling, and ordered automated rolling updates.

2. **Configure a Service**: You'll need to define a Kubernetes Service to provide network access to the MariaDB Galera Cluster.

3. **Implement Readiness and Liveness Probes**: These probes are used by Kubernetes to know when a container is ready to start accepting traffic and when to restart a container if it has failed.

4. **Use Persistent Volumes**: Persistent Volumes are necessary for storing the state of your database across pod restarts and re-scheduling.

5. **Define PodDisruptionBudget**: A PodDisruptionBudget (PDB) limits the number of Pod replicas that can go down simultaneously during voluntary disruptions and helps maintain the high availability of the cluster.

6. **Include ConfigMap or Secrets**: A ConfigMap or Secrets for storing configuration that should not be hard-coded into your StatefulSet, such as database configuration files or credentials.

Below, you'll find a TypeScript program using Pulumi to create a basic MariaDB Galera Cluster on Kubernetes. The details are essential to understand how each part contributes to the high-availability setup. Keep in mind that for a true production setup, further customization and security hardening will be necessary.

```typescript
import * as k8s from '@pulumi/kubernetes';

// A ConfigMap for the MariaDB Galera Cluster configuration
const mariadbConfig = new k8s.core.v1.ConfigMap("mariadb-config", {
    metadata: { name: "mariadb-config" },
    data: {
        "my.cnf": `
            [mysqld]
            query_cache_size=0
            binlog_format=ROW
            default-storage-engine=innodb
            innodb_autoinc_lock_mode=2
            innodb_doublewrite=1
            ... (other necessary MariaDB configurations for Galera)
        `,
    },
});

// A StafefulSet for the MariaDB Galera Cluster
const mariadbStatefulSet = new k8s.apps.v1.StatefulSet("mariadb-statefulset", {
    metadata: { name: "mariadb" },
    spec: {
        serviceName: "mariadb",
        replicas: 3, // Adjust the number of replicas as needed for your HA setup
        selector: { matchLabels: { app: "mariadb" }},
        template: {
            metadata: { labels: { app: "mariadb" }},
            spec: {
                containers: [{
                    name: "mariadb",
                    image: "mariadb:10.5", // Use the appropriate image for MariaDB with Galera
                    ports: [{ containerPort: 3306 }],
                    volumeMounts: [{
                        name: "config",
                        mountPath: "/etc/mysql/conf.d",
                    }],
                    // Define the readiness and liveness probes
                    readinessProbe: {
                        exec: { command: ["bash", "-c", "mysqladmin ping -u root"] },
                        initialDelaySeconds: 15,
                        timeoutSeconds: 2,
                    },
                    livenessProbe: {
                        exec: { command: ["bash", "-c", "mysqladmin ping -u root"] },
                        initialDelaySeconds: 40,
                        periodSeconds: 20,
                        timeoutSeconds: 3,
                    },
                    // Ensure that the environment variables are set appropriately
                    env: [
                        // You can use Kubernetes secrets to manage sensitive data like passwords
                    ],
                }],
                volumes: [{ name: "config", configMap: { name: "mariadb-config" }}],
            },
        },
        // Define the volume claim templates for persistent storage
        volumeClaimTemplates: [{
            metadata: { name: "mariadb-storage" },
            spec: {
                accessModes: ["ReadWriteOnce"],
                resources: {
                    requests: { storage: "10Gi" }, // Set the storage size as per your needs
                },
            },
        }],
    },
});

// Define the Service that exposes the MariaDB StatefulSet
const mariadbService = new k8s.core.v1.Service("mariadb-service", {
    metadata: { name: "mariadb" },
    spec: {
        ports: [{ port: 3306 }],
        clusterIP: "None",
        selector: { app: "mariadb" },
    },
});

// Define a PodDisruptionBudget for high availability
const mariadbPdb = new k8s.policy.v1beta1.PodDisruptionBudget("mariadb-pdb", {
    metadata: { name: "mariadb-pdb" },
    spec: {
        maxUnavailable: 1, // Allow no more than one pod to be unavailable
        selector: { matchLabels: { app: "mariadb" }},
    },
});

// Export the Service name and IP to access the MariaDB Galera Cluster
export const mariadbEndpoint = mariadbService.metadata.name;
```

**Explanation of the Components:**

- **ConfigMap (`mariadbConfig`)**: It holds the MariaDB configuration settings. Adjust the configurations in the `data` field according to your specific requirements.
  
- **StatefulSet (`mariadbStatefulSet`)**: The StatefulSet manages the deployment and scaling of a set of Pods and provides guarantees about the ordering and uniqueness of these Pods.
  
- **Service (`mariadbService`)**: The service provides a single point of entry to access the MariaDB replicas. Its `clusterIP` is set to "None" to create a headless service.
  
- **PodDisruptionBudget (`mariadbPdb`)**: To maintain high availability, PDB ensures that Kubernetes doesn't kill too many pods simultaneously.
  
**Further Steps:**

You would need to initialize the MariaDB Galera Cluster with the first node, then join other nodes to the cluster. Also, consider implementing robust security measures like using Kubernetes Secrets for sensitive information, configuring network policies, enabling SSL for database connections, and creating a backup strategy.

This setup has to be fine-tuned according to your organization's requirements and the specific characteristics of the Galera cluster you wish to deploy. It is important to thoroughly test this setup in a non-production environment before rolling it out into production.