Automatically adjust pod resource levels with the vertical pod autoscaler

The OKD Vertical Pod Autoscaler Operator (VPA) automatically reviews the historic and current CPU and memory resources for containers in pods and can update the resource limits and requests based on the usage values it learns. The VPA uses individual custom resources (CR) to update all of the pods associated with a workload object, such as a Deployment, DeploymentConfig, StatefulSet, Job, DaemonSet, ReplicaSet, or ReplicationController, in a project.

The VPA helps you to understand the optimal CPU and memory usage for your pods and can automatically maintain pod resources through the pod lifecycle.

About the Vertical Pod Autoscaler Operator

The Vertical Pod Autoscaler Operator (VPA) is implemented as an API resource and a custom resource (CR). The CR determines the actions the Vertical Pod Autoscaler Operator should take with the pods associated with a specific workload object, such as a daemon set, replication controller, and so forth, in a project.

You can use the default recommender or use your own alternative recommender to autoscale based on your own algorithms.

The default recommender automatically computes historic and current CPU and memory usage for the containers in those pods and uses this data to determine optimized resource limits and requests to ensure that these pods are operating efficiently at all times. For example, the default recommender suggests reduced resources for pods that are requesting more resources than they are using and increased resources for pods that are not requesting enough.

The VPA then automatically deletes any pods that are out of alignment with these recommendations one at a time, so that your applications can continue to serve requests with no downtime. The workload objects then re-deploy the pods with the original resource limits and requests. The VPA uses a mutating admission webhook to update the pods with optimized resource limits and requests before the pods are admitted to a node. If you do not want the VPA to delete pods, you can view the VPA resource limits and requests and manually update the pods as needed.

By default, workload objects must specify a minimum of two replicas in order for the VPA to automatically delete their pods. Workload objects that specify fewer replicas than this minimum are not deleted. If you manually delete these pods, when the workload object redeploys the pods, the VPA does update the new pods with its recommendations. You can change this minimum by modifying the VerticalPodAutoscalerController object as shown shown in Changing the VPA minimum value.

For example, if you have a pod that uses 50% of the CPU but only requests 10%, the VPA determines that the pod is consuming more CPU than requested and deletes the pod. The workload object, such as replica set, restarts the pods and the VPA updates the new pod with its recommended resources.

For developers, you can use the VPA to help ensure your pods stay up during periods of high demand by scheduling pods onto nodes that have appropriate resources for each pod.

Administrators can use the VPA to better utilize cluster resources, such as preventing pods from reserving more CPU resources than needed. The VPA monitors the resources that workloads are actually using and adjusts the resource requirements so capacity is available to other workloads. The VPA also maintains the ratios between limits and requests that are specified in initial container configuration.

If you stop running the VPA or delete a specific VPA CR in your cluster, the resource requests for the pods already modified by the VPA do not change. Any new pods get the resources defined in the workload object, not the previous recommendations made by the VPA.

Installing the Vertical Pod Autoscaler Operator

You can use the OKD web console to install the Vertical Pod Autoscaler Operator (VPA).

Prerequisites

  • Ensure that you have downloaded the pull secret from the Red Hat OpenShift Cluster Manager as shown in Obtaining the installation program in the installation documentation for your platform.

    If you have the pull secret, add the redhat-operators catalog to the OperatorHub custom resource (CR) as shown in Configuring OKD to use Red Hat Operators.

Procedure

  1. In the OKD web console, click Operators → OperatorHub.

  2. Choose VerticalPodAutoscaler from the list of available Operators, and click Install.

  3. On the Install Operator page, ensure that the Operator recommended namespace option is selected. This installs the Operator in the mandatory openshift-vertical-pod-autoscaler namespace, which is automatically created if it does not exist.

  4. Click Install.

  5. Verify the installation by listing the VPA Operator components:

    1. Navigate to Workloads → Pods.

    2. Select the openshift-vertical-pod-autoscaler project from the drop-down menu and verify that there are four pods running.

    3. Navigate to Workloads → Deployments to verify that there are four deployments running.

  6. Optional. Verify the installation in the OKD CLI using the following command:

    1. $ oc get all -n openshift-vertical-pod-autoscaler

    The output shows four pods and four deplyoments:

    Example output

    1. NAME                                                    READY   STATUS    RESTARTS   AGE
    2. pod/vertical-pod-autoscaler-operator-85b4569c47-2gmhc   1/1     Running   0          3m13s
    3. pod/vpa-admission-plugin-default-67644fc87f-xq7k9       1/1     Running   0          2m56s
    4. pod/vpa-recommender-default-7c54764b59-8gckt            1/1     Running   0          2m56s
    5. pod/vpa-updater-default-7f6cc87858-47vw9                1/1     Running   0          2m56s
    7. NAME                  TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
    8. service/vpa-webhook   ClusterIP   172.30.53.206   <none>        443/TCP   2m56s
    10. NAME                                               READY   UP-TO-DATE   AVAILABLE   AGE
    11. deployment.apps/vertical-pod-autoscaler-operator   1/1     1            1           3m13s
    12. deployment.apps/vpa-admission-plugin-default       1/1     1            1           2m56s
    13. deployment.apps/vpa-recommender-default            1/1     1            1           2m56s
    14. deployment.apps/vpa-updater-default                1/1     1            1           2m56s
    16. NAME                                                          DESIRED   CURRENT   READY   AGE
    17. replicaset.apps/vertical-pod-autoscaler-operator-85b4569c47   1         1         1       3m13s
    18. replicaset.apps/vpa-admission-plugin-default-67644fc87f       1         1         1       2m56s
    19. replicaset.apps/vpa-recommender-default-7c54764b59            1         1         1       2m56s
    20. replicaset.apps/vpa-updater-default-7f6cc87858                1         1         1       2m56s

About Using the Vertical Pod Autoscaler Operator

To use the Vertical Pod Autoscaler Operator (VPA), you create a VPA custom resource (CR) for a workload object in your cluster. The VPA learns and applies the optimal CPU and memory resources for the pods associated with that workload object. You can use a VPA with a deployment, stateful set, job, daemon set, replica set, or replication controller workload object. The VPA CR must be in the same project as the pods you want to monitor.

You use the VPA CR to associate a workload object and specify which mode the VPA operates in:

  • The Auto and Recreate modes automatically apply the VPA CPU and memory recommendations throughout the pod lifetime. The VPA deletes any pods in the project that are out of alignment with its recommendations. When redeployed by the workload object, the VPA updates the new pods with its recommendations.

  • The Initial mode automatically applies VPA recommendations only at pod creation.

  • The Off mode only provides recommended resource limits and requests, allowing you to manually apply the recommendations. The off mode does not update pods.

You can also use the CR to opt-out certain containers from VPA evaluation and updates.

For example, a pod has the following limits and requests:

  1. resources:
  2.   limits:
  3.     cpu: 1
  4.     memory: 500Mi
  5.   requests:
  6.     cpu: 500m
  7.     memory: 100Mi

After creating a VPA that is set to auto, the VPA learns the resource usage and deletes the pod. When redeployed, the pod uses the new resource limits and requests:

  1. resources:
  2.   limits:
  3.     cpu: 50m
  4.     memory: 1250Mi
  5.   requests:
  6.     cpu: 25m
  7.     memory: 262144k

You can view the VPA recommendations using the following command:

  1. $ oc get vpa <vpa-name> --output yaml

After a few minutes, the output shows the recommendations for CPU and memory requests, similar to the following:

Example output

  1. ...
  2. status:
  3. ...
  4.   recommendation:
  5.     containerRecommendations:
  6.     - containerName: frontend
  7.       lowerBound:
  8.         cpu: 25m
  9.         memory: 262144k
  10.       target:
  11.         cpu: 25m
  12.         memory: 262144k
  13.       uncappedTarget:
  14.         cpu: 25m
  15.         memory: 262144k
  16.       upperBound:
  17.         cpu: 262m
  18.         memory: "274357142"
  19.     - containerName: backend
  20.       lowerBound:
  21.         cpu: 12m
  22.         memory: 131072k
  23.       target:
  24.         cpu: 12m
  25.         memory: 131072k
  26.       uncappedTarget:
  27.         cpu: 12m
  28.         memory: 131072k
  29.       upperBound:
  30.         cpu: 476m
  31.         memory: "498558823"
  32. ...

The output shows the recommended resources, target, the minimum recommended resources, lowerBound, the highest recommended resources, upperBound, and the most recent resource recommendations, uncappedTarget.

The VPA uses the lowerBound and upperBound values to determine if a pod needs to be updated. If a pod has resource requests below the lowerBound values or above the upperBound values, the VPA terminates and recreates the pod with the target values.

Changing the VPA minimum value

By default, workload objects must specify a minimum of two replicas in order for the VPA to automatically delete and update their pods. As a result, workload objects that specify fewer than two replicas are not automatically acted upon by the VPA. The VPA does update new pods from these workload objects if the pods are restarted by some process external to the VPA. You can change this cluster-wide minimum value by modifying the minReplicas parameter in the VerticalPodAutoscalerController custom resource (CR).

For example, if you set minReplicas to 3, the VPA does not delete and update pods for workload objects that specify fewer than three replicas.

If you set minReplicas to 1, the VPA can delete the only pod for a workload object that specifies only one replica. You should use this setting with one-replica objects only if your workload can tolerate downtime whenever the VPA deletes a pod to adjust its resources. To avoid unwanted downtime with one-replica objects, configure the VPA CRs with the podUpdatePolicy set to Initial, which automatically updates the pod only when it is restarted by some process external to the VPA, or Off, which allows you to update the pod manually at an appropriate time for your application.

Example VerticalPodAutoscalerController object

  1. apiVersion: autoscaling.openshift.io/v1
  2. kind: VerticalPodAutoscalerController
  3. metadata:
  4.   creationTimestamp: "2021-04-21T19:29:49Z"
  5.   generation: 2
  6.   name: default
  7.   namespace: openshift-vertical-pod-autoscaler
  8.   resourceVersion: "142172"
  9.   uid: 180e17e9-03cc-427f-9955-3b4d7aeb2d59
  10. spec:
  11.   minReplicas: 3 (1)
  12.   podMinCPUMillicores: 25
  13.   podMinMemoryMb: 250
  14.   recommendationOnly: false
  15.   safetyMarginFraction: 0.15
1Specify the minimum number of replicas in a workload object for the VPA to act on. Any objects with replicas fewer than the minimum are not automatically deleted by the VPA.

Automatically applying VPA recommendations

To use the VPA to automatically update pods, create a VPA CR for a specific workload object with updateMode set to Auto or Recreate.

When the pods are created for the workload object, the VPA constantly monitors the containers to analyze their CPU and memory needs. The VPA deletes any pods that do not meet the VPA recommendations for CPU and memory. When redeployed, the pods use the new resource limits and requests based on the VPA recommendations, honoring any pod disruption budget set for your applications. The recommendations are added to the status field of the VPA CR for reference.

By default, workload objects must specify a minimum of two replicas in order for the VPA to automatically delete their pods. Workload objects that specify fewer replicas than this minimum are not deleted. If you manually delete these pods, when the workload object redeploys the pods, the VPA does update the new pods with its recommendations. You can change this minimum by modifying the VerticalPodAutoscalerController object as shown shown in Changing the VPA minimum value.

Example VPA CR for the Auto mode

  1. apiVersion: autoscaling.k8s.io/v1
  2. kind: VerticalPodAutoscaler
  3. metadata:
  4.   name: vpa-recommender
  5. spec:
  6.   targetRef:
  7.     apiVersion: "apps/v1"
  8.     kind:       Deployment (1)
  9.     name:       frontend (2)
  10.   updatePolicy:
  11.     updateMode: "Auto" (3)
1The type of workload object you want this VPA CR to manage.
2The name of the workload object you want this VPA CR to manage.
3Set the mode to Auto or Recreate:

  • Auto. The VPA assigns resource requests on pod creation and updates the existing pods by terminating them when the requested resources differ significantly from the new recommendation.

  • Recreate. The VPA assigns resource requests on pod creation and updates the existing pods by terminating them when the requested resources differ significantly from the new recommendation. This mode should be used rarely, only if you need to ensure that the pods are restarted whenever the resource request changes.

There must be operating pods in the project before the VPA can determine recommended resources and apply the recommendations to new pods.

Automatically applying VPA recommendations on pod creation

To use the VPA to apply the recommended resources only when a pod is first deployed, create a VPA CR for a specific workload object with updateMode set to Initial.

Then, manually delete any pods associated with the workload object that you want to use the VPA recommendations. In the Initial mode, the VPA does not delete pods and does not update the pods as it learns new resource recommendations.

Example VPA CR for the Initial mode

  1. apiVersion: autoscaling.k8s.io/v1
  2. kind: VerticalPodAutoscaler
  3. metadata:
  4.   name: vpa-recommender
  5. spec:
  6.   targetRef:
  7.     apiVersion: "apps/v1"
  8.     kind:       Deployment (1)
  9.     name:       frontend (2)
  10.   updatePolicy:
  11.     updateMode: "Initial" (3)
1The type of workload object you want this VPA CR to manage.
2The name of the workload object you want this VPA CR to manage.
3Set the mode to Initial. The VPA assigns resources when pods are created and does not change the resources during the lifetime of the pod.

There must be operating pods in the project before a VPA can determine recommended resources and apply the recommendations to new pods.

Manually applying VPA recommendations

To use the VPA to only determine the recommended CPU and memory values, create a VPA CR for a specific workload object with updateMode set to off.

When the pods are created for that workload object, the VPA analyzes the CPU and memory needs of the containers and records those recommendations in the status field of the VPA CR. The VPA does not update the pods as it determines new resource recommendations.

Example VPA CR for the Off mode

  1. apiVersion: autoscaling.k8s.io/v1
  2. kind: VerticalPodAutoscaler
  3. metadata:
  4.   name: vpa-recommender
  5. spec:
  6.   targetRef:
  7.     apiVersion: "apps/v1"
  8.     kind:       Deployment (1)
  9.     name:       frontend (2)
  10.   updatePolicy:
  11.     updateMode: "Off" (3)
1The type of workload object you want this VPA CR to manage.
2The name of the workload object you want this VPA CR to manage.
3Set the mode to Off.

You can view the recommendations using the following command.

  1. $ oc get vpa <vpa-name> --output yaml

With the recommendations, you can edit the workload object to add CPU and memory requests, then delete and redeploy the pods using the recommended resources.

There must be operating pods in the project before a VPA can determine recommended resources.

Exempting containers from applying VPA recommendations

If your workload object has multiple containers and you do not want the VPA to evaluate and act on all of the containers, create a VPA CR for a specific workload object and add a resourcePolicy to opt-out specific containers.

When the VPA updates the pods with recommended resources, any containers with a resourcePolicy are not updated and the VPA does not present recommendations for those containers in the pod.

  1. apiVersion: autoscaling.k8s.io/v1
  2. kind: VerticalPodAutoscaler
  3. metadata:
  4.   name: vpa-recommender
  5. spec:
  6.   targetRef:
  7.     apiVersion: "apps/v1"
  8.     kind:       Deployment (1)
  9.     name:       frontend (2)
  10.   updatePolicy:
  11.     updateMode: "Auto" (3)
  12.   resourcePolicy: (4)
  13.     containerPolicies:
  14.     - containerName: my-opt-sidecar
  15.       mode: "Off"
1The type of workload object you want this VPA CR to manage.
2The name of the workload object you want this VPA CR to manage.
3Set the mode to Auto, Recreate, or Off. The Recreate mode should be used rarely, only if you need to ensure that the pods are restarted whenever the resource request changes.
4Specify the containers you want to opt-out and set mode to Off.

For example, a pod has two containers, the same resource requests and limits:

  1. # ...
  2. spec:
  3.   containers:
  4.   - name: frontend
  5.     resources:
  6.       limits:
  7.         cpu: 1
  8.         memory: 500Mi
  9.       requests:
  10.         cpu: 500m
  11.         memory: 100Mi
  12.   - name: backend
  13.     resources:
  14.       limits:
  15.         cpu: "1"
  16.         memory: 500Mi
  17.       requests:
  18.         cpu: 500m
  19.         memory: 100Mi
  20. # ...

After launching a VPA CR with the backend container set to opt-out, the VPA terminates and recreates the pod with the recommended resources applied only to the frontend container:

  1. ...
  2. spec:
  3.   containers:
  4.     name: frontend
  5.     resources:
  6.       limits:
  7.         cpu: 50m
  8.         memory: 1250Mi
  9.       requests:
  10.         cpu: 25m
  11.         memory: 262144k
  12. ...
  13.     name: backend
  14.     resources:
  15.       limits:
  16.         cpu: "1"
  17.         memory: 500Mi
  18.       requests:
  19.         cpu: 500m
  20.         memory: 100Mi
  21. ...

Using an alternative recommender

You can use your own recommender to autoscale based on your own algorithms. If you do not specify an alternative recommender, OKD uses the default recommender, which suggests CPU and memory requests based on historical usage. Because there is no universal recommendation policy that applies to all types of workloads, you might want to create and deploy different recommenders for specific workloads.

For example, the default recommender might not accurately predict future resource usage when containers exhibit certain resource behaviors, such as cyclical patterns that alternate between usage spikes and idling as used by monitoring applications, or recurring and repeating patterns used with deep learning applications. Using the default recommender with these usage behaviors might result in significant over-provisioning and Out of Memory (OOM) kills for your applications.

Instructions for how to create a recommender are beyond the scope of this documentation,

Procedure

To use an alternative recommender for your pods:

  1. Create a service account for the alternative recommender and bind that service account to the required cluster role:

    1. apiVersion: v1 (1)
    2. kind: ServiceAccount
    3. metadata:
    4.   name: alt-vpa-recommender-sa
    5.   namespace: <namespace_name>
    6. ---
    7. apiVersion: rbac.authorization.k8s.io/v1 (2)
    8. kind: ClusterRoleBinding
    9. metadata:
    10.   name: system:example-metrics-reader
    11. roleRef:
    12.   apiGroup: rbac.authorization.k8s.io
    13.   kind: ClusterRole
    14.   name: system:metrics-reader
    15. subjects:
    16. - kind: ServiceAccount
    17.   name: alt-vpa-recommender-sa
    18.   namespace: <namespace_name>
    19. ---
    20. apiVersion: rbac.authorization.k8s.io/v1 (3)
    21. kind: ClusterRoleBinding
    22. metadata:
    23.   name: system:example-vpa-actor
    24. roleRef:
    25.   apiGroup: rbac.authorization.k8s.io
    26.   kind: ClusterRole
    27.   name: system:vpa-actor
    28. subjects:
    29. - kind: ServiceAccount
    30.   name: alt-vpa-recommender-sa
    31.   namespace: <namespace_name>
    32. ---
    33. apiVersion: rbac.authorization.k8s.io/v1 (4)
    34. kind: ClusterRoleBinding
    35. metadata:
    36.   name: system:example-vpa-target-reader-binding
    37. roleRef:
    38.   apiGroup: rbac.authorization.k8s.io
    39.   kind: ClusterRole
    40.   name: system:vpa-target-reader
    41. subjects:
    42. - kind: ServiceAccount
    43.   name: alt-vpa-recommender-sa
    44.   namespace: <namespace_name>
    1Creates a service accocunt for the recommender in the namespace where the recommender is deployed.
    2Binds the recommender service account to the metrics-reader role. Specify the namespace where the recommender is to be deployed.
    3Binds the recommender service account to the vpa-actor role. Specify the namespace where the recommender is to be deployed.
    4Binds the recommender service account to the vpa-target-reader role. Specify the namespace where the recommender is to be deployed.

  2. To add the alternative recommender to the cluster, create a Deployment object similar to the following:

    1. apiVersion: apps/v1
    2. kind: Deployment
    3. metadata:
    4.   name: alt-vpa-recommender
    5.   namespace: <namespace_name>
    6. spec:
    7.   replicas: 1
    8.   selector:
    9.     matchLabels:
    10.       app: alt-vpa-recommender
    11.   template:
    12.     metadata:
    13.       labels:
    14.         app: alt-vpa-recommender
    15.     spec:
    16.       containers: (1)
    17.       - name: recommender
    18.         image: quay.io/example/alt-recommender:latest (2)
    19.         imagePullPolicy: Always
    20.         resources:
    21.           limits:
    22.             cpu: 200m
    23.             memory: 1000Mi
    24.           requests:
    25.             cpu: 50m
    26.             memory: 500Mi
    27.         ports:
    28.         - name: prometheus
    29.           containerPort: 8942
    30.         securityContext:
    31.           allowPrivilegeEscalation: false
    32.           capabilities:
    33.             drop:
    34.               - ALL
    35.           seccompProfile:
    36.             type: RuntimeDefault
    37.       serviceAccountName: alt-vpa-recommender-sa (3)
    38.       securityContext:
    39.         runAsNonRoot: true
    1Creates a container for your alternative recommender.
    2Specifies your recommender image.
    3Associates the service account that you created for the recommender.

    A new pod is created for the alternative recommender in the same namespace.

    1. $ oc get pods

    Example output

    1. NAME                                        READY   STATUS    RESTARTS   AGE
    2. frontend-845d5478d-558zf                    1/1     Running   0          4m25s
    3. frontend-845d5478d-7z9gx                    1/1     Running   0          4m25s
    4. frontend-845d5478d-b7l4j                    1/1     Running   0          4m25s
    5. vpa-alt-recommender-55878867f9-6tp5v        1/1     Running   0          9s

  3. Configure a VPA CR that includes the name of the alternative recommender Deployment object.

    Example VPA CR to include the alternative recommender

    1. apiVersion: autoscaling.k8s.io/v1
    2. kind: VerticalPodAutoscaler
    3. metadata:
    4.   name: vpa-recommender
    5.   namespace: <namespace_name>
    6. spec:
    7.   recommenders:
    8.     - name: alt-vpa-recommender (1)
    9.   targetRef:
    10.     apiVersion: "apps/v1"
    11.     kind:       Deployment (2)
    12.     name:       frontend
    1Specifies the name of the alternative recommender deployment.
    2Specifies the name of an existing workload object you want this VPA to manage.

Using the Vertical Pod Autoscaler Operator

You can use the Vertical Pod Autoscaler Operator (VPA) by creating a VPA custom resource (CR). The CR indicates which pods it should analyze and determines the actions the VPA should take with those pods.

Prerequisites

  • The workload object that you want to autoscale must exist.

  • If you want to use an alternative recommender, a deployment including that recommender must exist.

Procedure

To create a VPA CR for a specific workload object:

  1. Change to the project where the workload object you want to scale is located.

    1. Create a VPA CR YAML file:

      1. apiVersion: autoscaling.k8s.io/v1
      2. kind: VerticalPodAutoscaler
      3. metadata:
      4.   name: vpa-recommender
      5. spec:
      6.   targetRef:
      7.     apiVersion: "apps/v1"
      8.     kind:       Deployment (1)
      9.     name:       frontend (2)
      10.   updatePolicy:
      11.     updateMode: "Auto" (3)
      12.   resourcePolicy: (4)
      13.     containerPolicies:
      14.     - containerName: my-opt-sidecar
      15.       mode: "Off"
      16.   recommenders: (5)
      17.     - name: my-recommender
      1Specify the type of workload object you want this VPA to manage: Deployment, StatefulSet, Job, DaemonSet, ReplicaSet, or ReplicationController.
      2Specify the name of an existing workload object you want this VPA to manage.
      3Specify the VPA mode:

      • auto to automatically apply the recommended resources on pods associated with the controller. The VPA terminates existing pods and creates new pods with the recommended resource limits and requests.

      • recreate to automatically apply the recommended resources on pods associated with the workload object. The VPA terminates existing pods and creates new pods with the recommended resource limits and requests. The recreate mode should be used rarely, only if you need to ensure that the pods are restarted whenever the resource request changes.

      • initial to automatically apply the recommended resources when pods associated with the workload object are created. The VPA does not update the pods as it learns new resource recommendations.

      • off to only generate resource recommendations for the pods associated with the workload object. The VPA does not update the pods as it learns new resource recommendations and does not apply the recommendations to new pods.

      4Optional. Specify the containers you want to opt-out and set the mode to Off.
      5Optional. Specify an alternative recommender.

    2. Create the VPA CR:

      1. $ oc create -f <file-name>.yaml

      After a few moments, the VPA learns the resource usage of the containers in the pods associated with the workload object.

      You can view the VPA recommendations using the following command:

      1. $ oc get vpa <vpa-name> --output yaml

      The output shows the recommendations for CPU and memory requests, similar to the following:

      Example output

      1. ...
      2. status:
      4. ...
      6.   recommendation:
      7.     containerRecommendations:
      8.     - containerName: frontend
      9.       lowerBound: (1)
      10.         cpu: 25m
      11.         memory: 262144k
      12.       target: (2)
      13.         cpu: 25m
      14.         memory: 262144k
      15.       uncappedTarget: (3)
      16.         cpu: 25m
      17.         memory: 262144k
      18.       upperBound: (4)
      19.         cpu: 262m
      20.         memory: "274357142"
      21.     - containerName: backend
      22.       lowerBound:
      23.         cpu: 12m
      24.         memory: 131072k
      25.       target:
      26.         cpu: 12m
      27.         memory: 131072k
      28.       uncappedTarget:
      29.         cpu: 12m
      30.         memory: 131072k
      31.       upperBound:
      32.         cpu: 476m
      33.         memory: "498558823"
      35. ...
      1lowerBound is the minimum recommended resource levels.
      2target is the recommended resource levels.
      3upperBound is the highest recommended resource levels.
      4uncappedTarget is the most recent resource recommendations.

Uninstalling the Vertical Pod Autoscaler Operator

You can remove the Vertical Pod Autoscaler Operator (VPA) from your OKD cluster. After uninstalling, the resource requests for the pods already modified by an existing VPA CR do not change. Any new pods get the resources defined in the workload object, not the previous recommendations made by the Vertical Pod Autoscaler Operator.

You can remove a specific VPA using the oc delete vpa <vpa-name> command. The same actions apply for resource requests as uninstalling the vertical pod autoscaler.

After removing the VPA Operator, it is recommended that you remove other components associated with the Operator to avoid potential issues.

Prerequisites

  • The Vertical Pod Autoscaler Operator must be installed.

Procedure

  1. In the OKD web console, click Operators → Installed Operators.

  2. Switch to the openshift-vertical-pod-autoscaler project.

  3. Find the VerticalPodAutoscaler Operator and click the Options menu. Select Uninstall Operator.

  4. Optional: To remove all operands associated with the Operator, in the dialog box, select Delete all operand instances for this operator checkbox.

  5. Click Uninstall.

  6. Optional: Use the OpenShift CLI to remove the VPA components:

    1. Delete the VPA mutating webhook configuration:

      1. $ oc delete mutatingwebhookconfigurations/vpa-webhook-config

    2. List any VPA custom resources:

      1. $ oc get verticalpodautoscalercheckpoints.autoscaling.k8s.io,verticalpodautoscalercontrollers.autoscaling.openshift.io,verticalpodautoscalers.autoscaling.k8s.io -o wide --all-namespaces

      Example output

      1. NAMESPACE      NAME                                                                       AGE
      2. my-project     verticalpodautoscalercheckpoint.autoscaling.k8s.io/vpa-recommender-httpd   5m46s
      4. NAMESPACE                           NAME                                                               AGE
      5. openshift-vertical-pod-autoscaler   verticalpodautoscalercontroller.autoscaling.openshift.io/default   11m
      7. NAMESPACE      NAME                                                       MODE   CPU   MEM       PROVIDED   AGE
      8. my-project     verticalpodautoscaler.autoscaling.k8s.io/vpa-recommender   Auto   93m   262144k   True       9m15s

    3. Delete the listed VPA custom resources. For example:

      1. $ oc delete verticalpodautoscalercheckpoint.autoscaling.k8s.io/vpa-recommender-httpd -n my-project
      1. $ oc delete verticalpodautoscalercontroller.autoscaling.openshift.io/default -n openshift-vertical-pod-autoscaler
      1. $ oc delete verticalpodautoscaler.autoscaling.k8s.io/vpa-recommender -n my-project

    4. List any VPA custom resource definitions (CRDs):

      1. $ oc get crd

      Example output

      1. NAME                                                              CREATED AT
      2.  ...
      3. verticalpodautoscalercheckpoints.autoscaling.k8s.io               2022-02-07T14:09:20Z
      4. verticalpodautoscalercontrollers.autoscaling.openshift.io         2022-02-07T14:09:20Z
      5. verticalpodautoscalers.autoscaling.k8s.io                         2022-02-07T14:09:20Z
      6.  ...

    5. Delete the listed VPA CRDs:

      1. $ oc delete crd verticalpodautoscalercheckpoints.autoscaling.k8s.io verticalpodautoscalercontrollers.autoscaling.openshift.io verticalpodautoscalers.autoscaling.k8s.io

      Deleting the CRDs removes the associated roles, cluster roles, and role bindings. However, there might be a few cluster roles that must be manually deleted.

    6. List any VPA cluster roles:

      1. $ oc get clusterrole | grep openshift-vertical-pod-autoscaler

      Example output

      1. openshift-vertical-pod-autoscaler-6896f-admin        2022-02-02T15:29:55Z
      2. openshift-vertical-pod-autoscaler-6896f-edit         2022-02-02T15:29:55Z
      3. openshift-vertical-pod-autoscaler-6896f-view         2022-02-02T15:29:55Z

    7. Delete the listed VPA cluster roles. For example:

      1. $ oc delete clusterrole openshift-vertical-pod-autoscaler-6896f-admin openshift-vertical-pod-autoscaler-6896f-edit openshift-vertical-pod-autoscaler-6896f-view

    8. Delete the VPA Operator:

      1. $ oc delete operator/vertical-pod-autoscaler.openshift-vertical-pod-autoscaler