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

Question

Pulumi · Accepted Answer

To deploy the `helm-guestbook` Helm chart on Google Kubernetes Engine (GKE), you'll need to perform several steps using Pulumi:

1. **Set up a GKE cluster**: Deploy a cluster where the Helm chart will reside.
2. **Install the Helm Chart**: Once the GKE cluster is in place, deploy the Helm chart to the cluster.

Below, you'll find a detailed Pulumi program written in TypeScript that accomplishes the deployment of a GKE cluster and then deploys the `helm-guestbook` Helm chart on it.

Here is a step-by-step explanation of the program components:

- **Import dependencies**: Pulumi SDKs for GKE and Helm will be imported.
- **Create a GKE cluster**: Define a new GKE cluster resource.
- **Deploy Helm chart**: After the cluster is available, deploy the `helm-guestbook` Helm chart to the new GKE cluster by creating a `helm.v3.Release` resource.

Now, let's write the program.

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

// Step 1: Create a GKE cluster
const gkeCluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        // You can adjust as necessary:
        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 GKE cluster name
export const clusterName = gkeCluster.name;

// Step 2: Install the "helm-guestbook" Helm chart
const kubeconfig = pulumi.
    all([gkeCluster.name, gkeCluster.endpoint, gkeCluster.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
`;
    });

// Use a Kubernetes Provider that uses our kubeconfig
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the helm-guestbook chart
const helmGuestbook = new k8s.helm.v3.Release("helm-guestbook", {
    chart: "guestbook",
    version: "0.2.0", // you can specify the chart version you want to deploy
    // Define any values we want to override.
    // This example demonstrates how you might configure a name property.
    values: {
        name: "hello-world",
    },
}, { provider: k8sProvider });

// Export the Helm release's name
export const guestbookName = helmGuestbook.status.name;
```

Explanation of the code:

- We initialize a new GKE cluster with `initialNodeCount` set to 2. This indicates we want two nodes in our cluster initially.
- The `nodeConfig` specifies the type of machine to use for the nodes and the OAuth scopes required for the various services the node might interact with.
- A `kubeconfig` is generated using the cluster's details which enables `kubectl` and other tools to communicate with the GKE cluster.
- We create a `k8s.Provider` which is configured with the `kubeconfig`. This tells Pulumi to use this configuration for deploying resources to this cluster.
- Finally, we create a Helm release using the `k8s.helm.v3.Release` resource. We specify the chart name as `guestbook` and can pin it to a version.

After writing your Pulumi program, you can deploy it using the Pulumi CLI. Running `pulumi up` will start the deployment process, and Pulumi will provide you with a preview of the resources that will be created. Confirming the preview will then apply the changes, set up the cluster, and deploy the Helm chart.

Remember that this program assumes you have `gcloud` installed and configured for access to your Google Cloud project, and that your Pulumi stack is appropriately configured for your GCP project and zone. Additionally, ensure you have the necessary permissions to create and manage GKE clusters in your GCP project.