Deploy the ververica-sql-template 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. First, you need to create a GKE cluster. Then, you'll need to set up Helm in your local environment and, finally, deploy the chart to the cluster.

Below is a program written in TypeScript that uses Pulumi to automate these tasks. This program assumes that you have already set up the Google Cloud SDK and Pulumi CLI on your machine and have logged in to both. It also assumes that you have Helm installed locally.

Let's walk through the program:

1. **Create a GKE cluster:** We will use the `gcp.container.Cluster` from Pulumi's GCP package to create a new Kubernetes cluster.
   
2. **Install Helm and Tiller:** Once the cluster is created, Pulumi can install Helm and Tiller (the Helm server-side component) inside the cluster if needed. However, with Helm 3, Tiller is no longer necessary, and Helm runs completely client-side. We will assume Helm 3 for this deployment.

3. **Deploy the Helm chart:** Finally, using the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes package, we will deploy the `ververica-sql-template` Helm chart from its repository.

Here is a Pulumi program that accomplishes this:

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

// Step 1: Create a GKE cluster.
const cluster = new gcp.container.Cluster("ververica-gke-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    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;

// Step 2: Configure Kubernetes provider to use the created GKE cluster.
const k8sProvider = new k8s.Provider("gke-k8s", {
    kubeconfig: cluster.endpoint.apply(endpoint => {
        return cluster.masterAuth.apply(masterAuth => {
            const context = `${gcp.config.project}_${gcp.config.zone}_${clusterName}`;
            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:
        access-token: ${masterAuth.clientCertificate}
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
        });
    }),
});

// Step 3: Deploy the Helm chart to the GKE cluster.
const ververicaChart = new k8s.helm.v3.Chart("ververica-sql-template", {
    chart: "ververica-sql-template",
    version: "1.0.0",
    fetchOpts: {
        repo: "https://charts.ververica.com",
    },
}, { provider: k8sProvider });

// Export the Helm chart name
export const ververicaChartName = ververicaChart.metadata.name;
```

In this program:

- We create a GKE cluster using `gcp.container.Cluster` and configure it with a basic node pool, specifying the machine type and the OAuth scopes required by GKE nodes.

- After the cluster is created, we configure the Pulumi Kubernetes provider to point to the created GKE cluster by generating a `kubeconfig` file dynamically.

- With the Kubernetes provider configured, we deploy the `ververica-sql-template` Helm chart to the cluster using `k8s.helm.v3.Chart`. You must provide the correct chart name and version, along with the chart's repository.

Please replace the `chart` and `version` properties with the actual chart name and version you intend to deploy. Also, ensure that you are using the correct repository URL.

When you run this Pulumi program with `pulumi up`, it will perform the following actions:

1. Provision a new GKE cluster with the specified settings.
2. Configure `kubectl` to interact with the new cluster by setting up `kubeconfig`.
3. Deploy the `ververica-sql-template` Helm chart to the GKE cluster.

Remember, before running this program, you must have Pulumi and Google Cloud SDK configured with your account credentials.

Please let me know if you need further details or explanations on each part of this script.