skypilot-nightly 1.0.0.dev20250329__py3-none-any.whl → 1.0.0.dev20250331__py3-none-any.whl

sky/serve/server/core.py

@@ -25,7 +25,6 @@ from sky.utils import command_runner
 from sky.utils import common
 from sky.utils import common_utils
 from sky.utils import controller_utils
-from sky.utils import resources_utils
 from sky.utils import rich_utils
 from sky.utils import subprocess_utils
 from sky.utils import ux_utils
@@ -33,74 +32,6 @@ from sky.utils import ux_utils
 logger = sky_logging.init_logger(__name__)
 
 
-def _validate_service_task(task: 'sky.Task') -> None:
-    """Validate the task for Sky Serve.
-
-    Args:
-        task: sky.Task to validate
-
-    Raises:
-        ValueError: if the arguments are invalid.
-        RuntimeError: if the task.serve is not found.
-    """
-    spot_resources: List['sky.Resources'] = [
-        resource for resource in task.resources if resource.use_spot
-    ]
-    # TODO(MaoZiming): Allow mixed on-demand and spot specification in resources
-    # On-demand fallback should go to the resources specified as on-demand.
-    if len(spot_resources) not in [0, len(task.resources)]:
-        with ux_utils.print_exception_no_traceback():
-            raise ValueError(
-                'Resources must either all use spot or none use spot. '
-                'To use on-demand and spot instances together, '
-                'use `dynamic_ondemand_fallback` or set '
-                'base_ondemand_fallback_replicas.')
-
-    if task.service is None:
-        with ux_utils.print_exception_no_traceback():
-            raise RuntimeError('Service section not found.')
-
-    policy_description = ('on-demand'
-                          if task.service.dynamic_ondemand_fallback else 'spot')
-    for resource in list(task.resources):
-        if resource.job_recovery is not None:
-            with ux_utils.print_exception_no_traceback():
-                raise ValueError('job_recovery is disabled for SkyServe. '
-                                 'SkyServe will replenish preempted spot '
-                                 f'with {policy_description} instances.')
-
-    replica_ingress_port: Optional[int] = int(
-        task.service.ports) if (task.service.ports is not None) else None
-    for requested_resources in task.resources:
-        if (task.service.use_ondemand_fallback and
-                not requested_resources.use_spot):
-            with ux_utils.print_exception_no_traceback():
-                raise ValueError(
-                    '`use_ondemand_fallback` is only supported '
-                    'for spot resources. Please explicitly specify '
-                    '`use_spot: true` in resources for on-demand fallback.')
-        if task.service.ports is None:
-            requested_ports = list(
-                resources_utils.port_ranges_to_set(requested_resources.ports))
-            if len(requested_ports) != 1:
-                with ux_utils.print_exception_no_traceback():
-                    raise ValueError(
-                        'To open multiple ports on the replica, please set the '
-                        '`service.ports` field to specify a main service port. '
-                        'Must only specify one port in resources otherwise. '
-                        'Each replica will use the port specified as '
-                        'application ingress port.')
-            service_port = requested_ports[0]
-            if replica_ingress_port is None:
-                replica_ingress_port = service_port
-            elif service_port != replica_ingress_port:
-                with ux_utils.print_exception_no_traceback():
-                    raise ValueError(
-                        f'Got multiple ports: {service_port} and '
-                        f'{replica_ingress_port} in different resources. '
-                        'Please specify the same port instead.')
-
-
 def _rewrite_tls_credential_paths_and_get_tls_env_vars(
         service_name: str, task: 'sky.Task') -> Dict[str, Any]:
     """Rewrite the paths of TLS credentials in the task.
@@ -113,7 +44,7 @@ def _rewrite_tls_credential_paths_and_get_tls_env_vars(
         The generated template variables for TLS.
     """
     service_spec = task.service
-    # Already checked by _validate_service_task
+    # Already checked by validate_service_task
     assert service_spec is not None
     if service_spec.tls_credential is None:
         return {'use_tls': False}
@@ -166,7 +97,7 @@ def up(
                              'only contains lower letters, numbers and dash): '
                              f'{constants.CLUSTER_NAME_VALID_REGEX}')
 
-    _validate_service_task(task)
+    serve_utils.validate_service_task(task)
     # Always apply the policy again here, even though it might have been applied
     # in the CLI. This is to ensure that we apply the policy to the final DAG
     # and get the mutated config.
@@ -322,7 +253,7 @@ def up(
                 skip_status_check=True).get(lb_port)
             assert socket_endpoint is not None, (
                 'Did not get endpoint for controller.')
-            # Already checked by _validate_service_task
+            # Already checked by validate_service_task
             assert task.service is not None
             protocol = ('http'
                         if task.service.tls_credential is None else 'https')
@@ -376,7 +307,7 @@ def update(
         mode: Update mode.
     """
     task.validate()
-    _validate_service_task(task)
+    serve_utils.validate_service_task(task)
 
     # Always apply the policy again here, even though it might have been applied
     # in the CLI. This is to ensure that we apply the policy to the final DAG

sky/serve/service_spec.py

@@ -10,6 +10,7 @@ from sky.adaptors import common as adaptors_common
 from sky.serve import constants
 from sky.serve import load_balancing_policies as lb_policies
 from sky.serve import serve_utils
+from sky.serve import spot_placer as spot_placer_lib
 from sky.utils import common_utils
 from sky.utils import schemas
 from sky.utils import ux_utils
@@ -30,6 +31,7 @@ class SkyServiceSpec:
         readiness_timeout_seconds: int,
         min_replicas: int,
         max_replicas: Optional[int] = None,
+        num_overprovision: Optional[int] = None,
         ports: Optional[str] = None,
         target_qps_per_replica: Optional[float] = None,
         post_data: Optional[Dict[str, Any]] = None,
@@ -37,6 +39,7 @@ class SkyServiceSpec:
         readiness_headers: Optional[Dict[str, str]] = None,
         dynamic_ondemand_fallback: Optional[bool] = None,
         base_ondemand_fallback_replicas: Optional[int] = None,
+        spot_placer: Optional[str] = None,
         upscale_delay_seconds: Optional[int] = None,
         downscale_delay_seconds: Optional[int] = None,
         load_balancing_policy: Optional[str] = None,
@@ -78,6 +81,7 @@ class SkyServiceSpec:
         self._readiness_timeout_seconds: int = readiness_timeout_seconds
         self._min_replicas: int = min_replicas
         self._max_replicas: Optional[int] = max_replicas
+        self._num_overprovision: Optional[int] = num_overprovision
         self._ports: Optional[str] = ports
         self._target_qps_per_replica: Optional[float] = target_qps_per_replica
         self._post_data: Optional[Dict[str, Any]] = post_data
@@ -88,6 +92,7 @@ class SkyServiceSpec:
             bool] = dynamic_ondemand_fallback
         self._base_ondemand_fallback_replicas: Optional[
             int] = base_ondemand_fallback_replicas
+        self._spot_placer: Optional[str] = spot_placer
         self._upscale_delay_seconds: Optional[int] = upscale_delay_seconds
         self._downscale_delay_seconds: Optional[int] = downscale_delay_seconds
         self._load_balancing_policy: Optional[str] = load_balancing_policy
@@ -161,6 +166,7 @@ class SkyServiceSpec:
                 min_replicas = constants.DEFAULT_MIN_REPLICAS
             service_config['min_replicas'] = min_replicas
             service_config['max_replicas'] = None
+            service_config['num_overprovision'] = None
             service_config['target_qps_per_replica'] = None
             service_config['upscale_delay_seconds'] = None
             service_config['downscale_delay_seconds'] = None
@@ -168,6 +174,8 @@ class SkyServiceSpec:
             service_config['min_replicas'] = policy_section['min_replicas']
             service_config['max_replicas'] = policy_section.get(
                 'max_replicas', None)
+            service_config['num_overprovision'] = policy_section.get(
+                'num_overprovision', None)
             service_config['target_qps_per_replica'] = policy_section.get(
                 'target_qps_per_replica', None)
             service_config['upscale_delay_seconds'] = policy_section.get(
@@ -179,6 +187,8 @@ class SkyServiceSpec:
                     'base_ondemand_fallback_replicas', None)
             service_config['dynamic_ondemand_fallback'] = policy_section.get(
                 'dynamic_ondemand_fallback', None)
+            service_config['spot_placer'] = policy_section.get(
+                'spot_placer', None)
 
         service_config['load_balancing_policy'] = config.get(
             'load_balancing_policy', None)
@@ -238,12 +248,15 @@ class SkyServiceSpec:
         add_if_not_none('readiness_probe', 'headers', self._readiness_headers)
         add_if_not_none('replica_policy', 'min_replicas', self.min_replicas)
         add_if_not_none('replica_policy', 'max_replicas', self.max_replicas)
+        add_if_not_none('replica_policy', 'num_overprovision',
+                        self.num_overprovision)
         add_if_not_none('replica_policy', 'target_qps_per_replica',
                         self.target_qps_per_replica)
         add_if_not_none('replica_policy', 'dynamic_ondemand_fallback',
                         self.dynamic_ondemand_fallback)
         add_if_not_none('replica_policy', 'base_ondemand_fallback_replicas',
                         self.base_ondemand_fallback_replicas)
+        add_if_not_none('replica_policy', 'spot_placer', self.spot_placer)
         add_if_not_none('replica_policy', 'upscale_delay_seconds',
                         self.upscale_delay_seconds)
         add_if_not_none('replica_policy', 'downscale_delay_seconds',
@@ -269,6 +282,9 @@ class SkyServiceSpec:
         policy_strs: List[str] = []
         if (self.dynamic_ondemand_fallback is not None and
                 self.dynamic_ondemand_fallback):
+            if self.spot_placer is not None:
+                if self.spot_placer == spot_placer_lib.SPOT_HEDGE_PLACER:
+                    return 'SpotHedge'
             policy_strs.append('Dynamic on-demand fallback')
             if self.base_ondemand_fallback_replicas is not None:
                 policy_strs.append(
@@ -281,8 +297,12 @@ class SkyServiceSpec:
                 policy_strs.append('Static spot mixture with '
                                    f'{self.base_ondemand_fallback_replicas} '
                                    f'base on-demand replica{plural}')
+        if self.spot_placer is not None:
+            if not policy_strs:
+                policy_strs.append('Spot placement')
+            policy_strs.append(f'with {self.spot_placer} placer')
         if not policy_strs:
-            return 'No spot fallback policy'
+            return 'No spot policy'
         return ' '.join(policy_strs)
 
     def autoscaling_policy_str(self):
@@ -294,9 +314,13 @@ class SkyServiceSpec:
         assert self.target_qps_per_replica is not None
         # TODO(tian): Refactor to contain more information
         max_plural = '' if self.max_replicas == 1 else 's'
+        overprovision_str = ''
+        if self.num_overprovision is not None:
+            overprovision_str = (
+                f' with {self.num_overprovision} overprovisioned replicas')
         return (f'Autoscaling from {self.min_replicas} to {self.max_replicas} '
-                f'replica{max_plural} (target QPS per replica: '
-                f'{self.target_qps_per_replica})')
+                f'replica{max_plural}{overprovision_str} (target QPS per '
+                f'replica: {self.target_qps_per_replica})')
 
     def set_ports(self, ports: str) -> None:
         self._ports = ports
@@ -339,6 +363,10 @@ class SkyServiceSpec:
         # If None, treated as having the same value of min_replicas.
         return self._max_replicas
 
+    @property
+    def num_overprovision(self) -> Optional[int]:
+        return self._num_overprovision
+
     @property
     def ports(self) -> Optional[str]:
         return self._ports
@@ -372,6 +400,10 @@ class SkyServiceSpec:
     def dynamic_ondemand_fallback(self) -> Optional[bool]:
         return self._dynamic_ondemand_fallback
 
+    @property
+    def spot_placer(self) -> Optional[str]:
+        return self._spot_placer
+
     @property
     def upscale_delay_seconds(self) -> Optional[int]:
         return self._upscale_delay_seconds

sky/serve/spot_placer.py

@@ -0,0 +1,278 @@
+"""Spot Placer for SpotHedge."""
+
+import collections
+import dataclasses
+import enum
+import typing
+from typing import Any, Dict, List, Optional, Set
+
+from sky import check as sky_check
+from sky import clouds as sky_clouds
+from sky import sky_logging
+from sky.clouds import cloud as sky_cloud
+from sky.utils import registry
+from sky.utils import resources_utils
+from sky.utils import ux_utils
+
+if typing.TYPE_CHECKING:
+    from sky import resources as resources_lib
+    from sky import task as task_lib
+    from sky.serve import service_spec
+
+logger = sky_logging.init_logger(__name__)
+
+SPOT_PLACERS = {}
+DEFAULT_SPOT_PLACER = None
+SPOT_HEDGE_PLACER = 'dynamic_fallback'
+
+
+@dataclasses.dataclass
+class Location:
+    """Location class of a spot instance."""
+    cloud: 'sky_clouds.Cloud'
+    region: str
+    zone: Optional[str]
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, Location):
+            return (self.cloud.is_same_cloud(other.cloud) and
+                    self.region == other.region and self.zone == other.zone)
+        return False
+
+    def __hash__(self) -> int:
+        return hash(
+            str(self.cloud) + self.region +
+            (self.zone if self.zone is not None else ''))
+
+    @classmethod
+    def from_resources(cls, resources: 'resources_lib.Resources') -> 'Location':
+        return cls(resources.cloud, resources.region, resources.zone)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {'cloud': self.cloud, 'region': self.region, 'zone': self.zone}
+
+    @classmethod
+    def from_pickleable(
+        cls,
+        data: Optional[Dict[str, Optional[str]]],
+    ) -> Optional['Location']:
+        if data is None:
+            return None
+        cloud = registry.CLOUD_REGISTRY.from_str(data['cloud'])
+        assert cloud is not None
+        assert data['region'] is not None
+        return cls(
+            cloud=cloud,
+            region=data['region'],
+            zone=data['zone'],
+        )
+
+    def to_pickleable(self) -> Dict[str, Optional[str]]:
+        return {
+            'cloud': str(self.cloud),
+            'region': self.region,
+            'zone': self.zone,
+        }
+
+
+class LocationStatus(enum.Enum):
+    """Location Spot Status."""
+    ACTIVE = 'ACTIVE'
+    PREEMPTED = 'PREEMPTED'
+
+
+def _get_possible_location_from_task(task: 'task_lib.Task') -> List[Location]:
+
+    def _without_location(
+            resources: 'resources_lib.Resources') -> 'resources_lib.Resources':
+        return resources.copy(cloud=None, region=None, zone=None)
+
+    assert task.resources  # Guaranteed in task constructor
+    empty_location_resources = _without_location(list(task.resources)[0])
+    empty_location_resources_config = empty_location_resources.to_yaml_config()
+
+    location_requirements: Dict[str, Dict[str, Set[str]]] = (
+        collections.defaultdict(lambda: collections.defaultdict(set)))
+
+    for r in task.resources:
+        if (_without_location(r).to_yaml_config() !=
+                empty_location_resources_config):
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(
+                    'Different resource configurations are not supported '
+                    'for spot placement. All resources must have the same '
+                    'configuration except for cloud/region/zone.')
+        if r.cloud is None:
+            continue
+        cloud_str = str(r.cloud)
+        if r.region is None:
+            # Access defaultdict to create empty entry if it doesn't exist.
+            _ = location_requirements[cloud_str]
+            continue
+        if r.zone is None:
+            # Same as above.
+            _ = location_requirements[cloud_str][r.region]
+            continue
+        location_requirements[cloud_str][r.region].add(r.zone)
+
+    clouds_list: List[sky_clouds.Cloud] = []
+    for c in location_requirements.keys():
+        cloud_obj = registry.CLOUD_REGISTRY.from_str(c)
+        assert cloud_obj is not None
+        clouds_list.append(cloud_obj)
+    if not clouds_list:
+        # If the cloud list is empty, that means the user has no location
+        # related requirements. Then we start with all enabled clouds and
+        # all possible regions and zones.
+        clouds_list = sky_check.get_cached_enabled_clouds_or_refresh(
+            capability=sky_cloud.CloudCapability.COMPUTE,
+            raise_if_no_cloud_access=False)
+        for cloud in clouds_list:
+            # Create empty entry for each cloud.
+            _ = location_requirements[str(cloud)]
+
+    possible_locations = set()
+    for cloud in clouds_list:
+        feasible_resources: resources_utils.FeasibleResources = (
+            cloud.get_feasible_launchable_resources(empty_location_resources,
+                                                    num_nodes=task.num_nodes))
+        for feasible in feasible_resources.resources_list:
+            # We set override_optimize_by_zone=True to force the provisioner
+            # to use zone-level provisioning. This is to get accurate location
+            # information.
+            launchables: List['resources_lib.Resources'] = (
+                resources_utils.make_launchables_for_valid_region_zones(
+                    feasible, override_optimize_by_zone=True))
+            for launchable in launchables:
+                cloud_str = str(launchable.cloud)
+                region = launchable.region
+                zone = launchable.zone
+                if (cloud_str not in location_requirements and
+                        location_requirements):
+                    continue
+                # We need to use .get() here to avoid creating extra entries in
+                # location_requirements, and being treated as user's requirement
+                # in the following regions.
+                cloud_reqs = location_requirements.get(cloud_str, {})
+                if region not in cloud_reqs and cloud_reqs:
+                    continue
+                region_reqs = cloud_reqs.get(region, set())
+                if zone not in region_reqs and region_reqs:
+                    continue
+                possible_locations.add(Location.from_resources(launchable))
+
+    return list(possible_locations)
+
+
+class SpotPlacer:
+    """Spot Placement specification."""
+
+    def __init__(self, task: 'task_lib.Task') -> None:
+        possible_locations = _get_possible_location_from_task(task)
+        logger.info(f'{len(possible_locations)} possible location candidates '
+                    'are enabled for spot placement.')
+        logger.debug(f'All possible locations: {possible_locations}')
+        self.location2status: Dict[Location, LocationStatus] = {
+            location: LocationStatus.ACTIVE for location in possible_locations
+        }
+        self.location2cost: Dict[Location, float] = {}
+        # Already checked there is only one resource in the task.
+        self.resources = list(task.resources)[0]
+        self.num_nodes = task.num_nodes
+
+    def __init_subclass__(cls, name: str, default: bool = False):
+        SPOT_PLACERS[name] = cls
+        if default:
+            global DEFAULT_SPOT_PLACER
+            assert DEFAULT_SPOT_PLACER is None, (
+                'Only one policy can be default.')
+            DEFAULT_SPOT_PLACER = name
+
+    def select_next_location(self,
+                             current_locations: List[Location]) -> Location:
+        """Select next location to place spot instance."""
+        raise NotImplementedError
+
+    def set_active(self, location: Location) -> None:
+        assert location in self.location2status, location
+        self.location2status[location] = LocationStatus.ACTIVE
+
+    def set_preemptive(self, location: Location) -> None:
+        assert location in self.location2status, location
+        self.location2status[location] = LocationStatus.PREEMPTED
+
+    def clear_preemptive_locations(self) -> None:
+        for location in self.location2status:
+            self.location2status[location] = LocationStatus.ACTIVE
+
+    def _min_cost_location(self, locations: List[Location]) -> Location:
+
+        def _get_cost_per_hour(location: Location) -> float:
+            if location in self.location2cost:
+                return self.location2cost[location]
+            # TODO(tian): Is there a better way to do this? This is for filling
+            # instance type so the get_cost() can operate normally.
+            r: 'resources_lib.Resources' = self.resources.copy(
+                **location.to_dict())
+            assert r.cloud is not None
+            rs = r.cloud.get_feasible_launchable_resources(
+                r, num_nodes=self.num_nodes).resources_list
+            # For some clouds, there might have multiple instance types
+            # satisfying the resource request. In such case we choose the
+            # cheapest one, as the optimizer does. Reference:
+            # sky/optimizer.py::Optimizer::_print_candidates
+            cost = min(r.get_cost(seconds=3600) for r in rs)
+            self.location2cost[location] = cost
+            return cost
+
+        return min(locations, key=_get_cost_per_hour)
+
+    def _location_with_status(self, status: LocationStatus) -> List[Location]:
+        return [
+            location
+            for location, location_type in self.location2status.items()
+            if location_type == status
+        ]
+
+    def active_locations(self) -> List[Location]:
+        return self._location_with_status(LocationStatus.ACTIVE)
+
+    def preemptive_locations(self) -> List[Location]:
+        return self._location_with_status(LocationStatus.PREEMPTED)
+
+    @classmethod
+    def from_task(cls, spec: 'service_spec.SkyServiceSpec',
+                  task: 'task_lib.Task') -> Optional['SpotPlacer']:
+        if spec.spot_placer is None:
+            return None
+        return SPOT_PLACERS[spec.spot_placer](task)
+
+
+class DynamicFallbackSpotPlacer(SpotPlacer,
+                                name=SPOT_HEDGE_PLACER,
+                                default=True):
+    """Dynamic Fallback Placer."""
+
+    def select_next_location(self,
+                             current_locations: List[Location]) -> Location:
+        active_locations = self.active_locations()
+        # Prioritize locations that are not currently used.
+        candidate_locations: List[Location] = [
+            location for location in active_locations
+            if location not in current_locations
+        ]
+        # If no candidate locations, use all active locations.
+        if not candidate_locations:
+            candidate_locations = active_locations
+        res = self._min_cost_location(candidate_locations)
+        logger.info(f'Active locations: {active_locations}\n'
+                    f'Current locations: {current_locations}\n'
+                    f'Candidate locations: {candidate_locations}\n'
+                    f'Selected location: {res}\n')
+        return res
+
+    def set_preemptive(self, location: Location) -> None:
+        super().set_preemptive(location)
+        # Prevent the case with only one active location.
+        if len(self.active_locations()) < 2:
+            self.clear_preemptive_locations()

sky/utils/registry.py

@@ -125,3 +125,5 @@ JOBS_RECOVERY_STRATEGY_REGISTRY: _Registry = (
         registry_name='jobs recovery strategy',
         exclude=None,
         type_register=True))
+
+# TODO(tian): Add a registry for spot placer.

sky/utils/resources_utils.py

@@ -216,3 +216,53 @@ def need_to_query_reservations() -> bool:
                 cloud_prioritize_reservations):
             return True
     return False
+
+
+def make_launchables_for_valid_region_zones(
+    launchable_resources: 'resources_lib.Resources',
+    override_optimize_by_zone: bool = False,
+) -> List['resources_lib.Resources']:
+    assert launchable_resources.is_launchable()
+    # In principle, all provisioning requests should be made at the granularity
+    # of a single zone. However, for on-demand instances, we batch the requests
+    # to the zones in the same region in order to leverage the region-level
+    # provisioning APIs of AWS and Azure. This way, we can reduce the number of
+    # API calls, and thus the overall failover time. Note that this optimization
+    # does not affect the user cost since the clouds charge the same prices for
+    # on-demand instances in the same region regardless of the zones. On the
+    # other hand, for spot instances, we do not batch the requests because the
+    # "AWS" spot prices may vary across zones.
+    # For GCP, we do not batch the requests because GCP reservation system is
+    # zone based. Therefore, price estimation is potentially different across
+    # zones.
+
+    # NOTE(woosuk): GCP does not support region-level provisioning APIs. Thus,
+    # while we return per-region resources here, the provisioner will still
+    # issue the request for one zone at a time.
+    # NOTE(woosuk): If we support Azure spot instances, we should batch the
+    # requests since Azure spot prices are region-level.
+    # TODO(woosuk): Batch the per-zone AWS spot instance requests if they are
+    # in the same region and have the same price.
+    # TODO(woosuk): A better design is to implement batching at a higher level
+    # (e.g., in provisioner or optimizer), not here.
+    launchables = []
+    regions = launchable_resources.get_valid_regions_for_launchable()
+    for region in regions:
+        optimize_by_zone = (override_optimize_by_zone or
+                            launchable_resources.cloud.optimize_by_zone())
+        # It is possible that we force the optimize_by_zone but some clouds
+        # do not support zone-level provisioning (i.e. Azure). So we check
+        # if there is zone-level information in the region first.
+        if (region.zones is not None and
+            (launchable_resources.use_spot or optimize_by_zone)):
+            # Spot instances.
+            # Do not batch the per-zone requests.
+            for zone in region.zones:
+                launchables.append(
+                    launchable_resources.copy(region=region.name,
+                                              zone=zone.name))
+        else:
+            # On-demand instances.
+            # Batch the requests at the granularity of a single region.
+            launchables.append(launchable_resources.copy(region=region.name))
+    return launchables

sky/utils/schemas.py

@@ -310,6 +310,7 @@ def get_service_schema():
     # To avoid circular imports, only import when needed.
     # pylint: disable=import-outside-toplevel
     from sky.serve import load_balancing_policies
+    from sky.serve import spot_placer
     return {
         '$schema': 'https://json-schema.org/draft/2020-12/schema',
         'type': 'object',
@@ -362,6 +363,10 @@ def get_service_schema():
                         'type': 'integer',
                         'minimum': 0,
                     },
+                    'num_overprovision': {
+                        'type': 'integer',
+                        'minimum': 0,
+                    },
                     'target_qps_per_replica': {
                         'type': 'number',
                         'minimum': 0,
@@ -373,6 +378,11 @@ def get_service_schema():
                         'type': 'integer',
                         'minimum': 0,
                     },
+                    'spot_placer': {
+                        'type': 'string',
+                        'case_insensitive_enum': list(
+                            spot_placer.SPOT_PLACERS.keys())
+                    },
                     'upscale_delay_seconds': {
                         'type': 'number',
                     },

{skypilot_nightly-1.0.0.dev20250329.dist-info → skypilot_nightly-1.0.0.dev20250331.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skypilot-nightly
-Version: 1.0.0.dev20250329
+Version: 1.0.0.dev20250331
 Summary: SkyPilot: An intercloud broker for the clouds
 Author: SkyPilot Team
 License: Apache 2.0