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

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Google Kubernetes Engine (GKE) using Pulumi involves several steps. You need to set up a GKE cluster, then use the Pulumi Kubernetes provider to deploy a Helm chart onto this cluster. In this walkthrough, I will guide you through the process of doing just that.

1. **Setting Up GKE Cluster**: First, we will create a GKE cluster, which will be our Kubernetes cluster managed by Google Cloud.
2. **Deploying the Helm Chart**: Once the cluster is up and running, we will make use of Pulumi's Kubernetes provider to deploy the `vehicle-dashboard` Helm chart to our cluster.

Below is a TypeScript program that performs these steps using Pulumi.

### Prerequisites

Ensure you have the following installed:
- [Pulumi CLI](https://www.pulumi.com/docs/get-started/install/)
- [Google Cloud SDK](https://cloud.google.com/sdk)
- [Node.js](https://nodejs.org/)
- [Helm](https://helm.sh/docs/intro/install/)

Also, make sure you've set up your Google Cloud credentials through the Cloud SDK by running `gcloud auth login` and `gcloud config set project [YOUR_GCP_PROJECT]`

### TypeScript Program

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("vehicle-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 Kubeconfig
export const kubeconfig = cluster.name.apply(name => {
    const cluster = gcp.container.getCluster({
        name: name,
        location: cluster.location,
        project: cluster.project,
    });
    return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${cluster.masterAuth.clusterCaCertificate}
    server: https://${cluster.endpoint}
  name: ${cluster.name}
contexts:
- context:
    cluster: ${cluster.name}
    user: ${cluster.name}
  name: ${cluster.name}
current-context: ${cluster.name}
kind: Config
preferences: {}
users:
- name: ${cluster.name}
  user:
    auth-provider:
      config:
        access-token: ${cluster.masterAuth.accessToken}
        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 vehicle-dashboard Helm chart
const vehicleDashboardChart = new k8s.helm.v3.Chart("vehicle-dashboard-chart", {
    chart: "vehicle-dashboard",
    // Assuming 'vehicle-dashboard' chart is available in a remote repository, you need to specify the repo URL
    // If the chart is stored locally, you would need to provide the local path reference
    fetchOpts:{
        repo: "http://charts.example.com/", // Replace with the actual Helm chart repository URL
    },
    values: {
        // Provide any values required to configure the 'vehicle-dashboard' chart here
    },
}, { provider: k8sProvider });

// Export the public IP to access vehicle-dashboard service
export const vehicleDashboardIp = vehicleDashboardChart.getResourceProperty("v1/Service", "vehicle-dashboard", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

### Explanation

- We first import the necessary modules for GCP and Kubernetes (`@pulumi/gcp` and `@pulumi/kubernetes`).
- We declare a new GKE cluster with `initialNodeCount` set to 2 and using a standard machine type.
- Once the cluster is created, we construct a kubeconfig file. This is used by Kubernetes clients, like `kubectl` and Pulumi, to connect to your cluster.
- We then create a Kubernetes provider that is specifically configured to communicate with our newly-created GKE cluster.
- With the Kubernetes provider in place, we deploy the `vehicle-dashboard` Helm chart. Note that the `repo` attribute should point to the Helm chart repository where `vehicle-dashboard` is hosted. If the chart is locally stored, you need to place the local directory path.
- Finally, we retrieve and export the public IP of the deployed service so we can access `vehicle-dashboard`.

As this program executes, Pulumi maintains the state of your infrastructure, and any changes you make will be safely and reliably managed.