Using kubernetes rabbitmq.com with image.toolkit.fluxcd.io

Question

Pulumi · Accepted Answer

To set up RabbitMQ on Kubernetes and synchronize the cluster with a Git repository using Flux, we will use the following resources:

1. **Kubernetes**: This is the container orchestration system where RabbitMQ will be deployed.
2. **RabbitMQ**: This is the open-source message broker software that we want to deploy on Kubernetes.
3. **Flux**: This is a tool for keeping Kubernetes clusters in sync with sources of configuration (like Git repositories) and automating updates to the configuration when there is new code to deploy.

We will start by creating a Kubernetes cluster, then deploy RabbitMQ onto the cluster, and finally set up Flux to ensure our cluster's configuration is in sync with a Git repository.

Here's how you can create a Kubernetes cluster and deploy RabbitMQ using Pulumi with TypeScript:

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

// Create a Kubernetes cluster using a managed Kubernetes provider such as EKS, GKE, or AKS.
// This example assumes you have already configured the cluster and Pulumi is just interacting with it.

// Create a Kubernetes namespace for RabbitMQ.
const rabbitmqNamespace = new k8s.core.v1.Namespace("rabbitmq", {
    metadata: {
        name: "rabbitmq"
    }
});

// Deploy RabbitMQ using the Bitnami RabbitMQ Helm Chart.
const rabbitmqChart = new k8s.helm.v3.Chart("rabbitmq", {
    chart: "rabbitmq",
    version: "8.25.7",
    namespace: rabbitmqNamespace.metadata.name,
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
});

// The above deployment will set up RabbitMQ but won't configure Flux just yet.
// Now, let's setup Flux to synchronize our Kubernetes cluster with a Git repository.
// The repository can contain the desired state of RabbitMQ, and Flux will ensure the cluster
// matches this state.

// Please replace the placeholders with your actual Git repository URL and other details.
const gitRepoUrl = "https://github.com/your-org/your-repo.git";
const gitBranch = "main";
const gitPath = "path/to/your/k8s/configs"; // Path within the Git repo where K8s manifests are located.

// Flux installation using the Flux Helm chart.
const fluxChart = new k8s.helm.v3.Chart("flux", {
    chart: "flux",
    version: "1.10.2",
    namespace: rabbitmqNamespace.metadata.name,
    values: {
        git: {
            url: gitRepoUrl,
            branch: gitBranch,
            path: gitPath,
        },
        sync: {
            interval: "1m" // How often Flux should sync with the Git repository.
        },
    },
    fetchOpts: {
        repo: "https://charts.fluxcd.io",
    },
});

// Export the public URL through which RabbitMQ can be accessed.
// Depending on your cluster setup and the RabbitMQ helm chart, this can vary.
export const rabbitmqUrl = rabbitmqChart.getResourceProperty("v1/Service", "rabbitmq", "status").apply(status => {
    const lb = status.loadBalancer;
    return lb.ingress[0].hostname || lb.ingress[0].ip;
});
```

This program performs the following actions:

1. Imports the necessary Pulumi packages for Kubernetes.
2. Creates a new namespace in Kubernetes for RabbitMQ.
3. Deploys RabbitMQ using a Helm chart from Bitnami's Helm chart repository.
4. Sets up Flux in the same namespace as RabbitMQ, configuring it to synchronize with a specified Git repository and path.

Things to note:

- Before running this program, ensure that you have Pulumi installed and configured to connect to your Kubernetes cluster.
- The `gitRepoUrl`, `gitBranch`, and `gitPath` variables need to be replaced with your actual repository details where you have your Kubernetes manifests stored.
- The `rabbitmqUrl` export statement is attempting to export the URL that can be used to access RabbitMQ. The actual format of this URL will depend upon how RabbitMQ is exposed by the chart and the type of Kubernetes service used.
- The synchronization interval in Flux is set to every minute, but you can adjust this according to your needs.
- The versions of the Helm charts are pinned for consistency, but you should check for the latest versions and their compatibility.
- The RabbitMQ Helm chart used in this example is from Bitnami, a trusted source for Helm charts, but you can use a different RabbitMQ chart if you prefer.

Make sure the Git repository you refer to in `gitRepoUrl` has the necessary Kubernetes configurations (manifests) for RabbitMQ so that Flux can apply them to your cluster.

To apply this Pulumi program, run `pulumi up`, which will execute the code to set up RabbitMQ and Flux on your Kubernetes cluster.