How do I deploy a RabbitMQ StatefulSet for consistent storage on Kubernetes?

In this guide, we will deploy a RabbitMQ StatefulSet on Kubernetes to ensure consistent storage. StatefulSets are used to manage stateful applications, which require persistent storage and stable network identities. We will use Pulumi to define and deploy the Kubernetes resources required for this setup.

Key Components:

StatefulSet: Manages the deployment and scaling of a set of pods, and provides guarantees about the ordering and uniqueness of these pods.
PersistentVolumeClaim: Requests storage resources to be used by the StatefulSet.
Service: Provides a stable network identity for the StatefulSet pods.

Below is the Pulumi program in TypeScript to deploy a RabbitMQ StatefulSet with consistent storage.

import * as pulumi from "@pulumi/pulumi";
import * as k8s from "@pulumi/kubernetes";

// Define the PersistentVolumeClaim for RabbitMQ data storage
const dataPersistentVolumeClaim = new k8s.core.v1.PersistentVolumeClaim("rabbitmq-data-pvc", {
    metadata: { name: "rabbitmq-data-pvc" },
    spec: {
        accessModes: ["ReadWriteOnce"],
        resources: {
            requests: {
                storage: "1Gi",
            },
        },
    },
});

// Define the RabbitMQ StatefulSet
const rabbitmqStatefulSet = new k8s.apps.v1.StatefulSet("rabbitmq-statefulset", {
    metadata: { name: "rabbitmq" },
    spec: {
        serviceName: "rabbitmq",
        replicas: 1,
        selector: {
            matchLabels: { app: "rabbitmq" },
        },
        template: {
            metadata: {
                labels: { app: "rabbitmq" },
            },
            spec: {
                containers: [
                    {
                        name: "rabbitmq",
                        image: "rabbitmq:3.8",
                        ports: [
                            { containerPort: 5672, name: "amqp" },
                            { containerPort: 15672, name: "management" },
                        ],
                        volumeMounts: [
                            {
                                name: "rabbitmq-data",
                                mountPath: "/var/lib/rabbitmq",
                            },
                        ],
                    },
                ],
            },
        },
        volumeClaimTemplates: [
            {
                metadata: { name: "rabbitmq-data" },
                spec: {
                    accessModes: ["ReadWriteOnce"],
                    resources: {
                        requests: {
                            storage: "1Gi",
                        },
                    },
                },
            },
        ],
    },
});

// Define the Service for RabbitMQ
const rabbitmqService = new k8s.core.v1.Service("rabbitmq-service", {
    metadata: { name: "rabbitmq" },
    spec: {
        ports: [
            { port: 5672, targetPort: "amqp" },
            { port: 15672, targetPort: "management" },
        ],
        selector: { app: "rabbitmq" },
    },
});

export const statefulSetName = rabbitmqStatefulSet.metadata.name;
export const serviceName = rabbitmqService.metadata.name;

Key Points:

We created a PersistentVolumeClaim to request storage for RabbitMQ data.
We defined a StatefulSet for RabbitMQ, ensuring each pod has a stable network identity and persistent storage.
We set up a Service to provide a stable network endpoint for accessing RabbitMQ.

Conclusion

We have successfully deployed a RabbitMQ StatefulSet with consistent storage using Pulumi. This setup ensures that RabbitMQ pods have persistent storage and stable network identities, which are crucial for stateful applications.

Deploy this code

Want to deploy this code? Sign up for a free Pulumi account to deploy in a few clicks.

New to Pulumi?

Want to deploy this code? Sign up with Pulumi to deploy in a few clicks.