recommendation post processor for integer CPU

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

@@ -67,6 +67,12 @@ var (
  cpuHistogramDecayHalfLife = flag.Duration("cpu-histogram-decay-half-life", model.DefaultCPUHistogramDecayHalfLife, `The amount of time it takes a historical CPU usage sample to lose half of its weight.`)
 )
 
+// Post processors flags
+var (
+ // CPU as integer to benefit for CPU management Static Policy ( https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/#static-policy )
+ postProcessorCPUasInteger = flag.Bool("cpu-integer-post-processor-enabled", false, "Enable the cpu-integer recommendation post processor. Only containers that specify it can have their CPU recommendation rounded up to an integer value.")
+)
+
 func main() {
  klog.InitFlags(nil)
  kube_flag.InitFlags()
@@ -86,6 +92,9 @@ func main() {
  postProcessors := []routines.RecommendationPostProcessor{
  &routines.CappingPostProcessor{},
  }
+ if *postProcessorCPUasInteger {
+ postProcessors = append(postProcessors, &routines.IntegerCPUPostProcessor{})
+ }
  recommender := routines.NewRecommender(config, *checkpointsGCInterval, useCheckpoints, *vpaObjectNamespace, *recommenderName, postProcessors)
 
  promQueryTimeout, err := time.ParseDuration(*queryTimeout)

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

@@ -0,0 +1,89 @@
+/*
+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"
+ vpa_types "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/apis/autoscaling.k8s.io/v1"
+ "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/recommender/model"
+ "math"
+ "strings"
+)
+
+// IntegerCPUPostProcessor ensures that the recommendation delivers an integer value for CPU
+// This is need for users who want to use CPU Management with static policy: https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/#static-policy
+type IntegerCPUPostProcessor struct{}
+
+const (
+ // The user interface for that post processor is an annotation on the VPA object with the following format:
+ // vpa-post-processor.kubernetes.io/{containerName}_integerCPU=true
+ vpaPostProcessorPrefix = "vpa-post-processor.kubernetes.io/"
+ vpaPostProcessorIntegerCPUSuffix = "_integerCPU"
+ vpaPostProcessorIntegerCPUValue = "true"
+)
+
+var _ RecommendationPostProcessor = &IntegerCPUPostProcessor{}
+
+// Process apply the capping post-processing to the recommendation.
+// For this post processor the CPU value is rounded up to an integer
+func (p *IntegerCPUPostProcessor) Process(vpa *model.Vpa, recommendation *vpa_types.RecommendedPodResources, policy *vpa_types.PodResourcePolicy) *vpa_types.RecommendedPodResources {
+
+ amendedRecommendation := recommendation.DeepCopy()
+
+ process := func(recommendation apiv1.ResourceList) {
+ for resourceName, recommended := range recommendation {
+ if resourceName != apiv1.ResourceCPU {
+ continue
+ }
+ v := float64(recommended.MilliValue()) / 1000
+ r := int64(math.Ceil(v))
+ recommended.Set(r)
+ recommendation[resourceName] = recommended
+ }
+ }
+
+ for key, value := range vpa.Annotations {
+ containerName := extractContainerName(key, vpaPostProcessorPrefix, vpaPostProcessorIntegerCPUSuffix)
+ if containerName == "" || value != vpaPostProcessorIntegerCPUValue {
+ continue
+ }
+
+ for _, r := range amendedRecommendation.ContainerRecommendations {
+ if r.ContainerName != containerName {
+ continue
+ }
+ process(r.Target)
+ process(r.LowerBound)
+ process(r.UpperBound)
+ process(r.UncappedTarget)
+ }
+ }
+ return amendedRecommendation
+}
+
+// extractContainerName return the container name for the feature based on annotation key
+// if the returned value is empty that means that the key does not match
+func extractContainerName(key, prefix, suffix string) string {
+ if !strings.HasPrefix(key, prefix) {
+ return ""
+ }
+ if !strings.HasSuffix(key, suffix) {
+ return ""
+ }
+
+ return key[len(prefix) : len(key)-len(suffix)]
+}

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

@@ -0,0 +1,160 @@
+/*
+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 (
+ "github.com/stretchr/testify/assert"
+ v1 "k8s.io/api/core/v1"
+ vpa_types "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/apis/autoscaling.k8s.io/v1"
+ "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/recommender/model"
+ "k8s.io/autoscaler/vertical-pod-autoscaler/pkg/utils/test"
+ "testing"
+)
+
+func Test_extractContainerName(t *testing.T) {
+ tests := []struct {
+ name string
+ key string
+ prefix string
+ suffix string
+ want string
+ }{
+ {
+ name: "empty",
+ key: "",
+ prefix: "",
+ suffix: "",
+ want: "",
+ },
+ {
+ name: "no match",
+ key: "abc",
+ prefix: "z",
+ suffix: "x",
+ want: "",
+ },
+ {
+ name: "match",
+ key: "abc",
+ prefix: "a",
+ suffix: "c",
+ want: "b",
+ },
+ {
+ name: "real",
+ key: vpaPostProcessorPrefix + "kafka" + vpaPostProcessorIntegerCPUSuffix,
+ prefix: vpaPostProcessorPrefix,
+ suffix: vpaPostProcessorIntegerCPUSuffix,
+ want: "kafka",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ assert.Equalf(t, tt.want, extractContainerName(tt.key, tt.prefix, tt.suffix), "extractContainerName(%v, %v, %v)", tt.key, tt.prefix, tt.suffix)
+ })
+ }
+}
+
+func Test_integerCPUPostProcessor_Process(t *testing.T) {
+ tests := []struct {
+ name string
+ vpa *model.Vpa
+ recommendation *vpa_types.RecommendedPodResources
+ want *vpa_types.RecommendedPodResources
+ }{
+ {
+ name: "No containers match",
+ vpa: &model.Vpa{Annotations: map[string]string{
+ vpaPostProcessorPrefix + "container-other" + vpaPostProcessorIntegerCPUSuffix: "true",
+ }},
+ recommendation: &vpa_types.RecommendedPodResources{
+ ContainerRecommendations: []vpa_types.RecommendedContainerResources{
+ test.Recommendation().WithContainer("container1").WithTarget("8.6", "200Mi").GetContainerResources(),
+ test.Recommendation().WithContainer("container2").WithTarget("8.2", "300Mi").GetContainerResources(),
+ },
+ },
+ want: &vpa_types.RecommendedPodResources{
+ ContainerRecommendations: []vpa_types.RecommendedContainerResources{
+ test.Recommendation().WithContainer("container1").WithTarget("8.6", "200Mi").GetContainerResources(),
+ test.Recommendation().WithContainer("container2").WithTarget("8.2", "300Mi").GetContainerResources(),
+ },
+ },
+ },
+ {
+ name: "2 containers, 1 matching only",
+ vpa: &model.Vpa{Annotations: map[string]string{
+ vpaPostProcessorPrefix + "container1" + vpaPostProcessorIntegerCPUSuffix: "true",
+ }},
+ recommendation: &vpa_types.RecommendedPodResources{
+ ContainerRecommendations: []vpa_types.RecommendedContainerResources{
+ test.Recommendation().WithContainer("container1").WithTarget("8.6", "200Mi").GetContainerResources(),
+ test.Recommendation().WithContainer("container2").WithTarget("8.2", "300Mi").GetContainerResources(),
+ },
+ },
+ want: &vpa_types.RecommendedPodResources{
+ ContainerRecommendations: []vpa_types.RecommendedContainerResources{
+ test.Recommendation().WithContainer("container1").WithTarget("9", "200Mi").GetContainerResources(),
+ test.Recommendation().WithContainer("container2").WithTarget("8.2", "300Mi").GetContainerResources(),
+ },
+ },
+ },
+ {
+ name: "2 containers, 2 matching",
+ vpa: &model.Vpa{Annotations: map[string]string{
+ vpaPostProcessorPrefix + "container1" + vpaPostProcessorIntegerCPUSuffix: "true",
+ vpaPostProcessorPrefix + "container2" + vpaPostProcessorIntegerCPUSuffix: "true",
+ }},
+ recommendation: &vpa_types.RecommendedPodResources{
+ ContainerRecommendations: []vpa_types.RecommendedContainerResources{
+ test.Recommendation().WithContainer("container1").WithTarget("8.6", "200Mi").GetContainerResources(),
+ test.Recommendation().WithContainer("container2").WithTarget("5.2", "300Mi").GetContainerResources(),
+ },
+ },
+ want: &vpa_types.RecommendedPodResources{
+ ContainerRecommendations: []vpa_types.RecommendedContainerResources{
+ test.Recommendation().WithContainer("container1").WithTarget("9", "200Mi").GetContainerResources(),
+ test.Recommendation().WithContainer("container2").WithTarget("6", "300Mi").GetContainerResources(),
+ },
+ },
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ c := IntegerCPUPostProcessor{}
+ got := c.Process(tt.vpa, tt.recommendation, nil)
+ assert.Equalf(t, reScale3(tt.want), reScale3(got), "Process(%v, %v, nil)", tt.vpa, tt.recommendation)
+ })
+ }
+}
+
+func reScale3(recommended *vpa_types.RecommendedPodResources) *vpa_types.RecommendedPodResources {
+
+ scale3 := func(rl v1.ResourceList) {
+ for k, v := range rl {
+ v.SetMilli(v.MilliValue())
+ rl[k] = v
+ }
+ }
+
+ for _, r := range recommended.ContainerRecommendations {
+ scale3(r.LowerBound)
+ scale3(r.Target)
+ scale3(r.UncappedTarget)
+ scale3(r.UpperBound)
+ }
+ return recommended
+}