Using kubernetes http.keda.sh with postgres-operator.crunchydata.com

Question

Pulumi · Accepted Answer

To integrate Kubernetes-based event-driven autoscaling (KEDA) with a PostgreSQL database operated by the Crunchy Data PostgreSQL Operator, you will need to create a custom setup that allows KEDA to scale Kubernetes `Deployments` or `StatefulSets` according to the metrics of interest from the PostgreSQL database. KEDA uses a concept called `ScaledObject` to configure how it should autoscale your application.

First, you'll need both KEDA and the Crunchy Data PostgreSQL Operator installed in your Kubernetes cluster. The operator is responsible for deploying and managing instances of PostgreSQL within a Kubernetes cluster.

Here’s a high-level overview of the steps you might take in a Pulumi program to integrate KEDA with Crunchy Data's PostgreSQL Operator in Kubernetes:

1. **Install KEDA:** We will define a `HelmChart` resource for KEDA, which will install the KEDA Operator into your Kubernetes cluster.
2. **Install Crunchy Data PostgreSQL Operator:** Similarly, we'll define another `HelmChart` resource for Crunchy Data PostgreSQL Operator.
3. **Deploy a PostgreSQL Instance:** We will configure a PostgreSQL instance managed by the operator.
4. **Create a ScaledObject:** Finally, we’ll create a `ScaledObject` custom resource that tells KEDA how to autoscale our application based on the PostgreSQL metrics.

For this explanation, I'm assuming you have a Kubernetes cluster up and running and have already configured the Pulumi CLI with credentials for your Kubernetes cluster.

Now, let me guide you through a basic Pulumi TypeScript program that demonstrates these steps:

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

// Initialize a Pulumi Kubernetes provider using the default kubeconfig credentials.
const k8sProvider = new kubernetes.Provider("k8s-provider", {});

// Install KEDA using the Helm chart.
const kedaChart = new kubernetes.helm.v3.Chart("keda", {
    chart: "keda",
    version: "2.4.0",
    fetchOpts: {
        repo: "https://kedacore.github.io/charts",
    },
}, { provider: k8sProvider });

// Output the status of KEDA installation.
export const kedaStatus = kedaChart.status;

// Install Crunchy Data PostgreSQL Operator using the Helm chart.
const postgresOperatorChart = new kubernetes.helm.v3.Chart("postgres-operator", {
    chart: "postgres-operator",
    version: "5.0.3", // Use the appropriate version
    fetchOpts: {
        repo: "https://charts.crunchydata.com/charts",
    },
}, { provider: k8sProvider });

// Deploy a PostgreSQL instance managed by the Crunchy Data PostgreSQL Operator.
// The following is a hypothetical custom resource. Replace it with an actual one from the documentation.
const pgInstance = new kubernetes.apiextensions.CustomResource("pg-instance", {
    apiVersion: "postgres-operator.crunchydata.com/v1beta1",
    kind: "PostgresCluster",
    metadata: {
        name: "example",
    },
    spec: {
        // Specify the configuration for your PostgreSQL instance
    },
}, { provider: k8sProvider });

// Define the `ScaledObject` for KEDA which will scale based on PostgreSQL metrics.
const scaledObject = new kubernetes.apiextensions.CustomResource("pg-scaledobject", {
    apiVersion: "keda.sh/v1alpha1",
    kind: "ScaledObject",
    metadata: {
        name: "postgres-scaledobject",
        labels: {
            deploymentName: "example-application", // This should match your deployment name
        },
    },
    spec: {
        scaleTargetRef: {
            deploymentName: "example-application",
        },
        triggers: [{
            type: "postgres", // This is an example, change it as per your trigger type
            metadata: {
                // Define the specifics for the PostgreSQL trigger
            },
        }],
        // Configuration for scaling, such as minReplicaCount and maxReplicaCount
    },
}, { provider: k8sProvider });

// Export required outputs.
export const scaledObjectName = scaledObject.metadata.name;
```

To break down what's happening in the code:

- We're using the `@pulumi/kubernetes` package to interact with Kubernetes and `@pulumi/kubernetes.helm.v3.Chart` to install Helm charts.
- We install KEDA and Crunchy Data PostgreSQL Operator by defining `HelmChart` resources. The properties of `HelmChart` include the name of the chart, the version, and the repository to fetch the chart from.
- We define a hypothetical `pgInstance` resource, which would represent the PostgreSQL database instance managed by the Crunchy Data operator. Since each operator tends to have its custom kinds of resources for deploying databases, you'll need to consult the [Crunchy Data PostgreSQL operator documentation](https://access.crunchydata.com/documentation/postgres-operator/latest/) for the exact details.
- We use a `CustomResource` to define the `ScaledObject` for KEDA, specifying the target to scale, and the metrics KEDA should watch for scaling purposes. The metadata, such as `deploymentName` and the `triggers` array, needs to be filled according to how you've set up your PostgreSQL instance and what metrics you wish to scale by.

I encourage you to refer to the [KEDA documentation](https://keda.sh/docs/2.4/concepts/) on `ScaledObjects` and triggers to understand the metrics and conditions you can use to control the autoscaling for your environment.

Remember that the `pgInstance` and `scaledObject` resources used in the code are placeholders; you'll need to replace this code with the actual resources and the specific configuration details for your environment.

Once you've calibrated your `ScaledObject` correctly, KEDA will automatically scale your application in and out based on the metrics from your PostgreSQL database.

The Pulumi program needs to be run using the Pulumi CLI, which will perform the actual deployments and configurations on your Kubernetes cluster.