Deploy the object-bucket-claim helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart to a Google Kubernetes Engine (GKE) cluster involves several steps:

1. You need a GKE cluster up and running.
2. Then you configure Pulumi to connect to your Kubernetes cluster.
3. After Pulumi has the connection details, you can deploy a Helm chart.

Below is a TypeScript program that outlines these steps using Pulumi's GKE and Helm resources.

Firstly, you ensure that you have Pulumi installed and configured with the Google Cloud provider. For the Helm chart, no specific configuration is needed, but you should have `kubectl` configured to interact with your cluster if you want to check the deployed resources manually.

Let's break down what each part of the program does:

- **`google-native.container/v1beta1.Cluster`:** This Pulumi resource is used to create a new GKE cluster. You must specify the necessary details such as the intended location for your cluster and the initial node count. Learn more about this resource in the [Pulumi documentation](https://www.pulumi.com/registry/packages/google-native/api-docs/container/v1beta1/cluster/).

- **`kubernetes.helm.sh/v3.Release`:** This resource from the Pulumi Kubernetes provider allows you to deploy software packaged as Helm charts into your Kubernetes clusters. The `chart` property specifies the name of the Helm chart you wish to deploy. You can also specify the chart version, values, namespace, and other Helm specific configurations. The `values` property can be used to provide custom configuration values for the chart, similar to how you would do with a `values.yaml` file. Detailed information about this resource is available in the [Pulumi documentation](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm.sh/v3/release/).

Here's the detailed program for deploying the `object-bucket-claim` Helm chart to a GKE cluster:

```typescript
import * as gcp from "@pulumi/gcp";
import * as kubernetes 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", // specify the version or use 'latest'
    location: "us-central1",
    nodeVersion: "latest",
    nodeConfig: {
        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 Cluster name
export const clusterName = cluster.name;

// Kubernetes provider to connect to the GKE cluster
const k8sProvider = new kubernetes.Provider("k8sProvider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the 'object-bucket-claim' Helm chart
const helmChart = new kubernetes.helm.v3.Chart("object-bucket-claim", {
    // Replace with the specific chart repository information if it's not in a well-known Helm repository
    // For example, if it's a local chart you could use 'path: "./path/to/chart"'
    chart: "object-bucket-claim",
    version: "1.0.0", // specify the version of the chart
    // You can specify the namespace where this chart will be installed. If not specified, it defaults to 'default'
    namespace: "default",
    // You can pass custom values to this chart by specifying them in 'values'
    // values: { /* custom chart values here */ },
}, { provider: k8sProvider });

// Export the status of the Helm Release
export const helmStatus = helmChart.status;
```

In this program, we are creating a new GKE cluster with a specific machine type and number of initial nodes. The version of GKE is set to 'latest', but you should specify an exact version for production use to avoid unintended upgrades. Then, we create a Kubernetes provider configured with the kubeconfig of the GKE cluster, which is then used to install the `object-bucket-claim` Helm chart.

Make sure to replace `"object-bucket-claim"` with the actual chart name and `"1.0.0"` with the version you wish to deploy. For charts that are not in a public repository, you might need to add additional configuration to identify the chart location, such as a private Helm repo URL, or specify a local path to the chart.

After setting up this program, run it with the following Pulumi CLI commands:
```shell
pulumi up
```

This command will provision the GKE cluster and deploy the Helm chart as described in your code. Once it's complete, you can check the status and connect to your GKE cluster using `kubectl` or Pulumi's export statements.