Deploy the keda-operator helm chart on Opensshift

Question

Pulumi · Accepted Answer

Deploying the KEDA (Kubernetes Event-Driven Autoscaling) operator on an OpenShift cluster involves creating a Helm Chart that contains all the necessary configurations for the KEDA operator. Pulumi's `kubernetes` package provides facilities to work with Helm charts through the `Chart` and `Release` resources.

Here's how you would set up a program to deploy the KEDA operator using a Helm Chart in TypeScript with Pulumi.

Firstly, ensure that you have Pulumi installed and configured for your environment.

Then, initialize a new Pulumi project with the TypeScript template if you haven't already done so:

```bash
pulumi new typescript
```

Next, add the necessary dependencies for the `@pulumi/kubernetes` package in your Pulumi project:

```bash
npm install @pulumi/kubernetes
```

Now, let me walk you through a simple Pulumi program that deploys the KEDA operator Helm chart on an OpenShift cluster.

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

// Create a Kubernetes namespace for KEDA
const kedaNamespace = new k8s.core.v1.Namespace("keda", {
    metadata: { 
        name: "keda" // The name of the namespace where KEDA will be installed
    }
});

// Define the Helm Chart for KEDA operator
const kedaChart = new k8s.helm.v3.Chart("keda-operator", {
    chart: "keda", // The name of the chart
    version: "2.4.0", // Specify the version of the chart
    namespace: kedaNamespace.metadata.name, // Deploy the chart in the created namespace
    fetchOpts: {
        repo: "https://kedacore.github.io/charts", // The repository where the chart is hosted
    }
}, { dependsOn: [kedaNamespace] }); // Ensure the namespace is created before the Helm chart is deployed

export const kedaOperatorChart = kedaChart;
```

This Pulumi program starts by importing the `@pulumi/kubernetes` package, which provides the means to interact with Kubernetes resources including namespaces and Helm charts.

Next, a new Kubernetes namespace called "keda" is created. Namespaces help you organize different environments within your Kubernetes cluster.

Then, we declare a Helm Chart with `k8s.helm.v3.Chart` where we specify the details for the KEDA operator chart. We provide the chart name (which is "keda"), the chart version, and the repository where the Helm chart is hosted.

Note the `dependsOn` option on the Helm Chart instantiation. This ensures that the Kubernetes Namespace is created before Pulumi tries to deploy the Helm Chart in it.

Lastly, we export the `kedaOperatorChart` as an export from our Pulumi program, which is helpful if we ever want to reference this chart's resources from another Pulumi stack.

To run this Pulumi program, you'll navigate to the directory where your Pulumi project is initialized and run the following commands:

```bash
pulumi up
```

Running `pulumi up` will prompt you to confirm the actions before it proceeds with the deployment. Once confirmed, Pulumi will deploy the KEDA operator into your OpenShift cluster.

Keep in mind that this program assumes you have an existing OpenShift cluster where you are authenticated, and your kubeconfig is set up correctly for Pulumi to interact with the cluster.