Deploy the preemptible-killer helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart to an Oracle Kubernetes Engine (OKE) cluster involves a few steps with Pulumi. First, we must ensure that we have an OKE cluster available and configured correctly. Once the cluster is ready, we'll use the kubernetes package to install the preemptible-killer Helm chart.

The preemptible-killer Helm chart is used to gracefully handle the termination of preemptible instances in a Kubernetes cluster. Preemptible instances are cost-effective but can be reclaimed by the cloud provider at any time, so a solution like preemptible-killer watches for termination notices and drains nodes before they are reclaimed.

Let's break down the Pulumi program to deploy this Helm chart:

Set up the OCI provider: We must configure the OCI (Oracle Cloud Infrastructure) provider to interact with our Oracle cloud resources.
Create or Select an Existing OKE Cluster: You would typically define an OKE cluster with Pulumi or select an existing one. Here we'll assume an existing cluster is selected for the purposes of deploying the Helm chart.
Install the Helm Chart: We will utilize the kubernetes.helm.sh/v3.Chart resource which allows us to deploy Helm charts into our Kubernetes cluster.

Below is the TypeScript program that deploys the preemptible-killer Helm chart to an existing OKE cluster:

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

// Step 1: Set up the Kubernetes Provider
// The kubeconfig for our OKE cluster can be obtained from the OCI console, environment variables, or a Pulumi stack reference.
const kubeconfig = "< Your Kubeconfig Here>";

// Initializing the Kubernetes Provider with the kubeconfig.
const clusterProvider = new k8s.Provider("okeProvider", {
    kubeconfig: kubeconfig,
});

// Step 2: Install the preemptible-killer Helm Chart
const chart = new k8s.helm.v3.Chart("preemptible-killer-chart", {
    // Assuming the chart is available in a reachable Helm repository.
    // The `repo` attribute specifies the Helm chart repository.
    // The `chart` attribute specifies the name of the chart in the repository.
    // The `version` attribute is optional and denotes the version of the chart to deploy.
    // The `values` attribute can be used to provide custom configuration values for the Helm chart.
    chart: "preemptible-killer",
    repo: "https://helm-repository-url/",
    version: "0.1.0", // Specify the chart version (Change as needed)
    values: {
        // Provide any custom values for `preemptible-killer` here.
        // This depends on the chart's configurable options.
    },
}, { provider: clusterProvider });

// Export the chart name as a stack output
export const chartName = chart.metadata.name;

Remember to replace "< Your Kubeconfig Here>" with the actual kubeconfig content for your OKE cluster, and ensure that the Helm chart repository URL is correct for the preemptible-killer chart.

Explanation:

Kubernetes Provider Setup: This block of code initializes a new Kubernetes provider by supplying it with a kubeconfig that allows Pulumi to communicate with your OKE cluster. Replace the placeholder with the kubeconfig from the Oracle Cloud Infrastructure console.
Helm Chart Installation: Here we create a new Helm Chart resource using Pulumi’s Kubernetes provider. This resource corresponds to a single deployment of a Helm chart in our Kubernetes cluster. The chart property indicates the name of the chart, and repo points to the Helm repository URL where the chart is hosted.
Exporting the Chart Name: Finally, we're exporting the name of the Helm release as a stack output, which can be useful for querying the deployment status or integrating with other processes.

After the Pulumi program is run, the preemptible-killer Helm chart is deployed to your OKE cluster and should begin monitoring for premature terminations of preemptible nodes. Should a node be pre-empted, the Helm chart's workload will ensure the node is appropriately drained, minimizing disruptions to your applications running within the cluster.