skypilot-nightly 1.0.0.dev20250529__py3-none-any.whl → 1.0.0.dev20250531__py3-none-any.whl

sky/provision/provisioner.py

@@ -15,6 +15,7 @@ import colorama
 import sky
 from sky import clouds
 from sky import exceptions
+from sky import global_user_state
 from sky import provision
 from sky import sky_logging
 from sky import skypilot_config
@@ -118,7 +119,7 @@ def bulk_provision(
         Cloud specific exceptions: If the provisioning process failed, cloud-
             specific exceptions will be raised by the cloud APIs.
     """
-    original_config = common_utils.read_yaml(cluster_yaml)
+    original_config = global_user_state.get_cluster_yaml_dict(cluster_yaml)
     head_node_type = original_config['head_node_type']
     bootstrap_config = provision_common.ProvisionConfig(
         provider_config=original_config['provider'],
@@ -413,9 +414,11 @@ def wait_for_ssh(cluster_info: provision_common.ClusterInfo,
 
 def _post_provision_setup(
         cloud_name: str, cluster_name: resources_utils.ClusterName,
-        cluster_yaml: str, provision_record: provision_common.ProvisionRecord,
+        handle_cluster_yaml: str,
+        provision_record: provision_common.ProvisionRecord,
         custom_resource: Optional[str]) -> provision_common.ClusterInfo:
-    config_from_yaml = common_utils.read_yaml(cluster_yaml)
+    config_from_yaml = global_user_state.get_cluster_yaml_dict(
+        handle_cluster_yaml)
     provider_config = config_from_yaml.get('provider')
     cluster_info = provision.get_cluster_info(cloud_name,
                                               provision_record.region,
@@ -446,7 +449,7 @@ def _post_provision_setup(
     # TODO(suquark): Move wheel build here in future PRs.
     # We don't set docker_user here, as we are configuring the VM itself.
     ssh_credentials = backend_utils.ssh_credential_from_yaml(
-        cluster_yaml, ssh_user=cluster_info.ssh_user)
+        handle_cluster_yaml, ssh_user=cluster_info.ssh_user)
     docker_config = config_from_yaml.get('docker', {})
 
     with rich_utils.safe_status(
@@ -657,7 +660,8 @@ def _post_provision_setup(
 @timeline.event
 def post_provision_runtime_setup(
         cloud_name: str, cluster_name: resources_utils.ClusterName,
-        cluster_yaml: str, provision_record: provision_common.ProvisionRecord,
+        handle_cluster_yaml: str,
+        provision_record: provision_common.ProvisionRecord,
         custom_resource: Optional[str],
         log_dir: str) -> provision_common.ClusterInfo:
     """Run internal setup commands after provisioning and before user setup.
@@ -675,11 +679,12 @@ def post_provision_runtime_setup(
     with provision_logging.setup_provision_logging(log_dir):
         try:
             logger.debug(_TITLE.format('System Setup After Provision'))
-            return _post_provision_setup(cloud_name,
-                                         cluster_name,
-                                         cluster_yaml=cluster_yaml,
-                                         provision_record=provision_record,
-                                         custom_resource=custom_resource)
+            return _post_provision_setup(
+                cloud_name,
+                cluster_name,
+                handle_cluster_yaml=handle_cluster_yaml,
+                provision_record=provision_record,
+                custom_resource=custom_resource)
         except Exception:  # pylint: disable=broad-except
             logger.error(
                 ux_utils.error_message(

sky/resources.py

@@ -98,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 = 25
+    _VERSION = 26
 
     def __init__(
         self,
@@ -117,6 +117,7 @@ class Resources:
         image_id: Union[Dict[Optional[str], str], str, None] = None,
         disk_size: Optional[int] = None,
         disk_tier: Optional[Union[str, resources_utils.DiskTier]] = None,
+        network_tier: Optional[Union[str, resources_utils.NetworkTier]] = None,
         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,
@@ -202,6 +203,8 @@ class Resources:
           disk_size: the size of the OS disk in GiB.
           disk_tier: the disk performance tier to use. If None, defaults to
             ``'medium'``.
+          network_tier: the network performance tier to use. If None, defaults to
+            ``'standard'``.
           ports: the ports to open on the instance.
           labels: the labels to apply to the instance. These are useful for
             assigning metadata that may be used by external tools.
@@ -309,6 +312,20 @@ class Resources:
             disk_tier = resources_utils.DiskTier(disk_tier_str)
         self._disk_tier = disk_tier
 
+        if isinstance(network_tier, str):
+            network_tier_str = str(network_tier).lower()
+            supported_tiers = [
+                tier.value for tier in resources_utils.NetworkTier
+            ]
+            if network_tier_str not in supported_tiers:
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError(
+                        f'Invalid network_tier {network_tier_str!r}. '
+                        f'Network tier must be one of '
+                        f'{", ".join(supported_tiers)}.')
+            network_tier = resources_utils.NetworkTier(network_tier_str)
+        self._network_tier = network_tier
+
         if ports is not None:
             if isinstance(ports, tuple):
                 ports = list(ports)
@@ -418,6 +435,10 @@ class Resources:
         if self.disk_tier is not None:
             disk_tier = f', disk_tier={self.disk_tier.value}'
 
+        network_tier = ''
+        if self.network_tier is not None:
+            network_tier = f', network_tier={self.network_tier.value}'
+
         disk_size = ''
         if self.disk_size != _DEFAULT_DISK_SIZE_GB:
             disk_size = f', disk_size={self.disk_size}'
@@ -437,7 +458,7 @@ class Resources:
         hardware_str = (
             f'{instance_type}{use_spot}'
             f'{cpus}{memory}{accelerators}{accelerator_args}{image_id}'
-            f'{disk_tier}{disk_size}{ports}')
+            f'{disk_tier}{network_tier}{disk_size}{ports}')
         # It may have leading ',' (for example, instance_type not set) or empty
         # spaces.  Remove them.
         while hardware_str and hardware_str[0] in (',', ' '):
@@ -567,6 +588,10 @@ class Resources:
     def disk_tier(self) -> Optional[resources_utils.DiskTier]:
         return self._disk_tier
 
+    @property
+    def network_tier(self) -> Optional[resources_utils.NetworkTier]:
+        return self._network_tier
+
     @property
     def ports(self) -> Optional[List[str]]:
         return self._ports
@@ -1223,7 +1248,6 @@ class Resources:
 
     def _try_validate_volumes(self) -> None:
         """Try to validate the volumes attribute.
-
         Raises:
             ValueError: if the attribute is invalid.
         """
@@ -1532,6 +1556,12 @@ class Resources:
                 if not (self.disk_tier <= other.disk_tier):  # pylint: disable=superfluous-parens
                     return False
 
+        if self.network_tier is not None:
+            if other.network_tier is None:
+                return False
+            if not self.network_tier <= other.network_tier:
+                return False
+
         if check_ports:
             if self.ports is not None:
                 if other.ports is None:
@@ -1586,6 +1616,7 @@ class Resources:
             not self._use_spot_specified,
             self._disk_size == _DEFAULT_DISK_SIZE_GB,
             self._disk_tier is None,
+            self._network_tier is None,
             self._image_id is None,
             self._ports is None,
             self._docker_login_config is None,
@@ -1629,6 +1660,7 @@ class Resources:
             zone=override.pop('zone', self.zone),
             image_id=override.pop('image_id', self.image_id),
             disk_tier=override.pop('disk_tier', self.disk_tier),
+            network_tier=override.pop('network_tier', self.network_tier),
             ports=override.pop('ports', self.ports),
             labels=override.pop('labels', self.labels),
             autostop=override.pop('autostop', current_autostop_config),
@@ -1667,6 +1699,9 @@ class Resources:
         if (self.disk_tier is not None and
                 self.disk_tier != resources_utils.DiskTier.BEST):
             features.add(clouds.CloudImplementationFeatures.CUSTOM_DISK_TIER)
+        if (self.network_tier is not None and
+                self.network_tier == resources_utils.NetworkTier.BEST):
+            features.add(clouds.CloudImplementationFeatures.CUSTOM_NETWORK_TIER)
         if self.extract_docker_image() is not None:
             features.add(clouds.CloudImplementationFeatures.DOCKER_IMAGE)
         elif self.image_id is not None:
@@ -1845,6 +1880,7 @@ class Resources:
         resources_fields['disk_size'] = config.pop('disk_size', None)
         resources_fields['image_id'] = config.pop('image_id', None)
         resources_fields['disk_tier'] = config.pop('disk_tier', None)
+        resources_fields['network_tier'] = config.pop('network_tier', None)
         resources_fields['ports'] = config.pop('ports', None)
         resources_fields['labels'] = config.pop('labels', None)
         resources_fields['autostop'] = config.pop('autostop', None)
@@ -1897,6 +1933,8 @@ class Resources:
         add_if_not_none('image_id', self.image_id)
         if self.disk_tier is not None:
             config['disk_tier'] = self.disk_tier.value
+        if self.network_tier is not None:
+            config['network_tier'] = self.network_tier.value
         add_if_not_none('ports', self.ports)
         add_if_not_none('labels', self.labels)
         if self.volumes is not None:
@@ -2081,6 +2119,9 @@ class Resources:
             if isinstance(state.get('_cloud', None), clouds.Kubernetes):
                 _maybe_add_docker_prefix_to_image_id(state['_image_id'])
 
+        if version < 26:
+            self._network_tier = state.get('_network_tier', None)
+
         self.__dict__.update(state)
 
 

sky/serve/controller.py

@@ -42,12 +42,13 @@ class SkyServeController:
     """
 
     def __init__(self, service_name: str, service_spec: serve.SkyServiceSpec,
-                 task_yaml: str, host: str, port: int) -> None:
+                 service_task_yaml: str, host: str, port: int) -> None:
         self._service_name = service_name
         self._replica_manager: replica_managers.ReplicaManager = (
-            replica_managers.SkyPilotReplicaManager(service_name=service_name,
-                                                    spec=service_spec,
-                                                    task_yaml_path=task_yaml))
+            replica_managers.SkyPilotReplicaManager(
+                service_name=service_name,
+                spec=service_spec,
+                service_task_yaml_path=service_task_yaml))
         self._autoscaler: autoscalers.Autoscaler = (
             autoscalers.Autoscaler.from_spec(service_name, service_spec))
         self._host = host
@@ -240,7 +241,9 @@ class SkyServeController:
 # TODO(tian): Probably we should support service that will stop the VM in
 # specific time period.
 def run_controller(service_name: str, service_spec: serve.SkyServiceSpec,
-                   task_yaml: str, controller_host: str, controller_port: int):
-    controller = SkyServeController(service_name, service_spec, task_yaml,
-                                    controller_host, controller_port)
+                   service_task_yaml: str, controller_host: str,
+                   controller_port: int):
+    controller = SkyServeController(service_name, service_spec,
+                                    service_task_yaml, controller_host,
+                                    controller_port)
     controller.run()

sky/serve/replica_managers.py

@@ -58,7 +58,7 @@ _MAX_NUM_LAUNCH = psutil.cpu_count() * 2
 # TODO(tian): Combine this with
 # sky/spot/recovery_strategy.py::StrategyExecutor::launch
 def launch_cluster(replica_id: int,
-                   task_yaml_path: str,
+                   service_task_yaml_path: str,
                    cluster_name: str,
                    resources_override: Optional[Dict[str, Any]] = None,
                    retry_until_up: bool = True,
@@ -78,7 +78,8 @@ def launch_cluster(replica_id: int,
                     f'{cluster_name} with resources override: '
                     f'{resources_override}')
     try:
-        config = common_utils.read_yaml(os.path.expanduser(task_yaml_path))
+        config = common_utils.read_yaml(
+            os.path.expanduser(service_task_yaml_path))
         task = sky.Task.from_yaml_config(config)
         if resources_override is not None:
             resources = task.resources
@@ -173,9 +174,9 @@ def terminate_cluster(cluster_name: str,
             time.sleep(gap_seconds)
 
 
-def _get_resources_ports(task_yaml: str) -> str:
+def _get_resources_ports(service_task_yaml_path: str) -> str:
     """Get the resources ports used by the task."""
-    task = sky.Task.from_yaml(task_yaml)
+    task = sky.Task.from_yaml(service_task_yaml_path)
     # Already checked all ports are valid in sky.serve.core.up
     assert task.resources, task
     assert task.service is not None, task
@@ -183,7 +184,7 @@ def _get_resources_ports(task_yaml: str) -> str:
     return task.service.ports
 
 
-def _should_use_spot(task_yaml: str,
+def _should_use_spot(service_task_yaml_path: str,
                      resource_override: Optional[Dict[str, Any]]) -> bool:
     """Get whether the task should use spot."""
     if resource_override is not None:
@@ -191,7 +192,7 @@ def _should_use_spot(task_yaml: str,
         if use_spot_override is not None:
             assert isinstance(use_spot_override, bool)
             return use_spot_override
-    task = sky.Task.from_yaml(task_yaml)
+    task = sky.Task.from_yaml(service_task_yaml_path)
     spot_use_resources = [
         resources for resources in task.resources if resources.use_spot
     ]
@@ -634,10 +635,10 @@ class SkyPilotReplicaManager(ReplicaManager):
     """
 
     def __init__(self, service_name: str, spec: 'service_spec.SkyServiceSpec',
-                 task_yaml_path: str) -> None:
+                 service_task_yaml_path: str) -> None:
         super().__init__(service_name, spec)
-        self._task_yaml_path = task_yaml_path
-        task = sky.Task.from_yaml(task_yaml_path)
+        self.service_task_yaml_path = service_task_yaml_path
+        task = sky.Task.from_yaml(service_task_yaml_path)
         self._spot_placer: Optional[spot_placer.SpotPlacer] = (
             spot_placer.SpotPlacer.from_task(spec, task))
         # TODO(tian): Store launch/down pid in the replica table, to make the
@@ -714,7 +715,8 @@ class SkyPilotReplicaManager(ReplicaManager):
             self._service_name, replica_id)
         log_file_name = serve_utils.generate_replica_launch_log_file_name(
             self._service_name, replica_id)
-        use_spot = _should_use_spot(self._task_yaml_path, resources_override)
+        use_spot = _should_use_spot(self.service_task_yaml_path,
+                                    resources_override)
         retry_until_up = True
         location = None
         if use_spot and self._spot_placer is not None:
@@ -742,10 +744,10 @@ class SkyPilotReplicaManager(ReplicaManager):
                 launch_cluster,
                 log_file_name,
             ).run,
-            args=(replica_id, self._task_yaml_path, cluster_name,
+            args=(replica_id, self.service_task_yaml_path, cluster_name,
                   resources_override, retry_until_up),
         )
-        replica_port = _get_resources_ports(self._task_yaml_path)
+        replica_port = _get_resources_ports(self.service_task_yaml_path)
 
         info = ReplicaInfo(replica_id, cluster_name, replica_port, use_spot,
                            location, self.latest_version, resources_override)
@@ -1290,11 +1292,11 @@ class SkyPilotReplicaManager(ReplicaManager):
             logger.error(f'Invalid version: {version}, '
                          f'latest version: {self.latest_version}')
             return
-        task_yaml_path = serve_utils.generate_task_yaml_file_name(
+        service_task_yaml_path = serve_utils.generate_task_yaml_file_name(
             self._service_name, version)
         serve_state.add_or_update_version(self._service_name, version, spec)
         self.latest_version = version
-        self._task_yaml_path = task_yaml_path
+        self.service_task_yaml_path = service_task_yaml_path
         self._update_mode = update_mode
 
         # Reuse all replicas that have the same config as the new version
@@ -1302,7 +1304,8 @@ class SkyPilotReplicaManager(ReplicaManager):
         # the latest version. This can significantly improve the speed
         # for updating an existing service with only config changes to the
         # service specs, e.g. scale down the service.
-        new_config = common_utils.read_yaml(os.path.expanduser(task_yaml_path))
+        new_config = common_utils.read_yaml(
+            os.path.expanduser(service_task_yaml_path))
         # Always create new replicas and scale down old ones when file_mounts
         # are not empty.
         if new_config.get('file_mounts', None) != {}:
@@ -1313,10 +1316,11 @@ class SkyPilotReplicaManager(ReplicaManager):
         for info in replica_infos:
             if info.version < version and not info.is_terminal:
                 # Assume user does not change the yaml file on the controller.
-                old_task_yaml_path = serve_utils.generate_task_yaml_file_name(
-                    self._service_name, info.version)
+                old_service_task_yaml_path = (
+                    serve_utils.generate_task_yaml_file_name(
+                        self._service_name, info.version))
                 old_config = common_utils.read_yaml(
-                    os.path.expanduser(old_task_yaml_path))
+                    os.path.expanduser(old_service_task_yaml_path))
                 for key in ['service']:
                     old_config.pop(key)
                 # Bump replica version if all fields except for service are

sky/serve/service.py

@@ -186,7 +186,8 @@ def _start(service_name: str, tmp_task_yaml: str, job_id: int):
 
     service_dir = os.path.expanduser(
         serve_utils.generate_remote_service_dir_name(service_name))
-    task_yaml = serve_utils.generate_task_yaml_file_name(service_name, version)
+    service_task_yaml = serve_utils.generate_task_yaml_file_name(
+        service_name, version)
 
     if not is_recovery:
         if (len(serve_state.get_services()) >=
@@ -218,7 +219,7 @@ def _start(service_name: str, tmp_task_yaml: str, job_id: int):
         # don't want the new file mounts to overwrite the old one, so we
         # sync to a tmp file first and then copy it to the final name
         # if there is no name conflict.
-        shutil.copy(tmp_task_yaml, task_yaml)
+        shutil.copy(tmp_task_yaml, service_task_yaml)
 
     controller_process = None
     load_balancer_process = None
@@ -249,8 +250,8 @@ def _start(service_name: str, tmp_task_yaml: str, job_id: int):
             controller_host = _get_controller_host()
             controller_process = multiprocessing.Process(
                 target=controller.run_controller,
-                args=(service_name, service_spec, task_yaml, controller_host,
-                      controller_port))
+                args=(service_name, service_spec, service_task_yaml,
+                      controller_host, controller_port))
             controller_process.start()
 
             if not is_recovery:

sky/server/common.py

@@ -533,10 +533,13 @@ def check_server_healthy_or_start_fn(deploy: bool = False,
     api_server_status = None
     try:
         api_server_status = check_server_healthy()
+        if api_server_status == ApiServerStatus.NEEDS_AUTH:
+            endpoint = get_server_url()
+            with ux_utils.print_exception_no_traceback():
+                raise exceptions.ApiServerAuthenticationError(endpoint)
     except exceptions.ApiServerConnectionError as exc:
         endpoint = get_server_url()
-        if (not is_api_server_local() or
-                api_server_status == ApiServerStatus.NEEDS_AUTH):
+        if not is_api_server_local():
             with ux_utils.print_exception_no_traceback():
                 raise exceptions.ApiServerConnectionError(endpoint) from exc
         # Lock to prevent multiple processes from starting the server at the

sky/server/constants.py

@@ -7,7 +7,7 @@ from sky.skylet import constants
 # API server version, whenever there is a change in API server that requires a
 # restart of the local API server or error out when the client does not match
 # the server version.
-API_VERSION = '6'
+API_VERSION = '7'
 
 # Prefix for API request names.
 REQUEST_NAME_PREFIX = 'sky.'

sky/server/requests/payloads.py

@@ -376,6 +376,7 @@ class JobsLogsBody(RequestBody):
     follow: bool = True
     controller: bool = False
     refresh: bool = False
+    tail: Optional[int] = None
 
 
 class RequestCancelBody(RequestBody):

sky/server/stream_utils.py

@@ -15,6 +15,8 @@ from sky.utils import rich_utils
 
 logger = sky_logging.init_logger(__name__)
 
+_HEARTBEAT_INTERVAL = 30
+
 
 async def _yield_log_file_with_payloads_skipped(
         log_file) -> AsyncGenerator[str, None]:
@@ -90,6 +92,8 @@ async def log_streamer(request_id: Optional[str],
             for line_str in lines:
                 yield line_str
 
+        last_heartbeat_time = asyncio.get_event_loop().time()
+
         while True:
             # Sleep 0 to yield control to allow other coroutines to run,
             # while keeps the loop tight to make log stream responsive.
@@ -106,15 +110,32 @@ async def log_streamer(request_id: Optional[str],
                         break
                 if not follow:
                     break
+
+                current_time = asyncio.get_event_loop().time()
+                if current_time - last_heartbeat_time >= _HEARTBEAT_INTERVAL:
+                    # Currently just used to keep the connection busy, refer to
+                    # https://github.com/skypilot-org/skypilot/issues/5750 for
+                    # more details.
+                    yield message_utils.encode_payload(
+                        rich_utils.Control.HEARTBEAT.encode(''))
+                    last_heartbeat_time = current_time
+
                 # Sleep shortly to avoid storming the DB and CPU, this has
                 # little impact on the responsivness here since we are waiting
                 # for a new line to come in.
                 await asyncio.sleep(0.1)
                 continue
+
+            # Refresh the heartbeat time, this is a trivial optimization for
+            # performance but it helps avoid unnecessary heartbeat strings
+            # being printed when the client runs in an old version.
+            last_heartbeat_time = asyncio.get_event_loop().time()
             line_str = line.decode('utf-8')
             if plain_logs:
                 is_payload, line_str = message_utils.decode_payload(
                     line_str, raise_for_mismatch=False)
+                # TODO(aylei): implement heartbeat mechanism for plain logs,
+                # sending invisible characters might be okay.
                 if is_payload:
                     continue
             yield line_str

sky/templates/kubernetes-ray.yml.j2

@@ -395,6 +395,13 @@ available_node_types:
               # STEP 1: Run apt update, install missing packages, and set up ssh.
               (
                 (
+                # For backwards compatibility, we put a marker file in the pod
+                # to indicate that the apt ssh setup step will write a completion
+                # marker file (/tmp/apt_ssh_setup_complete) to the pod.
+                # TODO: Remove this marker file and its usage in setup_commands
+                # after v0.11.0 release.
+                touch /tmp/apt_ssh_setup_started
+
                 DEBIAN_FRONTEND=noninteractive $(prefix_cmd) apt-get update > /tmp/apt-update.log 2>&1 || \
                 echo "Warning: apt-get update failed. Continuing anyway..." >> /tmp/apt-update.log
                 # Install both fuse2 and fuse3 for compatibility for all possible fuse adapters in advance,
@@ -402,7 +409,7 @@ available_node_types:
                 PACKAGES="rsync curl wget netcat gcc patch pciutils fuse fuse3 openssh-server";
 
                 # Separate packages into two groups: packages that are installed first
-                # so that curl, rsync and wget are available sooner to unblock the following
+                # so that curl, rsync, ssh and wget are available sooner to unblock the following
                 # conda installation and rsync.
                 # Also, we install fuse first to avoid confliction with fuse3.
                 set -e
@@ -494,6 +501,8 @@ available_node_types:
                 $(prefix_cmd) service ssh restart;
                 $(prefix_cmd) sed -i "s/mesg n/tty -s \&\& mesg n/" ~/.profile;
 
+                touch /tmp/apt_ssh_setup_complete
+                echo "=== SSH setup completed ==="
                 ) > /tmp/${STEPS[0]}.log 2>&1 || {
                   echo "Error: ${STEPS[0]} failed. Continuing anyway..." > /tmp/${STEPS[0]}.failed
                   cat /tmp/${STEPS[0]}.log
@@ -688,6 +697,13 @@ available_node_types:
               {{k8s_resource_key}}: {{accelerator_count}}
               {% endif %}
             {% endif %}
+          {% if k8s_ipc_lock_capability %}
+          securityContext:
+            capabilities:
+              add:
+                - IPC_LOCK
+          {% endif %}
+
 
       {% if high_availability %}
       pvc_spec:
@@ -791,6 +807,15 @@ setup_commands:
     {%- endfor %}
     STEPS=("apt-ssh-setup" "runtime-setup" "env-setup")
     start_epoch=$(date +%s);
+    
+    # Wait for SSH setup to complete before proceeding
+    if [ -f /tmp/apt_ssh_setup_started ]; then
+      echo "=== Logs for asynchronous SSH setup ===";
+      [ -f /tmp/apt_ssh_setup_complete ] && cat /tmp/${STEPS[0]}.log ||
+      { tail -f -n +1 /tmp/${STEPS[0]}.log & TAIL_PID=$!; echo "Tail PID: $TAIL_PID"; until [ -f /tmp/apt_ssh_setup_complete ]; do sleep 0.5; done; kill $TAIL_PID || true; };
+      [ -f /tmp/${STEPS[0]}.failed ] && { echo "Error: ${STEPS[0]} failed. Exiting."; exit 1; } || true;
+    fi
+    
     echo "=== Logs for asynchronous ray and skypilot installation ===";
     if [ -f /tmp/skypilot_is_nimbus ]; then
       echo "=== Logs for asynchronous ray and skypilot installation ===";

sky/utils/common_utils.py

@@ -324,9 +324,75 @@ def get_pretty_entrypoint_cmd() -> str:
         # Turn '/.../anaconda/envs/py36/bin/sky' into 'sky', but keep other
         # things like 'examples/app.py'.
         argv[0] = basename
+
+    # Redact sensitive environment variable values
+    argv = _redact_env_values(argv)
+
     return ' '.join(argv)
 
 
+def _redact_env_values(argv: List[str]) -> List[str]:
+    """Redact sensitive values from --env arguments.
+
+    Args:
+        argv: Command line arguments
+
+    Returns:
+        Modified argv with redacted --env values, or original argv if any error
+
+    Examples:
+        ['sky', 'launch', '--env', 'HF_TOKEN=secret'] ->
+        ['sky', 'launch', '--env', 'HF_TOKEN=<redacted>']
+
+        ['sky', 'launch', '--env=HF_TOKEN=secret'] ->
+        ['sky', 'launch', '--env=HF_TOKEN=<redacted>']
+
+        ['sky', 'launch', '--env', 'HF_TOKEN'] ->
+        ['sky', 'launch', '--env', 'HF_TOKEN'] (no change)
+    """
+    try:
+        if not argv:
+            return argv or []
+
+        result = []
+        i = 0
+
+        while i < len(argv):
+            arg = argv[i]
+
+            # Ensure arg is a string
+            if not isinstance(arg, str):
+                result.append(arg)
+                i += 1
+                continue
+
+            if arg == '--env' and i + 1 < len(argv):
+                result.append(arg)
+                next_arg = argv[i + 1]
+                # Ensure next_arg is a string and handle redaction safely
+                if isinstance(next_arg, str):
+                    redacted = re.sub(r'^([^=]+)=.*', r'\1=<redacted>',
+                                      next_arg)
+                    result.append(redacted)
+                else:
+                    result.append(next_arg)
+                i += 2
+            elif arg.startswith('--env='):
+                # Redact only if there's a value after the key
+                redacted = re.sub(r'^(--env=[^=]+)=.*', r'\1=<redacted>', arg)
+                result.append(redacted)
+                i += 1
+            else:
+                result.append(arg)
+                i += 1
+
+        return result
+    except Exception:  # pylint: disable=broad-except
+        # If anything goes wrong with redaction, return original argv
+        # This ensures the command can still execute
+        return argv or []
+
+
 def user_and_hostname_hash() -> str:
     """Returns a string containing <user>-<hostname hash last 4 chars>.
 

sky/utils/resources_utils.py

@@ -50,6 +50,32 @@ class DiskTier(enum.Enum):
         return types.index(self) <= types.index(other)
 
 
+class NetworkTier(enum.Enum):
+    """All network tiers supported by SkyPilot."""
+    STANDARD = 'standard'
+    BEST = 'best'
+
+    @classmethod
+    def supported_tiers(cls) -> List[str]:
+        return [tier.value for tier in cls]
+
+    @classmethod
+    def cli_help_message(cls) -> str:
+        return (
+            f'Network tier. Could be one of {", ".join(cls.supported_tiers())}'
+            f'. Default: {cls.STANDARD.value}')
+
+    @classmethod
+    def from_str(cls, tier: str) -> 'NetworkTier':
+        if tier not in cls.supported_tiers():
+            raise ValueError(f'Invalid network tier: {tier}')
+        return cls(tier)
+
+    def __le__(self, other: 'NetworkTier') -> bool:
+        types = list(NetworkTier)
+        return types.index(self) <= types.index(other)
+
+
 class StorageType(enum.Enum):
     """Storage type."""
     # Durable network storage, e.g. GCP persistent disks