✨ add min/max and additional annotations

modified:   README.md; modified:   controllers/pod_controller.go; modified:   controllers/pod_controller_functions.go; modified:   controllers/pod_controller_types.go

Author: amitai-devops

README.md

@@ -35,10 +35,12 @@ logLevel: info
 
     Enable a annotation filter for pod scraping. 
     Enabling this will ensure that the controller 
-    only sets requests of controllers of which PODS or NAMESPACE have the annotation. 
-    If false, will work on all pods in the cluster.
+    only sets requests of controllers of which PODS or NAMESPACE 
+    have the annotation set to "true".
+    If "false", will ignore annotations and work on all pods in the cluster.
 
     # auto.request.operator/optimize=true
+    # auto.request.operator/optimize=false
 
 --sample-size int (default 1)
 
@@ -69,10 +71,22 @@ logLevel: info
     Minimum memory in (Mi) that the controller can set a pod request to. 0 is infinite
 ```
 
-Disclaimer: 
+### Annotations 
+*If **annotation-filter** is **true**:*
+```
+auto.request.operator/optimize=true  # Optimize Pod/Namespace
+auto.request.operator/optimize=false # Ignore Pod/Namespace
+```
+These are available POD/Namespace annotations *Regardless of **annotation-filter**:*
+```
+auto.request.operator/optimize=false # Ignore Pod/Namespace when optimizing entire cluster
+auto.request.operator/mode=average   # Default Mode. Optimizes based on average. If ommited, mode is average
+auto.request.operator/mode=max       # Sets the request to the MAXIMUM of all sample points
+auto.request.operator/mode=min       # Sets the request to the MINIMUM of all sample points
+```
+### Disclaimer
 
 `sample-size` is the amount of data-points the controller will store in cache before constructing an average for the pod. After a requests resizing, the cache will clean itself and a new average will be calculated based on the sample size. If `min-seconds` has not yet passed since the pod has last been supposed to be sample-reconciled, the controller will keep sampling the pod until `min-seconds` have been reached and only then zero the sample and restart from cache.
-
 ## Limitations
 
 - Does not work with CRD controllers (such as Argo Rollouts)

controllers/pod_controller.go

@@ -19,6 +19,7 @@ package controllers
 import (
 	"context"
 	"fmt"
+	"math"
 	"time"
 
 	corev1 "k8s.io/api/core/v1"
@@ -34,7 +35,8 @@ import (
 // +kubebuilder:rbac:groups=core,resources=pods,verbs=get;list;watch;update;patch
 
 const (
-	operatorAnnotation = "auto.request.operator/optimize"
+	operatorAnnotation     = "auto.request.operator/optimize"
+	operatorModeAnnotation = "auto.request.operator/mode"
 )
 
 func cacheKeyFunc(obj interface{}) (string, error) {
@@ -68,8 +70,13 @@ func (r *PodReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.R
 		log.Error(err, "failed to get annotations")
 		return ctrl.Result{}, err
 	}
+	ignoreAnnotation, err := r.NamespaceOrPodHaveIgnoreAnnotation(pod, ctx)
+	if err != nil {
+		log.Error(err, "failed to get annotations")
+		return ctrl.Result{}, err
+	}
 
-	if (!r.EnableAnnotation) || (r.EnableAnnotation && annotation) {
+	if (!r.EnableAnnotation && !ignoreAnnotation) || (r.EnableAnnotation && annotation && !ignoreAnnotation) {
 
 		data, err := r.ClientSet.RESTClient().Get().AbsPath(fmt.Sprintf("apis/metrics.k8s.io/v1beta1/namespaces/%v/pods/%v", pod.Namespace, pod.Name)).DoRaw(ctx)
 
@@ -105,6 +112,10 @@ func (r *PodReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.R
 					for _, latestC := range LatestPodRequest.ContainerRequests {
 						if latestC.Name == sumC.Name {
 							sumCAddr := &sumC
+							sumCAddr.MaxCPU = int64(math.Max(float64(sumCAddr.MaxCPU), float64(latestC.CPU)))
+							sumCAddr.MaxMemory = int64(math.Max(float64(sumCAddr.MaxMemory), float64(latestC.Memory)))
+							sumCAddr.MinCPU = int64(math.Min(float64(sumCAddr.MinCPU), float64(latestC.CPU)))
+							sumCAddr.MinMemory = int64(math.Min(float64(sumCAddr.MinMemory), float64(latestC.Memory)))
 							sumCAddr.CPU += latestC.CPU
 							sumCAddr.Memory += latestC.Memory
 						}
@@ -140,15 +151,29 @@ func (r *PodReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.R
 								// if AverageUsageCPU < currentC.CPU {
 								if r.ValidateCPU(currentC.CPU, AverageUsageCPU) {
 									if pod.Spec.Containers[i].Resources.Requests != nil {
-										pod.Spec.Containers[i].Resources.Requests[v1.ResourceCPU] = resource.MustParse(fmt.Sprintf("%dm", AverageUsageCPU))
+										switch r.GetPodMode(pod, ctx) {
+										case "average":
+											pod.Spec.Containers[i].Resources.Requests[v1.ResourceCPU] = resource.MustParse(fmt.Sprintf("%dm", AverageUsageCPU))
+										case "min":
+											pod.Spec.Containers[i].Resources.Requests[v1.ResourceCPU] = resource.MustParse(fmt.Sprintf("%dm", c.MinCPU))
+										case "max":
+											pod.Spec.Containers[i].Resources.Requests[v1.ResourceCPU] = resource.MustParse(fmt.Sprintf("%dm", c.MaxCPU))
+										}
 										PodChange = true
 									}
 								}
 								// }
 								if r.ValidateMemory(currentC.Memory, AverageUsageMemory) {
 									if AverageUsageMemory > 0 {
 										if pod.Spec.Containers[i].Resources.Requests != nil {
-											pod.Spec.Containers[i].Resources.Requests[v1.ResourceMemory] = resource.MustParse(fmt.Sprintf("%dMi", AverageUsageMemory))
+											switch r.GetPodMode(pod, ctx) {
+											case "average":
+												pod.Spec.Containers[i].Resources.Requests[v1.ResourceCPU] = resource.MustParse(fmt.Sprintf("%dm", AverageUsageMemory))
+											case "min":
+												pod.Spec.Containers[i].Resources.Requests[v1.ResourceCPU] = resource.MustParse(fmt.Sprintf("%dm", c.MinMemory))
+											case "max":
+												pod.Spec.Containers[i].Resources.Requests[v1.ResourceCPU] = resource.MustParse(fmt.Sprintf("%dm", c.MaxMemory))
+											}
 											PodChange = true
 										}
 									}

controllers/pod_controller_functions.go

@@ -30,6 +30,39 @@ func (r *PodReconciler) NamespaceOrPodHaveAnnotation(pod corev1.Pod, ctx context
 	return (podHasAnnotation || namespaceHasAnnotation), nil
 }
 
+func (r *PodReconciler) NamespaceOrPodHaveIgnoreAnnotation(pod corev1.Pod, ctx context.Context) (bool, error) {
+	podHasIgnoreAnnotation := pod.Annotations[operatorAnnotation] == "false"
+	namespace, err := r.ClientSet.CoreV1().Namespaces().Get(ctx, pod.Namespace, metav1.GetOptions{})
+	if err != nil {
+		return false, err
+	}
+	namespaceHasIgnoreAnnotation := namespace.Annotations[operatorAnnotation] == "false"
+	return (namespaceHasIgnoreAnnotation) && (podHasIgnoreAnnotation), nil
+}
+
+func (r *PodReconciler) GetPodMode(pod corev1.Pod, ctx context.Context) string {
+	podHasAverage := pod.Annotations[operatorModeAnnotation] == "average"
+	podHasMin := pod.Annotations[operatorModeAnnotation] == "min"
+	podHasMax := pod.Annotations[operatorModeAnnotation] == "max"
+	namespace, err := r.ClientSet.CoreV1().Namespaces().Get(ctx, pod.Namespace, metav1.GetOptions{})
+	if err != nil {
+		return "average"
+	}
+	namespaceHasAverage := namespace.Annotations[operatorModeAnnotation] == "average"
+	namespaceHasMin := namespace.Annotations[operatorModeAnnotation] == "min"
+	namespaceHasMax := namespace.Annotations[operatorModeAnnotation] == "max"
+	if podHasAverage || namespaceHasAverage {
+		return "average"
+	}
+	if (podHasMax || namespaceHasMax) && !(podHasMin || namespaceHasMin) {
+		return "max"
+	}
+	if (podHasMin || namespaceHasMin) && !(podHasMax || namespaceHasMax) {
+		return "max"
+	}
+	return "average"
+}
+
 func (r *PodReconciler) UpdateKubeObject(pod client.Object, ctx context.Context) (ctrl.Result, error) {
 	if err := r.Update(ctx, pod); err != nil {
 		if apierrors.IsConflict(err) {

controllers/pod_controller_types.go

@@ -37,9 +37,13 @@ type PodRequests struct {
 }
 
 type ContainerRequests struct {
-	Name   string
-	CPU    int64 // Nanocores
-	Memory int64 // Mi
+	Name      string
+	CPU       int64 // Nanocores
+	MaxCPU    int64
+	MinCPU    int64
+	Memory    int64 // Mi
+	MaxMemory int64
+	MinMemory int64
 }
 
 type NewContainerRequests struct {