skypilot-nightly 1.0.0.dev20250520__py3-none-any.whl → 1.0.0.dev20250522__py3-none-any.whl

sky/provision/provisioner.py

@@ -17,6 +17,7 @@ from sky import clouds
 from sky import exceptions
 from sky import provision
 from sky import sky_logging
+from sky import skypilot_config
 from sky.adaptors import aws
 from sky.backends import backend_utils
 from sky.provision import common as provision_common
@@ -228,9 +229,9 @@ def _ssh_probe_command(ip: str,
                        ssh_port: int,
                        ssh_user: str,
                        ssh_private_key: str,
+                       ssh_probe_timeout: int,
                        ssh_proxy_command: Optional[str] = None) -> List[str]:
-    # NOTE: Ray uses 'uptime' command and 10s timeout, we use the same
-    # setting here.
+    # NOTE: Ray uses 'uptime' command, we use the same setting here.
     command = [
         'ssh',
         '-T',
@@ -244,7 +245,7 @@ def _ssh_probe_command(ip: str,
         '-o',
         'PasswordAuthentication=no',
         '-o',
-        'ConnectTimeout=10s',
+        f'ConnectTimeout={ssh_probe_timeout}s',
         '-o',
         f'UserKnownHostsFile={os.devnull}',
         '-o',
@@ -277,6 +278,7 @@ def _wait_ssh_connection_direct(ip: str,
                                 ssh_port: int,
                                 ssh_user: str,
                                 ssh_private_key: str,
+                                ssh_probe_timeout: int,
                                 ssh_control_name: Optional[str] = None,
                                 ssh_proxy_command: Optional[str] = None,
                                 **kwargs) -> Tuple[bool, str]:
@@ -305,6 +307,7 @@ def _wait_ssh_connection_direct(ip: str,
         if success:
             return _wait_ssh_connection_indirect(ip, ssh_port, ssh_user,
                                                  ssh_private_key,
+                                                 ssh_probe_timeout,
                                                  ssh_control_name,
                                                  ssh_proxy_command)
     except socket.timeout:  # this is the most expected exception
@@ -312,7 +315,7 @@ def _wait_ssh_connection_direct(ip: str,
     except Exception as e:  # pylint: disable=broad-except
         stderr = f'Error: {common_utils.format_exception(e)}'
     command = _ssh_probe_command(ip, ssh_port, ssh_user, ssh_private_key,
-                                 ssh_proxy_command)
+                                 ssh_probe_timeout, ssh_proxy_command)
     logger.debug(f'Waiting for SSH to {ip}. Try: '
                  f'{_shlex_join(command)}. '
                  f'{stderr}')
@@ -323,6 +326,7 @@ def _wait_ssh_connection_indirect(ip: str,
                                   ssh_port: int,
                                   ssh_user: str,
                                   ssh_private_key: str,
+                                  ssh_probe_timeout: int,
                                   ssh_control_name: Optional[str] = None,
                                   ssh_proxy_command: Optional[str] = None,
                                   **kwargs) -> Tuple[bool, str]:
@@ -333,14 +337,14 @@ def _wait_ssh_connection_indirect(ip: str,
     """
     del ssh_control_name, kwargs  # unused
     command = _ssh_probe_command(ip, ssh_port, ssh_user, ssh_private_key,
-                                 ssh_proxy_command)
+                                 ssh_probe_timeout, ssh_proxy_command)
     message = f'Waiting for SSH using command: {_shlex_join(command)}'
     logger.debug(message)
     try:
         proc = subprocess.run(command,
                               shell=False,
                               check=False,
-                              timeout=10,
+                              timeout=ssh_probe_timeout,
                               stdout=subprocess.DEVNULL,
                               stderr=subprocess.PIPE)
         if proc.returncode != 0:
@@ -383,8 +387,13 @@ def wait_for_ssh(cluster_info: provision_common.ClusterInfo,
     def _retry_ssh_thread(ip_ssh_port: Tuple[str, int]):
         ip, ssh_port = ip_ssh_port
         success = False
+        ssh_probe_timeout = skypilot_config.get_nested(
+            ('provision', 'ssh_timeout'), 10)
         while not success:
-            success, stderr = waiter(ip, ssh_port, **ssh_credentials)
+            success, stderr = waiter(ip,
+                                     ssh_port,
+                                     **ssh_credentials,
+                                     ssh_probe_timeout=ssh_probe_timeout)
             if not success and time.time() - start > timeout:
                 with ux_utils.print_exception_no_traceback():
                     raise RuntimeError(

sky/resources.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Literal, Optional, Set, Tuple, Union
 
 import colorama
 
+import sky
 from sky import check as sky_check
 from sky import clouds
 from sky import exceptions
@@ -20,6 +21,7 @@ from sky.utils import accelerator_registry
 from sky.utils import annotations
 from sky.utils import common_utils
 from sky.utils import config_utils
+from sky.utils import infra_utils
 from sky.utils import log_utils
 from sky.utils import registry
 from sky.utils import resources_utils
@@ -96,7 +98,7 @@ class Resources:
     """
     # If any fields changed, increment the version. For backward compatibility,
     # modify the __setstate__ method to handle the old version.
-    _VERSION = 23
+    _VERSION = 24
 
     def __init__(
         self,
@@ -106,6 +108,7 @@ class Resources:
         memory: Union[None, int, float, str] = None,
         accelerators: Union[None, str, Dict[str, Union[int, float]]] = None,
         accelerator_args: Optional[Dict[str, str]] = None,
+        infra: Optional[str] = None,
         use_spot: Optional[bool] = None,
         job_recovery: Optional[Union[Dict[str, Optional[Union[str, int]]],
                                      str]] = None,
@@ -117,6 +120,7 @@ class Resources:
         ports: Optional[Union[int, str, List[str], Tuple[str]]] = None,
         labels: Optional[Dict[str, str]] = None,
         autostop: Union[bool, int, Dict[str, Any], None] = None,
+        volumes: Optional[List[Dict[str, Any]]] = None,
         # Internal use only.
         # pylint: disable=invalid-name
         _docker_login_config: Optional[docker_utils.DockerLoginConfig] = None,
@@ -134,9 +138,9 @@ class Resources:
           .. code-block:: python
 
             # Fully specified cloud and instance type (is_launchable() is True).
-            sky.Resources(clouds.AWS(), 'p3.2xlarge')
-            sky.Resources(clouds.GCP(), 'n1-standard-16')
-            sky.Resources(clouds.GCP(), 'n1-standard-8', 'V100')
+            sky.Resources(infra='aws', instance_type='p3.2xlarge')
+            sky.Resources(infra='k8s/my-cluster-ctx', accelerators='V100')
+            sky.Resources(infra='gcp/us-central1', accelerators='V100')
 
             # Specifying required resources; the system decides the
             # cloud/instance type. The below are equivalent:
@@ -145,8 +149,9 @@ class Resources:
             sky.Resources(accelerators={'V100': 1})
             sky.Resources(cpus='2+', memory='16+', accelerators='V100')
 
+
         Args:
-          cloud: the cloud to use.
+          cloud: the cloud to use. Deprecated. Use `infra` instead.
           instance_type: the instance type to use.
           cpus: the number of CPUs required for the task.
             If a str, must be a string of the form ``'2'`` or ``'2+'``, where
@@ -160,6 +165,11 @@ class Resources:
             dict of the form ``{'V100': 2}`` or ``{'tpu-v2-8': 1}``.
           accelerator_args: accelerator-specific arguments. For example,
             ``{'tpu_vm': True, 'runtime_version': 'tpu-vm-base'}`` for TPUs.
+          infra: a string specifying the infrastructure to use, in the format
+            of "cloud/region" or "cloud/region/zone". For example,
+            `aws/us-east-1` or `k8s/my-cluster-ctx`. This is an alternative to
+            specifying cloud, region, and zone separately. If provided, it
+            takes precedence over cloud, region, and zone parameters.
           use_spot: whether to use spot instances. If None, defaults to
             False.
           job_recovery: the job recovery strategy to use for the managed
@@ -172,8 +182,8 @@ class Resources:
             - max_restarts_on_errors: the max number of restarts on user code
               errors.
 
-          region: the region to use.
-          zone: the zone to use.
+          region: the region to use. Deprecated. Use `infra` instead.
+          zone: the zone to use. Deprecated. Use `infra` instead.
           image_id: the image ID to use. If a str, must be a string
             of the image id from the cloud, such as AWS:
             ``'ami-1234567890abcdef0'``, GCP:
@@ -201,6 +211,7 @@ class Resources:
             not supported and will be ignored.
           autostop: the autostop configuration to use. For launched resources,
             may or may not correspond to the actual current autostop config.
+          volumes: the volumes to mount on the instance.
           _docker_login_config: the docker configuration to use. This includes
             the docker username, password, and registry server. If None, skip
             docker login.
@@ -218,6 +229,25 @@ class Resources:
             exceptions.NoCloudAccessError: if no public cloud is enabled.
         """
         self._version = self._VERSION
+
+        if infra is not None and (cloud is not None or region is not None or
+                                  zone is not None):
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError('Cannot specify both `infra` and `cloud`, '
+                                 '`region`, or `zone` parameters. '
+                                 f'Got: infra={infra}, cloud={cloud}, '
+                                 f'region={region}, zone={zone}')
+
+        # Infra is user facing, and cloud, region, zone in parameters are for
+        # backward compatibility. Internally, we keep using cloud, region, zone
+        # for simplicity.
+        if infra is not None:
+            infra_info = infra_utils.InfraInfo.from_str(infra)
+            # Infra takes precedence over individually specified parameters
+            cloud = sky.CLOUD_REGISTRY.from_str(infra_info.cloud)
+            region = infra_info.region
+            zone = infra_info.zone
+
         self._cloud = cloud
         self._region: Optional[str] = region
         self._zone: Optional[str] = zone
@@ -309,6 +339,7 @@ class Resources:
         self._set_memory(memory)
         self._set_accelerators(accelerators, accelerator_args)
         self._set_autostop_config(autostop)
+        self._set_volumes(volumes)
 
     def validate(self):
         """Validate the resources and infer the missing fields if possible."""
@@ -319,6 +350,7 @@ class Resources:
         self._try_validate_managed_job_attributes()
         self._try_validate_image_id()
         self._try_validate_disk_tier()
+        self._try_validate_volumes()
         self._try_validate_ports()
         self._try_validate_labels()
 
@@ -431,6 +463,11 @@ class Resources:
             repr_str += f'{region_str}{zone_str}'
         return repr_str
 
+    @property
+    def infra(self) -> infra_utils.InfraInfo:
+        cloud = str(self.cloud) if self.cloud is not None else None
+        return infra_utils.InfraInfo(cloud, self.region, self.zone)
+
     @property
     def cloud(self) -> Optional[clouds.Cloud]:
         return self._cloud
@@ -486,9 +523,9 @@ class Resources:
     def accelerators(self) -> Optional[Dict[str, Union[int, float]]]:
         """Returns the accelerators field directly or by inferring.
 
-        For example, Resources(AWS, 'p3.2xlarge') has its accelerators field
-        set to None, but this function will infer {'V100': 1} from the instance
-        type.
+        For example, Resources(infra='aws', instance_type='p3.2xlarge') has its
+        accelerators field set to None, but this function will infer {'V100': 1}
+        from the instance type.
         """
         if self._accelerators is not None:
             return self._accelerators
@@ -533,6 +570,10 @@ class Resources:
     def labels(self) -> Optional[Dict[str, str]]:
         return self._labels
 
+    @property
+    def volumes(self) -> Optional[List[Dict[str, Any]]]:
+        return self._volumes
+
     @property
     def autostop_config(self) -> Optional[AutostopConfig]:
         """The requested autostop config.
@@ -726,6 +767,91 @@ class Resources:
     ) -> None:
         self._autostop_config = AutostopConfig.from_yaml_config(autostop)
 
+    def _set_volumes(
+        self,
+        volumes: Optional[List[Dict[str, Any]]],
+    ) -> None:
+        if not volumes:
+            self._volumes = None
+            return
+        valid_volumes = []
+        supported_tiers = [tier.value for tier in resources_utils.DiskTier]
+        supported_storage_types = [
+            storage_type.value for storage_type in resources_utils.StorageType
+        ]
+        supported_attach_modes = [
+            attach_mode.value for attach_mode in resources_utils.DiskAttachMode
+        ]
+        network_type = resources_utils.StorageType.NETWORK
+        read_write_mode = resources_utils.DiskAttachMode.READ_WRITE
+        for volume in volumes:
+            if 'path' not in volume:
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError(f'Invalid volume {volume!r}. '
+                                     f'Volume must have a "path" field.')
+            if 'storage_type' not in volume:
+                volume['storage_type'] = network_type
+            else:
+                if isinstance(volume['storage_type'], str):
+                    storage_type_str = str(volume['storage_type']).lower()
+                    if storage_type_str not in supported_storage_types:
+                        logger.warning(
+                            f'Invalid storage_type {storage_type_str!r}. '
+                            f'Set it to '
+                            f'{network_type.value}.')
+                        volume['storage_type'] = network_type
+                    else:
+                        volume['storage_type'] = resources_utils.StorageType(
+                            storage_type_str)
+            if 'auto_delete' not in volume:
+                volume['auto_delete'] = False
+            if 'attach_mode' in volume:
+                if isinstance(volume['attach_mode'], str):
+                    attach_mode_str = str(volume['attach_mode']).lower()
+                    if attach_mode_str not in supported_attach_modes:
+                        logger.warning(
+                            f'Invalid attach_mode {attach_mode_str!r}. '
+                            f'Set it to {read_write_mode.value}.')
+                        volume['attach_mode'] = read_write_mode
+                    else:
+                        volume['attach_mode'] = resources_utils.DiskAttachMode(
+                            attach_mode_str)
+            else:
+                volume['attach_mode'] = read_write_mode
+            if volume['storage_type'] == network_type:
+                if ('disk_size' in volume and
+                        round(volume['disk_size']) != volume['disk_size']):
+                    with ux_utils.print_exception_no_traceback():
+                        raise ValueError(f'Volume size must be an integer. '
+                                         f'Got: {volume["size"]}.')
+                if 'name' not in volume:
+                    with ux_utils.print_exception_no_traceback():
+                        raise ValueError(f'Network volume {volume["path"]} '
+                                         f'must have "name" field.')
+            elif 'name' in volume:
+                logger.info(f'Volume {volume["path"]} is a local disk. '
+                            f'The "name" field will be ignored.')
+                del volume['name']
+            if 'disk_tier' in volume:
+                if isinstance(volume['disk_tier'], str):
+                    disk_tier_str = str(volume['disk_tier']).lower()
+                    if disk_tier_str not in supported_tiers:
+                        logger.warning(
+                            f'Invalid disk_tier {disk_tier_str!r}. '
+                            f'Set it to {resources_utils.DiskTier.BEST.value}.')
+                        volume['disk_tier'] = resources_utils.DiskTier.BEST
+                    else:
+                        volume['disk_tier'] = resources_utils.DiskTier(
+                            disk_tier_str)
+            elif volume['storage_type'] == network_type:
+                logger.debug(
+                    f'No disk_tier specified for volume {volume["path"]}. '
+                    f'Set it to {resources_utils.DiskTier.BEST.value}.')
+                volume['disk_tier'] = resources_utils.DiskTier.BEST
+
+            valid_volumes.append(volume)
+        self._volumes = valid_volumes
+
     def is_launchable(self) -> bool:
         """Returns whether the resource is launchable."""
         return self.cloud is not None and self._instance_type is not None
@@ -1090,6 +1216,48 @@ class Resources:
                         f'Disk tier {self.disk_tier.value} is not supported '
                         f'for instance type {self.instance_type}.') from None
 
+    def _try_validate_volumes(self) -> None:
+        """Try to validate the volumes attribute.
+
+        Raises:
+            ValueError: if the attribute is invalid.
+        """
+        if self.volumes is None:
+            return
+        if self.cloud is None:
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError('Cloud must be specified when '
+                                 'volumes are provided.')
+        if not self.cloud.is_same_cloud(clouds.GCP()):
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(f'Volumes are only supported for GCP'
+                                 f' not for {self.cloud}.')
+
+        need_region_or_zone = False
+        try:
+            for volume in self.volumes:
+                if ('name' in volume and volume['storage_type']
+                        == resources_utils.StorageType.NETWORK):
+                    need_region_or_zone = True
+                if 'disk_tier' not in volume:
+                    continue
+                # TODO(hailong): check instance local SSD
+                # support for instance_type.
+                # Refer to https://cloud.google.com/compute/docs/disks/local-ssd#machine-series-lssd # pylint: disable=line-too-long
+                self.cloud.check_disk_tier_enabled(self.instance_type,
+                                                   volume['disk_tier'])
+            if (need_region_or_zone and self._region is None and
+                    self._zone is None):
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError('When specifying the volume name, please'
+                                     ' also specify the region or zone.')
+        except exceptions.NotSupportedError:
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(
+                    f'Disk tier {volume["disk_tier"].value} is not '
+                    f'supported for instance type {self.instance_type}.'
+                ) from None
+
     def _try_validate_ports(self) -> None:
         """Try to validate the ports attribute.
 
@@ -1260,9 +1428,18 @@ class Resources:
             skypilot_config.get_nested(
                 (str(self.cloud).lower(), 'specific_reservations'), set()))
 
+        if isinstance(self.cloud, clouds.DummyCloud):
+            return self.cloud.get_reservations_available_resources(
+                instance_type='',
+                region='',
+                zone=None,
+                specific_reservations=specific_reservations)
+
         assert (self.cloud is not None and self.instance_type is not None and
-                self.region
-                is not None), ('Cloud, instance type, region must be specified')
+                self.region is not None), (
+                    f'Cloud, instance type, region must be specified. '
+                    f'Resources={self}, cloud={self.cloud}, '
+                    f'instance_type={self.instance_type}, region={self.region}')
         return self.cloud.get_reservations_available_resources(
             self.instance_type, self.region, self.zone, specific_reservations)
 
@@ -1450,6 +1627,8 @@ class Resources:
             ports=override.pop('ports', self.ports),
             labels=override.pop('labels', self.labels),
             autostop=override.pop('autostop', current_autostop_config),
+            volumes=override.pop('volumes', self.volumes),
+            infra=override.pop('infra', None),
             _docker_login_config=override.pop('_docker_login_config',
                                               self._docker_login_config),
             _docker_username_for_runpod=override.pop(
@@ -1489,6 +1668,12 @@ class Resources:
             features.add(clouds.CloudImplementationFeatures.IMAGE_ID)
         if self.ports is not None:
             features.add(clouds.CloudImplementationFeatures.OPEN_PORTS)
+        if self.volumes is not None:
+            for volume in self.volumes:
+                if 'disk_tier' in volume and volume[
+                        'disk_tier'] != resources_utils.DiskTier.BEST:
+                    features.add(
+                        clouds.CloudImplementationFeatures.CUSTOM_DISK_TIER)
         return features
 
     @staticmethod
@@ -1621,9 +1806,21 @@ class Resources:
     @classmethod
     def _from_yaml_config_single(cls, config: Dict[str, str]) -> 'Resources':
 
-        resources_fields = {}
+        resources_fields: Dict[str, Any] = {}
+
+        # Extract infra field if present
+        infra = config.pop('infra', None)
+        resources_fields['infra'] = infra
+
+        # Keep backward compatibility with cloud, region, zone
+        # Note: if both `infra` and any of `cloud`, `region`, `zone` are
+        # specified, it will raise an error during the Resources.__init__
+        # validation.
         resources_fields['cloud'] = registry.CLOUD_REGISTRY.from_str(
             config.pop('cloud', None))
+        resources_fields['region'] = config.pop('region', None)
+        resources_fields['zone'] = config.pop('zone', None)
+
         resources_fields['instance_type'] = config.pop('instance_type', None)
         resources_fields['cpus'] = config.pop('cpus', None)
         resources_fields['memory'] = config.pop('memory', None)
@@ -1641,13 +1838,12 @@ class Resources:
             # exclusive by the schema validation.
             resources_fields['job_recovery'] = config.pop('job_recovery', None)
         resources_fields['disk_size'] = config.pop('disk_size', None)
-        resources_fields['region'] = config.pop('region', None)
-        resources_fields['zone'] = config.pop('zone', None)
         resources_fields['image_id'] = config.pop('image_id', None)
         resources_fields['disk_tier'] = config.pop('disk_tier', None)
         resources_fields['ports'] = config.pop('ports', None)
         resources_fields['labels'] = config.pop('labels', None)
         resources_fields['autostop'] = config.pop('autostop', None)
+        resources_fields['volumes'] = config.pop('volumes', None)
         resources_fields['_docker_login_config'] = config.pop(
             '_docker_login_config', None)
         resources_fields['_docker_username_for_runpod'] = config.pop(
@@ -1679,7 +1875,10 @@ class Resources:
             if value is not None and value != 'None':
                 config[key] = value
 
-        add_if_not_none('cloud', str(self.cloud))
+        # Construct infra field if cloud is set
+        infra = self.infra.to_str()
+        add_if_not_none('infra', infra)
+
         add_if_not_none('instance_type', self.instance_type)
         add_if_not_none('cpus', self._cpus)
         add_if_not_none('memory', self.memory)
@@ -1690,13 +1889,26 @@ class Resources:
             add_if_not_none('use_spot', self.use_spot)
         add_if_not_none('job_recovery', self.job_recovery)
         add_if_not_none('disk_size', self.disk_size)
-        add_if_not_none('region', self.region)
-        add_if_not_none('zone', self.zone)
         add_if_not_none('image_id', self.image_id)
         if self.disk_tier is not None:
             config['disk_tier'] = self.disk_tier.value
         add_if_not_none('ports', self.ports)
         add_if_not_none('labels', self.labels)
+        if self.volumes is not None:
+            # Convert DiskTier/StorageType enum to string value for each volume
+            volumes = []
+            for volume in self.volumes:
+                volume_copy = volume.copy()
+                if 'disk_tier' in volume_copy:
+                    volume_copy['disk_tier'] = volume_copy['disk_tier'].value
+                if 'storage_type' in volume_copy:
+                    volume_copy['storage_type'] = volume_copy[
+                        'storage_type'].value
+                if 'attach_mode' in volume_copy:
+                    volume_copy['attach_mode'] = volume_copy[
+                        'attach_mode'].value
+                volumes.append(volume_copy)
+            config['volumes'] = volumes
         if self._autostop_config is not None:
             config['autostop'] = self._autostop_config.to_yaml_config()
         if self._docker_login_config is not None:
@@ -1857,6 +2069,9 @@ class Resources:
         if version < 23:
             self._autostop_config = None
 
+        if version < 24:
+            self._volumes = None
+
         self.__dict__.update(state)
 
 

sky/serve/serve_utils.py

@@ -1027,11 +1027,9 @@ def _format_replica_table(replica_records: List[Dict[str, Any]],
         return 'No existing replicas.'
 
     replica_columns = [
-        'SERVICE_NAME', 'ID', 'VERSION', 'ENDPOINT', 'LAUNCHED', 'RESOURCES',
-        'STATUS', 'REGION'
+        'SERVICE_NAME', 'ID', 'VERSION', 'ENDPOINT', 'LAUNCHED', 'INFRA',
+        'RESOURCES', 'STATUS'
     ]
-    if show_all:
-        replica_columns.append('ZONE')
     replica_table = log_utils.create_table(replica_columns)
 
     truncate_hint = ''
@@ -1047,21 +1045,17 @@ def _format_replica_table(replica_records: List[Dict[str, Any]],
         version = (record['version'] if 'version' in record else '-')
         replica_endpoint = endpoint if endpoint else '-'
         launched_at = log_utils.readable_time_duration(record['launched_at'])
+        infra = '-'
         resources_str = '-'
         replica_status = record['status']
         status_str = replica_status.colored_str()
-        region = '-'
-        zone = '-'
 
         replica_handle: Optional['backends.CloudVmRayResourceHandle'] = record[
             'handle']
         if replica_handle is not None:
+            infra = replica_handle.launched_resources.infra.formatted_str()
             resources_str = resources_utils.get_readable_resources_repr(
                 replica_handle, simplify=not show_all)
-            if replica_handle.launched_resources.region is not None:
-                region = replica_handle.launched_resources.region
-            if replica_handle.launched_resources.zone is not None:
-                zone = replica_handle.launched_resources.zone
 
         replica_values = [
             service_name,
@@ -1069,12 +1063,10 @@ def _format_replica_table(replica_records: List[Dict[str, Any]],
             version,
             replica_endpoint,
             launched_at,
+            infra,
             resources_str,
             status_str,
-            region,
         ]
-        if show_all:
-            replica_values.append(zone)
         replica_table.add_row(replica_values)
 
     return f'{replica_table}{truncate_hint}'

sky/serve/server/core.py

@@ -141,8 +141,7 @@ def up(
     # 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.
-    dag, mutated_user_config = admin_policy_utils.apply(
-        task, use_mutated_config_in_current_request=False)
+    dag, mutated_user_config = admin_policy_utils.apply(task)
     task = dag.tasks[0]
 
     with rich_utils.safe_status(
@@ -352,8 +351,7 @@ def update(
     # and get the mutated config.
     # TODO(cblmemo,zhwu): If a user sets a new skypilot_config, the update
     # will not apply the config.
-    dag, _ = admin_policy_utils.apply(
-        task, use_mutated_config_in_current_request=False)
+    dag, _ = admin_policy_utils.apply(task)
     task = dag.tasks[0]
 
     assert task.service is not None