Deploy the rollout-operator helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on a Google Kubernetes Engine (GKE) cluster involves several steps. First, you need to set up the GKE cluster if you haven't already. Then, you can use Pulumi's Kubernetes package to deploy the Helm chart onto the GKE cluster.

Below, I'll guide you through the following steps:

1. Setting up a GKE cluster.
2. Deploying a Helm chart on the GKE cluster.

For illustration purposes, we're going to use the `kubernetes.helm.sh/v3.Release` component from the Pulumi Kubernetes provider to deploy the `rollout-operator` Helm chart.

First, make sure you have imported the required packages and initialized a new project.

### Step 1: Setting Up a GKE Cluster

The first step is to create a new GKE cluster. We will use the `google-native.container/v1beta1.Cluster` resource to define and create the cluster. This resource allows us to define a GKE cluster's configuration, including its name, location, node pools, and other properties. Here's how you can do that:

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

// Create a GKE cluster configuration.
const cluster = new gcp.container.Cluster("my-gke-cluster", {
    // Specify the desired settings for the cluster.
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    location: "us-central1",
    nodeConfig: {
        // You can specify the machine type, disk size, and other configurations here.
        machineType: "n1-standard-1",
        diskSizeGb: 100,
    },
});

// Export the GKE cluster's kubeconfig.
export const kubeconfig = pulumi.all([cluster.name, cluster.endpoint, cluster.masterAuth]).apply(([name, endpoint, auth]) => {
    const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
    return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${auth.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: Deploying the `rollout-operator` Helm Chart

Once the GKE cluster is provisioned, we can deploy the `rollout-operator` Helm chart. We'll assume that the Helm chart is hosted in a public or private chart repository and that you have access to it.

We'll use the `kubernetes.helm.sh/v3.Release` resource to specify the Helm release. This resource encapsulates Helm's chart deployment capabilities.

```typescript
// Create a new Kubernetes provider instance that uses our kubeconfig from the GKE cluster above.
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the rollout-operator Helm chart using the Kubernetes provider.
const rolloutOperatorChart = new kubernetes.helm.v3.Release("rollout-operator", {
    chart: "rollout-operator", // Replace with the correct chart name or path.
    // Specify any custom repository or namespace, if needed.
    repositoryOpts: {
        repo: "https://charts.example.com/", // Replace with the actual Helm chart repository URL.
    },
    // You can specify custom values for the Helm chart here.
    // values: {
    //     key: "value",
    //     ...
    // },
}, { provider: k8sProvider });

// Export the status of the Helm release.
export const rolloutOperatorStatus = rolloutOperatorChart.status;
```

### Explanation

- We first declare the GKE cluster resource with the desired configurations concerning node count, GKE versions, and machine types.
- A kubeconfig is generated which is later used by the Kubernetes provider to deploy resources like the Helm chart onto the GKE cluster.
- Next, we instantiate the Kubernetes provider with the earlier generated kubeconfig.
- We declare a Helm release resource to deploy the `rollout-operator` Helm chart onto the GKE cluster.
- The Helm release resource details include the chart name and optional attributes such as repository options and custom values, which are useful for specifying Helm chart-related configurations.

This is a simple but complete Pulumi program to deploy a Helm chart to a GKE cluster. Remember to replace the placeholder values (like `https://charts.example.com/`) with the actual values for your specific use case before running the program.

Save the above code in a file named `index.ts`, and then run it using Pulumi CLI commands to deploy your GKE cluster and Helm chart. Here's what the deployment process will look like:

1. Run `pulumi up` to preview and deploy the changes.
2. Confirm the preview looks correct and select `yes` to proceed with the deployment.

This will set up the GKE cluster and deploy the `rollout-operator` Helm chart to the cluster.

Deploy the rollout-operator helm chart on Google Kubernetes Engine (GKE)

Step 1: Setting Up a GKE Cluster

Step 2: Deploying the rollout-operator Helm Chart

Explanation

Step 2: Deploying the `rollout-operator` Helm Chart