Merge pull request #160 from samuel-esp/feat/pdb-with-percentage

Feat: Scale PodDisruptionBudgets With Percentage Values

Author: samuel-esp

README.md

@@ -617,11 +617,21 @@ The feature to scale DaemonSets can be very useful for reducing the base occupan
 
 The feature to scale PodDisruptionBudgets can be useful to relax availability constraints on workloads. If enabled, the PodDisruptionBudget algorithm works like this:
 
-1. Downtime Hours: Kube Downscaler will bring `minAvailable` and `maxUnavailable` to 0
+1. Downtime Hours: Kube Downscaler will bring `minAvailable` and `maxUnavailable` to downtime replicas value
 2. Uptime Hours: Kube Downscaler will bring back `minAvailable` and `maxUnavailable` to their original value
 
-**Important**: Kube Downscaler, actually, cannot process values written in percentages. Resources with `minAvailable` or `maxUnavailable` written as percentages will be automatically excluded from scaling
+**Percentage Values**: Kube Downscaler can process PodDisruptionBudgets with `minAvailable` or `maxUnavailable`. In this case, during downtime hours, the following behavior applies:
+  1. The `downscaler/original-replicas` annotation will store the original percentage value (e.g., "75%") as a string. 
+  2. The `minAvailable`/`maxUnavailable` field of the object will be updated to the target downtime replicas value (e.g., 0) as an integer.
 
+The original percentage value in the `minAvailable`/`maxUnavailable` field will be restored once the downtime hours end
+
+**Downtime Replicas**: Kube Downscaler can process downtime replicas specified as a percentage. The behavior will be the following:
+  - If `--include-resources` only scales PodDisruptionBudgets, the value assigned to downtime replicas can be set as a percentage inside the global argument value `--downtime-replicas` or as a namespace/workload
+annotation `downscaler/donwtime-replicas` (e.g. `--donwtime-replicas="20%"` or `downscaler/donwtime-replicas: "10%"`)
+  - If `--include-resources` scales PodDisruptionBudgets and other resources, using a percentage value inside the global argument value `--downtime-replicas` or as a namespace
+annotation `downscaler/donwtime-replicas` will result in all other resources under its scope being ignored (e.g. if you set `--downtime-replicas="10%"` all resources inside the cluster other than PodDisruptionBudgets will be ignored,
+if you set `downscaler/donwtime-replicas: "10%"` at namespace level, all resources other than PodDisruptionBudgets in that namespace will be ignored)
 ### Scaling ScaledObjects
 
 The ability to downscale ScaledObjects is very useful for workloads that use Keda to support

kube_downscaler/cmd.py

@@ -111,9 +111,9 @@ def get_parser():
     )
     parser.add_argument(
         "--downtime-replicas",
-        type=int,
-        help="Default amount of replicas when downscaling (default: 0)",
-        default=int(os.getenv("DOWNTIME_REPLICAS", 0)),
+        type=str,
+        help="Default value used when downscaling (default: '0')",
+        default=os.getenv("DOWNTIME_REPLICAS", "0"),
     )
     parser.add_argument(
         "--deployment-time-annotation",

kube_downscaler/helper.py

@@ -71,6 +71,30 @@ def get_kube_api(timeout: int):
     return api
 
 
+def parse_int_or_percent(value, context, allow_negative):
+    s = str(value).strip()
+
+    if s.endswith("%"):
+        number_part = s[:-1].strip()
+        if number_part.isdigit():
+            val = int(number_part)
+            if 0 <= val <= 100:
+                return val, True
+            else:
+                raise ValueError(f"Percentage in {context} must be between 0 and 100.")
+        else:
+            raise ValueError(f"Invalid percentage format in {context}: must be digits before '%'.")
+
+    if allow_negative:
+        if (s.startswith("-") and s[1:].isdigit()) or s.isdigit():
+            return int(s), False
+    else:
+        if s.isdigit():
+            return int(s), False
+
+    raise ValueError(f"Invalid format for {context}: must be an integer like '10' or a percentage like '10%'.")
+
+
 def add_event(resource, message: str, reason: str, event_type: str, dry_run: bool):
     event = (
         pykube.objects.Event.objects(resource.api)

kube_downscaler/main.py

@@ -7,10 +7,15 @@
 from kube_downscaler import cmd
 from kube_downscaler import shutdown
 from kube_downscaler.scaler import scale
+from kube_downscaler import helper
 
 logger = logging.getLogger("downscaler")
 
 
+def parse_downtime_replicas(downtime_replicas):
+    value, is_percentage = helper.parse_int_or_percent(downtime_replicas, context="--downtime-replicas", allow_negative=False)
+    return value, is_percentage
+
 def main(args=None):
     parser = cmd.get_parser()
     args = parser.parse_args(args)
@@ -87,6 +92,8 @@ def run_loop(
     else:
         constrained_downscaler = False
 
+    downtime_replicas, is_downtime_replicas_percentage = parse_downtime_replicas(downtime_replicas)
+
     while True:
         try:
             scale(
@@ -108,6 +115,7 @@ def run_loop(
                 api_server_timeout=api_server_timeout,
                 max_retries_on_conflict=max_retries_on_conflict,
                 downtime_replicas=downtime_replicas,
+                is_downtime_replicas_percentage=is_downtime_replicas_percentage,
                 deployment_time_annotation=deployment_time_annotation,
                 enable_events=enable_events,
                 matching_labels=frozenset(