feat(recommender): enforce CPU/memory ratio via VPA API instead of flag

Author: Jrmy2402

vertical-pod-autoscaler/deploy/vpa-v1-crd-gen.yaml

@@ -354,6 +354,18 @@ spec:
                             Specifies the maximum amount of resources that will be recommended
                             for the container. The default is no maximum.
                           type: object
+                        memoryPerCPU:
+                          anyOf:
+                          - type: integer
+                          - type: string
+                          description: |-
+                            Enforce a fixed memory-per-CPU ratio for this container’s recommendations.
+                            If set, the recommender will adjust memory or CPU so that:
+                              memory_bytes = cpu_cores * memoryPerCPU (bytes per 1 core).
+                            Applied to Target, LowerBound, UpperBound, and UncappedTarget.
+                            Example: "4Gi" means 1 CPU -> 4 GiB.
+                          pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
+                          x-kubernetes-int-or-string: true
                         minAllowed:
                           additionalProperties:
                             anyOf:

vertical-pod-autoscaler/docs/api.md

@@ -48,6 +48,7 @@ _Appears in:_
 | `maxAllowed` _[ResourceList](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcelist-v1-core)_ | Specifies the maximum amount of resources that will be recommended<br />for the container. The default is no maximum. |  |  |
 | `controlledResources` _[ResourceName](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#resourcename-v1-core)_ | Specifies the type of recommendations that will be computed<br />(and possibly applied) by VPA.<br />If not specified, the default of [ResourceCPU, ResourceMemory] will be used. |  |  |
 | `controlledValues` _[ContainerControlledValues](#containercontrolledvalues)_ | Specifies which resource values should be controlled.<br />The default is "RequestsAndLimits". |  | Enum: [RequestsAndLimits RequestsOnly] <br /> |
+| `memoryPerCPU` _[Quantity](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.32/#quantity-resource-api)_ | Enforce a fixed memory-per-CPU ratio for this container’s recommendations.<br />If set, the recommender will adjust memory or CPU so that:<br />  memory_bytes = cpu_cores * memoryPerCPU (bytes per 1 core).<br />Applied to Target, LowerBound, UpperBound, and UncappedTarget.<br />Example: "4Gi" means 1 CPU -> 4 GiB. |  |  |
 
 
 #### ContainerScalingMode

vertical-pod-autoscaler/docs/flags.md

@@ -66,7 +66,6 @@ This document is auto-generated from the flag definitions in the VPA recommender
 | `container-recommendation-max-allowed-memory` |  |  | quantity   Maximum amount of memory that will be recommended for a container. VerticalPodAutoscaler-level maximum allowed takes precedence over the global maximum allowed. |
 | `cpu-histogram-decay-half-life` |  |  24h0m0s | duration                 The amount of time it takes a historical CPU usage sample to lose half of its weight.  |
 | `cpu-integer-post-processor-enabled` |  |  | Enable the cpu-integer recommendation post processor. The post processor will round up CPU recommendations to a whole CPU for pods which were opted in by setting an appropriate label on VPA object (experimental) |
-| `enforce-cpu-memory-ratio` | float |  | If > 0, enforce a fixed memory-per-CPU ratio expressed as bytes per millicores across all recommendations. |
 | `external-metrics-cpu-metric` | string |  | ALPHA.  Metric to use with external metrics provider for CPU usage. |
 | `external-metrics-memory-metric` | string |  | ALPHA.  Metric to use with external metrics provider for memory usage. |
 | `feature-gates` | mapStringBool |  | A set of key=value pairs that describe feature gates for alpha/experimental features. Options are:<br>AllAlpha=true\|false (ALPHA - default=false)<br>AllBeta=true\|false (BETA - default=false)<br>InPlaceOrRecreate=true\|false (BETA - default=true) |

vertical-pod-autoscaler/pkg/apis/autoscaling.k8s.io/v1/types.go

@@ -19,6 +19,7 @@ package v1
 import (
 	autoscaling "k8s.io/api/autoscaling/v1"
 	v1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
@@ -221,6 +222,14 @@ type ContainerResourcePolicy struct {
 	// The default is "RequestsAndLimits".
 	// +optional
 	ControlledValues *ContainerControlledValues `json:"controlledValues,omitempty" protobuf:"bytes,6,rep,name=controlledValues"`
+
+	// Enforce a fixed memory-per-CPU ratio for this container’s recommendations.
+	// If set, the recommender will adjust memory or CPU so that:
+	//   memory_bytes = cpu_cores * memoryPerCPU (bytes per 1 core).
+	// Applied to Target, LowerBound, UpperBound, and UncappedTarget.
+	// Example: "4Gi" means 1 CPU -> 4 GiB.
+	// +optional
+	MemoryPerCPU *resource.Quantity `json:"memoryPerCPU,omitempty"`
 }
 
 const (

vertical-pod-autoscaler/pkg/recommender/logic/recommender.go

@@ -40,7 +40,6 @@ var (
 	humanizeMemory             = flag.Bool("humanize-memory", false, "DEPRECATED: Convert memory values in recommendations to the highest appropriate SI unit with up to 2 decimal places for better readability. This flag is deprecated and will be removed in a future version. Use --round-memory-bytes instead.")
 	roundCPUMillicores         = flag.Int("round-cpu-millicores", 1, `CPU recommendation rounding factor in millicores. The CPU value will always be rounded up to the nearest multiple of this factor.`)
 	roundMemoryBytes           = flag.Int("round-memory-bytes", 1, `Memory recommendation rounding factor in bytes. The Memory value will always be rounded up to the nearest multiple of this factor.`)
-	enforceCPUMemoryRatio      = flag.Float64("enforce-cpu-memory-ratio", 0, `If > 0, enforce a fixed memory-per-CPU ratio expressed as bytes per millicores across all recommendations.`)
 )
 
 // PodResourceRecommender computes resource recommendation for a Vpa object.
@@ -195,10 +194,10 @@ func MapToListOfRecommendedContainerResources(resources RecommendedPodResources)
 	for _, name := range containerNames {
 		containerResources = append(containerResources, vpa_types.RecommendedContainerResources{
 			ContainerName:  name,
-			Target:         model.EnforceCPUMemoryRatio(model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes), enforceCPUMemoryRatio),
-			LowerBound:     model.EnforceCPUMemoryRatio(model.ResourcesAsResourceList(resources[name].LowerBound, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes), enforceCPUMemoryRatio),
-			UpperBound:     model.EnforceCPUMemoryRatio(model.ResourcesAsResourceList(resources[name].UpperBound, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes), enforceCPUMemoryRatio),
-			UncappedTarget: model.EnforceCPUMemoryRatio(model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes), enforceCPUMemoryRatio),
+			Target:         model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes),
+			LowerBound:     model.ResourcesAsResourceList(resources[name].LowerBound, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes),
+			UpperBound:     model.ResourcesAsResourceList(resources[name].UpperBound, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes),
+			UncappedTarget: model.ResourcesAsResourceList(resources[name].Target, *humanizeMemory, *roundCPUMillicores, *roundMemoryBytes),
 		})
 	}
 	recommendation := &vpa_types.RecommendedPodResources{

vertical-pod-autoscaler/pkg/recommender/main.go

@@ -268,6 +268,7 @@ func run(ctx context.Context, healthCheck *metrics.HealthCheck, commonFlag *comm
 		postProcessors = append(postProcessors, &routines.IntegerCPUPostProcessor{})
 	}
 
+	postProcessors = append(postProcessors, &routines.MemoryPerCPUPostProcessor{})
 	globalMaxAllowed := initGlobalMaxAllowed()
 	// CappingPostProcessor, should always come in the last position for post-processing
 	postProcessors = append(postProcessors, routines.NewCappingRecommendationProcessor(globalMaxAllowed))

vertical-pod-autoscaler/pkg/recommender/model/types.go

@@ -81,40 +81,6 @@ func ScaleResource(amount ResourceAmount, factor float64) ResourceAmount {
 	return resourceAmountFromFloat(float64(amount) * factor)
 }
 
-// EnforceCPUMemoryRatio adjusts the CPU or Memory to maintain a fixed ratio in bytes per millicore.
-// If the actual memory per millicore is too low, memory is increased.
-// If it is too high, CPU is increased.
-func EnforceCPUMemoryRatio(resources apiv1.ResourceList, ratioBytesPerMillicore *float64) apiv1.ResourceList {
-	if ratioBytesPerMillicore == nil || *ratioBytesPerMillicore <= 0 {
-		// No ratio specified or invalid ratio, nothing to do
-		return resources
-	}
-
-	cpuQty, hasCPU := resources[apiv1.ResourceCPU]
-	memQty, hasMem := resources[apiv1.ResourceMemory]
-
-	if !hasCPU || !hasMem || cpuQty.IsZero() || memQty.IsZero() {
-		return resources
-	}
-
-	cpuMilli := float64(cpuQty.MilliValue())
-	memBytes := float64(memQty.Value())
-
-	currentRatio := memBytes / cpuMilli
-
-	if currentRatio < *ratioBytesPerMillicore {
-		// Not enough RAM for the given CPU → increase memory
-		desiredMem := cpuMilli * *ratioBytesPerMillicore
-		resources[apiv1.ResourceMemory] = *resource.NewQuantity(int64(desiredMem), resource.BinarySI)
-	} else if currentRatio > *ratioBytesPerMillicore {
-		// Too much RAM for the given CPU → increase CPU
-		desiredCPU := memBytes / *ratioBytesPerMillicore
-		resources[apiv1.ResourceCPU] = *resource.NewMilliQuantity(int64(desiredCPU), resource.DecimalSI)
-	}
-
-	return resources
-}
-
 // ResourcesAsResourceList converts internal Resources representation to ResourcesList.
 func ResourcesAsResourceList(resources Resources, humanizeMemory bool, roundCPUMillicores, roundMemoryBytes int) apiv1.ResourceList {
 	result := make(apiv1.ResourceList)

vertical-pod-autoscaler/pkg/recommender/model/types_test.go

@@ -758,100 +758,3 @@ func TestResourceAmountFromFloat(t *testing.T) {
 		})
 	}
 }
-
-type EnforceCPUMemoryRatioTestCase struct {
-	name     string
-	input    apiv1.ResourceList
-	ratio    *float64
-	expected apiv1.ResourceList
-}
-
-func TestEnforceCPUMemoryRatio2(t *testing.T) {
-	// 1 CPU -> 4 GiB  => bytes per millicore
-	ratio4GiBPerCore := float64(4*1024*1024*1024) / 1000.0 // 4_294_967.296
-
-	tc := []EnforceCPUMemoryRatioTestCase{
-		{
-			name: "no ratio provided",
-			input: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1000, resource.DecimalSI),
-				apiv1.ResourceMemory: *resource.NewQuantity(4*1024*1024*1024, resource.BinarySI),
-			},
-			ratio: nil,
-			expected: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1000, resource.DecimalSI),
-				apiv1.ResourceMemory: *resource.NewQuantity(4*1024*1024*1024, resource.BinarySI),
-			},
-		},
-		{
-			name: "valid ratio already respected",
-			input: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(2000, resource.DecimalSI),       // 2 cores
-				apiv1.ResourceMemory: *resource.NewQuantity(8*1024*1024*1024, resource.BinarySI), // 8Gi
-			},
-			ratio: float64Ptr(ratio4GiBPerCore),
-			expected: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(2000, resource.DecimalSI),
-				apiv1.ResourceMemory: *resource.NewQuantity(8*1024*1024*1024, resource.BinarySI),
-			},
-		},
-		{
-			name: "too much RAM, should increase CPU",
-			input: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(1000, resource.DecimalSI),       // 1 core
-				apiv1.ResourceMemory: *resource.NewQuantity(8*1024*1024*1024, resource.BinarySI), // 8Gi
-			},
-			ratio: float64Ptr(ratio4GiBPerCore),
-			expected: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(2000, resource.DecimalSI), // 8Gi / 4 = 2 cores
-				apiv1.ResourceMemory: *resource.NewQuantity(8*1024*1024*1024, resource.BinarySI),
-			},
-		},
-		{
-			name: "not enough RAM, should increase RAM",
-			input: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(4000, resource.DecimalSI),       // 4 cores
-				apiv1.ResourceMemory: *resource.NewQuantity(8*1024*1024*1024, resource.BinarySI), // 8Gi
-			},
-			ratio: float64Ptr(ratio4GiBPerCore),
-			expected: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(4000, resource.DecimalSI),
-				apiv1.ResourceMemory: *resource.NewQuantity(16*1024*1024*1024, resource.BinarySI), // 4 cores * 4 = 16Gi
-			},
-		},
-		{
-			name: "missing memory, no-op",
-			input: apiv1.ResourceList{
-				apiv1.ResourceCPU: *resource.NewMilliQuantity(1000, resource.DecimalSI),
-			},
-			ratio: float64Ptr(ratio4GiBPerCore),
-			expected: apiv1.ResourceList{
-				apiv1.ResourceCPU: *resource.NewMilliQuantity(1000, resource.DecimalSI),
-			},
-		},
-		{
-			name: "zero values, no-op",
-			input: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(0, resource.DecimalSI),
-				apiv1.ResourceMemory: *resource.NewQuantity(0, resource.BinarySI),
-			},
-			ratio: float64Ptr(ratio4GiBPerCore),
-			expected: apiv1.ResourceList{
-				apiv1.ResourceCPU:    *resource.NewMilliQuantity(0, resource.DecimalSI),
-				apiv1.ResourceMemory: *resource.NewQuantity(0, resource.BinarySI),
-			},
-		},
-	}
-
-	for _, tc := range tc {
-		t.Run(tc.name, func(t *testing.T) {
-			result := EnforceCPUMemoryRatio(tc.input.DeepCopy(), tc.ratio)
-			assert.Equal(t, tc.expected[apiv1.ResourceCPU], result[apiv1.ResourceCPU])
-			assert.Equal(t, tc.expected[apiv1.ResourceMemory], result[apiv1.ResourceMemory])
-		})
-	}
-}
-
-func float64Ptr(v float64) *float64 {
-	return &v
-}

vertical-pod-autoscaler/pkg/recommender/routines/memory_per_cpu_post_processor.go

@@ -0,0 +1,103 @@
+/*
+Copyright 2022 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package routines
+
+import (
+	apiv1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+
+	vpa_types "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/apis/autoscaling.k8s.io/v1"
+	vpa_utils "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/vpa"
+)
+
+// MemoryPerCPUPostProcessor enforces a fixed memory-per-CPU ratio for each container's recommendation.
+// The ratio is defined in the container's policy as MemoryPerCPU (bytes per 1 CPU core).
+// Applied to Target, LowerBound, UpperBound, and UncappedTarget.
+type MemoryPerCPUPostProcessor struct{}
+
+var _ RecommendationPostProcessor = &MemoryPerCPUPostProcessor{}
+
+// Process applies the memory-per-CPU enforcement to the recommendation if specified in the container policy.
+func (p *MemoryPerCPUPostProcessor) Process(
+	vpa *vpa_types.VerticalPodAutoscaler,
+	recommendation *vpa_types.RecommendedPodResources,
+) *vpa_types.RecommendedPodResources {
+	if vpa == nil || vpa.Spec.ResourcePolicy == nil || recommendation == nil {
+		return recommendation
+	}
+
+	amendedRecommendation := recommendation.DeepCopy()
+
+	for _, r := range amendedRecommendation.ContainerRecommendations {
+		pol := vpa_utils.GetContainerResourcePolicy(r.ContainerName, vpa.Spec.ResourcePolicy)
+		if pol != nil && pol.MemoryPerCPU != nil {
+			memPerCPUBytes := pol.MemoryPerCPU.Value()
+			r.Target = enforceMemoryPerCPU(r.Target, memPerCPUBytes)
+			r.LowerBound = enforceMemoryPerCPU(r.LowerBound, memPerCPUBytes)
+			r.UpperBound = enforceMemoryPerCPU(r.UpperBound, memPerCPUBytes)
+			r.UncappedTarget = enforceMemoryPerCPU(r.UncappedTarget, memPerCPUBytes)
+		}
+	}
+
+	return amendedRecommendation
+}
+
+// enforceMemoryPerCPU adjusts CPU or Memory to satisfy:
+//
+//	memory_bytes = cpu_cores * memPerCPUBytes
+//
+// If memory is too low for the given CPU, increase memory.
+// If memory is too high for the given CPU, increase CPU.
+// enforceMemoryPerCPU adjusts CPU or Memory to satisfy:
+//
+//	memory_bytes = cpu_cores * memPerCPUBytes
+//
+// If memory is too low for the given CPU, increase memory.
+// If memory is too high for the given CPU, increase CPU.
+func enforceMemoryPerCPU(resources apiv1.ResourceList, bytesPerCore int64) apiv1.ResourceList {
+	if bytesPerCore <= 0 {
+		return resources
+	}
+
+	cpuQty, hasCPU := resources[apiv1.ResourceCPU]
+	memQty, hasMem := resources[apiv1.ResourceMemory]
+	if !hasCPU || !hasMem || cpuQty.IsZero() || memQty.IsZero() {
+		return resources
+	}
+
+	// cpuCores = milliCPU / 1000
+	cpuMilli := cpuQty.MilliValue()
+	memBytes := memQty.Value()
+
+	// Desired memory in bytes = CPU cores * bytes per core
+	desiredMem := divCeil(cpuMilli*bytesPerCore, 1000)
+
+	if memBytes < desiredMem {
+		// Not enough RAM → increase memory
+		resources[apiv1.ResourceMemory] = *resource.NewQuantity(desiredMem, resource.BinarySI)
+	} else if memBytes > desiredMem {
+		// Too much RAM → increase CPU
+		desiredMilli := divCeil(memBytes*1000, bytesPerCore)
+		resources[apiv1.ResourceCPU] = *resource.NewMilliQuantity(desiredMilli, resource.DecimalSI)
+	}
+
+	return resources
+}
+
+func divCeil(a, b int64) int64 {
+	return (a + b - 1) / b
+}