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

Question

Pulumi · Accepted Answer

To achieve the deployment of a RabbitMQ Helm chart on Google Kubernetes Engine (GKE), we will follow a series of steps using Pulumi with TypeScript.

Firstly, we need to create a GKE cluster where our RabbitMQ service will run. For that, we'll use the `gcp.container.Cluster` resource. This resource provisions a Kubernetes cluster in Google Cloud.

Once the GKE cluster is ready, we will use the package `kubernetes.helm.v3.Chart` from Pulumi's Kubernetes provider to deploy the RabbitMQ Helm chart. Helm charts are a convenient way to package and deploy applications on Kubernetes. RabbitMQ Helm chart is a pre-configured set of resources that will install RabbitMQ, a widely-used open-source message broker.

Here's a Pulumi program in TypeScript that accomplishes the deployment:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("rabbitmq-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
        oauthScopes: [
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring",
        ],
    },
});

// Export the Cluster name
export const clusterName = cluster.name;

// Export the kubeconfig to access the cluster
export const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
        return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.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
`;
    });

// Initialize a new k8s provider.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy RabbitMQ using the Helm chart.
const rabbitmqChart = new k8s.helm.v3.Chart("rabbitmq", {
    chart: "rabbitmq",
    version: "8.11.4",
    fetchOpts:{
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider: k8sProvider });

// Export the RabbitMQ service endpoint
export const rabbitmqServiceUrl = rabbitmqChart.getResourceProperty("v1/Service", "rabbitmq", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

Let's understand each part of the program:

- We begin by importing the necessary packages for GCP and Kubernetes.

- We then create a `Cluster` resource, specifying parameters like the number of nodes, machine type, and OAuth scopes necessary for the cluster nodes to interact with the Google Cloud services.

- We export the cluster name and generate a kubeconfig so that we can interact with the cluster via kubectl or any Kubernetes client library.

- We initialize a Pulumi Kubernetes provider with the kubeconfig from the GKE cluster. This provider is used to deploy and manage Kubernetes resources.

- Using the `Chart` resource within the `k8s.helm.v3` namespace, we deploy RabbitMQ. We specify the chart version to ensure repeatability and the Helm repository that contains the chart.

- Lastly, we export the IP address of the RabbitMQ service once it becomes available. This URL can be used to connect to RabbitMQ from outside the cluster.

Remember to replace the `version: "8.11.4"` with the version you want to deploy. You can find the latest version or alternative versions in the [Bitnami RabbitMQ Helm chart repository](https://github.com/bitnami/charts/tree/master/bitnami/rabbitmq).

Run this program with `pulumi up`, and it will create a new GKE cluster, setup authentication, and deploy RabbitMQ. After the deployment, you can use the exported `rabbitmqServiceUrl` to access RabbitMQ.