created a base function to compute resources

Author: sanderegg

packages/service-library/src/servicelib/docker_utils.py

@@ -326,3 +326,33 @@ async def _pull_image_with_retry() -> None:
                 )
 
         await _pull_image_with_retry()
+
+
+_CPUS_SAFE_MARGIN: Final[float] = (
+    1.4  # accounts for machine overhead (ops + sidecar itself)
+)
+_MACHINE_TOTAL_RAM_SAFE_MARGIN_RATIO: Final[float] = (
+    0.1  # NOTE: machines always have less available RAM than advertised
+)
+_SIDECARS_OPS_SAFE_RAM_MARGIN: Final[ByteSize] = TypeAdapter(ByteSize).validate_python(
+    "1GiB"
+)
+DYNAMIC_SIDECAR_MIN_CPUS: Final[float] = 0.5
+
+
+def estimate_dynamic_sidecar_resources_from_ec2_instance(
+    cpus: float, ram: int
+) -> tuple[float, int]:
+    """Estimates the resources available to a dynamic-sidecar running in an EC2 instance,
+    taking into account safe margins for CPU and RAM, as the EC2 full resources are not completely visible
+
+    Returns:
+        tuple: Estimated resources for the dynamic-sidecar (cpus, ram).
+    """
+    # dynamic-sidecar usually needs less CPU
+    sidecar_cpus = max(DYNAMIC_SIDECAR_MIN_CPUS, cpus - _CPUS_SAFE_MARGIN)
+    sidecar_ram = int(
+        ram - _MACHINE_TOTAL_RAM_SAFE_MARGIN_RATIO * ram - _SIDECARS_OPS_SAFE_RAM_MARGIN
+    )
+
+    return (sidecar_cpus, sidecar_ram)

services/autoscaling/src/simcore_service_autoscaling/modules/cluster_scaling/_provider_dynamic.py

@@ -1,28 +1,19 @@
 import dataclasses
-from typing import Final
 
 from aws_library.ec2 import EC2InstanceData, EC2Tags, Resources
 from aws_library.ec2._models import EC2InstanceType
 from fastapi import FastAPI
 from models_library.docker import DockerLabelKey
 from models_library.generated_models.docker_rest_api import Node, Task
-from pydantic import ByteSize, TypeAdapter
+from pydantic import ByteSize
+from servicelib.docker_utils import estimate_dynamic_sidecar_resources_from_ec2_instance
 from types_aiobotocore_ec2.literals import InstanceTypeType
 
 from ...core.settings import get_application_settings
 from ...models import AssociatedInstance
 from ...utils import utils_docker, utils_ec2
 from ..docker import get_docker_client
 
-_MACHINE_TOTAL_RAM_SAFE_MARGIN_RATIO: Final[float] = (
-    0.1  # NOTE: machines always have less available RAM than advertised
-)
-_SIDECARS_OPS_SAFE_RAM_MARGIN: Final[ByteSize] = TypeAdapter(ByteSize).validate_python(
-    "1GiB"
-)
-_CPUS_SAFE_MARGIN: Final[float] = 1.4
-_MIN_NUM_CPUS: Final[float] = 0.5
-
 
 class DynamicAutoscalingProvider:
     async def get_monitored_nodes(self, app: FastAPI) -> list[Node]:
@@ -132,13 +123,12 @@ def adjust_instance_type_resources(
     ) -> EC2InstanceType:
         assert self  # nosec
         assert app  # nosec
-        # nothing to do at the moment
-        adjusted_cpus = float(instance_type.resources.cpus) - _CPUS_SAFE_MARGIN
-        adjusted_ram = int(
-            instance_type.resources.ram
-            - _MACHINE_TOTAL_RAM_SAFE_MARGIN_RATIO * instance_type.resources.ram
-            - _SIDECARS_OPS_SAFE_RAM_MARGIN
+        adjusted_cpus, adjusted_ram = (
+            estimate_dynamic_sidecar_resources_from_ec2_instance(
+                instance_type.resources.cpus, instance_type.resources.ram
+            )
         )
+
         return dataclasses.replace(
             instance_type,
             resources=instance_type.resources.model_copy(

services/web/server/src/simcore_service_webserver/projects/_projects_service.py

@@ -88,6 +88,10 @@
     X_FORWARDED_PROTO,
     X_SIMCORE_USER_AGENT,
 )
+from servicelib.docker_utils import (
+    DYNAMIC_SIDECAR_MIN_CPUS,
+    estimate_dynamic_sidecar_resources_from_ec2_instance,
+)
 from servicelib.logging_utils import log_context
 from servicelib.rabbitmq import RemoteMethodNotRegisteredError, RPCServerError
 from servicelib.rabbitmq.rpc_interfaces.catalog import services as catalog_rpc
@@ -652,12 +656,12 @@ def _by_type_name(ec2: EC2InstanceTypeGet) -> bool:
             app, user_id, project_id, node_id, service_key, service_version
         )
         scalable_service_name = DEFAULT_SINGLE_SERVICE_NAME
-        new_cpus_value = float(selected_ec2_instance_type.cpus) - _CPUS_SAFE_MARGIN
-        new_ram_value = int(
-            selected_ec2_instance_type.ram
-            - _MACHINE_TOTAL_RAM_SAFE_MARGIN_RATIO * selected_ec2_instance_type.ram
-            - _SIDECARS_OPS_SAFE_RAM_MARGIN
+        new_cpus_value, new_ram_value = (
+            estimate_dynamic_sidecar_resources_from_ec2_instance(
+                selected_ec2_instance_type.cpus, selected_ec2_instance_type.ram
+            )
         )
+
         if DEFAULT_SINGLE_SERVICE_NAME not in node_resources:
             # NOTE: we go for the largest sub-service and scale it up/down
             scalable_service_name, hungry_service_resources = max(
@@ -680,17 +684,14 @@ def _by_type_name(ec2: EC2InstanceTypeGet) -> bool:
                         }
                     )
             new_cpus_value = max(
-                float(selected_ec2_instance_type.cpus)
-                - _CPUS_SAFE_MARGIN
-                - other_services_resources["CPU"],
-                _MIN_NUM_CPUS,
+                new_cpus_value - other_services_resources["CPU"],
+                DYNAMIC_SIDECAR_MIN_CPUS,
             )
-            new_ram_value = int(
-                selected_ec2_instance_type.ram
-                - _MACHINE_TOTAL_RAM_SAFE_MARGIN_RATIO * selected_ec2_instance_type.ram
-                - other_services_resources["RAM"]
-                - _SIDECARS_OPS_SAFE_RAM_MARGIN
+
+            new_ram_value = max(
+                int(new_ram_value - other_services_resources["RAM"]), 128 * 1024 * 1024
             )
+
         # scale the service
         node_resources[scalable_service_name].resources["CPU"].set_value(new_cpus_value)
         node_resources[scalable_service_name].resources["RAM"].set_value(new_ram_value)