Deploy the kafdrop helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Creating a deployment of the Kafdrop Helm chart on Google Kubernetes Engine (GKE) involves several steps using Pulumi:

1. **Setting up a GKE Cluster**: We'll need to create a GKE cluster where our applications will run.

2. **Helm Chart Deployment**: We'll use the `kubernetes.helm.v3.Chart` resource which allows us to deploy Helm charts in a Kubernetes cluster. Helm is a package manager for Kubernetes that simplifies deployment configuration.

To start, you'll need to have Pulumi and Google Cloud SDK installed and configured for your GCP account. Once the setup is complete, you can implement the following Pulumi program to deploy Kafdrop on GKE.

Below is the TypeScript program that creates a GKE cluster and deploys the Kafdrop Helm chart to it:

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

// Create a GKE cluster.
const cluster = new gcp.container.Cluster('kafdrop-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 = cluster.name;

// Export the Kubeconfig to access the cluster using kubectl.
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
`;
    });

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

// Deploy the Kafdrop Helm chart.
const kafdropChart = new k8s.helm.v3.Chart('kafdrop-chart', {
    chart: 'kafdrop',
    version: 'specific-version', // specify the version of the chart you want to deploy
    fetchOpts: {
        repo: 'https://obsidiandynamics.github.io/kafdrop', // the Helm chart repository
    },
}, { provider: k8sProvider });

// Export the Kafdrop service URL.
export const kafdropUrl = pulumi.all([kafdropChart.status]).apply(status => {
    const ingress = status.loadBalancer.ingress[0];
    return `http://${ingress.ip}:9000`; // The port is the default for Kafdrop, adjust if necessary.
});
```

### Explanation:

- We import the necessary libraries from Pulumi for deploying resources on Google Cloud and Kubernetes.
- We create a GKE cluster using `gcp.container.Cluster` with a specified number of nodes and machine type.
- We export a kubeconfig file that allows us to interact with the cluster using `kubectl`. This includes cluster name, endpoint, and master auth that we retrieve from the cluster object.
- We create a Kubernetes provider that specifies which cluster to deploy our Helm chart.
- We deploy Kafdrop using the `k8s.helm.v3.Chart` class. We specify the chart name, version, and repository.
- Finally, we export the URL that will be used to access Kafdrop once it's deployed. This assumes that the load balancer's external IP is accessible and that the deployed Helm chart creates a service of type LoadBalancer.

Remember to replace `'specific-version'` with the actual version of the Kafdrop Helm chart you wish to deploy.

After you have written this program into a file, such as `index.ts`, you can run it using Pulumi CLI commands:

```sh
pulumi up
```

This command will provision the GKE cluster and deploy the Kafdrop Helm chart. After the deployment is completed, Pulumi will provide the output variables like the cluster name and Kafdrop URL which you can use to access the dashboard.