Deploy the kafka-topics-ui helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the kafka-topics-ui Helm chart on Google Kubernetes Engine (GKE) using Pulumi, we'll follow these steps:

1. **Set up a GKE cluster**: Before deploying the Helm chart, we need a Kubernetes cluster. GKE is a managed environment for deploying, managing, and scaling containerized applications using Google infrastructure.

2. **Install and Configure Helm**: Helm is a package manager for Kubernetes that allows you to define, install, and upgrade even the most complex Kubernetes applications. Helm uses a packaging format called charts; in this case, kafka-topics-ui is such a chart.

3. **Deploy the Helm Chart**: After setting up a GKE cluster and configuring Helm, we will deploy the kafka-topics-ui Helm chart to our GKE cluster.

Below is a Pulumi program, written in TypeScript, that performs the necessary steps:

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

// Create a GKE cluster
const gkeCluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "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 = gkeCluster.name;

// Export the Cluster kubeconfig
export const kubeconfig = pulumi.
    all([gkeCluster.name, gkeCluster.endpoint, gkeCluster.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
`;
    });

// Create a Kubernetes provider instance that uses our cluster from above.
const clusterProvider = new k8s.Provider("my-gke-cluster-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the kafka-topics-ui Helm chart
const kafkaTopicsUiChart = new k8s.helm.v3.Chart("kafka-topics-ui", {
    chart: "kafka-topics-ui",
    version: "latest",  // Replace with specific chart version if needed
    fetchOpts: {
        repo: "https://raw.githubusercontent.com/lensesio/kafka-helm-charts/master/", // Official Helm chart repository for kafka-topics-ui
    },
}, { provider: clusterProvider });

// Export the Helm chart deployment name
export const kafkaTopicsUiChartName = kafkaTopicsUiChart.name;

```

In this program, we do the following:

- Import necessary Pulumi packages to access GCP and Kubernetes functionality.
- Define a GKE cluster with the desired configuration (node count, machine type, etc.). The OAuth scopes are selected to allow the nodes to interact with Google Cloud services effectively.
- Export the name of the cluster and generate a kubeconfig file. The kubeconfig is crucial for interacting with your cluster securely and is used by kubectl and other Kubernetes tools.
- Create a Pulumi Kubernetes provider, which encapsulates the kubeconfig and allows Pulumi to communicate with the GKE cluster.
- Instantiate the kafka-topics-ui Helm chart using the Pulumi Kubernetes `Chart` resource and specify the chart's repo URL.
- Finally, we export the name of the Helm chart deployment as a stack export.

To apply this Pulumi program and set up your GKE cluster with kafka-topics-ui, save it to a file named `index.ts`, and then you can run `pulumi up` in the same directory. Pulumi will execute the program and create the desired resources in your GCP account.

Make sure you have the [Pulumi CLI](https://www.pulumi.com/docs/get-started/install/) installed, and you're logged in with your GCP account set up (the `gcloud` CLI is authenticated, and the project is set). Visit the documentation pages for [`@pulumi/gcp`](https://www.pulumi.com/registry/packages/gcp/) and [`@pulumi/kubernetes`](https://www.pulumi.com/registry/packages/kubernetes/) if you need more information on these packages.