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

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE), we will execute the following steps:

1. **Set up a GKE cluster**: We first need to create a cluster where the Helm chart will be deployed. To do this, we'll use the `google-native.container.v1.Cluster` resource, which represents a GKE cluster in Google Cloud.

2. **Install the Helm Chart**: Once our cluster is up and running, we can deploy the Helm chart on it. For this task, we'll use the `kubernetes.helm.v3.Chart` resource, which allows us to deploy Helm charts in a Kubernetes cluster managed by Pulumi.

Here's the TypeScript program that performs these actions:

```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("guestbook-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest", // Specify the desired version for your nodes
    minMasterVersion: "latest", // Specify the desired version for your master
});

// Export the Cluster name
export const clusterName = cluster.name;

// Once the cluster is created, we can find out the endpoint, status, and kubeconfig required to manage 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
`;
});

// Deploy the Helm chart to the GKE cluster we created.
// Replace "REPOSITORY_NAME" and "CHART_NAME" with the actual name and chart from the Helm repository you want to use.
const guestbookChart = new k8s.helm.v3.Chart("guestbook", {
    chart: "guestbook",
    version: "0.2.0", // Specify the version of the chart you want to deploy
    fetchOpts: {
        repo: "http://storage.googleapis.com/kubernetes-charts", // The repository where your Helm chart is located
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig }) });

// Export the Guestbook chart resources
export const guestbookChartResources = guestbookChart.resources;
```

This program launches a GKE cluster and deploys the `guestbook` Helm chart to it. Let's break this down:

- **GKE Cluster**: We create a GKE cluster with two nodes using the `google-native.container.v1.Cluster` resource, specifying the node version to signify the Kubernetes version running on each node within our cluster.

- **Kubeconfig**: This block generates the kubeconfig file needed to interact with our GKE cluster programmatically. It includes authentication data retrieved from the created GKE cluster, setting the current context to our GKE cluster. We will use this `kubeconfig` to communicate with our Kubernetes cluster.

- **Helm Chart Deployment**: We use the `k8s.helm.v3.Chart` class from the `@pulumi/kubernetes` package to deploy the `guestbook` Helm chart. We fetch the chart from the specified Helm chart repository.

Please replace `"REPOSITORY_NAME"` and `"CHART_NAME"` with the actual names relevant to the Helm chart you are deploying. You might also need to adjust the `version` number to match the available Helm chart version in the repository.

To execute this program, save it as `index.ts`, ensure you have Pulumi installed and configured with appropriate GCP access, and then run:

```sh
pulumi up
```

Pulumi will perform the deployment, showing you the progress in the terminal. After the deployment successfully completes, you will see the output of the `kubeconfig` and other exported properties. You can use the generated `kubeconfig` with `kubectl` to manage your cluster:

```sh
kubectl --kubeconfig generated-kubeconfig.yaml get pods
```

Please note that Helm charts can have their own set of values you can override. Check out the specific Helm chart documentation you're trying to deploy to understand the default values and possible customizations.