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

Question

Pulumi · Accepted Answer

To deploy the Dashkiosk helm chart on Google Kubernetes Engine (GKE) with Pulumi, you'll need to perform a series of steps:

Set up a GKE cluster where the chart will be deployed.
Install the Helm chart onto the GKE cluster.

The Pulumi Kubernetes provider has support for Helm charts through the Chart resource. You can deploy charts from a Helm repository or from a local chart.

Here's how you can go about deploying the Helm chart:

Setting up a GKE Cluster

Before you can deploy the Helm chart, you need to ensure that you have a Kubernetes cluster running. For this, we will use Pulumi to provision a GKE cluster. Using the google-native.container.v1.Cluster resource, you can define the configurations for your GKE cluster.

Installing the Dashkiosk Helm chart

Once the cluster is up and running, you can deploy the Dashkiosk Helm chart. Using the kubernetes.helm.v3.Chart resource, you can specify the name of the chart and the repository where it is located.

Below is a Pulumi program written in TypeScript that demonstrates how to deploy a Dashkiosk Helm chart to a GKE cluster:

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

// Configure the GCP project and location (region) to deploy the resources
const projectName = pulumi.config.require("gcpProject");
const location = pulumi.config.require("gcpLocation");

// Create a GKE cluster
const cluster = new gcp.container.Cluster("dashkiosk-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    location: location,
    project: projectName,
});

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

// Once the cluster is created, we can grab the kubeconfig struct to access the Cluster from `kubectl`
const kubeconfig = pulumi.
    all([cluster.name, cluster.endpoint, cluster.masterAuth]).
    apply(([name, endpoint, masterAuth]) => {
        const context = `${projectName}_${location}_${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
`;
    });

// Export the Kubeconfig
export const Kubeconfig = kubeconfig;

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

// Install the dashkiosk Helm chart on the GKE cluster we provisioned earlier
const dashkioskChart = new k8s.helm.v3.Chart("dashkiosk", {
    chart: "dashkiosk",
    version: "x.y.z", // replace with the chart version you want to deploy
    fetchOpts: {
        repo: "http://helm-repository-url/", // replace with the URL of your Helm chart repository
    },
}, { provider: k8sProvider });

// Export the Dashkiosk endpoint address (This may vary based on your Helm chart's service configuration)
export const dashkioskAddress = dashkioskChart.getResourceProperty("v1/Service", "dashkiosk", "status").apply(status => status.loadBalancer.ingress[0].ip);

This program does the following:

Imports required Pulumi packages for working with GCP and Kubernetes.
Sets up the configuration for deploying a GKE cluster, including the project name, location, number of nodes, etc.
Provisions a GKE cluster with the specified configuration.
Generates a kubeconfig to allow communication with the cluster via kubectl.
Exports the cluster name and kubeconfig so that they can be easily accessed.
Creates a Kubernetes provider instance that refers to our GKE cluster.
Utilizes the k8s.helm.v3.Chart resource to install the Dashkiosk Helm chart by specifying the chart name and version, as well as the repository where it's hosted.
Exports the Dashkiosk service's external IP address for easy access after deployment.

Replace the placeholders like <project-name>, <location>, and <chart-version> with actual values that correspond to your GCP setup and the version of the Helm chart you wish to deploy.

You'll need to run pulumi up to deploy this program, and it will provision the resources in the order defined, giving you an output of the cluster endpoint and Dashkiosk service's IP address after successful deployment.

The resources you're using are linked below: