Deploy the tt-workflow-driver helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE) using Pulumi, we will follow these steps:

1. **Set up a GKE cluster**: We will create a Kubernetes cluster on GCP using Pulumi's GKE support.
2. **Deploy the Helm chart**: Once we have the cluster set up, we will deploy the Helm chart on it. Pulumi allows us to manage Helm charts as resources just like any cloud resource.

We'll use the `@pulumi/gcp` package to create a GKE cluster and the `@pulumi/kubernetes` package to deploy the Helm chart on it.

Below is a Pulumi program written in TypeScript that performs these 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 cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest", // Use the latest GKE version available
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Here you can specify the machine type you wish to use
    },
});

// 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 using the generated kubeconfig
const provider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the Helm chart to the cluster using the k8s Provider
const helmChart = new k8s.helm.v3.Chart("tt-workflow-driver-helm-chart", {
    chart: "tt-workflow-driver",
    version: "1.0.0", // replace with the desired chart version
    // Add any custom Helm chart values here
    values: {
        // Customize your Helm chart values
    },
}, { provider });

// Export the Helm chart status
export const helmChartStatus = helmChart.status;
```

### Explanation

- We declare a GKE Cluster called `gke-cluster` with the desired node count and machine type.
- We export the name of the cluster and the kubeconfig. This kubeconfig is necessary to interact with the Kubernetes cluster using `kubectl` or any relevant Kubernetes tooling.
- We create a new Kubernetes Provider that uses the kubeconfig of the GKE cluster.
- We then declare a Helm Chart resource called `tt-workflow-driver-helm-chart`, specifying the name of the chart and any values it requires.
- Lastly, we export the status of the Helm chart deployment, which can be useful for CI/CD or monitoring purposes.

Remember that before you run this code, you should have the Pulumi CLI installed, be authenticated against GCP, and have the `gcloud` CLI tool installed for the Pulumi GCP plugin to work correctly.