Deploy the spot-scheduler helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the spot-scheduler Helm chart on Google Kubernetes Engine (GKE), you'll need to accomplish a few tasks:

1. Create a GKE cluster in your Google Cloud Platform (GCP) project.
2. Install and configure Helm in your local environment (or wherever you plan to run the deployment from).
3. Add the Helm repository that contains the spot-scheduler chart if it's not part of the stable repository.
4. Use Helm to install the spot-scheduler chart on your GKE cluster.

Below is a Pulumi program written in TypeScript that:

- Provisions a GKE cluster using Pulumi's GCP provider.
- Configures the Kubernetes provider to interact with the GKE cluster.
- Installs the spot-scheduler Helm chart onto the GKE cluster using Pulumi's Helm Release resource.

Please keep in mind that you need to have Pulumi CLI installed and configured to connect to your GCP account, as well as Helm installed on the machine where this Pulumi program is executed.

Before you begin, make sure you have Pulumi and Helm installed locally, and you've logged in to your GCP account using the `gcloud` command-line tool.

Now let's look at the code:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("pulumi-gke-cluster", {
  initialNodeCount: 3,
  nodeVersion: "latest",
  minMasterVersion: "latest",
});

// Export the Cluster name and Kubeconfig
export const kubeconfig = pulumi.all([cluster.name, cluster.endpoint, cluster.masterAuth]).apply(([name, endpoint, masterAuth]) => {
  const kubeconfig = `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${endpoint}
  name: ${name}
contexts:
- context:
    cluster: ${name}
    user: ${name}
  name: ${name}
current-context: ${name}
kind: Config
preferences: {}
users:
- name: ${name}
  user:
    client-certificate-data: ${masterAuth.clientCertificate}
    client-key-data: ${masterAuth.clientKey}
  `;
  return kubeconfig;
});

// Create a Kubernetes Provider
const k8sProvider = new k8s.Provider("k8s-provider", {
  kubeconfig: kubeconfig.apply(JSON.stringify),
});

// Add Helm chart repository (optional, replace `<REPO_NAME>` with actual repository name if needed)
const repo = "stable"; // or use the name of your repository if the chart isn't in the stable repo
const repoUrl = "https://charts.helm.sh/stable"; // replace with the URL of your Helm repository
const chartName = "spot-scheduler"; // the name of the chart in the repository
const chartVersion = "0.1.0"; // specify the exact chart version you want to deploy

// Install spot-scheduler Helm chart onto the cluster
const spotScheduler = new helm.v2.Chart("spot-scheduler", {
  repo: repo,
  chart: chartName,
  version: chartVersion,
  namespace: "default", // Specify the namespace if you want to install it in a different namespace
}, { provider: k8sProvider });

// Export the public IP of the spot-scheduler (if applicable)
export const spotSchedulerIp = spotScheduler.getResourceProperty("v1/Service", "spot-scheduler", "status").apply(status => status.loadBalancer.ingress[0].ip);

```

Here is what each part of the code does:

- The `gcp.container.Cluster` resource creates a new GKE cluster. We are specifying the initial node count, as well as the Kubernetes versions for the nodes and the master.
- The `kubeconfig` constant creates the kubeconfig required to interact with your GKE cluster via Pulumi.
- The `k8s.Provider` resource is the Kubernetes provider that uses the generated kubeconfig to communicate with your GKE cluster.
- The `helm.v2.Chart` resource is used to deploy the spot-scheduler Helm chart into the GKE cluster created earlier. Ensure you have the correct repository name and chart version.
- The `spotSchedulerIp` is an exported variable that—if the spot-scheduler service type is LoadBalancer—will contain the public IP address for the spot-scheduler, allowing you to access the service outside of your cluster.

Remember that to run this Pulumi program, you need to execute `pulumi up` in the directory where your Pulumi program file resides. This command will create the resources in GCP as per the configuration defined in the above code.