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

Question

Pulumi · Accepted Answer

To deploy a Helm chart on a Google Kubernetes Engine (GKE) cluster, you'll need to complete a few steps:

1. **Set up a GKE cluster**: We'll first create a Kubernetes cluster on Google Cloud.
2. **Install the Helm CLI**: Helm is a package manager for Kubernetes, which simplifies deployment of applications. Helm uses a packaging format called charts. We will not detail the installation of Helm CLI here, as it is outside the scope of Pulumi, but you can find the installation guide on the [Helm website](https://helm.sh/docs/intro/install/).
3. **Deploy the Helm chart**: Finally, we'll use Pulumi's `harness.service.Helm` resource to deploy your Helm chart.

Below you will find a TypeScript Pulumi program that sets up a GKE cluster and deploys a Helm chart to it.

First, let's install the necessary Pulumi packages. Run these commands:

```bash
pulumi plugin install resource gcp v6.67.0
pulumi plugin install resource harness v0.0.6
```

Now, create a new file (`index.ts`, for example), and include the following Pulumi code:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("stage-cluster", {
    initialNodeCount: 1, // Minimal node count to start with
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // You can choose the machine type that best fits your workload
    },
});

// Deploy a Helm chart into the GKE cluster
const helmRelease = new harness.service.Helm("nginx-ingress", {
    appId: pulumi.interpolate`${cluster.project}`, // Assuming the Helm chart is within the same project
    name: "nginx-ingress",
    variables: [
        {
            name: "stage",
            type: "string",
            value: "true"
        },
    ],
});

// Export the necessary details from our program
export const clusterName = cluster.name;
export const kubeconfig = cluster.masterAuth.apply(auth => {
    const context = `${gcp.config.project}_${gcp.config.zone}_${clusterName}`;
    return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${auth.clusterCaCertificate}
    server: https://${cluster.endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      name: gcp
`;
});

// Note: You'll need to set the ID for the Helm chart application and adjust chart variables as per your chart.
```

The code above performs the following actions:

- Import the necessary Pulumi libraries.
- Create a new Google Kubernetes Engine cluster with a basic node configuration.
- Use the `harness.service.Helm` resource to deploy a Helm chart named `nginx-ingress`.
- Define the chart variables. This part is specific to the Helm chart you want to deploy and will need adjustment based on your Helm chart's values.
- Export the cluster name and a kubeconfig that can be used to manage the Kubernetes cluster and Helm release.

To deploy this code:

1. Save it as `index.ts`.
2. Run `pulumi up` to create the GKE cluster and deploy the Helm chart.

Remember to replace placeholder values like `appId` with actual values from your environment or Helm chart. To find out which values are required for your Helm chart, you might need to refer to the chart's documentation or `values.yaml` file.

Before running `pulumi up`, ensure that you've authenticated with Google Cloud and have set the appropriate Pulumi stack configuration for the GCP region and project you want to deploy to.

Please note that for a true staging environment, you might have additional configurations, such as database connections, persistent volumes, and more complex node configurations. The above is a simple starting point for deploying a Helm chart to GKE.