skypilot-nightly 1.0.0.dev2024053101__py3-none-any.whl → 1.0.0.dev2025022801__py3-none-any.whl

sky/provision/nebius/instance.py

@@ -0,0 +1,285 @@
+"""Nebius instance provisioning."""
+import time
+from typing import Any, Dict, List, Optional
+
+from sky import sky_logging
+from sky.provision import common
+from sky.provision.nebius import utils
+from sky.utils import common_utils
+from sky.utils import status_lib
+from sky.utils import ux_utils
+
+PENDING_STATUS = ['STARTING', 'DELETING', 'STOPPING']
+
+MAX_RETRIES_TO_LAUNCH = 120  # Maximum number of retries
+
+logger = sky_logging.init_logger(__name__)
+
+
+def _filter_instances(region: str,
+                      cluster_name_on_cloud: str,
+                      status_filters: Optional[List[str]],
+                      head_only: bool = False) -> Dict[str, Any]:
+    project_id = utils.get_project_by_region(region)
+    instances = utils.list_instances(project_id)
+    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['name'] and instance['name'].startswith(
+                f'{cluster_name_on_cloud}-'):
+            if head_only and instance['name'].endswith('-worker'):
+                continue
+            else:
+                filtered_instances[instance_id] = instance
+    return filtered_instances
+
+
+def _get_head_instance_id(instances: Dict[str, Any]) -> Optional[str]:
+    head_instance_id = None
+    for inst_id, inst in instances.items():
+        if inst['name'].endswith('-head'):
+            head_instance_id = inst_id
+            break
+    return head_instance_id
+
+
+def _wait_until_no_pending(region: str, cluster_name_on_cloud: str) -> None:
+    retry_count = 0
+    while retry_count < MAX_RETRIES_TO_LAUNCH:
+        instances = _filter_instances(region, cluster_name_on_cloud,
+                                      PENDING_STATUS)
+        if not instances:
+            break
+        logger.info(f'Waiting for {len(instances)} instances to be ready '
+                    f'(Attempt {retry_count + 1}/{MAX_RETRIES_TO_LAUNCH}).')
+        time.sleep(utils.POLL_INTERVAL)
+        retry_count += 1
+
+    if retry_count == MAX_RETRIES_TO_LAUNCH:
+        raise TimeoutError(f'Exceeded maximum retries '
+                           f'({MAX_RETRIES_TO_LAUNCH * utils.POLL_INTERVAL}'
+                           f' seconds) while waiting for instances'
+                           f' to be ready.')
+
+
+def run_instances(region: str, cluster_name_on_cloud: str,
+                  config: common.ProvisionConfig) -> common.ProvisionRecord:
+    """Runs instances for the given cluster."""
+    _wait_until_no_pending(region, cluster_name_on_cloud)
+    running_instances = _filter_instances(region, cluster_name_on_cloud,
+                                          ['RUNNING'])
+    head_instance_id = _get_head_instance_id(running_instances)
+    to_start_count = config.count - len(running_instances)
+    if to_start_count < 0:
+        raise RuntimeError(
+            f'Cluster {cluster_name_on_cloud} already has '
+            f'{len(running_instances)} nodes, 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='nebius',
+                                      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 = []
+    resumed_instance_ids = []
+    stopped_instances = _filter_instances(region, cluster_name_on_cloud,
+                                          ['STOPPED'])
+    if config.resume_stopped_nodes and len(stopped_instances) > to_start_count:
+
+        raise RuntimeError(
+            'The number of running/stopped/stopping instances combined '
+            f'({len(stopped_instances) + len(running_instances)}) in '
+            f'cluster "{cluster_name_on_cloud}" is greater than the '
+            f'number requested by the user ({config.count}). '
+            'This is likely a resource leak. '
+            'Use "sky down" to terminate the cluster.')
+
+    for stopped_instance_id, _ in stopped_instances.items():
+        if to_start_count > 0:
+            try:
+                utils.start(stopped_instance_id)
+                resumed_instance_ids.append(stopped_instance_id)
+                to_start_count -= 1
+                if stopped_instances[stopped_instance_id]['name'].endswith(
+                        '-head'):
+                    head_instance_id = stopped_instance_id
+            except Exception as e:  # pylint: disable=broad-except
+                logger.warning(f'Start instance error: {e}')
+                raise
+            time.sleep(utils.POLL_INTERVAL)  # to avoid fake STOPPED status
+            logger.info(f'Started instance {stopped_instance_id}.')
+
+    for _ in range(to_start_count):
+        node_type = 'head' if head_instance_id is None else 'worker'
+        try:
+            platform, preset = config.node_config['InstanceType'].split('_')
+            instance_id = utils.launch(
+                cluster_name_on_cloud=cluster_name_on_cloud,
+                node_type=node_type,
+                platform=platform,
+                preset=preset,
+                region=region,
+                image_family=config.node_config['ImageId'],
+                disk_size=config.node_config['DiskSize'],
+                user_data=config.node_config['UserData'])
+        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
+    assert head_instance_id is not None, 'head_instance_id should not be None'
+    return common.ProvisionRecord(provider_name='nebius',
+                                  cluster_name=cluster_name_on_cloud,
+                                  region=region,
+                                  zone=None,
+                                  head_instance_id=head_instance_id,
+                                  resumed_instance_ids=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:
+    _wait_until_no_pending(region, cluster_name_on_cloud)
+    if state is not None:
+        if state == status_lib.ClusterStatus.UP:
+            stopped_instances = _filter_instances(region, cluster_name_on_cloud,
+                                                  ['STOPPED'])
+            if stopped_instances:
+                raise RuntimeError(
+                    f'Cluster {cluster_name_on_cloud} is in UP state, but '
+                    f'{len(stopped_instances)} instances are stopped.')
+        if state == status_lib.ClusterStatus.STOPPED:
+            running_instances = _filter_instances(region, cluster_name_on_cloud,
+                                                  ['RUNNIG'])
+
+            if running_instances:
+                raise RuntimeError(
+                    f'Cluster {cluster_name_on_cloud} is in STOPPED state, but '
+                    f'{len(running_instances)} instances are running.')
+
+
+def stop_instances(
+    cluster_name_on_cloud: str,
+    provider_config: Optional[Dict[str, Any]] = None,
+    worker_only: bool = False,
+) -> None:
+    assert provider_config is not None
+    exist_instances = _filter_instances(provider_config['region'],
+                                        cluster_name_on_cloud, ['RUNNING'])
+    for instance in exist_instances:
+        if worker_only and instance.endswith('-head'):
+            continue
+        utils.stop(instance)
+
+
+def terminate_instances(
+    cluster_name_on_cloud: str,
+    provider_config: Optional[Dict[str, Any]] = None,
+    worker_only: bool = False,
+) -> None:
+    """See sky/provision/__init__.py"""
+
+    assert provider_config is not None
+    instances = _filter_instances(provider_config['region'],
+                                  cluster_name_on_cloud,
+                                  status_filters=None)
+    for inst_id, inst in instances.items():
+        logger.debug(f'Terminating instance {inst_id}: {inst}')
+        if worker_only and inst['name'].endswith('-head'):
+            continue
+        try:
+            utils.remove(inst_id)
+        except Exception as e:  # pylint: disable=broad-except
+            with ux_utils.print_exception_no_traceback():
+                raise RuntimeError(
+                    f'Failed to terminate instance {inst_id}: '
+                    f'{common_utils.format_exception(e, use_bracket=False)}'
+                ) from e
+    utils.delete_cluster(cluster_name_on_cloud, provider_config['region'])
+
+
+def get_cluster_info(
+        region: str,
+        cluster_name_on_cloud: str,
+        provider_config: Optional[Dict[str, Any]] = None) -> common.ClusterInfo:
+    _wait_until_no_pending(region, cluster_name_on_cloud)
+    running_instances = _filter_instances(region, 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['internal_ip'],
+                external_ip=instance_info['external_ip'],
+                tags={},
+            )
+        ]
+        if instance_info['name'].endswith('-head'):
+            head_instance_id = instance_id
+    assert head_instance_id is not None
+    return common.ClusterInfo(
+        instances=instances,
+        head_instance_id=head_instance_id,
+        provider_name='nebius',
+        provider_config=provider_config,
+    )
+
+
+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(provider_config['region'],
+                                  cluster_name_on_cloud, None)
+
+    status_map = {
+        'STARTING': status_lib.ClusterStatus.INIT,
+        'RUNNING': status_lib.ClusterStatus.UP,
+        'STOPPED': status_lib.ClusterStatus.STOPPED,
+        'STOPPING': status_lib.ClusterStatus.STOPPED,
+        'DELETING': status_lib.ClusterStatus.STOPPED,
+    }
+    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 open_ports(
+    cluster_name_on_cloud: str,
+    ports: List[str],
+    provider_config: Optional[Dict[str, Any]] = None,
+) -> None:
+    """See sky/provision/__init__.py"""
+    logger.debug(f'Skip opening ports {ports} for Nebius instances, as all '
+                 'ports are open by default.')
+    del cluster_name_on_cloud, provider_config, ports
+
+
+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/nebius/utils.py

@@ -0,0 +1,318 @@
+"""Nebius library wrapper for SkyPilot."""
+import time
+from typing import Any, Dict
+import uuid
+
+from sky import sky_logging
+from sky.adaptors import nebius
+from sky.utils import common_utils
+
+logger = sky_logging.init_logger(__name__)
+
+POLL_INTERVAL = 5
+
+
+def retry(func):
+    """Decorator to retry a function."""
+
+    def wrapper(*args, **kwargs):
+        """Wrapper for retrying a function."""
+        cnt = 0
+        while True:
+            try:
+                return func(*args, **kwargs)
+            except nebius.nebius.error.QueryError as e:
+                if cnt >= 3:
+                    raise
+                logger.warning('Retrying for exception: '
+                               f'{common_utils.format_exception(e)}.')
+                time.sleep(POLL_INTERVAL)
+
+    return wrapper
+
+
+def get_project_by_region(region: str) -> str:
+    service = nebius.iam().ProjectServiceClient(nebius.sdk())
+    projects = service.list(nebius.iam().ListProjectsRequest(
+        parent_id=nebius.get_tenant_id())).wait()
+    # To find a project in a specific region, we rely on the project ID to
+    # deduce the region, since there is currently no method to retrieve region
+    # information directly from the project. Additionally, there is only one
+    # project per region, and projects cannot be created at this time.
+    # The region is determined from the project ID using a region-specific
+    # identifier embedded in it.
+    # Project id looks like project-e00xxxxxxxxxxxxxx where
+    # e00 - id of region 'eu-north1'
+    # e01 - id of region 'eu-west1'
+    region_ids = {'eu-north1': 'e00', 'eu-west1': 'e01'}
+    # TODO(SalikovAlex): fix when info about region will be in projects list
+    # Currently, Nebius cloud supports 2 regions. We manually enumerate
+    # them here. Reference: https://docs.nebius.com/overview/regions
+
+    #  Check is there project if in config
+    preferable_project_id = nebius.get_project_id()
+    if preferable_project_id is not None:
+        if preferable_project_id[8:11] == region_ids[region]:
+            return preferable_project_id
+        logger.warning(
+            f'Can\'t use customized NEBIUS_PROJECT_ID ({preferable_project_id})'
+            f' for region {region}. Please check if the project ID is correct.')
+    for project in projects.items:
+        if project.metadata.id[8:11] == region_ids[region]:
+            return project.metadata.id
+    raise Exception(f'No project found for region "{region}".')
+
+
+def get_or_create_gpu_cluster(name: str, region: str) -> str:
+    """Creates a GPU cluster.
+    When creating a GPU cluster, select an InfiniBand fabric for it:
+
+    fabric-2, fabric-3 or fabric-4 for projects in the eu-north1 region.
+    fabric-5 for projects in the eu-west1 region.
+
+    https://docs.nebius.com/compute/clusters/gpu
+    """
+    project_id = get_project_by_region(region)
+    service = nebius.compute().GpuClusterServiceClient(nebius.sdk())
+    try:
+        cluster = service.get_by_name(nebius.nebius_common().GetByNameRequest(
+            parent_id=project_id,
+            name=name,
+        )).wait()
+        cluster_id = cluster.metadata.id
+    except nebius.request_error() as no_cluster_found_error:
+        if region == 'eu-north1':
+            fabric = 'fabric-4'
+        elif region == 'eu-west1':
+            fabric = 'fabric-5'
+        else:
+            raise RuntimeError(
+                f'Unsupported region {region}.') from no_cluster_found_error
+        cluster = service.create(nebius.compute().CreateGpuClusterRequest(
+            metadata=nebius.nebius_common().ResourceMetadata(
+                parent_id=project_id,
+                name=name,
+            ),
+            spec=nebius.compute().GpuClusterSpec(
+                infiniband_fabric=fabric))).wait()
+        cluster_id = cluster.resource_id
+    return cluster_id
+
+
+def delete_cluster(name: str, region: str) -> None:
+    """Delete a GPU cluster."""
+    project_id = get_project_by_region(region)
+    service = nebius.compute().GpuClusterServiceClient(nebius.sdk())
+    try:
+        cluster = service.get_by_name(nebius.nebius_common().GetByNameRequest(
+            parent_id=project_id,
+            name=name,
+        )).wait()
+        cluster_id = cluster.metadata.id
+        logger.debug(f'Found GPU Cluster : {cluster_id}.')
+        service.delete(
+            nebius.compute().DeleteGpuClusterRequest(id=cluster_id)).wait()
+        logger.debug(f'Deleted GPU Cluster : {cluster_id}.')
+    except nebius.request_error():
+        logger.debug('GPU Cluster does not exist.')
+
+
+def list_instances(project_id: str) -> Dict[str, Dict[str, Any]]:
+    """Lists instances associated with API key."""
+    service = nebius.compute().InstanceServiceClient(nebius.sdk())
+    result = service.list(
+        nebius.compute().ListInstancesRequest(parent_id=project_id)).wait()
+
+    instances = result
+
+    instance_dict: Dict[str, Dict[str, Any]] = {}
+    for instance in instances.items:
+        info = {}
+        info['status'] = instance.status.state.name
+        info['name'] = instance.metadata.name
+        if instance.status.network_interfaces:
+            info['external_ip'] = instance.status.network_interfaces[
+                0].public_ip_address.address.split('/')[0]
+            info['internal_ip'] = instance.status.network_interfaces[
+                0].ip_address.address.split('/')[0]
+        instance_dict[instance.metadata.id] = info
+
+    return instance_dict
+
+
+def stop(instance_id: str) -> None:
+    service = nebius.compute().InstanceServiceClient(nebius.sdk())
+    service.stop(nebius.compute().StopInstanceRequest(id=instance_id)).wait()
+    retry_count = 0
+    while retry_count < nebius.MAX_RETRIES_TO_INSTANCE_STOP:
+        service = nebius.compute().InstanceServiceClient(nebius.sdk())
+        instance = service.get(nebius.compute().GetInstanceRequest(
+            id=instance_id,)).wait()
+        if instance.status.state.name == 'STOPPED':
+            break
+        time.sleep(POLL_INTERVAL)
+        logger.debug(f'Waiting for instance {instance_id} stopping.')
+        retry_count += 1
+
+    if retry_count == nebius.MAX_RETRIES_TO_INSTANCE_STOP:
+        raise TimeoutError(
+            f'Exceeded maximum retries '
+            f'({nebius.MAX_RETRIES_TO_INSTANCE_STOP * POLL_INTERVAL}'
+            f' seconds) while waiting for instance {instance_id}'
+            f' to be stopped.')
+
+
+def start(instance_id: str) -> None:
+    service = nebius.compute().InstanceServiceClient(nebius.sdk())
+    service.start(nebius.compute().StartInstanceRequest(id=instance_id)).wait()
+    retry_count = 0
+    while retry_count < nebius.MAX_RETRIES_TO_INSTANCE_START:
+        service = nebius.compute().InstanceServiceClient(nebius.sdk())
+        instance = service.get(nebius.compute().GetInstanceRequest(
+            id=instance_id,)).wait()
+        if instance.status.state.name == 'RUNNING':
+            break
+        time.sleep(POLL_INTERVAL)
+        logger.debug(f'Waiting for instance {instance_id} starting.')
+        retry_count += 1
+
+    if retry_count == nebius.MAX_RETRIES_TO_INSTANCE_START:
+        raise TimeoutError(
+            f'Exceeded maximum retries '
+            f'({nebius.MAX_RETRIES_TO_INSTANCE_START * POLL_INTERVAL}'
+            f' seconds) while waiting for instance {instance_id}'
+            f' to be ready.')
+
+
+def launch(cluster_name_on_cloud: str, node_type: str, platform: str,
+           preset: str, region: str, image_family: str, disk_size: int,
+           user_data: str) -> str:
+    # Each node must have a unique name to avoid conflicts between
+    # multiple worker VMs. To ensure uniqueness,a UUID is appended
+    # to the node name.
+    instance_name = (f'{cluster_name_on_cloud}-'
+                     f'{uuid.uuid4().hex[:4]}-{node_type}')
+    logger.debug(f'Launching instance: {instance_name}')
+
+    disk_name = 'disk-' + instance_name
+    cluster_id = None
+    # 8 GPU virtual machines can be grouped into a GPU cluster.
+    # The GPU clusters are built with InfiniBand secure high-speed networking.
+    # https://docs.nebius.com/compute/clusters/gpu
+    if platform in ('gpu-h100-sxm', 'gpu-h200-sxm'):
+        if preset == '8gpu-128vcpu-1600gb':
+            cluster_id = get_or_create_gpu_cluster(cluster_name_on_cloud,
+                                                   region)
+
+    project_id = get_project_by_region(region)
+    service = nebius.compute().DiskServiceClient(nebius.sdk())
+    disk = service.create(nebius.compute().CreateDiskRequest(
+        metadata=nebius.nebius_common().ResourceMetadata(
+            parent_id=project_id,
+            name=disk_name,
+        ),
+        spec=nebius.compute().DiskSpec(
+            source_image_family=nebius.compute().SourceImageFamily(
+                image_family=image_family),
+            size_gibibytes=disk_size,
+            type=nebius.compute().DiskSpec.DiskType.NETWORK_SSD,
+        ))).wait()
+    disk_id = disk.resource_id
+    retry_count = 0
+    while retry_count < nebius.MAX_RETRIES_TO_DISK_CREATE:
+        disk = service.get_by_name(nebius.nebius_common().GetByNameRequest(
+            parent_id=project_id,
+            name=disk_name,
+        )).wait()
+        if disk.status.state.name == 'READY':
+            break
+        logger.debug(f'Waiting for disk {disk_name} to be ready.')
+        time.sleep(POLL_INTERVAL)
+        retry_count += 1
+
+    if retry_count == nebius.MAX_RETRIES_TO_DISK_CREATE:
+        raise TimeoutError(
+            f'Exceeded maximum retries '
+            f'({nebius.MAX_RETRIES_TO_DISK_CREATE * POLL_INTERVAL}'
+            f' seconds) while waiting for disk {disk_name}'
+            f' to be ready.')
+
+    service = nebius.vpc().SubnetServiceClient(nebius.sdk())
+    sub_net = service.list(nebius.vpc().ListSubnetsRequest(
+        parent_id=project_id,)).wait()
+
+    service = nebius.compute().InstanceServiceClient(nebius.sdk())
+    service.create(nebius.compute().CreateInstanceRequest(
+        metadata=nebius.nebius_common().ResourceMetadata(
+            parent_id=project_id,
+            name=instance_name,
+        ),
+        spec=nebius.compute().InstanceSpec(
+            gpu_cluster=nebius.compute().InstanceGpuClusterSpec(id=cluster_id,)
+            if cluster_id is not None else None,
+            boot_disk=nebius.compute().AttachedDiskSpec(
+                attach_mode=nebius.compute(
+                ).AttachedDiskSpec.AttachMode.READ_WRITE,
+                existing_disk=nebius.compute().ExistingDisk(id=disk_id)),
+            cloud_init_user_data=user_data,
+            resources=nebius.compute().ResourcesSpec(platform=platform,
+                                                     preset=preset),
+            network_interfaces=[
+                nebius.compute().NetworkInterfaceSpec(
+                    subnet_id=sub_net.items[0].metadata.id,
+                    ip_address=nebius.compute().IPAddress(),
+                    name='network-interface-0',
+                    public_ip_address=nebius.compute().PublicIPAddress())
+            ]))).wait()
+    instance_id = ''
+    retry_count = 0
+    while retry_count < nebius.MAX_RETRIES_TO_INSTANCE_READY:
+        service = nebius.compute().InstanceServiceClient(nebius.sdk())
+        instance = service.get_by_name(nebius.nebius_common().GetByNameRequest(
+            parent_id=project_id,
+            name=instance_name,
+        )).wait()
+        if instance.status.state.name == 'STARTING':
+            instance_id = instance.metadata.id
+            break
+        time.sleep(POLL_INTERVAL)
+        logger.debug(f'Waiting for instance {instance_name} start running.')
+        retry_count += 1
+
+    if retry_count == nebius.MAX_RETRIES_TO_INSTANCE_READY:
+        raise TimeoutError(
+            f'Exceeded maximum retries '
+            f'({nebius.MAX_RETRIES_TO_INSTANCE_READY * POLL_INTERVAL}'
+            f' seconds) while waiting for instance {instance_name}'
+            f' to be ready.')
+    return instance_id
+
+
+def remove(instance_id: str) -> None:
+    """Terminates the given instance."""
+    service = nebius.compute().InstanceServiceClient(nebius.sdk())
+    result = service.get(
+        nebius.compute().GetInstanceRequest(id=instance_id)).wait()
+    disk_id = result.spec.boot_disk.existing_disk.id
+    service.delete(
+        nebius.compute().DeleteInstanceRequest(id=instance_id)).wait()
+    retry_count = 0
+    # The instance begins deleting and attempts to delete the disk.
+    # Must wait until the disk is unlocked and becomes deletable.
+    while retry_count < nebius.MAX_RETRIES_TO_DISK_DELETE:
+        try:
+            service = nebius.compute().DiskServiceClient(nebius.sdk())
+            service.delete(
+                nebius.compute().DeleteDiskRequest(id=disk_id)).wait()
+            break
+        except nebius.request_error():
+            logger.debug('Waiting for disk deletion.')
+            time.sleep(POLL_INTERVAL)
+            retry_count += 1
+
+    if retry_count == nebius.MAX_RETRIES_TO_DISK_DELETE:
+        raise TimeoutError(
+            f'Exceeded maximum retries '
+            f'({nebius.MAX_RETRIES_TO_DISK_DELETE * POLL_INTERVAL}'
+            f' seconds) while waiting for disk {disk_id}'
+            f' to be deleted.')

sky/provision/oci/__init__.py

@@ -0,0 +1,15 @@
+"""OCI provisioner for SkyPilot.
+
+History:
+ - Hysun He (hysun.he@oracle.com) @ Oct.16, 2024: Initial implementation
+"""
+
+from sky.provision.oci.config import bootstrap_instances
+from sky.provision.oci.instance import cleanup_ports
+from sky.provision.oci.instance import get_cluster_info
+from sky.provision.oci.instance import open_ports
+from sky.provision.oci.instance import query_instances
+from sky.provision.oci.instance import run_instances
+from sky.provision.oci.instance import stop_instances
+from sky.provision.oci.instance import terminate_instances
+from sky.provision.oci.instance import wait_instances

sky/provision/oci/config.py

@@ -0,0 +1,51 @@
+"""OCI configuration bootstrapping.
+
+Creates the resource group and deploys the configuration template to OCI for
+a cluster to be launched.
+
+History:
+ - Hysun He (hysun.he@oracle.com) @ Oct.16, 2024: Initial implementation
+"""
+
+from sky import exceptions
+from sky import sky_logging
+from sky.adaptors import oci as oci_adaptor
+from sky.clouds.utils import oci_utils
+from sky.provision import common
+from sky.provision.oci.query_utils import query_helper
+
+logger = sky_logging.init_logger(__name__)
+
+
+@common.log_function_start_end
+def bootstrap_instances(
+        region: str, cluster_name_on_cloud: str,
+        config: common.ProvisionConfig) -> common.ProvisionConfig:
+    """See sky/provision/__init__.py"""
+    # OCI module import and oci client
+    oci_adaptor.get_core_client(region, oci_utils.oci_config.get_profile())
+
+    # Find / create a compartment for creating instances.
+    compartment = query_helper.find_compartment(region)
+
+    # Find the configured VCN, or create a new one.
+    vcn = query_helper.find_create_vcn_subnet(region)
+    if vcn is None:
+        # pylint: disable=line-too-long
+        raise exceptions.ResourcesUnavailableError(
+            'Failed to create a new VCN, possibly you hit the resource limitation.'
+        )
+
+    node_config = config.node_config
+
+    # Subscribe the image if it is from Marketplace listing.
+    query_helper.subscribe_image(
+        compartment_id=compartment,
+        listing_id=node_config['AppCatalogListingId'],
+        resource_version=node_config['ResourceVersion'],
+        region=region,
+    )
+
+    logger.info(f'Using cluster name: {cluster_name_on_cloud}')
+
+    return config