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

Question

Pulumi · Accepted Answer

To deploy the delta-sharing-server Helm chart on Google Kubernetes Engine (GKE) using Pulumi, you need to perform a series of steps. These steps involve setting up a GKE cluster and using the Pulumi Kubernetes provider to deploy the Helm chart onto the cluster.

Below, you'll find a Pulumi program in TypeScript that accomplishes this. The program is divided into two portions. First, we define necessary resources using Google Cloud and Kubernetes Pulumi providers to create a GKE cluster. Then, we deploy the Helm chart to this newly created cluster.

Here is what the program does:

Setup GKE Cluster: We start by defining a GKE cluster using google-native.container.v1beta1.Cluster from the Google Native Pulumi provider. We specify the necessary details for the cluster, such as location, initial node count, and machine type for the nodes.
Deploy Helm Chart: Once the cluster is created, we use the kubernetes.helm.v3.Chart resource from the Kubernetes Pulumi provider to deploy the delta-sharing-server Helm chart. We specify the chart name, version, and repository (if it's not a standard Helm chart in the default repo).

Now, let's jump into the Pulumi TypeScript program:

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("delta-sharing-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "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;

// Export the Kubeconfig file to interact with 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 instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("gkeK8s", {
    kubeconfig: kubeconfig,
});

// Deploy the delta-sharing-server helm chart
const chart = new k8s.helm.v3.Chart("delta-sharing-server", {
    chart: "delta-sharing-server",
    // Assuming you're using a Helm chart available on a known Helm chart repository,
    // uncomment and set the 'repo' field accordingly:
    // repo: "https://<helm-chart-repo>",
    version: "<version>",
    // If the chart requires custom values, specify them as an object in the `values` field.
    // values: { /* custom values here */ },
}, { provider: k8sProvider });

// Export the Helm chart deployment status
export const chartStatus = chart.status;

Explanation of important points in above program:

The GKE cluster is created using Pulumi's gcp.container.Cluster resource.
The kubeconfig is generated to communicate with the cluster using kubectl, this is exported so it can be used outside Pulumi if needed.
A k8s.Provider instance is created which takes the kubeconfig as input, enabling Pulumi to deploy resources to our GKE cluster.
The kubernetes.helm.v3.Chart resource is used to deploy the Helm chart, which is named delta-sharing-server. You might need to provide additional configuration parameters via values depending on the Helm chart specifics. The repo and version arguments should be provided if the chart is not in the default repo or if you want to pin to a specific version.

To run the above Pulumi program, make sure to have Pulumi installed and configured with access to your Google Cloud account. You will need to have gcloud CLI installed and authenticated on the machine where you run Pulumi for the GKE authentication via the generated kubeconfig.

Please replace <helm-chart-repo> with the actual URL of the Helm repository where the delta-sharing-server chart is hosted, and <version> with the specific chart version you want to install. If the chart is stored in the default Helm repository, you can omit the repo field.

After setting up the program, deploy it by running pulumi up in the directory where your Pulumi program is located. This command will start the deployment process, which will be managed by Pulumi.