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

Question

Pulumi · Accepted Answer

To deploy a Helm chart, such as Terraboard, on Google Kubernetes Engine (GKE), you'll need to complete several steps. We'll walk through setting up a GKE cluster, installing the Helm CLI on our Pulumi program, and then deploying the Terraboard Helm chart to the cluster.

First, let's break down the steps we need to take:

1. **Provision a GKE Cluster:** We need a running Kubernetes cluster on GKE. We'll create one using Pulumi's GCP provider.
2. **Configure Kubeconfig:** To interact with the Kubernetes cluster, we'll need to obtain the kubeconfig file from GKE.
3. **Install Helm and Deploy Chart:** We'll install Helm (which is a package manager for Kubernetes) into our Pulumi program and use it to deploy the Terraboard Helm chart.

Below is the Pulumi TypeScript program to carry out these steps. The code comments explain each part of the code:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("terraboard-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        preemptible: true,
        machineType: "n1-standard-1",
    },
});

// Export the Kubeconfig
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 kubernetes.Provider("k8s-provider", {
    kubeconfig: kubeConfig,
});

// Install the Terraboard Helm chart
const terraboardHelmChart = new kubernetes.helm.v3.Chart("terraboard", {
    chart: "terraboard",
    fetchOpts:{
        repo: "https://charts.helm.sh/stable",
    },
}, { provider: k8sProvider });

// Export the Helm chart name and status
export const helmChartName = terraboardHelmChart.metadata.apply(metadata => metadata.name);
export const helmChartStatus = terraboardHelmChart.status.apply(status => status);

```

### Explanation:
The program flow is as follows:

1. We import the necessary modules from Pulumi, specifically `pulumi`, `gcp`, and `kubernetes` which are used to interact with GCP and Kubernetes.
2. A new GKE cluster named `terraboard-cluster` is created with two nodes of type `n1-standard-1` which are preemptible to save costs.
3. We configure the `kubeConfig` by using `pulumi.all`, which combines multiple outputs into a single output, and manifest the kubeconfig needed to interact with the cluster.
4. Using the kubeconfig, we create a Kubernetes provider named `k8s-provider`. This allows Pulumi to interact with the provided Kubernetes cluster.
5. We declare the `terraboardHelmChart` using Pulumi's Kubernetes provider, specifying the chart name and the repository where the chart is located.
6. Lastly, we export the Helm chart name and status as stack outputs which are printed to the console after the program runs.

Please note that for this example to work, you must have Pulumi installed, be authenticated with GCP, and have access to the `gcloud` command-line tool from where you're running the Pulumi program. Terraboard does require additional configuration like specifying the backend storage and access credentials, make sure to update the `values` field in the `terraboardHelmChart` for those configurations based on your requirements.