Deploy the rabbitmq-helm-chart helm chart on Opensshift

Question

Pulumi · Accepted Answer

To deploy the RabbitMQ Helm Chart on an OpenShift cluster, you'll be using Pulumi's Kubernetes provider. Pulumi provides a `Chart` resource as part of their Kubernetes provider, which is designed to work with Helm charts. The `Chart` resource allows you to deploy Helm charts into a Kubernetes cluster from within a Pulumi program.

Here’s a step-by-step explanation followed by the code to deploy the RabbitMQ Helm Chart:

1. **Import necessary dependencies**: Import Pulumi's Kubernetes package to interact with your Kubernetes cluster and deploy resources.

2. **Create a Kubernetes provider instance**: This is necessary if you’re interacting with a cluster that is not the default configured in your `kubeconfig` file.

3. **Deploy RabbitMQ using `Chart` resource**: You will instantiate a `Chart` resource from Pulumi's Kubernetes provider. You'll need to specify the necessary parameters which include the chart name (`rabbitmq`), and the repository where the chart can be found.

Please note that before running this Pulumi program, you should have access to an OpenShift cluster and have the `kubectl` CLI tool configured to communicate with it. Pulumi will use the configuration from `kubectl` to interact with your OpenShift cluster.

4. **Export desired outputs**: After deployment, export any outputs you might need, like the service URL or any other relevant information.

Remember that Helm charts can have configurable values, and you may need to customize these values as per your requirements. You can specify these values in the `values` property of the `Chart`.

Now, let's see the Pulumi TypeScript code that would achieve this:

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

// Assuming you have set up and selected the OpenShift context in your kubeconfig,
// Pulumi will use that context to create the following resources.

const chartName = "rabbitmq";
const chartVersion = "8.11.0"; // Use the chart version you need
const releaseName = "rabbitmq-release"; // Set a release name for the helm chart

// Deploy RabbitMQ Helm Chart
const rabbitmqChart = new k8s.helm.v3.Chart(releaseName, {
  chart: chartName,
  version: chartVersion,
  fetchOpts: {
    repo: "https://charts.bitnami.com/bitnami",
  },
  values: {
    // Here you can provide custom values for the RabbitMQ Helm Chart,
    // for example:
    // replicaCount: 3,
    // persistence: {
    //   enabled: true,
    //   storageClass: "my-storage-class"
    // },
    // You will need to refer to the chart's values.yaml file to get the
    // correct key/value pairs for configuration
  },
  // Note: If your OpenShift cluster uses a specific namespace for deployments,
  // you should specify the `namespace` property in this resource.
});

// Export the endpoint of RabbitMQ
export const rabbitmqEndpoint = rabbitmqChart.getResourceProperty(
  "v1/Service", `${releaseName}-${chartName}`, "status"
).apply(status => status.loadBalancer.ingress[0].ip || status.loadBalancer.ingress[0].hostname);
```

In this code:
- `@pulumi/kubernetes` is the Pulumi Kubernetes package that allows you to write code to interact with Kubernetes resources.
- `rabbitmqChart` is an instance of the `Chart` resource which references the RabbitMQ Helm chart.
- The `fetchOpts` configures where Pulumi should fetch the chart from—in this case, the Bitnami Helm repository.

Once this program is executed with Pulumi, it should deploy RabbitMQ onto your OpenShift cluster. You can tweak the `values` property to fine-tune your RabbitMQ setup based on the RabbitMQ chart's [`values.yaml`](https://github.com/bitnami/charts/blob/master/bitnami/rabbitmq/values.yaml).

Before you run this Pulumi program, make sure you have Pulumi installed and the OpenShift CLI tool `oc` configured for access to your OpenShift cluster. You may also need to log in to your cluster (using `oc login` or via `kubectl`) so that Pulumi can use those credentials to create resources on your behalf.

Finally, execute your Pulumi program through the command line as follows:

```shell
pulumi up
```

This will start the deployment process. Follow the prompts Pulumi provides to apply the changes. Once completed, the RabbitMQ Helm chart will be deployed to your OpenShift cluster.