Deploy the project-origin-stack helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart to a Google Kubernetes Engine (GKE) cluster using Pulumi, you'll first need to create the GKE cluster and then deploy the Helm chart to this cluster. In this detailed walkthrough, I'll guide you through the process of doing exactly that using TypeScript and Pulumi.

We'll be using the `@pulumi/gcp` package to create the GKE cluster and the `@pulumi/kubernetes` package to work with Kubernetes resources, including deploying a Helm chart. First, you need to make sure you have installed Pulumi and configured your GCP credentials.

Here's a step-by-step breakdown of the Pulumi program in TypeScript:

1. **Creating a GCP GKE Cluster**: We'll write code that uses Pulumi's Google Cloud provider to create a new GKE cluster.

2. **Configuring Kubernetes Provider**: Once the GKE cluster is running, we will use Pulumi's Kubernetes provider to interact with the cluster. This provider requires kubeconfig as input, which we'll obtain from the created GKE cluster.

3. **Deploying the Helm Chart**: Finally, with the Kubernetes provider configured and pointing to our new GKE cluster, we will use it to deploy a Helm chart into the cluster.

Below is the full Pulumi program in TypeScript that completes these three steps and deploys the `project-origin-stack` Helm chart on GKE:

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

const projectName = pulumi.getProject();
const stackName = pulumi.getStack();

// Step 1: Creating the GKE Cluster
const cluster = new gcp.container.Cluster("gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "e2-medium", // choose an appropriate machine type
        oauthScopes: [
            "https://www.googleapis.com/auth/cloud-platform",
        ],
    },
});

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

// Obtain the kubeconfig from the created GKE cluster
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
`;
    });

// Step 2: Configuring the Kubernetes Provider
const k8sProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: kubeconfig,
});

// Step 3: Deploying the Helm Chart
const helmChart = new k8s.helm.v3.Chart("project-origin-stack", {
    repo: "example", // specify your Helm chart repository here
    chart: "project-origin-stack",
    version: "1.0.0", // use the appropriate chart version
}, { provider: k8sProvider });

// Export the Helm chart deployment name
export const helmChartName = helmChart.getChart().name;
```

Please replace `"example"` in the Helm chart repository URL with the actual repository where your Helm chart is located. You should also provide the accurate chart version you wish to deploy.

This program performs the following actions:

- It creates a GKE cluster with two nodes and specifies the machine type for these nodes.
- It exports the GKE cluster name for easy access.
- It generates kubeconfig using the details from the created GKE cluster, which is necessary to communicate with the Kubernetes API.
- It sets up the Kubernetes provider with the generated kubeconfig, enabling Pulumi to deploy Kubernetes resources to the GKE cluster.
- It deploys the `project-origin-stack` Helm chart to the GKE cluster using the specified repository and version.

To execute this Pulumi program:

- Save the code in a file named `index.ts`.
- Run `pulumi up` in the directory containing your `index.ts`. This will instruct Pulumi to create the resources as specified in the program.

Pulumi will provide a preview of the actions and prompt you for confirmation before applying the changes. Once you confirm, Pulumi will proceed with the creation of the resources. After the process completes, Pulumi will output the names of the created GKE cluster and the deployed Helm chart.