Add support for autoscaling deployments (#305)

* Add support for autoscaling deployments

* Change deployment autoscaling request schema

* Add autoscaling options to output of the deployments details command

* Add missing help for new options

* Add autoscaling options to deployments update command

Author: BartoszCki

gradient/api_sdk/clients/deployment_client.py

@@ -55,6 +55,7 @@ def create(
             workspace_username=None,
             workspace_password=None,
             project_id=None,
+            autoscaling=None,
     ):
         """
         Method to create a Deployment instance.
@@ -104,6 +105,7 @@ def create(
         :param str workspace_username: Project git repository username
         :param str workspace_password: Project git repository password
         :param str project_id: Project ID
+        :param models.AutoscalingDefinition autoscaling: Deployment autoscaling definition
 
         :returns: Created deployment id
         :rtype: str
@@ -135,6 +137,7 @@ def create(
             workspace_username=workspace_username,
             workspace_password=workspace_password,
             project_id=project_id,
+            autoscaling=autoscaling,
         )
 
         repository = self.build_repository(repositories.CreateDeployment)
@@ -233,6 +236,7 @@ def update(
             workspace_password=None,
             project_id=None,
             command=None,
+            autoscaling=None,
     ):
         deployment = models.Deployment(
             deployment_type=deployment_type,
@@ -261,6 +265,7 @@ def update(
             workspace_password=workspace_password,
             project_id=project_id,
             command=command,
+            autoscaling=autoscaling,
         )
 
         repository = self.build_repository(repositories.UpdateDeployment)

gradient/api_sdk/models/__init__.py

@@ -1,7 +1,7 @@
 from .artifact import Artifact
 from .cluster import Cluster
 from .dataset import Dataset, VolumeOptions
-from .deployment import Deployment
+from .deployment import Deployment, AutoscalingDefinition, AutoscalingMetric
 from .experiment import BaseExperiment, MultiNodeExperiment, SingleNodeExperiment, MpiMultiNodeExperiment
 from .hyperparameter import Hyperparameter
 from .job import Job

gradient/api_sdk/models/deployment.py

@@ -3,6 +3,22 @@
 import attr
 
 
+@attr.s
+class AutoscalingMetric(object):
+    type = attr.ib(type=str)
+    name = attr.ib(type=str)
+    value_type = attr.ib(type=str)
+    value = attr.ib(type=float)
+
+
+@attr.s
+class AutoscalingDefinition(object):
+    min_instance_count = attr.ib(type=int, default=None)
+    max_instance_count = attr.ib(type=int, default=None)
+    scale_cooldown_period = attr.ib(type=int, default=None)
+    metrics = attr.ib(type=list, factory=list)  # instances of AutoscalerMetric
+
+
 @attr.s
 class Deployment(object):
     """
@@ -82,6 +98,7 @@ class Deployment(object):
     workspace_username = attr.ib(type=str, default=None)
     workspace_password = attr.ib(type=str, default=None)
     metrics_url = attr.ib(type=str, default=None)
+    autoscaling = attr.ib(type=AutoscalingDefinition, default=None)
 
     dt_created = attr.ib(type=datetime.datetime, default=None)
     dt_modified = attr.ib(type=datetime.datetime, default=None)

gradient/api_sdk/serializers/base.py

@@ -5,10 +5,10 @@ class BaseSchema(marshmallow.Schema):
     MODEL = None
 
     @marshmallow.post_dump
-    def remove_none_values(self, data):
+    def remove_none_or_empty_values(self, data):
         return {
             key: value for key, value in data.items()
-            if value not in (None, {})
+            if value not in (None, {}, [])
         }
 
     def get_instance(self, obj_dict, many=False):

gradient/api_sdk/serializers/deployment.py

@@ -4,6 +4,24 @@
 from .. import models
 
 
+class AutoscalingMetricSchema(BaseSchema):
+    MODEL = models.AutoscalingMetric
+
+    type = ma.fields.Str()
+    name = ma.fields.Str()
+    value_type = ma.fields.Str(dump_to="valueType", load_from="valueType")
+    value = ma.fields.Float()
+
+
+class AutoscalingDefinitionSchema(BaseSchema):
+    MODEL = models.AutoscalingDefinition
+
+    min_instance_count = ma.fields.Int(dump_to="minInstanceCount", load_from="minInstanceCount")
+    max_instance_count = ma.fields.Int(dump_to="maxInstanceCount", load_from="maxInstanceCount")
+    scale_cooldown_period = ma.fields.Int(dump_to="scaleCooldownPeriod", load_from="scaleCooldownPeriod")
+    metrics = ma.fields.Nested(AutoscalingMetricSchema, many=True, default=None)
+
+
 class DeploymentSchema(BaseSchema):
     MODEL = models.Deployment
 
@@ -46,6 +64,7 @@ class DeploymentSchema(BaseSchema):
     dt_started = ma.fields.DateTime(dump_to="dtStarted", load_from="dtStarted")
     dt_stopped = ma.fields.DateTime(dump_to="dtStopped", load_from="dtStopped")
     dt_deleted = ma.fields.DateTime(dump_to="dtDeleted", load_from="dtDeleted")
+    autoscaling = ma.fields.Nested(AutoscalingDefinitionSchema)
 
 
 class DeploymentCreateSchema(DeploymentSchema):

gradient/cli/deployments.py

@@ -25,6 +25,52 @@ def get_workspace_handler(api_key):
     return workspace_handler
 
 
+def validate_autoscaling_metric_or_resource(ctx, param, value, metric_type):
+    """
+    value in = ("cpu/targetAverage:10")
+    value out = ({"type": instance,
+                  "name": "cpu",
+                  "value_type": "targetAverage",
+                  "value": 10})
+    """
+
+    if value is None:
+        return None
+
+    old_values = value
+    new_values = []
+
+    for old_value in old_values:
+        try:
+            name, values = old_value.split("/", 1)
+            value_type, value = values.split(":", 1)
+            value = float(value)
+        except Exception as e:
+            debug_msg = "Error occurred while validating autoscaling {} with value {}: {}" \
+                .format(metric_type, old_value, e)
+            clilogger.CliLogger().debug(debug_msg)
+
+            msg = "value need to be in format resource_name/value_type:value for example cpu/targetAverage:60" \
+                .format(old_value)
+            raise click.BadParameter(msg)
+
+        new_value = {"type": metric_type,
+                     "name": name,
+                     "value_type": value_type,
+                     "value": value}
+        new_values.append(new_value)
+
+    return tuple(new_values)
+
+
+def validate_autoscaling_metric(ctx, param, value):
+    return validate_autoscaling_metric_or_resource(ctx, param, value, "Metric")
+
+
+def validate_autoscaling_resource(ctx, param, value):
+    return validate_autoscaling_metric_or_resource(ctx, param, value, "Resource")
+
+
 @cli.group("deployments", help="Manage deployments", cls=ClickGroup)
 def deployments_group():
     pass
@@ -220,6 +266,40 @@ def deployments_metrics():
     help="Workspace password",
     cls=common.GradientOption,
 )
+@click.option(
+    "--minInstanceCount",
+    "min_instance_count",
+    help="Minimal instance count",
+    cls=common.GradientOption,
+)
+@click.option(
+    "--maxInstanceCount",
+    "max_instance_count",
+    help="Maximal instance count",
+    cls=common.GradientOption,
+)
+@click.option(
+    "--scaleCooldownPeriod",
+    "scale_cooldown_period",
+    help="Scale cooldown period",
+    cls=common.GradientOption,
+)
+@click.option(
+    "--metric",
+    "metrics",
+    multiple=True,
+    callback=validate_autoscaling_metric,
+    help="Autoscaling metrics. Example: my_metric/targetAverage:21.37",
+    cls=common.GradientOption,
+)
+@click.option(
+    "--resource",
+    "resources",
+    multiple=True,
+    callback=validate_autoscaling_resource,
+    help="Autoscaling resources. Example: cpu/target:60",
+    cls=common.GradientOption,
+)
 @api_key_option
 @common.options_file
 def create_deployment(api_key, options_file, **kwargs):
@@ -490,6 +570,40 @@ def delete_deployment(id_, options_file, api_key):
     help="Workspace password",
     cls=common.GradientOption,
 )
+@click.option(
+    "--minInstanceCount",
+    "min_instance_count",
+    help="Minimal instance count",
+    cls=common.GradientOption,
+)
+@click.option(
+    "--maxInstanceCount",
+    "max_instance_count",
+    help="Maximal instance count",
+    cls=common.GradientOption,
+)
+@click.option(
+    "--scaleCooldownPeriod",
+    "scale_cooldown_period",
+    help="Scale cooldown period",
+    cls=common.GradientOption,
+)
+@click.option(
+    "--metric",
+    "metrics",
+    multiple=True,
+    callback=validate_autoscaling_metric,
+    help="Autoscaling metrics. Example: my_metric/targetAverage:21.37",
+    cls=common.GradientOption,
+)
+@click.option(
+    "--resource",
+    "resources",
+    multiple=True,
+    callback=validate_autoscaling_resource,
+    help="Autoscaling resources. Example: cpu/target:60",
+    cls=common.GradientOption,
+)
 @api_key_option
 @common.options_file
 def update_deployment(deployment_id, api_key, options_file, **kwargs):

gradient/commands/deployments.py

@@ -1,4 +1,5 @@
 import abc
+import itertools
 import json
 import pydoc
 
@@ -7,8 +8,8 @@
 from click import style
 from halo import halo
 
-from gradient import exceptions, DeploymentsClient
-from gradient.api_sdk import sdk_exceptions, utils, models
+from gradient import exceptions, DeploymentsClient, AutoscalingMetric, AutoscalingDefinition
+from gradient.api_sdk import sdk_exceptions, utils
 from gradient.api_sdk.config import config
 from gradient.api_sdk.utils import concatenate_urls
 from gradient.cli_constants import CLI_PS_CLIENT_NAME
@@ -27,6 +28,29 @@ def _get_client(self, api_key, logger):
         return client
 
 
+class HandleAutoscalingOptions(object):
+    def _handle_autoscaling_options(self, kwargs):
+        autoscaling_metrics_and_resources = []
+        metrics = kwargs.pop("metrics", None) or []
+        resources = kwargs.pop("resources", None) or []
+        for metric_dict in itertools.chain(resources, metrics):
+            metric = AutoscalingMetric(
+                type=metric_dict["type"],
+                name=metric_dict["name"],
+                value_type=metric_dict["value_type"],
+                value=metric_dict["value"],
+            )
+            autoscaling_metrics_and_resources.append(metric)
+
+        autoscaling_definition = AutoscalingDefinition(
+            min_instance_count=kwargs.pop("min_instance_count", None),
+            max_instance_count=kwargs.pop("max_instance_count", None),
+            scale_cooldown_period=kwargs.pop("scale_cooldown_period", None),
+            metrics=autoscaling_metrics_and_resources,
+        )
+        kwargs["autoscaling"] = autoscaling_definition
+
+
 class HandleWorkspaceMixin(object):
     def _handle_workspace(self, instance_dict):
         handler = self.workspace_handler.handle(instance_dict)
@@ -37,14 +61,15 @@ def _handle_workspace(self, instance_dict):
             instance_dict["workspace_url"] = handler
 
 
-class CreateDeploymentCommand(BaseDeploymentCommand, HandleWorkspaceMixin):
+class CreateDeploymentCommand(HandleAutoscalingOptions, BaseDeploymentCommand, HandleWorkspaceMixin):
     def __init__(self, workspace_handler, *args, **kwargs):
         super(CreateDeploymentCommand, self).__init__(*args, **kwargs)
         self.workspace_handler = workspace_handler
 
     def execute(self, **kwargs):
         self._handle_auth(kwargs)
         self._handle_workspace(kwargs)
+        self._handle_autoscaling_options(kwargs)
         with halo.Halo(text="Creating new deployment", spinner="dots"):
             deployment_id = self.client.create(**kwargs)
 
@@ -131,13 +156,14 @@ def execute(self, **kwargs):
         self.logger.log("Deployment deleted")
 
 
-class UpdateDeploymentCommand(BaseDeploymentCommand, HandleWorkspaceMixin):
+class UpdateDeploymentCommand(HandleAutoscalingOptions, BaseDeploymentCommand, HandleWorkspaceMixin):
     def __init__(self, workspace_handler, *args, **kwargs):
         super(UpdateDeploymentCommand, self).__init__(*args, **kwargs)
         self.workspace_handler = workspace_handler
 
     def execute(self, deployment_id, **kwargs):
         self._handle_workspace(kwargs)
+        self._handle_autoscaling_options(kwargs)
 
         with halo.Halo(text="Updating deployment data", spinner="dots"):
             self.client.update(deployment_id, **kwargs)
@@ -151,6 +177,7 @@ def _get_table_data(self, instance):
         :param models.Deployment instance:
         """
         tags_string = ", ".join(instance.tags)
+        autoscaling_metrics_string = self.get_autoscaling_metrics_string(instance)
 
         data = (
             ("ID", instance.id),
@@ -166,9 +193,21 @@ def _get_table_data(self, instance):
             ("API type", instance.api_type),
             ("Cluster ID", instance.cluster_id),
             ("Tags", tags_string),
+            ("Min Instance Count", getattr(instance.autoscaling, "min_instance_count", "")),
+            ("Max Instance Count", getattr(instance.autoscaling, "max_instance_count", "")),
+            ("Scale Cooldown Period", getattr(instance.autoscaling, "scale_cooldown_period", "")),
+            ("Autoscaling Metrics", autoscaling_metrics_string),
         )
         return data
 
+    def get_autoscaling_metrics_string(self, instance):
+        if not instance.autoscaling or not instance.autoscaling.metrics:
+            return ""
+
+        s = "\n".join("{}/{}:{}".format(m.name, m.value_type, m.value)
+                      for m in instance.autoscaling.metrics)
+        return s
+
 
 class DeploymentAddTagsCommand(BaseDeploymentCommand):
     def execute(self, deployment_id, *args, **kwargs):

tests/config_files/deployments_update.yaml

@@ -20,11 +20,19 @@ imageUrl: https://www.latlmes.com/breaking/paperspace-now-has-a-100-bilion-valua
 imageUsername: some_image_username
 instanceCount: 666
 machineType: G1
+maxInstanceCount: 64
 method: some_method
+metric:
+  - loss/target:2.0
+  - keton/target:21.37
+minInstanceCount: "4"
 modelId: some_model_id
 name: some_name
 ports: '5000'
 projectId: some_project_id
+resource:
+  - cpu/targetAverage:10
+scaleCooldownPeriod: 123
 workspace: s3://some-workspace
 workspaceRef: some_branch_name
 workspaceUsername: username