Utilizing VerticalPodAutoscaler for resource optimization in clusters

Question

Pulumi · Accepted Answer

To utilize Vertical Pod Autoscaler (VPA) with Pulumi for resource optimization in Kubernetes clusters, you'd typically need to deploy Kubernetes resources that define the VPA configuration. The VPA automatically adjusts the CPU and memory reservations for your pods to help them use resources more efficiently while keeping the defined service levels.

The resources you need to manage, such as `VerticalPodAutoscaler` itself or supporting configuration, might not be directly represented in the Pulumi Registry Results you see here, but you can utilize the Kubernetes CRD (Custom Resource Definition) support in Pulumi's Kubernetes provider to apply any Kubernetes manifest.

The VPA functionality in Kubernetes clusters is provided by the Kubernetes Autoscaler project and needs to be installed in your cluster before you can start defining VPA resources.

Here's a Pulumi program in TypeScript that demonstrates how to deploy a VPA resource assuming that the VPA is already installed in your cluster.

First, make sure you have `@pulumi/kubernetes` installed:

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

Next, you can define a VPA resource for your application:

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

// Define a VerticalPodAutoscaler resource for a given deployment.
const vpa = new k8s.apiextensions.CustomResource("example-vpa", {
    apiVersion: "autoscaling.k8s.io/v1",
    kind: "VerticalPodAutoscaler",
    metadata: {
        name: "example-vpa-resource",
    },
    spec: {
        targetRef: {
            apiVersion: "apps/v1",
            kind: "Deployment",
            name: "example-deployment" // Replace with the name of your deployment
        },
        updatePolicy: {
            updateMode: "Auto" // Other modes include "Off" and "Recreate"
        },
        resourcePolicy: {
            containerPolicies: [
                {
                    containerName: "example-container", // Replace with the name of the container you want to autoscale
                    minAllowed: {
                        cpu: "200m",
                        memory: "100Mi"
                    },
                    maxAllowed: {
                        cpu: "2",
                        memory: "1Gi"
                    },
                    controlledResources: ["cpu", "memory"] // Resources to be controlled by VPA
                }
            ]
        }
    }
});

export const vpaName = vpa.metadata.name;
```

This Pulumi program defines a `CustomResource` for the VPA manipulations. In `spec`, you must refer to a deployment that VPA should manage — replace `example-deployment` with the name of your deployment, and also adjust the container name and resource limits to fit your use case.

The `updatePolicy` field in the VPA spec can be set to "Auto" to enable automatic updates of pods by the VPA. This includes evicting pods and creating new ones with adjusted resource limits if required. Be cautious with production workloads; you may want to use "Off" to only get recommendations, or "Initial" to only apply resources at pod creation, depending on your use case.

Please note that you would need to have VPA running in your cluster to use this resource. You can usually install it using Helm or directly applying YAML files from the Kubernetes Autoscaler project.

Lastly, we export the name of the VPA so that it's printed out when you run `pulumi up`.

For the VPA to work properly, you would typically first install it in your cluster. This would involve deploying the VPA components like so (not included in the Pulumi code above):

```yaml
# This is a Kubernetes YAML manifest, not a Pulumi program, and is provided for reference purposes.
apiVersion: v1
kind: Namespace
metadata:
  name: kube-system
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: vpa-recommender
  namespace: kube-system
# ...more configurations needed for the VPA components...
```

After installing the VPA to your Kubernetes cluster, the above Pulumi program can be used to define how VPA should manage the resources of pods in a particular deployment. Remember to replace placeholder values with actual names and resources as per your setup.

More information about installing and configuring VPA can be found in the [Vertical Pod Autoscaler documentation](https://github.com/kubernetes/autoscaler/tree/master/vertical-pod-autoscaler).