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

sky/clouds/service_catalog/nebius_catalog.py

@@ -0,0 +1,116 @@
+"""Nebius Catalog.
+
+This module loads the service catalog file and can be used to query
+instance types and pricing information for Nebius.
+"""
+import typing
+from typing import Dict, List, Optional, Tuple, Union
+
+from sky.clouds.service_catalog import common
+from sky.utils import resources_utils
+from sky.utils import ux_utils
+
+if typing.TYPE_CHECKING:
+    from sky.clouds import cloud
+
+# Keep it synced with the frequency in
+# skypilot-catalog/.github/workflows/update-Nebius-catalog.yml
+_PULL_FREQUENCY_HOURS = 7
+
+_df = common.read_catalog('nebius/vms.csv')
+
+
+def instance_type_exists(instance_type: str) -> bool:
+    return common.instance_type_exists_impl(_df, instance_type)
+
+
+def validate_region_zone(
+        region: Optional[str],
+        zone: Optional[str]) -> Tuple[Optional[str], Optional[str]]:
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Nebius does not support zones.')
+    return common.validate_region_zone_impl('nebius', _df, region, zone)
+
+
+def get_hourly_cost(instance_type: str,
+                    use_spot: bool = False,
+                    region: Optional[str] = None,
+                    zone: Optional[str] = None) -> float:
+    """Returns the cost, or the cheapest cost among all zones for spot."""
+    assert not use_spot, 'Nebius does not support spot.'
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Nebius does not support zones.')
+    return common.get_hourly_cost_impl(_df, instance_type, use_spot, region,
+                                       zone)
+
+
+def get_vcpus_mem_from_instance_type(
+        instance_type: str) -> Tuple[Optional[float], Optional[float]]:
+    return common.get_vcpus_mem_from_instance_type_impl(_df, instance_type)
+
+
+def get_default_instance_type(
+        cpus: Optional[str] = None,
+        memory: Optional[str] = None,
+        disk_tier: Optional[resources_utils.DiskTier] = None) -> Optional[str]:
+    del disk_tier  # unused
+    return common.get_instance_type_for_cpus_mem_impl(_df, cpus, memory)
+
+
+def get_accelerators_from_instance_type(
+        instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
+    return common.get_accelerators_from_instance_type_impl(_df, instance_type)
+
+
+def get_instance_type_for_accelerator(
+        acc_name: str,
+        acc_count: int,
+        cpus: Optional[str] = None,
+        memory: Optional[str] = None,
+        use_spot: bool = False,
+        region: Optional[str] = None,
+        zone: Optional[str] = None) -> Tuple[Optional[List[str]], List[str]]:
+    """Filter the instance types based on resource requirements.
+
+    Returns a list of instance types satisfying the required count of
+    accelerators with sorted prices and a list of candidates with fuzzy search.
+    """
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Nebius does not support zones.')
+    return common.get_instance_type_for_accelerator_impl(df=_df,
+                                                         acc_name=acc_name,
+                                                         acc_count=acc_count,
+                                                         cpus=cpus,
+                                                         memory=memory,
+                                                         use_spot=use_spot,
+                                                         region=region,
+                                                         zone=zone)
+
+
+def regions() -> List['cloud.Region']:
+    return common.get_region_zones(_df, use_spot=False)
+
+
+def get_region_zones_for_instance_type(instance_type: str,
+                                       use_spot: bool) -> List['cloud.Region']:
+    df = _df[_df['InstanceType'] == instance_type]
+    return common.get_region_zones(df, use_spot)
+
+
+def list_accelerators(
+        gpus_only: bool,
+        name_filter: Optional[str],
+        region_filter: Optional[str],
+        quantity_filter: Optional[int],
+        case_sensitive: bool = True,
+        all_regions: bool = False,
+        require_price: bool = True) -> Dict[str, List[common.InstanceTypeInfo]]:
+    """Returns all instance types in Nebius offering GPUs."""
+
+    del require_price  # Unused.
+    return common.list_accelerators_impl('nebius', _df, gpus_only, name_filter,
+                                         region_filter, quantity_filter,
+                                         case_sensitive, all_regions)

sky/clouds/service_catalog/oci_catalog.py

@@ -7,14 +7,17 @@ History:
  - Hysun He (hysun.he@oracle.com) @ Apr, 2023: Initial implementation
  - Hysun He (hysun.he@oracle.com) @ Jun, 2023: Reduce retry times by
    excluding those unsubscribed regions.
+ - Hysun He (hysun.he@oracle.com) @ Oct 14, 2024: Bug fix for validation
+   of the Marketplace images
 """
 
 import logging
 import threading
 import typing
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
 from sky.adaptors import oci as oci_adaptor
+from sky.clouds import OCI
 from sky.clouds.service_catalog import common
 from sky.clouds.utils import oci_utils
 from sky.utils import resources_utils
@@ -63,7 +66,7 @@ def _get_df() -> 'pd.DataFrame':
             logger.debug(f'It is OK goes here when testing: {str(e)}')
             subscribed_regions = []
 
-        except oci_adaptor.service_exception() as e:
+        except oci_adaptor.oci.exceptions.ServiceError as e:
             # Should never expect going here. However, we still catch
             # it so that if any OCI call failed, the program can still
             # proceed with try-and-error way.
@@ -102,7 +105,6 @@ def get_default_instance_type(
         cpus: Optional[str] = None,
         memory: Optional[str] = None,
         disk_tier: Optional[resources_utils.DiskTier] = None) -> Optional[str]:
-    del disk_tier  # unused
     if cpus is None:
         cpus = f'{oci_utils.oci_config.DEFAULT_NUM_VCPUS}+'
 
@@ -111,12 +113,17 @@ def get_default_instance_type(
     else:
         memory_gb_or_ratio = memory
 
+    def _filter_disk_type(instance_type: str) -> bool:
+        valid, _ = OCI.check_disk_tier(instance_type, disk_tier)
+        return valid
+
     instance_type_prefix = tuple(
         f'{family}' for family in oci_utils.oci_config.DEFAULT_INSTANCE_FAMILY)
 
     df = _get_df()
     df = df[df['InstanceType'].notna()]
     df = df[df['InstanceType'].str.startswith(instance_type_prefix)]
+    df = df.loc[df['InstanceType'].apply(_filter_disk_type)]
 
     logger.debug(f'# get_default_instance_type: {df}')
     return common.get_instance_type_for_cpus_mem_impl(df, cpus,
@@ -124,7 +131,7 @@ def get_default_instance_type(
 
 
 def get_accelerators_from_instance_type(
-        instance_type: str) -> Optional[Dict[str, int]]:
+        instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
     return common.get_accelerators_from_instance_type_impl(
         _get_df(), instance_type)
 
@@ -201,4 +208,24 @@ def get_image_id_from_tag(tag: str, region: Optional[str]) -> Optional[str]:
 
 def is_image_tag_valid(tag: str, region: Optional[str]) -> bool:
     """Returns whether the image tag is valid."""
+    # Oct.14, 2024 by Hysun He: Marketplace images are region neutral, so don't
+    # check with region for the Marketplace images.
+    df = _image_df[_image_df['Tag'].str.fullmatch(tag)]
+    if df.empty:
+        return False
+    app_catalog_listing_id = df['AppCatalogListingId'].iloc[0]
+    if app_catalog_listing_id:
+        return True
     return common.is_image_tag_valid_impl(_image_df, tag, region)
+
+
+def get_image_os_from_tag(tag: str, region: Optional[str]) -> Optional[str]:
+    del region
+    df = _image_df[_image_df['Tag'].str.fullmatch(tag)]
+    if df.empty:
+        os_type = oci_utils.oci_config.get_default_image_os()
+    else:
+        os_type = df['OS'].iloc[0]
+
+    logger.debug(f'Operation system for the image {tag} is {os_type}')
+    return os_type

sky/clouds/service_catalog/paperspace_catalog.py

@@ -5,7 +5,7 @@ query instance types and pricing information for Paperspace.
 """
 
 import typing
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
 from sky.clouds.service_catalog import common
 from sky.utils import ux_utils
@@ -60,7 +60,7 @@ def get_default_instance_type(
 
 
 def get_accelerators_from_instance_type(
-        instance_type: str) -> Optional[Dict[str, int]]:
+        instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
     return common.get_accelerators_from_instance_type_impl(_df, instance_type)
 
 

sky/clouds/service_catalog/runpod_catalog.py

@@ -5,7 +5,7 @@ query instance types and pricing information for RunPod.
 """
 
 import typing
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
 from sky.clouds.service_catalog import common
 from sky.utils import ux_utils
@@ -56,7 +56,7 @@ def get_default_instance_type(cpus: Optional[str] = None,
 
 
 def get_accelerators_from_instance_type(
-        instance_type: str) -> Optional[Dict[str, int]]:
+        instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
     return common.get_accelerators_from_instance_type_impl(_df, instance_type)
 
 

sky/clouds/service_catalog/scp_catalog.py

@@ -5,7 +5,7 @@ instance types and pricing information for SCP.
 """
 
 import typing
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
 from sky.clouds.service_catalog import common
 from sky.utils import resources_utils
@@ -67,7 +67,7 @@ def get_default_instance_type(
 
 
 def get_accelerators_from_instance_type(
-        instance_type: str) -> Optional[Dict[str, int]]:
+        instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
     return common.get_accelerators_from_instance_type_impl(_df, instance_type)
 
 

sky/clouds/service_catalog/vast_catalog.py

@@ -0,0 +1,104 @@
+""" Vast | Catalog
+
+This module loads the service catalog file and can be used to
+query instance types and pricing information for Vast.ai.
+"""
+
+import typing
+from typing import Dict, List, Optional, Tuple, Union
+
+from sky.clouds.service_catalog import common
+from sky.utils import ux_utils
+
+if typing.TYPE_CHECKING:
+    from sky.clouds import cloud
+
+_df = common.read_catalog('vast/vms.csv')
+
+
+def instance_type_exists(instance_type: str) -> bool:
+    return common.instance_type_exists_impl(_df, instance_type)
+
+
+def validate_region_zone(
+        region: Optional[str],
+        zone: Optional[str]) -> Tuple[Optional[str], Optional[str]]:
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Vast does not support zones.')
+    return common.validate_region_zone_impl('vast', _df, region, zone)
+
+
+def get_hourly_cost(instance_type: str,
+                    use_spot: bool = False,
+                    region: Optional[str] = None,
+                    zone: Optional[str] = None) -> float:
+    """Returns the cost, or the cheapest cost among all zones for spot."""
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Vast does not support zones.')
+    return common.get_hourly_cost_impl(_df, instance_type, use_spot, region,
+                                       zone)
+
+
+def get_vcpus_mem_from_instance_type(
+        instance_type: str) -> Tuple[Optional[float], Optional[float]]:
+    return common.get_vcpus_mem_from_instance_type_impl(_df, instance_type)
+
+
+def get_default_instance_type(cpus: Optional[str] = None,
+                              memory: Optional[str] = None,
+                              disk_tier: Optional[str] = None) -> Optional[str]:
+    del disk_tier
+    # NOTE: After expanding catalog to multiple entries, you may
+    # want to specify a default instance type or family.
+    return common.get_instance_type_for_cpus_mem_impl(_df, cpus, memory)
+
+
+def get_accelerators_from_instance_type(
+        instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
+    return common.get_accelerators_from_instance_type_impl(_df, instance_type)
+
+
+def get_instance_type_for_accelerator(
+        acc_name: str,
+        acc_count: int,
+        cpus: Optional[str] = None,
+        memory: Optional[str] = None,
+        use_spot: bool = False,
+        region: Optional[str] = None,
+        zone: Optional[str] = None) -> Tuple[Optional[List[str]], List[str]]:
+    """Returns a list of instance types that have the given accelerator."""
+    if zone is not None:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Vast does not support zones.')
+    return common.get_instance_type_for_accelerator_impl(df=_df,
+                                                         acc_name=acc_name,
+                                                         acc_count=acc_count,
+                                                         cpus=cpus,
+                                                         memory=memory,
+                                                         use_spot=use_spot,
+                                                         region=region,
+                                                         zone=zone)
+
+
+def get_region_zones_for_instance_type(instance_type: str,
+                                       use_spot: bool) -> List['cloud.Region']:
+    df = _df[_df['InstanceType'] == instance_type]
+    return common.get_region_zones(df, use_spot)
+
+
+# TODO: this differs from the fluffy catalog version
+def list_accelerators(
+        gpus_only: bool,
+        name_filter: Optional[str],
+        region_filter: Optional[str],
+        quantity_filter: Optional[int],
+        case_sensitive: bool = True,
+        all_regions: bool = False,
+        require_price: bool = True) -> Dict[str, List[common.InstanceTypeInfo]]:
+    """Returns all instance types in Vast offering GPUs."""
+    del require_price  # Unused.
+    return common.list_accelerators_impl('Vast', _df, gpus_only, name_filter,
+                                         region_filter, quantity_filter,
+                                         case_sensitive, all_regions)

sky/clouds/service_catalog/vsphere_catalog.py

@@ -2,7 +2,7 @@
 import io
 import os
 import typing
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple, Union
 
 from sky.adaptors import common as adaptors_common
 from sky.clouds.service_catalog import common
@@ -85,7 +85,7 @@ def get_default_instance_type(
 
 
 def get_accelerators_from_instance_type(
-        instance_type: str) -> Optional[Dict[str, int]]:
+        instance_type: str) -> Optional[Dict[str, Union[int, float]]]:
     return common.get_accelerators_from_instance_type_impl(
         _get_df(), instance_type)
 

sky/clouds/utils/aws_utils.py

@@ -0,0 +1,65 @@
+"""Utilities for AWS."""
+import dataclasses
+import enum
+import time
+from typing import List
+
+import cachetools
+
+from sky import skypilot_config
+from sky.adaptors import aws
+
+
+class ReservationType(str, enum.Enum):
+    DEFAULT = 'default'
+    BLOCK = 'capacity-block'
+
+
+@dataclasses.dataclass
+class AWSReservation:
+    name: str
+    instance_type: str
+    zone: str
+    available_resources: int
+    # Whether the reservation is targeted, i.e. can only be consumed when
+    # the reservation name is specified.
+    targeted: bool
+    type: ReservationType
+
+
+def use_reservations() -> bool:
+    prioritize_reservations = skypilot_config.get_nested(
+        ('aws', 'prioritize_reservations'), False)
+    specific_reservations = skypilot_config.get_nested(
+        ('aws', 'specific_reservations'), set())
+    return prioritize_reservations or specific_reservations
+
+
+@cachetools.cached(cache=cachetools.TTLCache(maxsize=100,
+                                             ttl=300,
+                                             timer=time.time))
+def list_reservations_for_instance_type(
+    instance_type: str,
+    region: str,
+) -> List[AWSReservation]:
+    if not use_reservations():
+        return []
+    ec2 = aws.client('ec2', region_name=region)
+    response = ec2.describe_capacity_reservations(Filters=[{
+        'Name': 'instance-type',
+        'Values': [instance_type]
+    }, {
+        'Name': 'state',
+        'Values': ['active']
+    }])
+    reservations = response['CapacityReservations']
+    return [
+        AWSReservation(name=r['CapacityReservationId'],
+                       instance_type=r['InstanceType'],
+                       zone=r['AvailabilityZone'],
+                       available_resources=r['AvailableInstanceCount'],
+                       targeted=r['InstanceMatchCriteria'] == 'targeted',
+                       type=ReservationType(r.get('ReservationType',
+                                                  'default')))
+        for r in reservations
+    ]

sky/clouds/utils/azure_utils.py

@@ -0,0 +1,91 @@
+"""Utilies for Azure"""
+
+import typing
+
+from sky import exceptions
+from sky.adaptors import azure
+from sky.utils import ux_utils
+
+if typing.TYPE_CHECKING:
+    from azure.mgmt import compute as azure_compute
+    from azure.mgmt.compute import models as azure_compute_models
+
+
+def validate_image_id(image_id: str):
+    """Check if the image ID has a valid format.
+
+    Raises:
+        ValueError: If the image ID is invalid.
+    """
+    image_id_colon_splitted = image_id.split(':')
+    image_id_slash_splitted = image_id.split('/')
+    if len(image_id_slash_splitted) != 5 and len(image_id_colon_splitted) != 4:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(
+                f'Invalid image id for Azure: {image_id}. Expected format: \n'
+                '* Marketplace image ID: <publisher>:<offer>:<sku>:<version>\n'
+                '* Community image ID: '
+                '/CommunityGalleries/<gallery-name>/Images/<image-name>')
+    if len(image_id_slash_splitted) == 5:
+        _, gallery_type, _, image_type, _ = image_id.split('/')
+        if gallery_type != 'CommunityGalleries' or image_type != 'Images':
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(
+                    f'Invalid community image id for Azure: {image_id}.\n'
+                    'Expected format: '
+                    '/CommunityGalleries/<gallery-name>/Images/<image-name>')
+
+
+def get_community_image(
+        compute_client: 'azure_compute.ComputeManagementClient', image_id: str,
+        region: str) -> 'azure_compute_models.CommunityGalleryImage':
+    """Get community image from cloud.
+
+    Args:
+        image_id: /CommunityGalleries/<gallery-name>/Images/<image-name>
+    Raises:
+        ResourcesUnavailableError
+    """
+    try:
+        _, _, gallery_name, _, image_name = image_id.split('/')
+        return compute_client.community_gallery_images.get(
+            location=region,
+            public_gallery_name=gallery_name,
+            gallery_image_name=image_name)
+    except azure.exceptions().AzureError as e:
+        raise exceptions.ResourcesUnavailableError(
+            f'Community image {image_id} does not exist in region {region}.'
+        ) from e
+
+
+def get_community_image_size(
+        compute_client: 'azure_compute.ComputeManagementClient',
+        gallery_name: str, image_name: str, region: str) -> float:
+    """Get the size of the community image from cloud.
+
+    Args:
+        image_id: /CommunityGalleries/<gallery-name>/Images/<image-name>
+    Raises:
+        ResourcesUnavailableError
+    """
+    try:
+        image_versions = compute_client.community_gallery_image_versions.list(
+            location=region,
+            public_gallery_name=gallery_name,
+            gallery_image_name=image_name,
+        )
+        image_versions = list(image_versions)
+        if not image_versions:
+            raise exceptions.ResourcesUnavailableError(
+                f'No versions available for Azure community image {image_name}')
+        latest_version = image_versions[-1].name
+
+        image_details = compute_client.community_gallery_image_versions.get(
+            location=region,
+            public_gallery_name=gallery_name,
+            gallery_image_name=image_name,
+            gallery_image_version_name=latest_version)
+        return image_details.storage_profile.os_disk_image.disk_size_gb
+    except azure.exceptions().AzureError as e:
+        raise exceptions.ResourcesUnavailableError(
+            f'Failed to get community image size: {e}.') from e

sky/clouds/utils/gcp_utils.py

@@ -17,6 +17,7 @@ import cachetools
 from sky import sky_logging
 from sky import skypilot_config
 from sky.provision.gcp import constants
+from sky.provision.kubernetes import utils as kubernetes_utils
 from sky.utils import subprocess_utils
 
 if typing.TYPE_CHECKING:
@@ -35,7 +36,10 @@ def is_tpu(resources: Optional['resources_lib.Resources']) -> bool:
 def is_tpu_vm(resources: Optional['resources_lib.Resources']) -> bool:
     if not is_tpu(resources):
         return False
-    assert resources is not None
+    assert (resources is not None and len(resources.accelerators) == 1)
+    acc, _ = list(resources.accelerators.items())[0]
+    if kubernetes_utils.is_tpu_on_gke(acc):
+        return False
     if resources.accelerator_args is None:
         return True
     return resources.accelerator_args.get('tpu_vm', True)
@@ -49,14 +53,6 @@ def is_tpu_vm_pod(resources: Optional['resources_lib.Resources']) -> bool:
     return not acc.endswith('-8')
 
 
-def get_num_tpu_devices(resources: Optional['resources_lib.Resources']) -> int:
-    if resources is None or not is_tpu(resources):
-        raise ValueError('resources must be a valid TPU resource.')
-    acc, _ = list(resources.accelerators.items())[0]
-    num_tpu_devices = int(int(acc.split('-')[2]) / 8)
-    return num_tpu_devices
-
-
 @dataclasses.dataclass
 class SpecificReservation:
     count: int

sky/clouds/utils/oci_utils.py

@@ -1,15 +1,26 @@
 """OCI Configuration.
 History:
- - Zhanghao Wu @ Oct 2023: Formatting and refactoring
  - Hysun He (hysun.he@oracle.com) @ Apr, 2023: Initial implementation
+ - Zhanghao Wu @ Oct 2023: Formatting and refactoring
+ - Hysun He (hysun.he@oracle.com) @ Oct, 2024: Add default image OS
+   configuration.
+ - Hysun He (hysun.he@oracle.com) @ Nov.12, 2024: Add the constant
+   SERVICE_PORT_RULE_TAG
+ - Hysun He (hysun.he@oracle.com) @ Jan.01, 2025: Set the default image
+   from ubuntu 20.04 to ubuntu 22.04, including:
+   - GPU: skypilot:gpu-ubuntu-2004 -> skypilot:gpu-ubuntu-2204
+   - CPU: skypilot:cpu-ubuntu-2004 -> skypilot:cpu-ubuntu-2204
+ - Hysun He (hysun.he@oracle.com) @ Jan.01, 2025: Support reuse existing
+   VCN for SkyServe.
 """
-import logging
 import os
 
+from sky import sky_logging
 from sky import skypilot_config
 from sky.utils import resources_utils
+from sky.utils import status_lib
 
-logger = logging.getLogger(__name__)
+logger = sky_logging.init_logger(__name__)
 
 
 class OCIConfig:
@@ -39,6 +50,9 @@ class OCIConfig:
     VCN_CIDR_INTERNET = '0.0.0.0/0'
     VCN_CIDR = '192.168.0.0/16'
     VCN_SUBNET_CIDR = '192.168.0.0/18'
+    SERVICE_PORT_RULE_TAG = 'SkyServe-Service-Port'
+    # NSG name template
+    NSG_NAME_TEMPLATE = 'nsg_{cluster_name}'
 
     MAX_RETRY_COUNT = 3
     RETRY_INTERVAL_BASE_SECONDS = 5
@@ -75,6 +89,19 @@ class OCIConfig:
         resources_utils.DiskTier.HIGH: DISK_TIER_HIGH,
     }
 
+    # Oracle instance's lifecycle state to sky state mapping.
+    # For Oracle VM instance's lifecyle state, please refer to the link:
+    # https://docs.oracle.com/en-us/iaas/api/#/en/iaas/latest/Instance/
+    STATE_MAPPING_OCI_TO_SKY = {
+        'PROVISIONING': status_lib.ClusterStatus.INIT,
+        'STARTING': status_lib.ClusterStatus.INIT,
+        'RUNNING': status_lib.ClusterStatus.UP,
+        'STOPPING': status_lib.ClusterStatus.STOPPED,
+        'STOPPED': status_lib.ClusterStatus.STOPPED,
+        'TERMINATED': None,
+        'TERMINATING': None,
+    }
+
     @classmethod
     def get_compartment(cls, region):
         # Allow task(cluster)-specific compartment/VCN parameters.
@@ -84,8 +111,15 @@ class OCIConfig:
             ('oci', region, 'compartment_ocid'), default_compartment_ocid)
         return compartment
 
+    @classmethod
+    def get_vcn_ocid(cls, region):
+        # Will reuse the regional VCN if specified.
+        vcn = skypilot_config.get_nested(('oci', region, 'vcn_ocid'), None)
+        return vcn
+
     @classmethod
     def get_vcn_subnet(cls, region):
+        # Will reuse the subnet if specified.
         vcn = skypilot_config.get_nested(('oci', region, 'vcn_subnet'), None)
         return vcn
 
@@ -96,7 +130,7 @@ class OCIConfig:
         # the sky's user-config file (if not specified, use the hardcode one at
         # last)
         return skypilot_config.get_nested(('oci', 'default', 'image_tag_gpu'),
-                                          'skypilot:gpu-ubuntu-2004')
+                                          'skypilot:gpu-ubuntu-2204')
 
     @classmethod
     def get_default_image_tag(cls) -> str:
@@ -104,7 +138,7 @@ class OCIConfig:
         # set the default image tag in the sky's user-config file. (if not
         # specified, use the hardcode one at last)
         return skypilot_config.get_nested(
-            ('oci', 'default', 'image_tag_general'), 'skypilot:cpu-ubuntu-2004')
+            ('oci', 'default', 'image_tag_general'), 'skypilot:cpu-ubuntu-2204')
 
     @classmethod
     def get_sky_user_config_file(cls) -> str:
@@ -121,5 +155,13 @@ class OCIConfig:
         return skypilot_config.get_nested(
             ('oci', 'default', 'oci_config_profile'), 'DEFAULT')
 
+    @classmethod
+    def get_default_image_os(cls) -> str:
+        # Get the default image OS. Instead of hardcoding, we give a choice to
+        # set the default image OS type in the sky's user-config file. (if not
+        # specified, use the hardcode one at last)
+        return skypilot_config.get_nested(('oci', 'default', 'image_os_type'),
+                                          'ubuntu')
+
 
 oci_config = OCIConfig()