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

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Google Kubernetes Engine (GKE) with Pulumi, you would follow a series of steps:

1. **Set up a new GKE cluster:** To run any workloads, including Helm charts, you first need a Kubernetes cluster. Pulumi can be used to provision a new GKE cluster.

2. **Install the Helm chart:** Once you have a cluster, you can use Pulumi's `helm.v3.Chart` class—a component from the Pulumi Kubernetes library—to deploy the Helm chart to your GKE cluster.

Here's a step-by-step guide in TypeScript, accompanied by a Pulumi program that accomplishes these steps:

### Step 1: Create a GKE cluster
First, we'll start by defining a new GKE cluster. This is where your applications will be deployed. We're using Pulumi's GCP provider to create this cluster.

The `gcp.container.Cluster` resource is used to define the GKE cluster's properties such as location, node configuration, networking, and others.

### Step 2: Deploy the Helm chart
With the cluster in place, you can deploy the Helm chart. Pulumi's `helm.v3.Chart` resource directly interacts with Helm and Kubernetes, making it possible to deploy charts in a manner similar to using `helm` from the command line, but with all the benefits of versioning, configuration, and management that Pulumi offers.

In the below program, we will:
- Import necessary packages
- Create a GKE cluster
- Deploy the `ts-server` Helm chart to the cluster

Here is the complete program:

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

const name = "ts-server-chart";

// Create a GKE cluster
const cluster = new gcp.container.Cluster(name, {
    initialNodeCount: 2,
    nodeConfig: {
        machineType: "n1-standard-1", // Choose a machine type based on your workload requirements
        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 Cluster name
export const clusterName = cluster.name;

// Export the Kubeconfig to access 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
`;
    });

// Create a Kubernetes Provider pointing to the new cluster
const k8sProvider = new k8s.Provider(name, { kubeconfig: kubeconfig });

// Deploy the `ts-server` Helm chart
const tsServerChart = new k8s.helm.v3.Chart(name, {
    chart: "ts-server",   // The name of the Helm chart to deploy
    // You might need to specify the repository where the Helm chart is located using the `repo` argument.
    version: "0.1.0",
    // Specify chart values here using `values` or `valueYaml`
}, { provider: k8sProvider });

// Export the Helm chart deployment status
export const tsServerStatus = tsServerChart.status;
```

To use the above Pulumi program, replace the string `"ts-server"` with the actual name of the Helm chart you want to deploy. If the chart is not hosted in the default Helm chart repositories, you'll also need to specify the `repo` option where the chart is hosted.

Please note that to run this program, you'll need to have the Pulumi CLI installed, along with access to a GCP account where you can create GKE clusters. The `kubeconfig` string allows you to interact with your GKE cluster using `kubectl` once the cluster is up and running.