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

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Google Kubernetes Engine (GKE) involves several steps. First, you need to create a GKE cluster, and then you can deploy the Helm chart to the cluster. Here is a step-by-step guide with a Pulumi program in TypeScript on how to achieve this.

### Step 1: Create a GKE Cluster

A GKE cluster hosts our Kubernetes environment. We use the `google-native.container/v1.Cluster` resource to define the GKE cluster parameters and create it. When defining a cluster, we can specify various configurations like the initial node count, machine type, node version, and so on. Refer to the official Pulumi documentation for the [`google-native.container/v1.Cluster`](https://www.pulumi.com/registry/packages/google-native/api-docs/container/v1/cluster/) resource to know more about the configurable options.

### Step 2: Deploy the Helm Chart

Once the cluster is up and running, we can deploy Helm charts to it. For this, we use the `kubernetes.helm.sh/v3.Release` resource from Pulumi's Kubernetes provider to manage the Helm release. This resource lets us specify the Helm chart to deploy, including the chart's name, version, values, and repository information.

Let's proceed with the Pulumi program in TypeScript:

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

// Create a GKE cluster.
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
        oauthScopes: [
            "https://www.googleapis.com/auth/ndev.clouddns.readwrite",
            "https://www.googleapis.com/auth/ndev.cloudman.readonly",
            "https://www.googleapis.com/auth/ndev.cloudman",
            "https://www.googleapis.com/auth/cloud-platform",
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.full_control",
        ],
    },
});

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

// Export the Cluster kubeconfig
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 that uses our cluster from above.
const clusterProvider = new k8s.Provider("my-gke-cluster-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the Helm chart 'uui' to the cluster.
const uuiChart = new k8s.helm.v3.Release("uui", {
    chart: "uui",
    version: "1.0.0", // specify the chart version
    repositoryOpts: {
        repo: "http://charts.example.com/", // specify the Helm chart repository
    },
    values: {
        // Define values for the Helm chart as needed.
    },
}, { provider: clusterProvider });

// Export the Helm chart release name
export const uuiReleaseName = uuiChart.name;
```

### Explanation:

1. We import the necessary Pulumi packages for GCP and Kubernetes.
2. We define a new GKE cluster with the `gcp.container.Cluster` resource, specifying some of the required options like `initialNodeCount`, `nodeVersion`, etc.
3. We export the cluster name and generate a kubeconfig file which will be used by the Kubernetes provider to manage resources in the cluster.
4. We create a Pulumi Kubernetes provider that points to our GKE cluster.
5. Using the `k8s.helm.v3.Release` resource, we deploy the `uui` Helm chart to the GKE cluster, pointing to the repository where the Helm chart is located and defining any values required by the chart.

With this program, Pulumi manages the creation of the GKE cluster and the deployment of the Helm chart. To deploy the chart, save this code in a file, say `index.ts`, and then run `pulumi up` to preview and apply the changes.

Remember to replace `http://charts.example.com/` with the actual Helm repository URL hosting the `uui` chart and `1.0.0` with the actual version of the chart you want to deploy. Adjust the configurations as necessary based on your specific requirements for the cluster and helm release.