Deploy the rabbitmq-observability helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the RabbitMQ Observability Helm chart on Google Kubernetes Engine (GKE), we'll need to:

1. Create a GKE cluster, which is a managed Kubernetes service provided by Google Cloud Platform (GCP).
2. Install and configure Helm on our local machine or within a CI pipeline to manage Kubernetes applications.
3. Use the Helm chart for RabbitMQ Observability to deploy RabbitMQ within our GKE cluster.

Below, you'll find a Pulumi program written in TypeScript that demonstrates how to accomplish these tasks. Our program will leverage Pulumi's GCP and Kubernetes providers to create the necessary cloud infrastructure.

The primary resources we're going to use are:
- `google-native.container/v1beta1.Cluster`: To create a GKE cluster.
- `kubernetes.helm.v3.Chart`: To deploy the RabbitMQ Observability Helm chart within our cluster.

For simplicity, we'll assume you have already set up your Pulumi environment and have the necessary GCP credentials configured.

Let's start by creating a GKE cluster. We will use the `google-native.container/v1beta1.Cluster` resource for this purpose. This resource will define a Kubernetes cluster within Google's cloud infrastructure.

Following the creation of the cluster, we'll deploy the RabbitMQ Helm chart. We will use Pulumi's `kubernetes.helm.v3.Chart` resource, which allows us to deploy Helm charts within a Kubernetes cluster managed by Pulumi.

Here's how you can do it:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as k8s from "@pulumi/kubernetes";
import * as gcpNative from "@pulumi/google-native";

// Create a GKE cluster.
const cluster = new gcpNative.container.v1beta1.Cluster("rabbitmq-cluster", {
    project: gcp.config.project, // Assumes project is set in pulumi config
    location: "us-central1",
    initialNodeCount: 1,
    nodeConfig: {
        machineType: "n1-standard-1", // Choose an appropriate machine type
    },
});

// Export the cluster name and kubeconfig.
export const clusterName = cluster.name;
export const kubeconfig = pulumi.all([cluster.name, cluster.endpoint, cluster.masterAuth]).apply(([name, endpoint, auth]) => {
    const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
    return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${auth.clusterCaCertificate}
    server: https://${endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      config:
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
});

// Provision a Helm chart for RabbitMQ Observability in the GKE cluster.
const rabbitmqChart = new k8s.helm.v3.Chart("rabbitmq-observability", {
    chart: "rabbitmq",
    version: "8.22.0", // Specify the version of RabbitMQ Observability Helm chart
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
}, {
    provider: new k8s.Provider("k8s-provider", {
        kubeconfig: kubeconfig,
    }),
});

// Export the RabbitMQ service URL.
export const rabbitmqServiceUrl = pulumi.interpolate`http://${rabbitmqChart.getResourceProperty("v1/Service", "rabbitmq-observability", "status").apply(status => status.loadBalancer.ingress[0].ip)}:15672`;
```

In this Pulumi program, we are:

1. Importing required Pulumi packages for Kubernetes and GCP.
2. Defining a GKE cluster by providing a minimal set of parameters. These include the number of nodes for the cluster and the machine type for those nodes (which determines the amount of CPU and memory).
3. Exporting some critical cluster information like the cluster name and the kubeconfig. The kubeconfig is essential for configuring `kubectl`, the Kubernetes command-line tool, and Pulumi with access to the Kubernetes cluster.
4. Creating a `kubernetes.helm.v3.Chart` resource that installs the RabbitMQ Helm chart on the cluster we just created. The chart is fetched from the given Helm repository URL and version number. As this example deploys RabbitMQ, make sure that you are using the correct chart that corresponds to RabbitMQ Observability, as the names may vary. You would adjust the `chart`, `version`, and `fetchOpts.repo` according to the RabbitMQ Observability chart details.
5. Exporting the `rabbitmqServiceUrl` which will be the endpoint to access the RabbitMQ management console once your service is up and running. Note that this assumes your RabbitMQ chart exposes a LoadBalancer service; you might need to adjust this part if your deployment differs.

After deploying this Pulumi program, you should have a running GKE cluster with RabbitMQ installed and observable through any configured monitoring solutions.