skypilot-nightly 1.0.0.dev20250203__py3-none-any.whl → 1.0.0.dev20250205__py3-none-any.whl

sky/jobs/scheduler.py

@@ -60,6 +60,14 @@ logger = sky_logging.init_logger('sky.jobs.controller')
 _MANAGED_JOB_SCHEDULER_LOCK = '~/.sky/locks/managed_job_scheduler.lock'
 _ALIVE_JOB_LAUNCH_WAIT_INTERVAL = 0.5
 
+# Based on testing, assume a running job uses 350MB memory.
+JOB_MEMORY_MB = 350
+# Past 2000 simultaneous jobs, we become unstable.
+# See https://github.com/skypilot-org/skypilot/issues/4649.
+MAX_JOB_LIMIT = 2000
+# Number of ongoing launches launches allowed per CPU.
+LAUNCHES_PER_CPU = 4
+
 
 @lru_cache(maxsize=1)
 def _get_lock_path() -> str:
@@ -247,15 +255,16 @@ def _set_alive_waiting(job_id: int) -> None:
 
 
 def _get_job_parallelism() -> int:
-    # Assume a running job uses 350MB memory.
-    # We observe 230-300 in practice.
-    job_memory = 350 * 1024 * 1024
-    return max(psutil.virtual_memory().total // job_memory, 1)
+    job_memory = JOB_MEMORY_MB * 1024 * 1024
+
+    job_limit = min(psutil.virtual_memory().total // job_memory, MAX_JOB_LIMIT)
+
+    return max(job_limit, 1)
 
 
 def _get_launch_parallelism() -> int:
     cpus = os.cpu_count()
-    return cpus * 4 if cpus is not None else 1
+    return cpus * LAUNCHES_PER_CPU if cpus is not None else 1
 
 
 def _can_start_new_job() -> bool:

sky/provision/__init__.py

@@ -22,6 +22,7 @@ from sky.provision import kubernetes
 from sky.provision import lambda_cloud
 from sky.provision import oci
 from sky.provision import runpod
+from sky.provision import vast
 from sky.provision import vsphere
 from sky.utils import command_runner
 from sky.utils import timeline

sky/provision/lambda_cloud/instance.py

@@ -64,6 +64,21 @@ def _get_ssh_key_name(prefix: str = '') -> str:
     return name
 
 
+def _get_private_ip(instance_info: Dict[str, Any], single_node: bool) -> str:
+    private_ip = instance_info.get('private_ip')
+    if private_ip is None:
+        if single_node:
+            # The Lambda cloud API may return an instance info without
+            # private IP. It does not align with their docs, but we still
+            # allow single-node cluster to proceed with provisioning, by using
+            # 127.0.0.1, as private IP is not critical for single-node case.
+            return '127.0.0.1'
+        msg = f'Failed to retrieve private IP for instance {instance_info}.'
+        logger.error(msg)
+        raise RuntimeError(msg)
+    return private_ip
+
+
 def run_instances(region: str, cluster_name_on_cloud: str,
                   config: common.ProvisionConfig) -> common.ProvisionRecord:
     """Runs instances for the given cluster"""
@@ -197,13 +212,14 @@ def get_cluster_info(
 ) -> common.ClusterInfo:
     del region  # unused
     running_instances = _filter_instances(cluster_name_on_cloud, ['active'])
+    single_node = len(running_instances) == 1
     instances: Dict[str, List[common.InstanceInfo]] = {}
     head_instance_id = None
     for instance_id, instance_info in running_instances.items():
         instances[instance_id] = [
             common.InstanceInfo(
                 instance_id=instance_id,
-                internal_ip=instance_info['private_ip'],
+                internal_ip=_get_private_ip(instance_info, single_node),
                 external_ip=instance_info['ip'],
                 ssh_port=22,
                 tags={},

sky/provision/vast/__init__.py

@@ -0,0 +1,10 @@
+"""Vast provisioner for SkyPilot."""
+
+from sky.provision.vast.config import bootstrap_instances
+from sky.provision.vast.instance import cleanup_ports
+from sky.provision.vast.instance import get_cluster_info
+from sky.provision.vast.instance import query_instances
+from sky.provision.vast.instance import run_instances
+from sky.provision.vast.instance import stop_instances
+from sky.provision.vast.instance import terminate_instances
+from sky.provision.vast.instance import wait_instances

sky/provision/vast/config.py

@@ -0,0 +1,11 @@
+"""Vast configuration bootstrapping."""
+
+from sky.provision import common
+
+
+def bootstrap_instances(
+        region: str, cluster_name: str,
+        config: common.ProvisionConfig) -> common.ProvisionConfig:
+    """Bootstraps instances for the given cluster."""
+    del region, cluster_name  # unused
+    return config

sky/provision/vast/instance.py

@@ -0,0 +1,247 @@
+"""Vast instance provisioning."""
+import time
+from typing import Any, Dict, List, Optional
+
+from sky import sky_logging
+from sky import status_lib
+from sky.provision import common
+from sky.provision.vast import utils
+from sky.utils import common_utils
+from sky.utils import ux_utils
+
+POLL_INTERVAL = 10
+
+logger = sky_logging.init_logger(__name__)
+# a much more convenient method
+status_filter = lambda machine_dict, stat_list: {
+    k: v for k, v in machine_dict.items() if v['status'] in stat_list
+}
+
+
+def _filter_instances(cluster_name_on_cloud: str,
+                      status_filters: Optional[List[str]],
+                      head_only: bool = False) -> Dict[str, Any]:
+
+    instances = utils.list_instances()
+    possible_names = [f'{cluster_name_on_cloud}-head']
+    if not head_only:
+        possible_names.append(f'{cluster_name_on_cloud}-worker')
+
+    filtered_instances = {}
+    for instance_id, instance in instances.items():
+        if (status_filters is not None and
+                instance['status'] not in status_filters):
+            continue
+        if instance.get('name') in possible_names:
+            filtered_instances[instance_id] = instance
+    return filtered_instances
+
+
+def _get_head_instance_id(instances: Dict[str, Any]) -> Optional[str]:
+    for inst_id, inst in instances.items():
+        if inst['name'].endswith('-head'):
+            return inst_id
+    return None
+
+
+def run_instances(region: str, cluster_name_on_cloud: str,
+                  config: common.ProvisionConfig) -> common.ProvisionRecord:
+    """Runs instances for the given cluster."""
+    pending_status = ['CREATED', 'RESTARTING']
+
+    created_instance_ids = []
+    instances: Dict[str, Any] = {}
+
+    while True:
+        instances = _filter_instances(cluster_name_on_cloud, None)
+        if not status_filter(instances, pending_status):
+            break
+        logger.info(f'Waiting for {len(instances)} instances to be ready.')
+        time.sleep(POLL_INTERVAL)
+
+    running_instances = status_filter(instances, ['RUNNING'])
+    head_instance_id = _get_head_instance_id(running_instances)
+    stopped_instances = status_filter(instances, ['EXITED', 'STOPPED'])
+
+    if config.resume_stopped_nodes and stopped_instances:
+        for instance in stopped_instances.values():
+            utils.start(instance['id'])
+    else:
+        to_start_count = config.count - (len(running_instances) +
+                                         len(stopped_instances))
+        if to_start_count < 0:
+            raise RuntimeError(f'Cluster {cluster_name_on_cloud} already has '
+                               f'{len(running_instances)} nodes,'
+                               f'but {config.count} are required.')
+        if to_start_count == 0:
+            if head_instance_id is None:
+                raise RuntimeError(
+                    f'Cluster {cluster_name_on_cloud} has no head node.')
+            logger.info(
+                f'Cluster {cluster_name_on_cloud} already has '
+                f'{len(running_instances)} nodes, no need to start more.')
+            return common.ProvisionRecord(provider_name='vast',
+                                          cluster_name=cluster_name_on_cloud,
+                                          region=region,
+                                          zone=None,
+                                          head_instance_id=head_instance_id,
+                                          resumed_instance_ids=[],
+                                          created_instance_ids=[])
+
+        for _ in range(to_start_count):
+            node_type = 'head' if head_instance_id is None else 'worker'
+            try:
+                instance_id = utils.launch(
+                    name=f'{cluster_name_on_cloud}-{node_type}',
+                    instance_type=config.node_config['InstanceType'],
+                    region=region,
+                    disk_size=config.node_config['DiskSize'],
+                    preemptible=config.node_config['Preemptible'],
+                    image_name=config.node_config['ImageId'])
+            except Exception as e:  # pylint: disable=broad-except
+                logger.warning(f'run_instances error: {e}')
+                raise
+            logger.info(f'Launched instance {instance_id}.')
+            created_instance_ids.append(instance_id)
+            if head_instance_id is None:
+                head_instance_id = instance_id
+
+    # Wait for instances to be ready.
+    while True:
+        instances = _filter_instances(cluster_name_on_cloud, ['RUNNING'])
+        ready_instance_cnt = 0
+        for instance_id, instance in instances.items():
+            if instance.get('ssh_port') is not None:
+                ready_instance_cnt += 1
+        logger.info('Waiting for instances to be ready: '
+                    f'({ready_instance_cnt}/{config.count}).')
+        if ready_instance_cnt == config.count:
+            break
+
+        time.sleep(POLL_INTERVAL)
+
+    head_instance_id = _get_head_instance_id(utils.list_instances())
+    assert head_instance_id is not None, 'head_instance_id should not be None'
+    return common.ProvisionRecord(provider_name='vast',
+                                  cluster_name=cluster_name_on_cloud,
+                                  region=region,
+                                  zone=None,
+                                  head_instance_id=head_instance_id,
+                                  resumed_instance_ids=[],
+                                  created_instance_ids=created_instance_ids)
+
+
+def wait_instances(region: str, cluster_name_on_cloud: str,
+                   state: Optional[status_lib.ClusterStatus]) -> None:
+    del region, cluster_name_on_cloud, state
+
+
+def stop_instances(
+    cluster_name_on_cloud: str,
+    provider_config: Optional[Dict[str, Any]] = None,
+    worker_only: bool = False,
+) -> None:
+    return action_instances('stop', cluster_name_on_cloud, provider_config,
+                            worker_only)
+
+
+def terminate_instances(
+    cluster_name_on_cloud: str,
+    provider_config: Optional[Dict[str, Any]] = None,
+    worker_only: bool = False,
+) -> None:
+    return action_instances('remove', cluster_name_on_cloud, provider_config,
+                            worker_only)
+
+
+def action_instances(
+    fn: str,
+    cluster_name_on_cloud: str,
+    provider_config: Optional[Dict[str, Any]] = None,
+    worker_only: bool = False,
+) -> None:
+    """See sky/provision/__init__.py"""
+    del provider_config  # unused
+    instances = _filter_instances(cluster_name_on_cloud, None)
+    for inst_id, inst in instances.items():
+        logger.debug(f'Instance {fn} {inst_id}: {inst}')
+        if worker_only and inst['name'].endswith('-head'):
+            continue
+        try:
+            getattr(utils, fn)(inst_id)
+        except Exception as e:  # pylint: disable=broad-except
+            with ux_utils.print_exception_no_traceback():
+                raise RuntimeError(
+                    f'Failed to {fn} instance {inst_id}: '
+                    f'{common_utils.format_exception(e, use_bracket=False)}'
+                ) from e
+
+
+def get_cluster_info(
+        region: str,
+        cluster_name_on_cloud: str,
+        provider_config: Optional[Dict[str, Any]] = None) -> common.ClusterInfo:
+    del region  # unused
+    running_instances = _filter_instances(cluster_name_on_cloud, ['RUNNING'])
+    instances: Dict[str, List[common.InstanceInfo]] = {}
+    head_instance_id = None
+    for instance_id, instance_info in running_instances.items():
+        instances[instance_id] = [
+            common.InstanceInfo(
+                instance_id=instance_id,
+                internal_ip=instance_info['local_ipaddrs'].strip(),
+                external_ip=instance_info['public_ipaddr'],
+                ssh_port=instance_info['ports']['22/tcp'][0]['HostPort'],
+                tags={},
+            )
+        ]
+        if instance_info['name'].endswith('-head'):
+            head_instance_id = instance_id
+
+    return common.ClusterInfo(
+        instances=instances,
+        head_instance_id=head_instance_id,
+        provider_name='vast',
+        provider_config=provider_config,
+    )
+
+
+def open_ports(
+    cluster_name_on_cloud: str,
+    ports: List[str],
+    provider_config: Optional[Dict[str, Any]] = None,
+) -> None:
+    raise NotImplementedError('open_ports is not supported for Vast')
+
+
+def query_instances(
+    cluster_name_on_cloud: str,
+    provider_config: Optional[Dict[str, Any]] = None,
+    non_terminated_only: bool = True,
+) -> Dict[str, Optional[status_lib.ClusterStatus]]:
+    """See sky/provision/__init__.py"""
+
+    assert provider_config is not None, (cluster_name_on_cloud, provider_config)
+    instances = _filter_instances(cluster_name_on_cloud, None)
+    # "running", "frozen", "stopped", "unknown", "loading"
+    status_map = {
+        'LOADING': status_lib.ClusterStatus.INIT,
+        'EXITED': status_lib.ClusterStatus.STOPPED,
+        'STOPPED': status_lib.ClusterStatus.STOPPED,
+        'RUNNING': status_lib.ClusterStatus.UP,
+    }
+    statuses: Dict[str, Optional[status_lib.ClusterStatus]] = {}
+    for inst_id, inst in instances.items():
+        status = status_map[inst['status']]
+        if non_terminated_only and status is None:
+            continue
+        statuses[inst_id] = status
+    return statuses
+
+
+def cleanup_ports(
+    cluster_name_on_cloud: str,
+    ports: List[str],
+    provider_config: Optional[Dict[str, Any]] = None,
+) -> None:
+    del cluster_name_on_cloud, ports, provider_config  # Unused.

sky/provision/vast/utils.py

@@ -0,0 +1,161 @@
+# pylint: disable=assignment-from-no-return
+#
+# The pylint exception above is an accomodation for
+# false positives generated by pylint for the Vast
+# python sdk.
+#
+"""Vast library wrapper for SkyPilot."""
+from typing import Any, Dict, List
+
+from sky import sky_logging
+from sky.adaptors import vast
+
+logger = sky_logging.init_logger(__name__)
+
+
+def list_instances() -> Dict[str, Dict[str, Any]]:
+    """Lists instances associated with API key."""
+    instances = vast.vast().show_instances()
+
+    instance_dict: Dict[str, Dict[str, Any]] = {}
+    for instance in instances:
+        instance['id'] = str(instance['id'])
+        info = instance
+
+        if isinstance(instance['actual_status'], str):
+            info['status'] = instance['actual_status'].upper()
+        else:
+            info['status'] = 'UNKNOWN'
+        info['name'] = instance['label']
+
+        instance_dict[instance['id']] = info
+
+    return instance_dict
+
+
+def launch(name: str, instance_type: str, region: str, disk_size: int,
+           image_name: str, preemptible: bool) -> str:
+    """Launches an instance with the given parameters.
+
+    Converts the instance_type to the Vast GPU name, finds the specs for the
+    GPU, and launches the instance.
+
+    Notes:
+
+      *  `georegion`: This is a feature flag to provide an additional
+         scope of geographical specificy while maintaining backward
+         compatibility.
+
+      *  `chunked`: This is a feature flag to give breadth to the
+         snowflake nature of the vast catalog marketplace. It rounds
+         down various specifications of machines to emulate an instance
+         type and make them more interchangeable.
+
+      *  `disk_size`: We look for instances that are of the requested
+         size or greater than it. For instance, `disk_size=100` might
+         return something with `disk_size` at 102 or even 1000.
+
+         The disk size {xx} GB is not exactly matched the requested
+         size {yy} GB. It is possible to charge extra cost on disk.
+
+      *  `geolocation`: Geolocation on Vast can be as specific as the
+         host chooses to be. They can say, for instance, "Yutakachō,
+         Shinagawa District, Tokyo, JP." Such a specific geolocation
+         as ours would fail to return this host in a simple string
+         comparison if a user searched for "JP".
+
+         Since regardless of specificity, all our geolocations end
+         in two-letter country codes we just snip that to conform
+         to how many providers state their geolocation.
+
+      *  Since the catalog is cached, we can't gaurantee availability
+         of any machine at the point of inquiry.  As a consequence we
+         search for the machine again and potentially return a failure
+         if there is no availability.
+
+	  *  We pass in the cpu_ram here as a guarantor to make sure the
+		 instance we match with will be compliant with the requested
+		 amount of memory.
+
+      *  Vast instance types are an invention for skypilot. Refer to
+         service_catalog/vast_catalog.py for the current construction
+         of the type.
+
+    """
+    cpu_ram = float(instance_type.split('-')[-1]) / 1024
+    gpu_name = instance_type.split('-')[1].replace('_', ' ')
+    num_gpus = int(instance_type.split('-')[0].replace('x', ''))
+
+    query = ' '.join([
+        'chunked=true',
+        'georegion=true',
+        f'geolocation="{region[-2:]}"',
+        f'disk_space>={disk_size}',
+        f'num_gpus={num_gpus}',
+        f'gpu_name="{gpu_name}"',
+        f'cpu_ram>="{cpu_ram}"',
+    ])
+
+    instance_list = vast.vast().search_offers(query=query)
+
+    if isinstance(instance_list, int) or len(instance_list) == 0:
+        raise RuntimeError('Failed to create instances, could not find an '
+                           f'offer that satisfies the requirements "{query}".')
+
+    instance_touse = instance_list[0]
+
+    launch_params = {
+        'id': instance_touse['id'],
+        'direct': True,
+        'ssh': True,
+        'env': '-e __SOURCE=skypilot',
+        'onstart_cmd': ';'.join([
+            'touch ~/.no_auto_tmux',
+            f'echo "{vast.vast().api_key_access}" > ~/.vast_api_key',
+        ]),
+        'label': name,
+        'image': image_name
+    }
+
+    if preemptible:
+        launch_params['min_bid'] = instance_touse['min_bid']
+
+    new_instance_contract = vast.vast().create_instance(**launch_params)
+
+    new_instance = vast.vast().show_instance(
+        id=new_instance_contract['new_contract'])
+
+    return new_instance['id']
+
+
+def start(instance_id: str) -> None:
+    """Starts the given instance."""
+    vast.vast().start_instance(id=instance_id)
+
+
+def stop(instance_id: str) -> None:
+    """Stops the given instance."""
+    vast.vast().stop_instance(id=instance_id)
+
+
+def remove(instance_id: str) -> None:
+    """Terminates the given instance."""
+    vast.vast().destroy_instance(id=instance_id)
+
+
+def get_ssh_ports(cluster_name: str) -> List[int]:
+    """Gets the SSH ports for the given cluster."""
+    logger.debug(f'Getting SSH ports for cluster {cluster_name}.')
+
+    instances = list_instances()
+    possible_names = [f'{cluster_name}-head', f'{cluster_name}-worker']
+
+    ssh_ports = []
+
+    for instance in instances.values():
+        if instance['name'] in possible_names:
+            ssh_ports.append(instance['ssh_port'])
+    assert ssh_ports, (
+        f'Could not find any instances for cluster {cluster_name}.')
+
+    return ssh_ports

sky/serve/serve_state.py

@@ -55,33 +55,35 @@ def create_table(cursor: 'sqlite3.Cursor', conn: 'sqlite3.Connection') -> None:
         PRIMARY KEY (service_name, replica_id))""")
     cursor.execute("""\
         CREATE TABLE IF NOT EXISTS version_specs (
-        version INTEGER, 
+        version INTEGER,
         service_name TEXT,
         spec BLOB,
         PRIMARY KEY (service_name, version))""")
     conn.commit()
 
+    # Backward compatibility.
+    db_utils.add_column_to_table(cursor, conn, 'services',
+                                 'requested_resources_str', 'TEXT')
+    # Deprecated: switched to `active_versions` below for the version
+    # considered active by the load balancer. The
+    # authscaler/replica_manager version can be found in the
+    # version_specs table.
+    db_utils.add_column_to_table(
+        cursor, conn, 'services', 'current_version',
+        f'INTEGER DEFAULT {constants.INITIAL_VERSION}')
+    # The versions that is activated for the service. This is a list
+    # of integers in json format.
+    db_utils.add_column_to_table(cursor, conn, 'services', 'active_versions',
+                                 f'TEXT DEFAULT {json.dumps([])!r}')
+    db_utils.add_column_to_table(cursor, conn, 'services',
+                                 'load_balancing_policy', 'TEXT DEFAULT NULL')
+    # Whether the service's load balancer is encrypted with TLS.
+    db_utils.add_column_to_table(cursor, conn, 'services', 'tls_encrypted',
+                                 'INTEGER DEFAULT 0')
+    conn.commit()
+
 
-_DB = db_utils.SQLiteConn(_DB_PATH, create_table)
-# Backward compatibility.
-db_utils.add_column_to_table(_DB.cursor, _DB.conn, 'services',
-                             'requested_resources_str', 'TEXT')
-# Deprecated: switched to `active_versions` below for the version considered
-# active by the load balancer. The authscaler/replica_manager version can be
-# found in the version_specs table.
-db_utils.add_column_to_table(_DB.cursor, _DB.conn, 'services',
-                             'current_version',
-                             f'INTEGER DEFAULT {constants.INITIAL_VERSION}')
-# The versions that is activated for the service. This is a list of integers in
-# json format.
-db_utils.add_column_to_table(_DB.cursor, _DB.conn, 'services',
-                             'active_versions',
-                             f'TEXT DEFAULT {json.dumps([])!r}')
-db_utils.add_column_to_table(_DB.cursor, _DB.conn, 'services',
-                             'load_balancing_policy', 'TEXT DEFAULT NULL')
-# Whether the service's load balancer is encrypted with TLS.
-db_utils.add_column_to_table(_DB.cursor, _DB.conn, 'services', 'tls_encrypted',
-                             'INTEGER DEFAULT 0')
+db_utils.SQLiteConn(_DB_PATH, create_table)
 _UNIQUE_CONSTRAINT_FAILED_ERROR_MSG = 'UNIQUE constraint failed: services.name'
 
 

sky/setup_files/dependencies.py

@@ -131,6 +131,7 @@ extras_require: Dict[str, List[str]] = {
     'cudo': ['cudo-compute>=0.1.10'],
     'paperspace': [],  # No dependencies needed for paperspace
     'do': ['pydo>=0.3.0', 'azure-core>=1.24.0', 'azure-common'],
+    'vast': ['vastai-sdk>=0.1.12'],
     'vsphere': [
         'pyvmomi==8.0.1.0.2',
         # vsphere-automation-sdk is also required, but it does not have

sky/templates/vast-ray.yml.j2

@@ -0,0 +1,70 @@
+cluster_name: {{cluster_name_on_cloud}}
+
+# The maximum number of workers nodes to launch in addition to the head node.
+max_workers: {{num_nodes - 1}}
+upscaling_speed: {{num_nodes - 1}}
+idle_timeout_minutes: 60
+
+provider:
+  type: external
+  module: sky.provision.vast
+  region: "{{region}}"
+  disable_launch_config_check: true
+
+auth:
+  ssh_user: root
+  ssh_private_key: {{ssh_private_key}}
+
+available_node_types:
+  ray_head_default:
+    resources: {}
+    node_config:
+      InstanceType: {{instance_type}}
+      DiskSize: {{disk_size}}
+      ImageId: {{image_id}}
+      Preemptible: {{use_spot}}
+      PublicKey: |-
+        skypilot:ssh_public_key_content
+
+head_node_type: ray_head_default
+
+# Format: `REMOTE_PATH : LOCAL_PATH`
+file_mounts: {
+  "{{sky_ray_yaml_remote_path}}": "{{sky_ray_yaml_local_path}}",
+  "{{sky_remote_path}}/{{sky_wheel_hash}}": "{{sky_local_path}}",
+{%- for remote_path, local_path in credentials.items() %}
+  "{{remote_path}}": "{{local_path}}",
+{%- endfor %}
+}
+
+rsync_exclude: []
+
+initialization_commands: []
+
+# List of shell commands to run to set up nodes.
+# NOTE: these are very performance-sensitive. Each new item opens/closes an SSH
+# connection, which is expensive. Try your best to co-locate commands into fewer
+# items!
+#
+# Increment the following for catching performance bugs easier:
+#   current num items (num SSH connections): 1
+setup_commands:
+  # Create ~/.ssh/config file in case the file does not exist in the image.
+  # Line 'rm ..': there is another installation of pip.
+  # Line 'sudo bash ..': set the ulimit as suggested by ray docs for performance. https://docs.ray.io/en/latest/cluster/vms/user-guides/large-cluster-best-practices.html#system-configuration
+  # Line 'sudo grep ..': set the number of threads per process to unlimited to avoid ray job submit stucking issue when the number of running ray jobs increase.
+  # Line 'mkdir -p ..': disable host key check
+  # Line 'python3 -c ..': patch the buggy ray files and enable `-o allow_other` option for `goofys`
+  - {%- for initial_setup_command in initial_setup_commands %}
+    {{ initial_setup_command }}
+    {%- endfor %}
+    mkdir -p ~/.ssh; touch ~/.ssh/config; which patch > /dev/null || sudo apt install -y patch;
+    {{ conda_installation_commands }}
+    {{ ray_skypilot_installation_commands }}
+    sudo bash -c 'rm -rf /etc/security/limits.d; echo "* soft nofile 1048576" >> /etc/security/limits.conf; echo "* hard nofile 1048576" >> /etc/security/limits.conf';
+    sudo grep -e '^DefaultTasksMax' /etc/systemd/system.conf || (sudo bash -c 'echo "DefaultTasksMax=infinity" >> /etc/systemd/system.conf'); sudo systemctl set-property user-$(id -u $(whoami)).slice TasksMax=infinity; sudo systemctl daemon-reload;
+    (grep -Pzo -q "Host \*\n  StrictHostKeyChecking no" ~/.ssh/config) || printf "Host *\n  StrictHostKeyChecking no\n" >> ~/.ssh/config;
+   
+
+# Command to start ray clusters are now placed in `sky.provision.instance_setup`.
+# We do not need to list it here anymore.

sky/utils/controller_utils.py

@@ -261,6 +261,11 @@ def _get_cloud_dependencies_installation_commands(
             if controller != Controllers.JOBS_CONTROLLER:
                 # We only need IBM deps on the jobs controller.
                 cloud_python_dependencies = []
+        elif isinstance(cloud, clouds.Vast):
+            step_prefix = prefix_str.replace('<step>', str(len(commands) + 1))
+            commands.append(f'echo -en "\\r{step_prefix}Vast{empty_str}" && '
+                            'pip list | grep vastai_sdk > /dev/null 2>&1 || '
+                            'pip install "vastai_sdk>=0.1.12" > /dev/null 2>&1')
 
         python_packages.update(cloud_python_dependencies)