skypilot-nightly 1.0.0.dev20250728__py3-none-any.whl → 1.0.0.dev20250730__py3-none-any.whl

sky/data/storage.py

@@ -1,4 +1,6 @@
 """Storage and Store Classes for Sky Data."""
+from abc import abstractmethod
+from dataclasses import dataclass
 import enum
 import hashlib
 import os
@@ -7,7 +9,7 @@ import shlex
 import subprocess
 import time
 import typing
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
 import urllib.parse
 
 import colorama
@@ -126,40 +128,68 @@ class StoreType(enum.Enum):
     NEBIUS = 'NEBIUS'
     VOLUME = 'VOLUME'
 
+    @classmethod
+    def _get_s3_compatible_store_by_cloud(cls,
+                                          cloud_name: str) -> Optional[str]:
+        """Get S3-compatible store type by cloud name."""
+        for store_type, store_class in _S3_COMPATIBLE_STORES.items():
+            config = store_class.get_config()
+            if config.cloud_name.lower() == cloud_name:
+                return store_type
+        return None
+
+    @classmethod
+    def _get_s3_compatible_config(
+            cls, store_type: str) -> Optional['S3CompatibleConfig']:
+        """Get S3-compatible store configuration by store type."""
+        store_class = _S3_COMPATIBLE_STORES.get(store_type)
+        if store_class:
+            return store_class.get_config()
+        return None
+
+    @classmethod
+    def find_s3_compatible_config_by_prefix(
+            cls, source: str) -> Optional['StoreType']:
+        """Get S3-compatible store type by URL prefix."""
+        for store_type, store_class in _S3_COMPATIBLE_STORES.items():
+            config = store_class.get_config()
+            if source.startswith(config.url_prefix):
+                return StoreType(store_type)
+        return None
+
     @classmethod
     def from_cloud(cls, cloud: str) -> 'StoreType':
-        if cloud.lower() == str(clouds.AWS()).lower():
-            return StoreType.S3
-        elif cloud.lower() == str(clouds.GCP()).lower():
+        cloud_lower = cloud.lower()
+        if cloud_lower == str(clouds.GCP()).lower():
             return StoreType.GCS
-        elif cloud.lower() == str(clouds.IBM()).lower():
+        elif cloud_lower == str(clouds.IBM()).lower():
             return StoreType.IBM
-        elif cloud.lower() == cloudflare.NAME.lower():
-            return StoreType.R2
-        elif cloud.lower() == str(clouds.Azure()).lower():
+        elif cloud_lower == str(clouds.Azure()).lower():
             return StoreType.AZURE
-        elif cloud.lower() == str(clouds.OCI()).lower():
+        elif cloud_lower == str(clouds.OCI()).lower():
             return StoreType.OCI
-        elif cloud.lower() == str(clouds.Nebius()).lower():
-            return StoreType.NEBIUS
-        elif cloud.lower() == str(clouds.Lambda()).lower():
+        elif cloud_lower == str(clouds.Lambda()).lower():
             with ux_utils.print_exception_no_traceback():
                 raise ValueError('Lambda Cloud does not provide cloud storage.')
-        elif cloud.lower() == str(clouds.SCP()).lower():
+        elif cloud_lower == str(clouds.SCP()).lower():
             with ux_utils.print_exception_no_traceback():
                 raise ValueError('SCP does not provide cloud storage.')
+        else:
+            s3_store_type = cls._get_s3_compatible_store_by_cloud(cloud_lower)
+            if s3_store_type:
+                return cls(s3_store_type)
 
         raise ValueError(f'Unsupported cloud for StoreType: {cloud}')
 
     def to_cloud(self) -> str:
-        if self == StoreType.S3:
-            return str(clouds.AWS())
-        elif self == StoreType.GCS:
+        config = self._get_s3_compatible_config(self.value)
+        if config:
+            return config.cloud_name
+
+        if self == StoreType.GCS:
             return str(clouds.GCP())
         elif self == StoreType.AZURE:
             return str(clouds.Azure())
-        elif self == StoreType.R2:
-            return cloudflare.NAME
         elif self == StoreType.IBM:
             return str(clouds.IBM())
         elif self == StoreType.OCI:
@@ -169,41 +199,34 @@ class StoreType(enum.Enum):
 
     @classmethod
     def from_store(cls, store: 'AbstractStore') -> 'StoreType':
-        if isinstance(store, S3Store):
-            return StoreType.S3
-        elif isinstance(store, GcsStore):
+        if isinstance(store, S3CompatibleStore):
+            return cls(store.get_store_type())
+
+        if isinstance(store, GcsStore):
             return StoreType.GCS
         elif isinstance(store, AzureBlobStore):
             return StoreType.AZURE
-        elif isinstance(store, R2Store):
-            return StoreType.R2
         elif isinstance(store, IBMCosStore):
             return StoreType.IBM
         elif isinstance(store, OciStore):
             return StoreType.OCI
-        elif isinstance(store, NebiusStore):
-            return StoreType.NEBIUS
         else:
             with ux_utils.print_exception_no_traceback():
                 raise ValueError(f'Unknown store type: {store}')
 
     def store_prefix(self) -> str:
-        if self == StoreType.S3:
-            return 's3://'
-        elif self == StoreType.GCS:
+        config = self._get_s3_compatible_config(self.value)
+        if config:
+            return config.url_prefix
+
+        if self == StoreType.GCS:
             return 'gs://'
         elif self == StoreType.AZURE:
             return 'https://'
-        # R2 storages use 's3://' as a prefix for various aws cli commands
-        elif self == StoreType.R2:
-            return 'r2://'
         elif self == StoreType.IBM:
             return 'cos://'
         elif self == StoreType.OCI:
             return 'oci://'
-        # Nebius storages use 's3://' as a prefix for various aws cli commands
-        elif self == StoreType.NEBIUS:
-            return 'nebius://'
         else:
             with ux_utils.print_exception_no_traceback():
                 raise ValueError(f'Unknown store type: {self}')
@@ -252,12 +275,20 @@ class StoreType(enum.Enum):
                 elif store_type == StoreType.IBM:
                     bucket_name, sub_path, region = data_utils.split_cos_path(
                         store_url)
-                elif store_type == StoreType.R2:
-                    bucket_name, sub_path = data_utils.split_r2_path(store_url)
                 elif store_type == StoreType.GCS:
                     bucket_name, sub_path = data_utils.split_gcs_path(store_url)
-                elif store_type == StoreType.S3:
-                    bucket_name, sub_path = data_utils.split_s3_path(store_url)
+                else:
+                    # Check compatible stores
+                    for compatible_store_type, store_class in \
+                        _S3_COMPATIBLE_STORES.items():
+                        if store_type.value == compatible_store_type:
+                            config = store_class.get_config()
+                            bucket_name, sub_path = config.split_path(store_url)
+                            break
+                    else:
+                        # If we get here, it's an unknown S3-compatible store
+                        raise ValueError(
+                            f'Unknown S3-compatible store type: {store_type}')
                 return store_type, bucket_name, \
                     sub_path, storage_account_name, region
         raise ValueError(f'Unknown store URL: {store_url}')
@@ -752,20 +783,19 @@ class Storage(object):
                 # If source is a pre-existing bucket, connect to the bucket
                 # If the bucket does not exist, this will error out
                 if isinstance(self.source, str):
-                    if self.source.startswith('s3://'):
-                        self.add_store(StoreType.S3)
-                    elif self.source.startswith('gs://'):
+                    if self.source.startswith('gs://'):
                         self.add_store(StoreType.GCS)
                     elif data_utils.is_az_container_endpoint(self.source):
                         self.add_store(StoreType.AZURE)
-                    elif self.source.startswith('r2://'):
-                        self.add_store(StoreType.R2)
                     elif self.source.startswith('cos://'):
                         self.add_store(StoreType.IBM)
                     elif self.source.startswith('oci://'):
                         self.add_store(StoreType.OCI)
-                    elif self.source.startswith('nebius://'):
-                        self.add_store(StoreType.NEBIUS)
+
+                    store_type = StoreType.find_s3_compatible_config_by_prefix(
+                        self.source)
+                    if store_type:
+                        self.add_store(store_type)
 
     def get_bucket_sub_path_prefix(self, blob_path: str) -> str:
         """Adds the bucket sub path prefix to the blob path."""
@@ -981,12 +1011,25 @@ class Storage(object):
             # When initializing from global_user_state, we override the
             # source from the YAML
             try:
-                if s_type == StoreType.S3:
+                if s_type.value in _S3_COMPATIBLE_STORES:
+                    store_class = _S3_COMPATIBLE_STORES[s_type.value]
+                    store = store_class.from_metadata(
+                        s_metadata,
+                        source=self.source,
+                        sync_on_reconstruction=self.sync_on_reconstruction,
+                        _bucket_sub_path=self._bucket_sub_path)
+                elif s_type == StoreType.S3:
                     store = S3Store.from_metadata(
                         s_metadata,
                         source=self.source,
                         sync_on_reconstruction=self.sync_on_reconstruction,
                         _bucket_sub_path=self._bucket_sub_path)
+                elif s_type == StoreType.R2:
+                    store = R2Store.from_metadata(
+                        s_metadata,
+                        source=self.source,
+                        sync_on_reconstruction=self.sync_on_reconstruction,
+                        _bucket_sub_path=self._bucket_sub_path)
                 elif s_type == StoreType.GCS:
                     store = GcsStore.from_metadata(
                         s_metadata,
@@ -1001,12 +1044,6 @@ class Storage(object):
                         source=self.source,
                         sync_on_reconstruction=self.sync_on_reconstruction,
                         _bucket_sub_path=self._bucket_sub_path)
-                elif s_type == StoreType.R2:
-                    store = R2Store.from_metadata(
-                        s_metadata,
-                        source=self.source,
-                        sync_on_reconstruction=self.sync_on_reconstruction,
-                        _bucket_sub_path=self._bucket_sub_path)
                 elif s_type == StoreType.IBM:
                     store = IBMCosStore.from_metadata(
                         s_metadata,
@@ -1107,20 +1144,17 @@ class Storage(object):
             return store
 
         store_cls: Type[AbstractStore]
-        if store_type == StoreType.S3:
-            store_cls = S3Store
+        # First check if it's a registered S3-compatible store
+        if store_type.value in _S3_COMPATIBLE_STORES:
+            store_cls = _S3_COMPATIBLE_STORES[store_type.value]
         elif store_type == StoreType.GCS:
             store_cls = GcsStore
         elif store_type == StoreType.AZURE:
             store_cls = AzureBlobStore
-        elif store_type == StoreType.R2:
-            store_cls = R2Store
         elif store_type == StoreType.IBM:
             store_cls = IBMCosStore
         elif store_type == StoreType.OCI:
             store_cls = OciStore
-        elif store_type == StoreType.NEBIUS:
-            store_cls = NebiusStore
         else:
             with ux_utils.print_exception_no_traceback():
                 raise exceptions.StorageSpecError(
@@ -1344,101 +1378,261 @@ class Storage(object):
         return config
 
 
-class S3Store(AbstractStore):
-    """S3Store inherits from Storage Object and represents the backend
-    for S3 buckets.
+# Registry for S3-compatible stores
+_S3_COMPATIBLE_STORES = {}
+
+
+def register_s3_compatible_store(store_class):
+    """Decorator to automatically register S3-compatible stores."""
+    store_type = store_class.get_store_type()
+    _S3_COMPATIBLE_STORES[store_type] = store_class
+    return store_class
+
+
+@dataclass
+class S3CompatibleConfig:
+    """Configuration for S3-compatible storage providers."""
+    # Provider identification
+    store_type: str  # Store type identifier (e.g., "S3", "R2", "MINIO")
+    url_prefix: str  # URL prefix (e.g., "s3://", "r2://", "minio://")
+
+    # Client creation
+    client_factory: Callable[[Optional[str]], Any]
+    resource_factory: Callable[[str], StorageHandle]
+    split_path: Callable[[str], Tuple[str, str]]
+    verify_bucket: Callable[[str], bool]
+
+    # CLI configuration
+    aws_profile: Optional[str] = None
+    get_endpoint_url: Optional[Callable[[], str]] = None
+    credentials_file: Optional[str] = None
+    extra_cli_args: Optional[List[str]] = None
+
+    # Provider-specific settings
+    cloud_name: str = ''
+    default_region: Optional[str] = None
+    access_denied_message: str = 'Access Denied'
+
+    # Mounting
+    mount_cmd_factory: Optional[Callable] = None
+    mount_cached_cmd_factory: Optional[Callable] = None
+
+    def __post_init__(self):
+        if self.extra_cli_args is None:
+            self.extra_cli_args = []
+
+
+class S3CompatibleStore(AbstractStore):
+    """Base class for S3-compatible object storage providers.
+
+    This class provides a unified interface for all S3-compatible storage
+    providers (AWS S3, Cloudflare R2, Nebius, MinIO, etc.) by leveraging
+    a configuration-driven approach that eliminates code duplication.
+
+    ## Adding a New S3-Compatible Store
+
+    To add a new S3-compatible storage provider (e.g., MinIO),
+    follow these steps:
+
+    ### 1. Add Store Type to Enum
+    First, add your store type to the StoreType enum:
+    ```python
+    class StoreType(enum.Enum):
+        # ... existing entries ...
+        MINIO = 'MINIO'
+    ```
+
+    ### 2. Create Store Class
+    Create a new store class that inherits from S3CompatibleStore:
+    ```python
+    @register_s3_compatible_store
+    class MinIOStore(S3CompatibleStore):
+        '''MinIOStore for MinIO object storage.'''
+
+        @classmethod
+        def get_config(cls) -> S3CompatibleConfig:
+            '''Return the configuration for MinIO.'''
+            return S3CompatibleConfig(
+                store_type='MINIO',
+                url_prefix='minio://',
+                client_factory=lambda region:\
+                    data_utils.create_minio_client(region),
+                resource_factory=lambda name:\
+                    minio.resource('s3').Bucket(name),
+                split_path=data_utils.split_minio_path,
+                aws_profile='minio',
+                get_endpoint_url=lambda: minio.get_endpoint_url(),
+                cloud_name='minio',
+                default_region='us-east-1',
+                mount_cmd_factory=mounting_utils.get_minio_mount_cmd,
+            )
+    ```
+
+    ### 3. Implement Required Utilities
+    Create the necessary utility functions:
+
+    #### In `sky/data/data_utils.py`:
+    ```python
+    def create_minio_client(region: Optional[str] = None):
+        '''Create MinIO S3 client.'''
+        return boto3.client('s3',
+                          endpoint_url=minio.get_endpoint_url(),
+                          aws_access_key_id=minio.get_access_key(),
+                          aws_secret_access_key=minio.get_secret_key(),
+                          region_name=region or 'us-east-1')
+
+    def split_minio_path(minio_path: str) -> Tuple[str, str]:
+        '''Split minio://bucket/key into (bucket, key).'''
+        path_parts = minio_path.replace('minio://', '').split('/', 1)
+        bucket = path_parts[0]
+        key = path_parts[1] if len(path_parts) > 1 else ''
+        return bucket, key
+    ```
+
+    #### In `sky/utils/mounting_utils.py`:
+    ```python
+    def get_minio_mount_cmd(profile: str, bucket_name: str, endpoint_url: str,
+                           mount_path: str,
+                           bucket_sub_path: Optional[str]) -> str:
+        '''Generate MinIO mount command using s3fs.'''
+        # Implementation similar to other S3-compatible mount commands
+        pass
+    ```
+
+    ### 4. Create Adapter Module (if needed)
+    Create `sky/adaptors/minio.py` for MinIO-specific configuration:
+    ```python
+    '''MinIO adapter for SkyPilot.'''
+
+    MINIO_PROFILE_NAME = 'minio'
+
+    def get_endpoint_url() -> str:
+        '''Get MinIO endpoint URL from configuration.'''
+        # Read from ~/.minio/config or environment variables
+        pass
+
+    def resource(resource_name: str):
+        '''Get MinIO resource.'''
+        # Implementation for creating MinIO resources
+        pass
+    ```
+
     """
 
-    _DEFAULT_REGION = 'us-east-1'
     _ACCESS_DENIED_MESSAGE = 'Access Denied'
-    _CUSTOM_ENDPOINT_REGIONS = [
-        'ap-east-1', 'me-south-1', 'af-south-1', 'eu-south-1', 'eu-south-2',
-        'ap-south-2', 'ap-southeast-3', 'ap-southeast-4', 'me-central-1',
-        'il-central-1'
-    ]
 
     def __init__(self,
                  name: str,
                  source: str,
-                 region: Optional[str] = _DEFAULT_REGION,
+                 region: Optional[str] = None,
                  is_sky_managed: Optional[bool] = None,
                  sync_on_reconstruction: bool = True,
                  _bucket_sub_path: Optional[str] = None):
+        # Initialize configuration first to get defaults
+        self.config = self.__class__.get_config()
+
+        # Use provider's default region if not specified
+        if region is None:
+            region = self.config.default_region
+
+        # Initialize S3CompatibleStore specific attributes
         self.client: 'mypy_boto3_s3.Client'
         self.bucket: 'StorageHandle'
-        # TODO(romilb): This is purely a stopgap fix for
-        #  https://github.com/skypilot-org/skypilot/issues/3405
-        # We should eventually make all opt-in regions also work for S3 by
-        # passing the right endpoint flags.
-        if region in self._CUSTOM_ENDPOINT_REGIONS:
-            logger.warning('AWS opt-in regions are not supported for S3. '
-                           f'Falling back to default region '
-                           f'{self._DEFAULT_REGION} for bucket {name!r}.')
-            region = self._DEFAULT_REGION
+
+        # Call parent constructor
         super().__init__(name, source, region, is_sky_managed,
                          sync_on_reconstruction, _bucket_sub_path)
 
+    @classmethod
+    @abstractmethod
+    def get_config(cls) -> S3CompatibleConfig:
+        """Return the configuration for this S3-compatible provider."""
+        pass
+
+    @classmethod
+    def get_store_type(cls) -> str:
+        """Return the store type identifier from configuration."""
+        return cls.get_config().store_type
+
+    @property
+    def provider_prefixes(self) -> set:
+        """Dynamically get all provider prefixes from registered stores."""
+        prefixes = set()
+
+        # Get prefixes from all registered S3-compatible stores
+        for store_class in _S3_COMPATIBLE_STORES.values():
+            config = store_class.get_config()
+            prefixes.add(config.url_prefix)
+
+        # Add hardcoded prefixes for non-S3-compatible stores
+        prefixes.update({
+            'gs://',  # GCS
+            'https://',  # Azure
+            'cos://',  # IBM COS
+            'oci://',  # OCI
+        })
+
+        return prefixes
+
     def _validate(self):
         if self.source is not None and isinstance(self.source, str):
-            if self.source.startswith('s3://'):
-                assert self.name == data_utils.split_s3_path(self.source)[0], (
-                    'S3 Bucket is specified as path, the name should be the'
-                    ' same as S3 bucket.')
+            if self.source.startswith(self.config.url_prefix):
+                bucket_name, _ = self.config.split_path(self.source)
+                assert self.name == bucket_name, (
+                    f'{self.config.store_type} Bucket is specified as path, '
+                    f'the name should be the same as {self.config.store_type} '
+                    f'bucket.')
+                # Only verify if this is NOT the same store type as the source
+                if self.__class__.get_store_type() != self.config.store_type:
+                    assert self.config.verify_bucket(self.name), (
+                        f'Source specified as {self.source},'
+                        f'a {self.config.store_type} '
+                        f'bucket. {self.config.store_type} Bucket should exist.'
+                    )
             elif self.source.startswith('gs://'):
                 assert self.name == data_utils.split_gcs_path(self.source)[0], (
                     'GCS Bucket is specified as path, the name should be '
                     'the same as GCS bucket.')
-                assert data_utils.verify_gcs_bucket(self.name), (
-                    f'Source specified as {self.source}, a GCS bucket. ',
-                    'GCS Bucket should exist.')
+                if not isinstance(self, GcsStore):
+                    assert data_utils.verify_gcs_bucket(self.name), (
+                        f'Source specified as {self.source}, a GCS bucket. ',
+                        'GCS Bucket should exist.')
             elif data_utils.is_az_container_endpoint(self.source):
                 storage_account_name, container_name, _ = (
                     data_utils.split_az_path(self.source))
                 assert self.name == container_name, (
                     'Azure bucket is specified as path, the name should be '
                     'the same as Azure bucket.')
-                assert data_utils.verify_az_bucket(
-                    storage_account_name, self.name), (
-                        f'Source specified as {self.source}, an Azure bucket. '
+                if not isinstance(self, AzureBlobStore):
+                    assert data_utils.verify_az_bucket(
+                        storage_account_name, self.name
+                    ), (f'Source specified as {self.source}, an Azure bucket. '
                         'Azure bucket should exist.')
-            elif self.source.startswith('r2://'):
-                assert self.name == data_utils.split_r2_path(self.source)[0], (
-                    'R2 Bucket is specified as path, the name should be '
-                    'the same as R2 bucket.')
-                assert data_utils.verify_r2_bucket(self.name), (
-                    f'Source specified as {self.source}, a R2 bucket. ',
-                    'R2 Bucket should exist.')
-            elif self.source.startswith('nebius://'):
-                assert self.name == data_utils.split_nebius_path(
-                    self.source)[0], (
-                        'Nebius Object Storage is specified as path, the name '
-                        'should be the same as Nebius Object Storage bucket.')
-                assert data_utils.verify_nebius_bucket(self.name), (
-                    f'Source specified as {self.source}, a Nebius Object '
-                    f'Storage bucket. Nebius Object Storage Bucket should'
-                    f' exist.')
             elif self.source.startswith('cos://'):
                 assert self.name == data_utils.split_cos_path(self.source)[0], (
                     'COS Bucket is specified as path, the name should be '
                     'the same as COS bucket.')
-                assert data_utils.verify_ibm_cos_bucket(self.name), (
-                    f'Source specified as {self.source}, a COS bucket. ',
-                    'COS Bucket should exist.')
+                if not isinstance(self, IBMCosStore):
+                    assert data_utils.verify_ibm_cos_bucket(self.name), (
+                        f'Source specified as {self.source}, a COS bucket. ',
+                        'COS Bucket should exist.')
             elif self.source.startswith('oci://'):
                 raise NotImplementedError(
-                    'Moving data from OCI to S3 is currently not supported.')
+                    f'Moving data from OCI to {self.source} is ',
+                    'currently not supported.')
+
         # Validate name
         self.name = self.validate_name(self.name)
 
         # Check if the storage is enabled
-        if not _is_storage_cloud_enabled(str(clouds.AWS())):
+        if not _is_storage_cloud_enabled(self.config.cloud_name):
             with ux_utils.print_exception_no_traceback():
                 raise exceptions.ResourcesUnavailableError(
-                    'Storage \'store: s3\' specified, but ' \
-                    'AWS access is disabled. To fix, enable '\
-                    'AWS by running `sky check`. More info: '\
-                    'https://docs.skypilot.co/en/latest/getting-started/installation.html.' # pylint: disable=line-too-long
-                    )
+                    f'Storage "store: {self.config.store_type.lower()}" '
+                    f'specified, but '
+                    f'{self.config.cloud_name} access is disabled. '
+                    'To fix, enable '
+                    f'{self.config.cloud_name} by running `sky check`.')
 
     @classmethod
     def validate_name(cls, name: str) -> str:
@@ -1510,7 +1704,7 @@ class S3Store(AbstractStore):
           StorageBucketGetError: If fetching existing bucket fails
           StorageInitError: If general initialization fails.
         """
-        self.client = data_utils.create_s3_client(self.region)
+        self.client = self.config.client_factory(self.region)
         self.bucket, is_new_bucket = self._get_bucket()
         if self.is_sky_managed is None:
             # If is_sky_managed is not specified, then this is a new storage
@@ -1532,16 +1726,10 @@ class S3Store(AbstractStore):
             if isinstance(self.source, list):
                 self.batch_aws_rsync(self.source, create_dirs=True)
             elif self.source is not None:
-                if self.source.startswith('s3://'):
-                    pass
-                elif self.source.startswith('gs://'):
-                    self._transfer_to_s3()
-                elif self.source.startswith('r2://'):
-                    self._transfer_to_s3()
-                elif self.source.startswith('oci://'):
-                    self._transfer_to_s3()
-                elif self.source.startswith('nebius://'):
-                    self._transfer_to_s3()
+                if self._is_same_provider_source():
+                    pass  # No transfer needed
+                elif self._needs_cross_provider_transfer():
+                    self._transfer_from_other_provider()
                 else:
                     self.batch_aws_rsync([self.source])
         except exceptions.StorageUploadError:
@@ -1550,57 +1738,94 @@ class S3Store(AbstractStore):
             raise exceptions.StorageUploadError(
                 f'Upload failed for store {self.name}') from e
 
+    def _is_same_provider_source(self) -> bool:
+        """Check if source is from the same provider."""
+        return isinstance(self.source, str) and self.source.startswith(
+            self.config.url_prefix)
+
+    def _needs_cross_provider_transfer(self) -> bool:
+        """Check if source needs cross-provider transfer."""
+        if not isinstance(self.source, str):
+            return False
+        return any(
+            self.source.startswith(prefix) for prefix in self.provider_prefixes)
+
+    def _detect_source_type(self) -> str:
+        """Detect the source provider type from URL."""
+        if not isinstance(self.source, str):
+            return 'unknown'
+
+        for provider in self.provider_prefixes:
+            if self.source.startswith(provider):
+                return provider[:-len('://')]
+        return ''
+
+    def _transfer_from_other_provider(self):
+        """Transfer data from another cloud to this S3-compatible store."""
+        source_type = self._detect_source_type()
+        target_type = self.config.store_type.lower()
+
+        if hasattr(data_transfer, f'{source_type}_to_{target_type}'):
+            transfer_func = getattr(data_transfer,
+                                    f'{source_type}_to_{target_type}')
+            transfer_func(self.name, self.name)
+        else:
+            with ux_utils.print_exception_no_traceback():
+                raise NotImplementedError(
+                    f'Transfer from {source_type} to {target_type} '
+                    'is not yet supported.')
+
     def delete(self) -> None:
+        """Delete the bucket or sub-path."""
         if self._bucket_sub_path is not None and not self.is_sky_managed:
             return self._delete_sub_path()
 
-        deleted_by_skypilot = self._delete_s3_bucket(self.name)
+        deleted_by_skypilot = self._delete_bucket(self.name)
+        provider = self.config.store_type
         if deleted_by_skypilot:
-            msg_str = f'Deleted S3 bucket {self.name}.'
+            msg_str = f'Deleted {provider} bucket {self.name}.'
         else:
-            msg_str = f'S3 bucket {self.name} may have been deleted ' \
+            msg_str = f'{provider} bucket {self.name} may have been deleted ' \
                       f'externally. Removing from local state.'
-        logger.info(f'{colorama.Fore.GREEN}{msg_str}'
-                    f'{colorama.Style.RESET_ALL}')
-
-    def _delete_sub_path(self) -> None:
-        assert self._bucket_sub_path is not None, 'bucket_sub_path is not set'
-        deleted_by_skypilot = self._delete_s3_bucket_sub_path(
-            self.name, self._bucket_sub_path)
-        if deleted_by_skypilot:
-            msg_str = f'Removed objects from S3 bucket ' \
-                      f'{self.name}/{self._bucket_sub_path}.'
-        else:
-            msg_str = f'Failed to remove objects from S3 bucket ' \
-                      f'{self.name}/{self._bucket_sub_path}.'
-        logger.info(f'{colorama.Fore.GREEN}{msg_str}'
-                    f'{colorama.Style.RESET_ALL}')
+        logger.info(f'{colorama.Fore.GREEN}{msg_str}{colorama.Style.RESET_ALL}')
 
     def get_handle(self) -> StorageHandle:
-        return aws.resource('s3').Bucket(self.name)
+        """Get storage handle using provider's resource factory."""
+        return self.config.resource_factory(self.name)
 
-    def batch_aws_rsync(self,
-                        source_path_list: List[Path],
-                        create_dirs: bool = False) -> None:
-        """Invokes aws s3 sync to batch upload a list of local paths to S3
+    def _download_file(self, remote_path: str, local_path: str) -> None:
+        """Download file using S3 API."""
+        self.bucket.download_file(remote_path, local_path)
+
+    def mount_command(self, mount_path: str) -> str:
+        """Get mount command using provider's mount factory."""
+        if self.config.mount_cmd_factory is None:
+            raise exceptions.NotSupportedError(
+                f'Mounting not supported for {self.config.store_type}')
 
-        AWS Sync by default uses 10 threads to upload files to the bucket.  To
-        increase parallelism, modify max_concurrent_requests in your aws config
-        file (Default path: ~/.aws/config).
+        install_cmd = mounting_utils.get_s3_mount_install_cmd()
+        mount_cmd = self.config.mount_cmd_factory(self.bucket.name, mount_path,
+                                                  self._bucket_sub_path)
+        return mounting_utils.get_mounting_command(mount_path, install_cmd,
+                                                   mount_cmd)
 
-        Since aws s3 sync does not support batch operations, we construct
-        multiple commands to be run in parallel.
+    def mount_cached_command(self, mount_path: str) -> str:
+        """Get cached mount command. Can be overridden by subclasses."""
+        if self.config.mount_cached_cmd_factory is None:
+            raise exceptions.NotSupportedError(
+                f'Cached mounting not supported for {self.config.store_type}')
 
-        Args:
-            source_path_list: List of paths to local files or directories
-            create_dirs: If the local_path is a directory and this is set to
-                False, the contents of the directory are directly uploaded to
-                root of the bucket. If the local_path is a directory and this is
-                set to True, the directory is created in the bucket root and
-                contents are uploaded to it.
-        """
-        sub_path = (f'/{self._bucket_sub_path}'
-                    if self._bucket_sub_path else '')
+        install_cmd = mounting_utils.get_rclone_install_cmd()
+        mount_cmd = self.config.mount_cached_cmd_factory(
+            self.bucket.name, mount_path, self._bucket_sub_path)
+        return mounting_utils.get_mounting_command(mount_path, install_cmd,
+                                                   mount_cmd)
+
+    def batch_aws_rsync(self,
+                        source_path_list: List[Path],
+                        create_dirs: bool = False) -> None:
+        """Generic S3-compatible rsync using AWS CLI."""
+        sub_path = f'/{self._bucket_sub_path}' if self._bucket_sub_path else ''
 
         def get_file_sync_command(base_dir_path, file_names):
             includes = ' '.join([
@@ -1608,10 +1833,28 @@ class S3Store(AbstractStore):
                 for file_name in file_names
             ])
             base_dir_path = shlex.quote(base_dir_path)
-            sync_command = ('aws s3 sync --no-follow-symlinks --exclude="*" '
-                            f'{includes} {base_dir_path} '
-                            f's3://{self.name}{sub_path}')
-            return sync_command
+
+            # Build AWS CLI command with provider-specific configuration
+            cmd_parts = ['aws s3 sync --no-follow-symlinks --exclude="*"']
+            cmd_parts.append(f'{includes} {base_dir_path}')
+            cmd_parts.append(f's3://{self.name}{sub_path}')
+
+            # Add provider-specific arguments
+            if self.config.get_endpoint_url:
+                cmd_parts.append(
+                    f'--endpoint-url {self.config.get_endpoint_url()}')
+            if self.config.aws_profile:
+                cmd_parts.append(f'--profile={self.config.aws_profile}')
+            if self.config.extra_cli_args:
+                cmd_parts.extend(self.config.extra_cli_args)
+
+            # Handle credentials file via environment
+            cmd = ' '.join(cmd_parts)
+            if self.config.credentials_file:
+                cmd = 'AWS_SHARED_CREDENTIALS_FILE=' + \
+                f'{self.config.credentials_file} {cmd}'
+
+            return cmd
 
         def get_dir_sync_command(src_dir_path, dest_dir_name):
             # we exclude .git directory from the sync
@@ -1619,11 +1862,11 @@ class S3Store(AbstractStore):
             excluded_list.append('.git/*')
 
             # Process exclusion patterns to make them work correctly with aws
-            # s3 sync
+            # s3 sync - this logic is from S3Store2 to ensure compatibility
             processed_excludes = []
             for excluded_path in excluded_list:
                 # Check if the path is a directory exclusion pattern
-                # For AWS S3 sync, directory patterns need to end with "/**" to
+                # For AWS S3 sync, directory patterns need to end with "/*" to
                 # exclude all contents
                 if (excluded_path.endswith('/') or os.path.isdir(
                         os.path.join(src_dir_path, excluded_path.rstrip('/')))):
@@ -1638,10 +1881,25 @@ class S3Store(AbstractStore):
                 for file_name in processed_excludes
             ])
             src_dir_path = shlex.quote(src_dir_path)
-            sync_command = (f'aws s3 sync --no-follow-symlinks {excludes} '
-                            f'{src_dir_path} '
-                            f's3://{self.name}{sub_path}/{dest_dir_name}')
-            return sync_command
+
+            cmd_parts = ['aws s3 sync --no-follow-symlinks']
+            cmd_parts.append(f'{excludes} {src_dir_path}')
+            cmd_parts.append(f's3://{self.name}{sub_path}/{dest_dir_name}')
+
+            if self.config.get_endpoint_url:
+                cmd_parts.append(
+                    f'--endpoint-url {self.config.get_endpoint_url()}')
+            if self.config.aws_profile:
+                cmd_parts.append(f'--profile={self.config.aws_profile}')
+            if self.config.extra_cli_args:
+                cmd_parts.extend(self.config.extra_cli_args)
+
+            cmd = ' '.join(cmd_parts)
+            if self.config.credentials_file:
+                cmd = 'AWS_SHARED_CREDENTIALS_FILE=' + \
+                f'{self.config.credentials_file} {cmd}'
+
+            return cmd
 
         # Generate message for upload
         if len(source_path_list) > 1:
@@ -1649,9 +1907,12 @@ class S3Store(AbstractStore):
         else:
             source_message = source_path_list[0]
 
+        provider_prefix = self.config.url_prefix
         log_path = sky_logging.generate_tmp_logging_file_path(
             _STORAGE_LOG_FILE_NAME)
-        sync_path = f'{source_message} -> s3://{self.name}{sub_path}/'
+        sync_path = (f'{source_message} -> '
+                     f'{provider_prefix}{self.name}{sub_path}/')
+
         with rich_utils.safe_status(
                 ux_utils.spinner_message(f'Syncing {sync_path}',
                                          log_path=log_path)):
@@ -1661,151 +1922,78 @@ class S3Store(AbstractStore):
                 get_dir_sync_command,
                 log_path,
                 self.name,
-                self._ACCESS_DENIED_MESSAGE,
+                self.config.access_denied_message,
                 create_dirs=create_dirs,
                 max_concurrent_uploads=_MAX_CONCURRENT_UPLOADS)
+
         logger.info(
             ux_utils.finishing_message(f'Storage synced: {sync_path}',
                                        log_path))
 
-    def _transfer_to_s3(self) -> None:
-        assert isinstance(self.source, str), self.source
-        if self.source.startswith('gs://'):
-            data_transfer.gcs_to_s3(self.name, self.name)
-        elif self.source.startswith('r2://'):
-            data_transfer.r2_to_s3(self.name, self.name)
-
     def _get_bucket(self) -> Tuple[StorageHandle, bool]:
-        """Obtains the S3 bucket.
-
-        If the bucket exists, this method will return the bucket.
-        If the bucket does not exist, there are three cases:
-          1) Raise an error if the bucket source starts with s3://
-          2) Return None if bucket has been externally deleted and
-             sync_on_reconstruction is False
-          3) Create and return a new bucket otherwise
-
-        Raises:
-            StorageSpecError: If externally created bucket is attempted to be
-                mounted without specifying storage source.
-            StorageBucketCreateError: If creating the bucket fails
-            StorageBucketGetError: If fetching a bucket fails
-            StorageExternalDeletionError: If externally deleted storage is
-                attempted to be fetched while reconstructing the storage for
-                'sky storage delete' or 'sky start'
-        """
-        s3 = aws.resource('s3')
-        bucket = s3.Bucket(self.name)
+        """Get or create bucket using S3 API."""
+        bucket = self.config.resource_factory(self.name)
 
         try:
             # Try Public bucket case.
-            # This line does not error out if the bucket is an external public
-            # bucket or if it is a user's bucket that is publicly
-            # accessible.
             self.client.head_bucket(Bucket=self.name)
             self._validate_existing_bucket()
             return bucket, False
         except aws.botocore_exceptions().ClientError as e:
             error_code = e.response['Error']['Code']
-            # AccessDenied error for buckets that are private and not owned by
-            # user.
             if error_code == '403':
-                command = f'aws s3 ls {self.name}'
+                command = f'aws s3 ls s3://{self.name}'
+                if self.config.aws_profile:
+                    command += f' --profile={self.config.aws_profile}'
+                if self.config.get_endpoint_url:
+                    command += f' --endpoint-url '\
+                        f'{self.config.get_endpoint_url()}'
+                if self.config.credentials_file:
+                    command = (f'AWS_SHARED_CREDENTIALS_FILE='
+                               f'{self.config.credentials_file} {command}')
                 with ux_utils.print_exception_no_traceback():
                     raise exceptions.StorageBucketGetError(
                         _BUCKET_FAIL_TO_CONNECT_MESSAGE.format(name=self.name) +
                         f' To debug, consider running `{command}`.') from e
 
-        if isinstance(self.source, str) and self.source.startswith('s3://'):
+        if isinstance(self.source, str) and self.source.startswith(
+                self.config.url_prefix):
             with ux_utils.print_exception_no_traceback():
                 raise exceptions.StorageBucketGetError(
                     'Attempted to use a non-existent bucket as a source: '
-                    f'{self.source}. Consider using `aws s3 ls '
-                    f'{self.source}` to debug.')
+                    f'{self.source}.')
 
-        # If bucket cannot be found in both private and public settings,
-        # the bucket is to be created by Sky. However, creation is skipped if
-        # Store object is being reconstructed for deletion or re-mount with
-        # sky start, and error is raised instead.
+        # If bucket cannot be found, create it if needed
         if self.sync_on_reconstruction:
-            bucket = self._create_s3_bucket(self.name, self.region)
+            bucket = self._create_bucket(self.name)
             return bucket, True
         else:
-            # Raised when Storage object is reconstructed for sky storage
-            # delete or to re-mount Storages with sky start but the storage
-            # is already removed externally.
             raise exceptions.StorageExternalDeletionError(
                 'Attempted to fetch a non-existent bucket: '
                 f'{self.name}')
 
-    def _download_file(self, remote_path: str, local_path: str) -> None:
-        """Downloads file from remote to local on s3 bucket
-        using the boto3 API
-
-        Args:
-          remote_path: str; Remote path on S3 bucket
-          local_path: str; Local path on user's device
-        """
-        self.bucket.download_file(remote_path, local_path)
-
-    def mount_command(self, mount_path: str) -> str:
-        """Returns the command to mount the bucket to the mount_path.
-
-        Uses goofys to mount the bucket.
-
-        Args:
-          mount_path: str; Path to mount the bucket to.
-        """
-        install_cmd = mounting_utils.get_s3_mount_install_cmd()
-        mount_cmd = mounting_utils.get_s3_mount_cmd(self.bucket.name,
-                                                    mount_path,
-                                                    self._bucket_sub_path)
-        return mounting_utils.get_mounting_command(mount_path, install_cmd,
-                                                   mount_cmd)
-
-    def mount_cached_command(self, mount_path: str) -> str:
-        install_cmd = mounting_utils.get_rclone_install_cmd()
-        rclone_profile_name = (
-            data_utils.Rclone.RcloneStores.S3.get_profile_name(self.name))
-        rclone_config = data_utils.Rclone.RcloneStores.S3.get_config(
-            rclone_profile_name=rclone_profile_name)
-        mount_cached_cmd = mounting_utils.get_mount_cached_cmd(
-            rclone_config, rclone_profile_name, self.bucket.name, mount_path)
-        return mounting_utils.get_mounting_command(mount_path, install_cmd,
-                                                   mount_cached_cmd)
-
-    def _create_s3_bucket(self,
-                          bucket_name: str,
-                          region=_DEFAULT_REGION) -> StorageHandle:
-        """Creates S3 bucket with specific name in specific region
-
-        Args:
-          bucket_name: str; Name of bucket
-          region: str; Region name, e.g. us-west-1, us-east-2
-        Raises:
-          StorageBucketCreateError: If bucket creation fails.
-        """
-        s3_client = self.client
+    def _create_bucket(self, bucket_name: str) -> StorageHandle:
+        """Create bucket using S3 API."""
         try:
             create_bucket_config: Dict[str, Any] = {'Bucket': bucket_name}
-            # If default us-east-1 region of create_bucket API is used,
-            # the LocationConstraint must not be specified.
-            # Reference: https://stackoverflow.com/a/51912090
-            if region is not None and region != 'us-east-1':
+            if self.region is not None and self.region != 'us-east-1':
                 create_bucket_config['CreateBucketConfiguration'] = {
-                    'LocationConstraint': region
+                    'LocationConstraint': self.region
                 }
-            s3_client.create_bucket(**create_bucket_config)
+            self.client.create_bucket(**create_bucket_config)
             logger.info(
                 f'  {colorama.Style.DIM}Created S3 bucket {bucket_name!r} in '
-                f'{region or "us-east-1"}{colorama.Style.RESET_ALL}')
+                f'{self.region or "us-east-1"}{colorama.Style.RESET_ALL}')
 
             # Add AWS tags configured in config.yaml to the bucket.
             # This is useful for cost tracking and external cleanup.
             bucket_tags = skypilot_config.get_effective_region_config(
-                cloud='aws', region=None, keys=('labels',), default_value={})
+                cloud=self.config.cloud_name,
+                region=None,
+                keys=('labels',),
+                default_value={})
             if bucket_tags:
-                s3_client.put_bucket_tagging(
+                self.client.put_bucket_tagging(
                     Bucket=bucket_name,
                     Tagging={
                         'TagSet': [{
@@ -1813,17 +2001,38 @@ class S3Store(AbstractStore):
                             'Value': v
                         } for k, v in bucket_tags.items()]
                     })
-
         except aws.botocore_exceptions().ClientError as e:
             with ux_utils.print_exception_no_traceback():
                 raise exceptions.StorageBucketCreateError(
                     f'Attempted to create a bucket {self.name} but failed.'
                 ) from e
-        return aws.resource('s3').Bucket(bucket_name)
+        return self.config.resource_factory(bucket_name)
+
+    def _delete_bucket(self, bucket_name: str) -> bool:
+        """Delete bucket using AWS CLI."""
+        cmd_parts = [f'aws s3 rb s3://{bucket_name} --force']
+
+        if self.config.aws_profile:
+            cmd_parts.append(f'--profile={self.config.aws_profile}')
+        if self.config.get_endpoint_url:
+            cmd_parts.append(f'--endpoint-url {self.config.get_endpoint_url()}')
+
+        remove_command = ' '.join(cmd_parts)
+
+        if self.config.credentials_file:
+            remove_command = (f'AWS_SHARED_CREDENTIALS_FILE='
+                              f'{self.config.credentials_file} '
+                              f'{remove_command}')
 
-    def _execute_s3_remove_command(self, command: str, bucket_name: str,
-                                   hint_operating: str,
-                                   hint_failed: str) -> bool:
+        return self._execute_remove_command(
+            remove_command, bucket_name,
+            f'Deleting {self.config.store_type} bucket {bucket_name}',
+            (f'Failed to delete {self.config.store_type} bucket '
+             f'{bucket_name}.'))
+
+    def _execute_remove_command(self, command: str, bucket_name: str,
+                                hint_operating: str, hint_failed: str) -> bool:
+        """Execute bucket removal command."""
         try:
             with rich_utils.safe_status(
                     ux_utils.spinner_message(hint_operating)):
@@ -1842,47 +2051,42 @@ class S3Store(AbstractStore):
                         f'Detailed error: {e.output}')
         return True
 
-    def _delete_s3_bucket(self, bucket_name: str) -> bool:
-        """Deletes S3 bucket, including all objects in bucket
+    def _delete_sub_path(self) -> None:
+        """Remove objects from the sub path in the bucket."""
+        assert self._bucket_sub_path is not None, 'bucket_sub_path is not set'
+        deleted_by_skypilot = self._delete_bucket_sub_path(
+            self.name, self._bucket_sub_path)
+        provider = self.config.store_type
+        if deleted_by_skypilot:
+            msg_str = (f'Removed objects from {provider} bucket '
+                       f'{self.name}/{self._bucket_sub_path}.')
+        else:
+            msg_str = (f'Failed to remove objects from {provider} bucket '
+                       f'{self.name}/{self._bucket_sub_path}.')
+        logger.info(f'{colorama.Fore.GREEN}{msg_str}{colorama.Style.RESET_ALL}')
 
-        Args:
-          bucket_name: str; Name of bucket
+    def _delete_bucket_sub_path(self, bucket_name: str, sub_path: str) -> bool:
+        """Delete objects in the sub path from the bucket."""
+        cmd_parts = [f'aws s3 rm s3://{bucket_name}/{sub_path}/ --recursive']
 
-        Returns:
-         bool; True if bucket was deleted, False if it was deleted externally.
+        if self.config.aws_profile:
+            cmd_parts.append(f'--profile={self.config.aws_profile}')
+        if self.config.get_endpoint_url:
+            cmd_parts.append(f'--endpoint-url {self.config.get_endpoint_url()}')
 
-        Raises:
-            StorageBucketDeleteError: If deleting the bucket fails.
-        """
-        # Deleting objects is very slow programatically
-        # (i.e. bucket.objects.all().delete() is slow).
-        # In addition, standard delete operations (i.e. via `aws s3 rm`)
-        # are slow, since AWS puts deletion markers.
-        # https://stackoverflow.com/questions/49239351/why-is-it-so-much-slower-to-delete-objects-in-aws-s3-than-it-is-to-create-them
-        # The fastest way to delete is to run `aws s3 rb --force`,
-        # which removes the bucket by force.
-        remove_command = f'aws s3 rb s3://{bucket_name} --force'
-        success = self._execute_s3_remove_command(
-            remove_command, bucket_name,
-            f'Deleting S3 bucket [green]{bucket_name}[/]',
-            f'Failed to delete S3 bucket {bucket_name}.')
-        if not success:
-            return False
+        remove_command = ' '.join(cmd_parts)
 
-        # Wait until bucket deletion propagates on AWS servers
-        while data_utils.verify_s3_bucket(bucket_name):
-            time.sleep(0.1)
-        return True
+        if self.config.credentials_file:
+            remove_command = (f'AWS_SHARED_CREDENTIALS_FILE='
+                              f'{self.config.credentials_file} '
+                              f'{remove_command}')
 
-    def _delete_s3_bucket_sub_path(self, bucket_name: str,
-                                   sub_path: str) -> bool:
-        """Deletes the sub path from the bucket."""
-        remove_command = f'aws s3 rm s3://{bucket_name}/{sub_path}/ --recursive'
-        return self._execute_s3_remove_command(
-            remove_command, bucket_name, f'Removing objects from S3 bucket '
-            f'[green]{bucket_name}/{sub_path}[/]',
-            f'Failed to remove objects from S3 bucket {bucket_name}/{sub_path}.'
-        )
+        return self._execute_remove_command(
+            remove_command, bucket_name,
+            (f'Removing objects from {self.config.store_type} bucket '
+             f'{bucket_name}/{sub_path}'),
+            (f'Failed to remove objects from {self.config.store_type} '
+             f'bucket {bucket_name}/{sub_path}.'))
 
 
 class GcsStore(AbstractStore):
@@ -3287,22 +3491,23 @@ class AzureBlobStore(AbstractStore):
         return True
 
 
-class R2Store(AbstractStore):
-    """R2Store inherits from S3Store Object and represents the backend
-    for R2 buckets.
-    """
-
+class IBMCosStore(AbstractStore):
+    """IBMCosStore inherits from Storage Object and represents the backend
+    for COS buckets.
+    """
     _ACCESS_DENIED_MESSAGE = 'Access Denied'
 
     def __init__(self,
                  name: str,
                  source: str,
-                 region: Optional[str] = 'auto',
+                 region: Optional[str] = 'us-east',
                  is_sky_managed: Optional[bool] = None,
-                 sync_on_reconstruction: Optional[bool] = True,
+                 sync_on_reconstruction: bool = True,
                  _bucket_sub_path: Optional[str] = None):
-        self.client: 'mypy_boto3_s3.Client'
+        self.client: 'storage.Client'
         self.bucket: 'StorageHandle'
+        self.rclone_profile_name = (
+            data_utils.Rclone.RcloneStores.IBM.get_profile_name(self.name))
         super().__init__(name, source, region, is_sky_managed,
                          sync_on_reconstruction, _bucket_sub_path)
 
@@ -3336,6 +3541,9 @@ class R2Store(AbstractStore):
                 assert self.name == data_utils.split_r2_path(self.source)[0], (
                     'R2 Bucket is specified as path, the name should be '
                     'the same as R2 bucket.')
+                assert data_utils.verify_r2_bucket(self.name), (
+                    f'Source specified as {self.source}, a R2 bucket. ',
+                    'R2 Bucket should exist.')
             elif self.source.startswith('nebius://'):
                 assert self.name == data_utils.split_nebius_path(
                     self.source)[0], (
@@ -3347,29 +3555,59 @@ class R2Store(AbstractStore):
                     f'exist.')
             elif self.source.startswith('cos://'):
                 assert self.name == data_utils.split_cos_path(self.source)[0], (
-                    'IBM COS Bucket is specified as path, the name should be '
+                    'COS Bucket is specified as path, the name should be '
                     'the same as COS bucket.')
-                assert data_utils.verify_ibm_cos_bucket(self.name), (
-                    f'Source specified as {self.source}, a COS bucket. ',
-                    'COS Bucket should exist.')
-            elif self.source.startswith('oci://'):
-                raise NotImplementedError(
-                    'Moving data from OCI to R2 is currently not supported.')
-
         # Validate name
-        self.name = S3Store.validate_name(self.name)
-        # Check if the storage is enabled
-        if not _is_storage_cloud_enabled(cloudflare.NAME):
+        self.name = IBMCosStore.validate_name(self.name)
+
+    @classmethod
+    def validate_name(cls, name: str) -> str:
+        """Validates the name of a COS bucket.
+
+        Rules source: https://ibm.github.io/ibm-cos-sdk-java/com/ibm/cloud/objectstorage/services/s3/model/Bucket.html  # pylint: disable=line-too-long
+        """
+
+        def _raise_no_traceback_name_error(err_str):
             with ux_utils.print_exception_no_traceback():
-                raise exceptions.ResourcesUnavailableError(
-                    'Storage \'store: r2\' specified, but ' \
-                    'Cloudflare R2 access is disabled. To fix, '\
-                    'enable Cloudflare R2 by running `sky check`. '\
-                    'More info: https://docs.skypilot.co/en/latest/getting-started/installation.html.'  # pylint: disable=line-too-long
-                    )
+                raise exceptions.StorageNameError(err_str)
+
+        if name is not None and isinstance(name, str):
+            if not 3 <= len(name) <= 63:
+                _raise_no_traceback_name_error(
+                    f'Invalid store name: {name} must be between 3 (min) '
+                    'and 63 (max) characters long.')
+
+            # Check for valid characters and start/end with a letter or number
+            pattern = r'^[a-z0-9][-a-z0-9.]*[a-z0-9]$'
+            if not re.match(pattern, name):
+                _raise_no_traceback_name_error(
+                    f'Invalid store name: {name} can consist only of '
+                    'lowercase letters, numbers, dots (.), and dashes (-). '
+                    'It must begin and end with a letter or number.')
+
+            # Check for two adjacent periods or dashes
+            if any(substring in name for substring in ['..', '--']):
+                _raise_no_traceback_name_error(
+                    f'Invalid store name: {name} must not contain '
+                    'two adjacent periods/dashes')
+
+            # Check for IP address format
+            ip_pattern = r'^(?:\d{1,3}\.){3}\d{1,3}$'
+            if re.match(ip_pattern, name):
+                _raise_no_traceback_name_error(
+                    f'Invalid store name: {name} must not be formatted as '
+                    'an IP address (for example, 192.168.5.4).')
+
+            if any(substring in name for substring in ['.-', '-.']):
+                _raise_no_traceback_name_error(
+                    f'Invalid store name: {name} must '
+                    'not allow substrings: ".-", "-." .')
+        else:
+            _raise_no_traceback_name_error('Store name must be specified.')
+        return name
 
     def initialize(self):
-        """Initializes the R2 store object on the cloud.
+        """Initializes the cos store object on the cloud.
 
         Initialization involves fetching bucket if exists, or creating it if
         it does not.
@@ -3379,7 +3617,8 @@ class R2Store(AbstractStore):
           StorageBucketGetError: If fetching existing bucket fails
           StorageInitError: If general initialization fails.
         """
-        self.client = data_utils.create_r2_client(self.region)
+        self.client = ibm.get_cos_client(self.region)
+        self.s3_resource = ibm.get_cos_resource(self.region)
         self.bucket, is_new_bucket = self._get_bucket()
         if self.is_sky_managed is None:
             # If is_sky_managed is not specified, then this is a new storage
@@ -3389,7 +3628,7 @@ class R2Store(AbstractStore):
             self.is_sky_managed = is_new_bucket
 
     def upload(self):
-        """Uploads source to store bucket.
+        """Uploads files from local machine to bucket.
 
         Upload must be called by the Storage handler - it is not called on
         Store initialization.
@@ -3399,22 +3638,26 @@ class R2Store(AbstractStore):
         """
         try:
             if isinstance(self.source, list):
-                self.batch_aws_rsync(self.source, create_dirs=True)
+                self.batch_ibm_rsync(self.source, create_dirs=True)
             elif self.source is not None:
-                if self.source.startswith('s3://'):
-                    self._transfer_to_r2()
-                elif self.source.startswith('gs://'):
-                    self._transfer_to_r2()
-                elif self.source.startswith('r2://'):
+                if self.source.startswith('cos://'):
+                    # cos bucket used as a dest, can't be used as source.
                     pass
-                elif self.source.startswith('oci://'):
-                    self._transfer_to_r2()
+                elif self.source.startswith('s3://'):
+                    raise Exception('IBM COS currently not supporting'
+                                    'data transfers between COS and S3')
                 elif self.source.startswith('nebius://'):
-                    self._transfer_to_r2()
+                    raise Exception('IBM COS currently not supporting'
+                                    'data transfers between COS and Nebius')
+                elif self.source.startswith('gs://'):
+                    raise Exception('IBM COS currently not supporting'
+                                    'data transfers between COS and GS')
+                elif self.source.startswith('r2://'):
+                    raise Exception('IBM COS currently not supporting'
+                                    'data transfers between COS and r2')
                 else:
-                    self.batch_aws_rsync([self.source])
-        except exceptions.StorageUploadError:
-            raise
+                    self.batch_ibm_rsync([self.source])
+
         except Exception as e:
             raise exceptions.StorageUploadError(
                 f'Upload failed for store {self.name}') from e
@@ -3423,41 +3666,28 @@ class R2Store(AbstractStore):
         if self._bucket_sub_path is not None and not self.is_sky_managed:
             return self._delete_sub_path()
 
-        deleted_by_skypilot = self._delete_r2_bucket(self.name)
-        if deleted_by_skypilot:
-            msg_str = f'Deleted R2 bucket {self.name}.'
-        else:
-            msg_str = f'R2 bucket {self.name} may have been deleted ' \
-                      f'externally. Removing from local state.'
-        logger.info(f'{colorama.Fore.GREEN}{msg_str}'
+        self._delete_cos_bucket()
+        logger.info(f'{colorama.Fore.GREEN}Deleted COS bucket {self.name}.'
                     f'{colorama.Style.RESET_ALL}')
 
     def _delete_sub_path(self) -> None:
         assert self._bucket_sub_path is not None, 'bucket_sub_path is not set'
-        deleted_by_skypilot = self._delete_r2_bucket_sub_path(
-            self.name, self._bucket_sub_path)
-        if deleted_by_skypilot:
-            msg_str = f'Removed objects from R2 bucket ' \
-                      f'{self.name}/{self._bucket_sub_path}.'
-        else:
-            msg_str = f'Failed to remove objects from R2 bucket ' \
-                      f'{self.name}/{self._bucket_sub_path}.'
-        logger.info(f'{colorama.Fore.GREEN}{msg_str}'
-                    f'{colorama.Style.RESET_ALL}')
+        bucket = self.s3_resource.Bucket(self.name)
+        try:
+            self._delete_cos_bucket_objects(bucket, self._bucket_sub_path + '/')
+        except ibm.ibm_botocore.exceptions.ClientError as e:
+            if e.__class__.__name__ == 'NoSuchBucket':
+                logger.debug('bucket already removed')
 
     def get_handle(self) -> StorageHandle:
-        return cloudflare.resource('s3').Bucket(self.name)
+        return self.s3_resource.Bucket(self.name)
 
-    def batch_aws_rsync(self,
+    def batch_ibm_rsync(self,
                         source_path_list: List[Path],
                         create_dirs: bool = False) -> None:
-        """Invokes aws s3 sync to batch upload a list of local paths to R2
-
-        AWS Sync by default uses 10 threads to upload files to the bucket.  To
-        increase parallelism, modify max_concurrent_requests in your aws config
-        file (Default path: ~/.aws/config).
+        """Invokes rclone copy to batch upload a list of local paths to cos
 
-        Since aws s3 sync does not support batch operations, we construct
+        Since rclone does not support batch operations, we construct
         multiple commands to be run in parallel.
 
         Args:
@@ -3471,49 +3701,58 @@ class R2Store(AbstractStore):
         sub_path = (f'/{self._bucket_sub_path}'
                     if self._bucket_sub_path else '')
 
-        def get_file_sync_command(base_dir_path, file_names):
+        def get_dir_sync_command(src_dir_path, dest_dir_name) -> str:
+            """returns an rclone command that copies a complete folder
+              from 'src_dir_path' to bucket/'dest_dir_name'.
+
+            `rclone copy` copies files from source path to target.
+            files with identical names at won't be copied over, unless
+            their modification date is more recent.
+            works similarly to `aws sync` (without --delete).
+
+            Args:
+                src_dir_path (str): local source path from which to copy files.
+                dest_dir_name (str): remote target path files are copied to.
+
+            Returns:
+                str: bash command using rclone to sync files. Executed remotely.
+            """
+
+            # .git directory is excluded from the sync
+            # wrapping src_dir_path with "" to support path with spaces
+            src_dir_path = shlex.quote(src_dir_path)
+            sync_command = ('rclone copy --exclude ".git/*" '
+                            f'{src_dir_path} '
+                            f'{self.rclone_profile_name}:{self.name}{sub_path}'
+                            f'/{dest_dir_name}')
+            return sync_command
+
+        def get_file_sync_command(base_dir_path, file_names) -> str:
+            """returns an rclone command that copies files: 'file_names'
+               from base directory: `base_dir_path` to bucket.
+
+            `rclone copy` copies files from source path to target.
+            files with identical names at won't be copied over, unless
+            their modification date is more recent.
+            works similarly to `aws sync` (without --delete).
+
+            Args:
+                base_dir_path (str): local path from which to copy files.
+                file_names (List): specific file names to copy.
+
+            Returns:
+                str: bash command using rclone to sync files
+            """
+
+            # wrapping file_name with "" to support spaces
             includes = ' '.join([
                 f'--include {shlex.quote(file_name)}'
                 for file_name in file_names
             ])
-            endpoint_url = cloudflare.create_endpoint()
             base_dir_path = shlex.quote(base_dir_path)
-            sync_command = (
-                'AWS_SHARED_CREDENTIALS_FILE='
-                f'{cloudflare.R2_CREDENTIALS_PATH} '
-                'aws s3 sync --no-follow-symlinks --exclude="*" '
-                f'{includes} {base_dir_path} '
-                f's3://{self.name}{sub_path} '
-                f'--endpoint {endpoint_url} '
-                # R2 does not support CRC64-NVME
-                # which is the default for aws s3 sync
-                # https://community.cloudflare.com/t/an-error-occurred-internalerror-when-calling-the-putobject-operation/764905/13
-                f'--checksum-algorithm CRC32 '
-                f'--profile={cloudflare.R2_PROFILE_NAME}')
-            return sync_command
-
-        def get_dir_sync_command(src_dir_path, dest_dir_name):
-            # we exclude .git directory from the sync
-            excluded_list = storage_utils.get_excluded_files(src_dir_path)
-            excluded_list.append('.git/*')
-            excludes = ' '.join([
-                f'--exclude {shlex.quote(file_name)}'
-                for file_name in excluded_list
-            ])
-            endpoint_url = cloudflare.create_endpoint()
-            src_dir_path = shlex.quote(src_dir_path)
-            sync_command = (
-                'AWS_SHARED_CREDENTIALS_FILE='
-                f'{cloudflare.R2_CREDENTIALS_PATH} '
-                f'aws s3 sync --no-follow-symlinks {excludes} '
-                f'{src_dir_path} '
-                f's3://{self.name}{sub_path}/{dest_dir_name} '
-                f'--endpoint {endpoint_url} '
-                # R2 does not support CRC64-NVME
-                # which is the default for aws s3 sync
-                # https://community.cloudflare.com/t/an-error-occurred-internalerror-when-calling-the-putobject-operation/764905/13
-                f'--checksum-algorithm CRC32 '
-                f'--profile={cloudflare.R2_PROFILE_NAME}')
+            sync_command = ('rclone copy '
+                            f'{includes} {base_dir_path} '
+                            f'{self.rclone_profile_name}:{self.name}{sub_path}')
             return sync_command
 
         # Generate message for upload
@@ -3524,7 +3763,8 @@ class R2Store(AbstractStore):
 
         log_path = sky_logging.generate_tmp_logging_file_path(
             _STORAGE_LOG_FILE_NAME)
-        sync_path = f'{source_message} -> r2://{self.name}{sub_path}/'
+        sync_path = (
+            f'{source_message} -> cos://{self.region}/{self.name}{sub_path}/')
         with rich_utils.safe_status(
                 ux_utils.spinner_message(f'Syncing {sync_path}',
                                          log_path=log_path)):
@@ -3541,1236 +3781,306 @@ class R2Store(AbstractStore):
             ux_utils.finishing_message(f'Storage synced: {sync_path}',
                                        log_path))
 
-    def _transfer_to_r2(self) -> None:
-        assert isinstance(self.source, str), self.source
-        if self.source.startswith('gs://'):
-            data_transfer.gcs_to_r2(self.name, self.name)
-        elif self.source.startswith('s3://'):
-            data_transfer.s3_to_r2(self.name, self.name)
-        elif self.source.startswith('nebius://'):
-            data_transfer.s3_to_r2(self.name, self.name)
-
     def _get_bucket(self) -> Tuple[StorageHandle, bool]:
-        """Obtains the R2 bucket.
+        """returns IBM COS bucket object if exists, otherwise creates it.
 
-        If the bucket exists, this method will return the bucket.
-        If the bucket does not exist, there are three cases:
-          1) Raise an error if the bucket source starts with s3://
-          2) Return None if bucket has been externally deleted and
-             sync_on_reconstruction is False
-          3) Create and return a new bucket otherwise
+        Returns:
+          StorageHandle(str): bucket name
+          bool: indicates whether a new bucket was created.
 
         Raises:
             StorageSpecError: If externally created bucket is attempted to be
                 mounted without specifying storage source.
-            StorageBucketCreateError: If creating the bucket fails
+            StorageBucketCreateError: If bucket creation fails.
             StorageBucketGetError: If fetching a bucket fails
             StorageExternalDeletionError: If externally deleted storage is
                 attempted to be fetched while reconstructing the storage for
                 'sky storage delete' or 'sky start'
         """
-        r2 = cloudflare.resource('s3')
-        bucket = r2.Bucket(self.name)
-        endpoint_url = cloudflare.create_endpoint()
+
+        bucket_profile_name = (data_utils.Rclone.RcloneStores.IBM.value +
+                               self.name)
         try:
-            # Try Public bucket case.
-            # This line does not error out if the bucket is an external public
-            # bucket or if it is a user's bucket that is publicly
-            # accessible.
-            self.client.head_bucket(Bucket=self.name)
-            self._validate_existing_bucket()
-            return bucket, False
-        except aws.botocore_exceptions().ClientError as e:
-            error_code = e.response['Error']['Code']
-            # AccessDenied error for buckets that are private and not owned by
-            # user.
-            if error_code == '403':
-                command = ('AWS_SHARED_CREDENTIALS_FILE='
-                           f'{cloudflare.R2_CREDENTIALS_PATH} '
-                           f'aws s3 ls s3://{self.name} '
-                           f'--endpoint {endpoint_url} '
-                           f'--profile={cloudflare.R2_PROFILE_NAME}')
-                with ux_utils.print_exception_no_traceback():
-                    raise exceptions.StorageBucketGetError(
-                        _BUCKET_FAIL_TO_CONNECT_MESSAGE.format(name=self.name) +
-                        f' To debug, consider running `{command}`.') from e
+            bucket_region = data_utils.get_ibm_cos_bucket_region(self.name)
+        except exceptions.StorageBucketGetError as e:
+            with ux_utils.print_exception_no_traceback():
+                command = f'rclone lsd {bucket_profile_name}: '
+                raise exceptions.StorageBucketGetError(
+                    _BUCKET_FAIL_TO_CONNECT_MESSAGE.format(name=self.name) +
+                    f' To debug, consider running `{command}`.') from e
+
+        try:
+            uri_region = data_utils.split_cos_path(
+                self.source)[2]  # type: ignore
+        except ValueError:
+            # source isn't a cos uri
+            uri_region = ''
+
+        # bucket's region doesn't match specified region in URI
+        if bucket_region and uri_region and uri_region != bucket_region\
+              and self.sync_on_reconstruction:
+            with ux_utils.print_exception_no_traceback():
+                raise exceptions.StorageBucketGetError(
+                    f'Bucket {self.name} exists in '
+                    f'region {bucket_region}, '
+                    f'but URI specified region {uri_region}.')
 
-        if isinstance(self.source, str) and self.source.startswith('r2://'):
+        if not bucket_region and uri_region:
+            # bucket doesn't exist but source is a bucket URI
             with ux_utils.print_exception_no_traceback():
                 raise exceptions.StorageBucketGetError(
                     'Attempted to use a non-existent bucket as a source: '
-                    f'{self.source}. Consider using '
-                    '`AWS_SHARED_CREDENTIALS_FILE='
-                    f'{cloudflare.R2_CREDENTIALS_PATH} aws s3 ls '
-                    f's3://{self.name} '
-                    f'--endpoint {endpoint_url} '
-                    f'--profile={cloudflare.R2_PROFILE_NAME}\' '
-                    'to debug.')
-
-        # If bucket cannot be found in both private and public settings,
-        # the bucket is to be created by Sky. However, creation is skipped if
-        # Store object is being reconstructed for deletion or re-mount with
-        # sky start, and error is raised instead.
-        if self.sync_on_reconstruction:
-            bucket = self._create_r2_bucket(self.name)
-            return bucket, True
-        else:
+                    f'{self.name} by providing URI. Consider using '
+                    '`rclone lsd <remote>` on relevant remotes returned '
+                    'via `rclone listremotes` to debug.')
+
+        data_utils.Rclone.store_rclone_config(
+            self.name,
+            data_utils.Rclone.RcloneStores.IBM,
+            self.region,  # type: ignore
+        )
+
+        if not bucket_region and self.sync_on_reconstruction:
+            # bucket doesn't exist
+            return self._create_cos_bucket(self.name, self.region), True
+        elif not bucket_region and not self.sync_on_reconstruction:
             # Raised when Storage object is reconstructed for sky storage
             # delete or to re-mount Storages with sky start but the storage
             # is already removed externally.
             raise exceptions.StorageExternalDeletionError(
                 'Attempted to fetch a non-existent bucket: '
                 f'{self.name}')
-
+        else:
+            # bucket exists
+            bucket = self.s3_resource.Bucket(self.name)
+            self._validate_existing_bucket()
+            return bucket, False
+
     def _download_file(self, remote_path: str, local_path: str) -> None:
-        """Downloads file from remote to local on r2 bucket
+        """Downloads file from remote to local on s3 bucket
         using the boto3 API
 
         Args:
-          remote_path: str; Remote path on R2 bucket
+          remote_path: str; Remote path on S3 bucket
           local_path: str; Local path on user's device
         """
-        self.bucket.download_file(remote_path, local_path)
+        self.client.download_file(self.name, local_path, remote_path)
 
     def mount_command(self, mount_path: str) -> str:
         """Returns the command to mount the bucket to the mount_path.
 
-        Uses goofys to mount the bucket.
+        Uses rclone to mount the bucket.
+        Source: https://github.com/rclone/rclone
 
         Args:
           mount_path: str; Path to mount the bucket to.
         """
-        install_cmd = mounting_utils.get_s3_mount_install_cmd()
-        endpoint_url = cloudflare.create_endpoint()
-        r2_credential_path = cloudflare.R2_CREDENTIALS_PATH
-        r2_profile_name = cloudflare.R2_PROFILE_NAME
-        mount_cmd = mounting_utils.get_r2_mount_cmd(
-            r2_credential_path, r2_profile_name, endpoint_url, self.bucket.name,
-            mount_path, self._bucket_sub_path)
-        return mounting_utils.get_mounting_command(mount_path, install_cmd,
-                                                   mount_cmd)
-
-    def mount_cached_command(self, mount_path: str) -> str:
+        # install rclone if not installed.
         install_cmd = mounting_utils.get_rclone_install_cmd()
-        rclone_profile_name = (
-            data_utils.Rclone.RcloneStores.R2.get_profile_name(self.name))
-        rclone_config = data_utils.Rclone.RcloneStores.R2.get_config(
-            rclone_profile_name=rclone_profile_name)
-        mount_cached_cmd = mounting_utils.get_mount_cached_cmd(
-            rclone_config, rclone_profile_name, self.bucket.name, mount_path)
+        rclone_config = data_utils.Rclone.RcloneStores.IBM.get_config(
+            rclone_profile_name=self.rclone_profile_name,
+            region=self.region)  # type: ignore
+        mount_cmd = (
+            mounting_utils.get_cos_mount_cmd(
+                rclone_config,
+                self.rclone_profile_name,
+                self.bucket.name,
+                mount_path,
+                self._bucket_sub_path,  # type: ignore
+            ))
         return mounting_utils.get_mounting_command(mount_path, install_cmd,
-                                                   mount_cached_cmd)
+                                                   mount_cmd)
 
-    def _create_r2_bucket(self,
-                          bucket_name: str,
-                          region='auto') -> StorageHandle:
-        """Creates R2 bucket with specific name in specific region
+    def _create_cos_bucket(self,
+                           bucket_name: str,
+                           region='us-east') -> StorageHandle:
+        """Creates IBM COS bucket with specific name in specific region
 
         Args:
           bucket_name: str; Name of bucket
-          region: str; Region name, r2 automatically sets region
+          region: str; Region name, e.g. us-east, us-south
         Raises:
           StorageBucketCreateError: If bucket creation fails.
         """
-        r2_client = self.client
         try:
-            if region is None:
-                r2_client.create_bucket(Bucket=bucket_name)
-            else:
-                location = {'LocationConstraint': region}
-                r2_client.create_bucket(Bucket=bucket_name,
-                                        CreateBucketConfiguration=location)
-                logger.info(f'  {colorama.Style.DIM}Created R2 bucket '
-                            f'{bucket_name!r} in {region}'
-                            f'{colorama.Style.RESET_ALL}')
-        except aws.botocore_exceptions().ClientError as e:
+            self.client.create_bucket(
+                Bucket=bucket_name,
+                CreateBucketConfiguration={
+                    'LocationConstraint': f'{region}-smart'
+                })
+            logger.info(f'  {colorama.Style.DIM}Created IBM COS bucket '
+                        f'{bucket_name!r} in {region} '
+                        'with storage class smart tier'
+                        f'{colorama.Style.RESET_ALL}')
+            self.bucket = self.s3_resource.Bucket(bucket_name)
+
+        except ibm.ibm_botocore.exceptions.ClientError as e:  # type: ignore[union-attr]  # pylint: disable=line-too-long
             with ux_utils.print_exception_no_traceback():
                 raise exceptions.StorageBucketCreateError(
-                    f'Attempted to create a bucket '
-                    f'{self.name} but failed.') from e
-        return cloudflare.resource('s3').Bucket(bucket_name)
-
-    def _execute_r2_remove_command(self, command: str, bucket_name: str,
-                                   hint_operating: str,
-                                   hint_failed: str) -> bool:
-        try:
-            with rich_utils.safe_status(
-                    ux_utils.spinner_message(hint_operating)):
-                subprocess.check_output(command.split(' '),
-                                        stderr=subprocess.STDOUT,
-                                        shell=True)
-        except subprocess.CalledProcessError as e:
-            if 'NoSuchBucket' in e.output.decode('utf-8'):
-                logger.debug(
-                    _BUCKET_EXTERNALLY_DELETED_DEBUG_MESSAGE.format(
-                        bucket_name=bucket_name))
-                return False
-            else:
-                with ux_utils.print_exception_no_traceback():
-                    raise exceptions.StorageBucketDeleteError(
-                        f'{hint_failed}'
-                        f'Detailed error: {e.output}')
-        return True
-
-    def _delete_r2_bucket_sub_path(self, bucket_name: str,
-                                   sub_path: str) -> bool:
-        """Deletes the sub path from the bucket."""
-        endpoint_url = cloudflare.create_endpoint()
-        remove_command = (
-            f'AWS_SHARED_CREDENTIALS_FILE={cloudflare.R2_CREDENTIALS_PATH} '
-            f'aws s3 rm s3://{bucket_name}/{sub_path}/ --recursive '
-            f'--endpoint {endpoint_url} '
-            f'--profile={cloudflare.R2_PROFILE_NAME}')
-        return self._execute_r2_remove_command(
-            remove_command, bucket_name,
-            f'Removing objects from R2 bucket {bucket_name}/{sub_path}',
-            f'Failed to remove objects from R2 bucket {bucket_name}/{sub_path}.'
-        )
-
-    def _delete_r2_bucket(self, bucket_name: str) -> bool:
-        """Deletes R2 bucket, including all objects in bucket
+                    f'Failed to create bucket: '
+                    f'{bucket_name}') from e
 
-        Args:
-          bucket_name: str; Name of bucket
+        s3_bucket_exists_waiter = self.client.get_waiter('bucket_exists')
+        s3_bucket_exists_waiter.wait(Bucket=bucket_name)
 
-        Returns:
-         bool; True if bucket was deleted, False if it was deleted externally.
+        return self.bucket
 
-        Raises:
-            StorageBucketDeleteError: If deleting the bucket fails.
-        """
-        # Deleting objects is very slow programmatically
-        # (i.e. bucket.objects.all().delete() is slow).
-        # In addition, standard delete operations (i.e. via `aws s3 rm`)
-        # are slow, since AWS puts deletion markers.
-        # https://stackoverflow.com/questions/49239351/why-is-it-so-much-slower-to-delete-objects-in-aws-s3-than-it-is-to-create-them
-        # The fastest way to delete is to run `aws s3 rb --force`,
-        # which removes the bucket by force.
-        endpoint_url = cloudflare.create_endpoint()
-        remove_command = (
-            f'AWS_SHARED_CREDENTIALS_FILE={cloudflare.R2_CREDENTIALS_PATH} '
-            f'aws s3 rb s3://{bucket_name} --force '
-            f'--endpoint {endpoint_url} '
-            f'--profile={cloudflare.R2_PROFILE_NAME}')
-
-        success = self._execute_r2_remove_command(
-            remove_command, bucket_name, f'Deleting R2 bucket {bucket_name}',
-            f'Failed to delete R2 bucket {bucket_name}.')
-        if not success:
-            return False
+    def _delete_cos_bucket_objects(self,
+                                   bucket: Any,
+                                   prefix: Optional[str] = None) -> None:
+        bucket_versioning = self.s3_resource.BucketVersioning(bucket.name)
+        if bucket_versioning.status == 'Enabled':
+            if prefix is not None:
+                res = list(
+                    bucket.object_versions.filter(Prefix=prefix).delete())
+            else:
+                res = list(bucket.object_versions.delete())
+        else:
+            if prefix is not None:
+                res = list(bucket.objects.filter(Prefix=prefix).delete())
+            else:
+                res = list(bucket.objects.delete())
+        logger.debug(f'Deleted bucket\'s content:\n{res}, prefix: {prefix}')
 
-        # Wait until bucket deletion propagates on AWS servers
-        while data_utils.verify_r2_bucket(bucket_name):
-            time.sleep(0.1)
-        return True
+    def _delete_cos_bucket(self) -> None:
+        bucket = self.s3_resource.Bucket(self.name)
+        try:
+            self._delete_cos_bucket_objects(bucket)
+            bucket.delete()
+            bucket.wait_until_not_exists()
+        except ibm.ibm_botocore.exceptions.ClientError as e:
+            if e.__class__.__name__ == 'NoSuchBucket':
+                logger.debug('bucket already removed')
+        data_utils.Rclone.delete_rclone_bucket_profile(
+            self.name, data_utils.Rclone.RcloneStores.IBM)
 
 
-class IBMCosStore(AbstractStore):
-    """IBMCosStore inherits from Storage Object and represents the backend
-    for COS buckets.
+class OciStore(AbstractStore):
+    """OciStore inherits from Storage Object and represents the backend
+    for OCI buckets.
     """
-    _ACCESS_DENIED_MESSAGE = 'Access Denied'
+
+    _ACCESS_DENIED_MESSAGE = 'AccessDeniedException'
 
     def __init__(self,
                  name: str,
-                 source: str,
-                 region: Optional[str] = 'us-east',
+                 source: Optional[SourceType],
+                 region: Optional[str] = None,
                  is_sky_managed: Optional[bool] = None,
-                 sync_on_reconstruction: bool = True,
+                 sync_on_reconstruction: Optional[bool] = True,
                  _bucket_sub_path: Optional[str] = None):
-        self.client: 'storage.Client'
-        self.bucket: 'StorageHandle'
-        self.rclone_profile_name = (
-            data_utils.Rclone.RcloneStores.IBM.get_profile_name(self.name))
-        super().__init__(name, source, region, is_sky_managed,
-                         sync_on_reconstruction, _bucket_sub_path)
-
-    def _validate(self):
-        if self.source is not None and isinstance(self.source, str):
-            if self.source.startswith('s3://'):
-                assert self.name == data_utils.split_s3_path(self.source)[0], (
-                    'S3 Bucket is specified as path, the name should be the'
-                    ' same as S3 bucket.')
-                assert data_utils.verify_s3_bucket(self.name), (
-                    f'Source specified as {self.source}, a S3 bucket. ',
-                    'S3 Bucket should exist.')
-            elif self.source.startswith('gs://'):
-                assert self.name == data_utils.split_gcs_path(self.source)[0], (
-                    'GCS Bucket is specified as path, the name should be '
-                    'the same as GCS bucket.')
-                assert data_utils.verify_gcs_bucket(self.name), (
-                    f'Source specified as {self.source}, a GCS bucket. ',
-                    'GCS Bucket should exist.')
-            elif data_utils.is_az_container_endpoint(self.source):
-                storage_account_name, container_name, _ = (
-                    data_utils.split_az_path(self.source))
-                assert self.name == container_name, (
-                    'Azure bucket is specified as path, the name should be '
-                    'the same as Azure bucket.')
-                assert data_utils.verify_az_bucket(
-                    storage_account_name, self.name), (
-                        f'Source specified as {self.source}, an Azure bucket. '
-                        'Azure bucket should exist.')
-            elif self.source.startswith('r2://'):
-                assert self.name == data_utils.split_r2_path(self.source)[0], (
-                    'R2 Bucket is specified as path, the name should be '
-                    'the same as R2 bucket.')
-                assert data_utils.verify_r2_bucket(self.name), (
-                    f'Source specified as {self.source}, a R2 bucket. ',
-                    'R2 Bucket should exist.')
-            elif self.source.startswith('nebius://'):
-                assert self.name == data_utils.split_nebius_path(
-                    self.source)[0], (
-                        'Nebius Object Storage is specified as path, the name '
-                        'should be the same as Nebius Object Storage bucket.')
-                assert data_utils.verify_nebius_bucket(self.name), (
-                    f'Source specified as {self.source}, a Nebius Object '
-                    f'Storage  bucket. Nebius Object Storage Bucket should '
-                    f'exist.')
-            elif self.source.startswith('cos://'):
-                assert self.name == data_utils.split_cos_path(self.source)[0], (
-                    'COS Bucket is specified as path, the name should be '
-                    'the same as COS bucket.')
-        # Validate name
-        self.name = IBMCosStore.validate_name(self.name)
-
-    @classmethod
-    def validate_name(cls, name: str) -> str:
-        """Validates the name of a COS bucket.
-
-        Rules source: https://ibm.github.io/ibm-cos-sdk-java/com/ibm/cloud/objectstorage/services/s3/model/Bucket.html  # pylint: disable=line-too-long
-        """
-
-        def _raise_no_traceback_name_error(err_str):
-            with ux_utils.print_exception_no_traceback():
-                raise exceptions.StorageNameError(err_str)
-
-        if name is not None and isinstance(name, str):
-            if not 3 <= len(name) <= 63:
-                _raise_no_traceback_name_error(
-                    f'Invalid store name: {name} must be between 3 (min) '
-                    'and 63 (max) characters long.')
-
-            # Check for valid characters and start/end with a letter or number
-            pattern = r'^[a-z0-9][-a-z0-9.]*[a-z0-9]$'
-            if not re.match(pattern, name):
-                _raise_no_traceback_name_error(
-                    f'Invalid store name: {name} can consist only of '
-                    'lowercase letters, numbers, dots (.), and dashes (-). '
-                    'It must begin and end with a letter or number.')
-
-            # Check for two adjacent periods or dashes
-            if any(substring in name for substring in ['..', '--']):
-                _raise_no_traceback_name_error(
-                    f'Invalid store name: {name} must not contain '
-                    'two adjacent periods/dashes')
-
-            # Check for IP address format
-            ip_pattern = r'^(?:\d{1,3}\.){3}\d{1,3}$'
-            if re.match(ip_pattern, name):
-                _raise_no_traceback_name_error(
-                    f'Invalid store name: {name} must not be formatted as '
-                    'an IP address (for example, 192.168.5.4).')
-
-            if any(substring in name for substring in ['.-', '-.']):
-                _raise_no_traceback_name_error(
-                    f'Invalid store name: {name} must '
-                    'not allow substrings: ".-", "-." .')
-        else:
-            _raise_no_traceback_name_error('Store name must be specified.')
-        return name
-
-    def initialize(self):
-        """Initializes the cos store object on the cloud.
-
-        Initialization involves fetching bucket if exists, or creating it if
-        it does not.
+        self.client: Any
+        self.bucket: StorageHandle
+        self.oci_config_file: str
+        self.config_profile: str
+        self.compartment: str
+        self.namespace: str
 
-        Raises:
-          StorageBucketCreateError: If bucket creation fails
-          StorageBucketGetError: If fetching existing bucket fails
-          StorageInitError: If general initialization fails.
-        """
-        self.client = ibm.get_cos_client(self.region)
-        self.s3_resource = ibm.get_cos_resource(self.region)
-        self.bucket, is_new_bucket = self._get_bucket()
-        if self.is_sky_managed is None:
-            # If is_sky_managed is not specified, then this is a new storage
-            # object (i.e., did not exist in global_user_state) and we should
-            # set the is_sky_managed property.
-            # If is_sky_managed is specified, then we take no action.
-            self.is_sky_managed = is_new_bucket
-
-    def upload(self):
-        """Uploads files from local machine to bucket.
-
-        Upload must be called by the Storage handler - it is not called on
-        Store initialization.
-
-        Raises:
-            StorageUploadError: if upload fails.
-        """
-        try:
-            if isinstance(self.source, list):
-                self.batch_ibm_rsync(self.source, create_dirs=True)
-            elif self.source is not None:
-                if self.source.startswith('cos://'):
-                    # cos bucket used as a dest, can't be used as source.
-                    pass
-                elif self.source.startswith('s3://'):
-                    raise Exception('IBM COS currently not supporting'
-                                    'data transfers between COS and S3')
-                elif self.source.startswith('nebius://'):
-                    raise Exception('IBM COS currently not supporting'
-                                    'data transfers between COS and Nebius')
-                elif self.source.startswith('gs://'):
-                    raise Exception('IBM COS currently not supporting'
-                                    'data transfers between COS and GS')
-                elif self.source.startswith('r2://'):
-                    raise Exception('IBM COS currently not supporting'
-                                    'data transfers between COS and r2')
-                else:
-                    self.batch_ibm_rsync([self.source])
-
-        except Exception as e:
-            raise exceptions.StorageUploadError(
-                f'Upload failed for store {self.name}') from e
-
-    def delete(self) -> None:
-        if self._bucket_sub_path is not None and not self.is_sky_managed:
-            return self._delete_sub_path()
-
-        self._delete_cos_bucket()
-        logger.info(f'{colorama.Fore.GREEN}Deleted COS bucket {self.name}.'
-                    f'{colorama.Style.RESET_ALL}')
-
-    def _delete_sub_path(self) -> None:
-        assert self._bucket_sub_path is not None, 'bucket_sub_path is not set'
-        bucket = self.s3_resource.Bucket(self.name)
-        try:
-            self._delete_cos_bucket_objects(bucket, self._bucket_sub_path + '/')
-        except ibm.ibm_botocore.exceptions.ClientError as e:
-            if e.__class__.__name__ == 'NoSuchBucket':
-                logger.debug('bucket already removed')
-
-    def get_handle(self) -> StorageHandle:
-        return self.s3_resource.Bucket(self.name)
-
-    def batch_ibm_rsync(self,
-                        source_path_list: List[Path],
-                        create_dirs: bool = False) -> None:
-        """Invokes rclone copy to batch upload a list of local paths to cos
-
-        Since rclone does not support batch operations, we construct
-        multiple commands to be run in parallel.
-
-        Args:
-            source_path_list: List of paths to local files or directories
-            create_dirs: If the local_path is a directory and this is set to
-                False, the contents of the directory are directly uploaded to
-                root of the bucket. If the local_path is a directory and this is
-                set to True, the directory is created in the bucket root and
-                contents are uploaded to it.
-        """
-        sub_path = (f'/{self._bucket_sub_path}'
-                    if self._bucket_sub_path else '')
-
-        def get_dir_sync_command(src_dir_path, dest_dir_name) -> str:
-            """returns an rclone command that copies a complete folder
-              from 'src_dir_path' to bucket/'dest_dir_name'.
-
-            `rclone copy` copies files from source path to target.
-            files with identical names at won't be copied over, unless
-            their modification date is more recent.
-            works similarly to `aws sync` (without --delete).
-
-            Args:
-                src_dir_path (str): local source path from which to copy files.
-                dest_dir_name (str): remote target path files are copied to.
-
-            Returns:
-                str: bash command using rclone to sync files. Executed remotely.
-            """
-
-            # .git directory is excluded from the sync
-            # wrapping src_dir_path with "" to support path with spaces
-            src_dir_path = shlex.quote(src_dir_path)
-            sync_command = ('rclone copy --exclude ".git/*" '
-                            f'{src_dir_path} '
-                            f'{self.rclone_profile_name}:{self.name}{sub_path}'
-                            f'/{dest_dir_name}')
-            return sync_command
-
-        def get_file_sync_command(base_dir_path, file_names) -> str:
-            """returns an rclone command that copies files: 'file_names'
-               from base directory: `base_dir_path` to bucket.
-
-            `rclone copy` copies files from source path to target.
-            files with identical names at won't be copied over, unless
-            their modification date is more recent.
-            works similarly to `aws sync` (without --delete).
-
-            Args:
-                base_dir_path (str): local path from which to copy files.
-                file_names (List): specific file names to copy.
-
-            Returns:
-                str: bash command using rclone to sync files
-            """
-
-            # wrapping file_name with "" to support spaces
-            includes = ' '.join([
-                f'--include {shlex.quote(file_name)}'
-                for file_name in file_names
-            ])
-            base_dir_path = shlex.quote(base_dir_path)
-            sync_command = ('rclone copy '
-                            f'{includes} {base_dir_path} '
-                            f'{self.rclone_profile_name}:{self.name}{sub_path}')
-            return sync_command
-
-        # Generate message for upload
-        if len(source_path_list) > 1:
-            source_message = f'{len(source_path_list)} paths'
-        else:
-            source_message = source_path_list[0]
-
-        log_path = sky_logging.generate_tmp_logging_file_path(
-            _STORAGE_LOG_FILE_NAME)
-        sync_path = (
-            f'{source_message} -> cos://{self.region}/{self.name}{sub_path}/')
-        with rich_utils.safe_status(
-                ux_utils.spinner_message(f'Syncing {sync_path}',
-                                         log_path=log_path)):
-            data_utils.parallel_upload(
-                source_path_list,
-                get_file_sync_command,
-                get_dir_sync_command,
-                log_path,
-                self.name,
-                self._ACCESS_DENIED_MESSAGE,
-                create_dirs=create_dirs,
-                max_concurrent_uploads=_MAX_CONCURRENT_UPLOADS)
-        logger.info(
-            ux_utils.finishing_message(f'Storage synced: {sync_path}',
-                                       log_path))
-
-    def _get_bucket(self) -> Tuple[StorageHandle, bool]:
-        """returns IBM COS bucket object if exists, otherwise creates it.
-
-        Returns:
-          StorageHandle(str): bucket name
-          bool: indicates whether a new bucket was created.
-
-        Raises:
-            StorageSpecError: If externally created bucket is attempted to be
-                mounted without specifying storage source.
-            StorageBucketCreateError: If bucket creation fails.
-            StorageBucketGetError: If fetching a bucket fails
-            StorageExternalDeletionError: If externally deleted storage is
-                attempted to be fetched while reconstructing the storage for
-                'sky storage delete' or 'sky start'
-        """
-
-        bucket_profile_name = (data_utils.Rclone.RcloneStores.IBM.value +
-                               self.name)
-        try:
-            bucket_region = data_utils.get_ibm_cos_bucket_region(self.name)
-        except exceptions.StorageBucketGetError as e:
-            with ux_utils.print_exception_no_traceback():
-                command = f'rclone lsd {bucket_profile_name}: '
-                raise exceptions.StorageBucketGetError(
-                    _BUCKET_FAIL_TO_CONNECT_MESSAGE.format(name=self.name) +
-                    f' To debug, consider running `{command}`.') from e
-
-        try:
-            uri_region = data_utils.split_cos_path(
-                self.source)[2]  # type: ignore
-        except ValueError:
-            # source isn't a cos uri
-            uri_region = ''
-
-        # bucket's region doesn't match specified region in URI
-        if bucket_region and uri_region and uri_region != bucket_region\
-              and self.sync_on_reconstruction:
-            with ux_utils.print_exception_no_traceback():
-                raise exceptions.StorageBucketGetError(
-                    f'Bucket {self.name} exists in '
-                    f'region {bucket_region}, '
-                    f'but URI specified region {uri_region}.')
-
-        if not bucket_region and uri_region:
-            # bucket doesn't exist but source is a bucket URI
-            with ux_utils.print_exception_no_traceback():
-                raise exceptions.StorageBucketGetError(
-                    'Attempted to use a non-existent bucket as a source: '
-                    f'{self.name} by providing URI. Consider using '
-                    '`rclone lsd <remote>` on relevant remotes returned '
-                    'via `rclone listremotes` to debug.')
-
-        data_utils.Rclone.store_rclone_config(
-            self.name,
-            data_utils.Rclone.RcloneStores.IBM,
-            self.region,  # type: ignore
-        )
-
-        if not bucket_region and self.sync_on_reconstruction:
-            # bucket doesn't exist
-            return self._create_cos_bucket(self.name, self.region), True
-        elif not bucket_region and not self.sync_on_reconstruction:
-            # Raised when Storage object is reconstructed for sky storage
-            # delete or to re-mount Storages with sky start but the storage
-            # is already removed externally.
-            raise exceptions.StorageExternalDeletionError(
-                'Attempted to fetch a non-existent bucket: '
-                f'{self.name}')
-        else:
-            # bucket exists
-            bucket = self.s3_resource.Bucket(self.name)
-            self._validate_existing_bucket()
-            return bucket, False
-
-    def _download_file(self, remote_path: str, local_path: str) -> None:
-        """Downloads file from remote to local on s3 bucket
-        using the boto3 API
-
-        Args:
-          remote_path: str; Remote path on S3 bucket
-          local_path: str; Local path on user's device
-        """
-        self.client.download_file(self.name, local_path, remote_path)
-
-    def mount_command(self, mount_path: str) -> str:
-        """Returns the command to mount the bucket to the mount_path.
-
-        Uses rclone to mount the bucket.
-        Source: https://github.com/rclone/rclone
-
-        Args:
-          mount_path: str; Path to mount the bucket to.
-        """
-        # install rclone if not installed.
-        install_cmd = mounting_utils.get_rclone_install_cmd()
-        rclone_config = data_utils.Rclone.RcloneStores.IBM.get_config(
-            rclone_profile_name=self.rclone_profile_name,
-            region=self.region)  # type: ignore
-        mount_cmd = (
-            mounting_utils.get_cos_mount_cmd(
-                rclone_config,
-                self.rclone_profile_name,
-                self.bucket.name,
-                mount_path,
-                self._bucket_sub_path,  # type: ignore
-            ))
-        return mounting_utils.get_mounting_command(mount_path, install_cmd,
-                                                   mount_cmd)
-
-    def _create_cos_bucket(self,
-                           bucket_name: str,
-                           region='us-east') -> StorageHandle:
-        """Creates IBM COS bucket with specific name in specific region
-
-        Args:
-          bucket_name: str; Name of bucket
-          region: str; Region name, e.g. us-east, us-south
-        Raises:
-          StorageBucketCreateError: If bucket creation fails.
-        """
-        try:
-            self.client.create_bucket(
-                Bucket=bucket_name,
-                CreateBucketConfiguration={
-                    'LocationConstraint': f'{region}-smart'
-                })
-            logger.info(f'  {colorama.Style.DIM}Created IBM COS bucket '
-                        f'{bucket_name!r} in {region} '
-                        'with storage class smart tier'
-                        f'{colorama.Style.RESET_ALL}')
-            self.bucket = self.s3_resource.Bucket(bucket_name)
-
-        except ibm.ibm_botocore.exceptions.ClientError as e:  # type: ignore[union-attr]  # pylint: disable=line-too-long
-            with ux_utils.print_exception_no_traceback():
-                raise exceptions.StorageBucketCreateError(
-                    f'Failed to create bucket: '
-                    f'{bucket_name}') from e
-
-        s3_bucket_exists_waiter = self.client.get_waiter('bucket_exists')
-        s3_bucket_exists_waiter.wait(Bucket=bucket_name)
-
-        return self.bucket
-
-    def _delete_cos_bucket_objects(self,
-                                   bucket: Any,
-                                   prefix: Optional[str] = None) -> None:
-        bucket_versioning = self.s3_resource.BucketVersioning(bucket.name)
-        if bucket_versioning.status == 'Enabled':
-            if prefix is not None:
-                res = list(
-                    bucket.object_versions.filter(Prefix=prefix).delete())
-            else:
-                res = list(bucket.object_versions.delete())
-        else:
-            if prefix is not None:
-                res = list(bucket.objects.filter(Prefix=prefix).delete())
-            else:
-                res = list(bucket.objects.delete())
-        logger.debug(f'Deleted bucket\'s content:\n{res}, prefix: {prefix}')
-
-    def _delete_cos_bucket(self) -> None:
-        bucket = self.s3_resource.Bucket(self.name)
-        try:
-            self._delete_cos_bucket_objects(bucket)
-            bucket.delete()
-            bucket.wait_until_not_exists()
-        except ibm.ibm_botocore.exceptions.ClientError as e:
-            if e.__class__.__name__ == 'NoSuchBucket':
-                logger.debug('bucket already removed')
-        data_utils.Rclone.delete_rclone_bucket_profile(
-            self.name, data_utils.Rclone.RcloneStores.IBM)
-
-
-class OciStore(AbstractStore):
-    """OciStore inherits from Storage Object and represents the backend
-    for OCI buckets.
-    """
-
-    _ACCESS_DENIED_MESSAGE = 'AccessDeniedException'
-
-    def __init__(self,
-                 name: str,
-                 source: Optional[SourceType],
-                 region: Optional[str] = None,
-                 is_sky_managed: Optional[bool] = None,
-                 sync_on_reconstruction: Optional[bool] = True,
-                 _bucket_sub_path: Optional[str] = None):
-        self.client: Any
-        self.bucket: StorageHandle
-        self.oci_config_file: str
-        self.config_profile: str
-        self.compartment: str
-        self.namespace: str
-
-        # Region is from the specified name in <bucket>@<region> format.
-        # Another case is name can also be set by the source, for example:
-        #   /datasets-storage:
-        #       source: oci://RAGData@us-sanjose-1
-        # The name in above mount will be set to RAGData@us-sanjose-1
-        region_in_name = None
-        if name is not None and '@' in name:
-            self._validate_bucket_expr(name)
-            name, region_in_name = name.split('@')
-
-        # Region is from the specified source in oci://<bucket>@<region> format
-        region_in_source = None
-        if isinstance(source,
-                      str) and source.startswith('oci://') and '@' in source:
-            self._validate_bucket_expr(source)
-            source, region_in_source = source.split('@')
-
-        if region_in_name is not None and region_in_source is not None:
-            # This should never happen because name and source will never be
-            # the remote bucket at the same time.
-            assert region_in_name == region_in_source, (
-                f'Mismatch region specified. Region in name {region_in_name}, '
-                f'but region in source is {region_in_source}')
-
-        if region_in_name is not None:
-            region = region_in_name
-        elif region_in_source is not None:
-            region = region_in_source
-
-        # Default region set to what specified in oci config.
-        if region is None:
-            region = oci.get_oci_config()['region']
-
-        # So far from now on, the name and source are canonical, means there
-        # is no region (@<region> suffix) associated with them anymore.
-
-        super().__init__(name, source, region, is_sky_managed,
-                         sync_on_reconstruction, _bucket_sub_path)
-        # TODO(zpoint): add _bucket_sub_path to the sync/mount/delete commands
-
-    def _validate_bucket_expr(self, bucket_expr: str):
-        pattern = r'^(\w+://)?[A-Za-z0-9-._]+(@\w{2}-\w+-\d{1})$'
-        if not re.match(pattern, bucket_expr):
-            raise ValueError(
-                'The format for the bucket portion is <bucket>@<region> '
-                'when specify a region with a bucket.')
-
-    def _validate(self):
-        if self.source is not None and isinstance(self.source, str):
-            if self.source.startswith('oci://'):
-                assert self.name == data_utils.split_oci_path(self.source)[0], (
-                    'OCI Bucket is specified as path, the name should be '
-                    'the same as OCI bucket.')
-            elif not re.search(r'^\w+://', self.source):
-                # Treat it as local path.
-                pass
-            else:
-                raise NotImplementedError(
-                    f'Moving data from {self.source} to OCI is not supported.')
-
-        # Validate name
-        self.name = self.validate_name(self.name)
-        # Check if the storage is enabled
-        if not _is_storage_cloud_enabled(str(clouds.OCI())):
-            with ux_utils.print_exception_no_traceback():
-                raise exceptions.ResourcesUnavailableError(
-                    'Storage \'store: oci\' specified, but ' \
-                    'OCI access is disabled. To fix, enable '\
-                    'OCI by running `sky check`. '\
-                    'More info: https://skypilot.readthedocs.io/en/latest/getting-started/installation.html.' # pylint: disable=line-too-long
-                    )
-
-    @classmethod
-    def validate_name(cls, name) -> str:
-        """Validates the name of the OCI store.
-
-        Source for rules: https://docs.oracle.com/en-us/iaas/Content/Object/Tasks/managingbuckets.htm#Managing_Buckets # pylint: disable=line-too-long
-        """
-
-        def _raise_no_traceback_name_error(err_str):
-            with ux_utils.print_exception_no_traceback():
-                raise exceptions.StorageNameError(err_str)
-
-        if name is not None and isinstance(name, str):
-            # Check for overall length
-            if not 1 <= len(name) <= 256:
-                _raise_no_traceback_name_error(
-                    f'Invalid store name: name {name} must contain 1-256 '
-                    'characters.')
-
-            # Check for valid characters and start/end with a number or letter
-            pattern = r'^[A-Za-z0-9-._]+$'
-            if not re.match(pattern, name):
-                _raise_no_traceback_name_error(
-                    f'Invalid store name: name {name} can only contain '
-                    'upper or lower case letters, numeric characters, hyphens '
-                    '(-), underscores (_), and dots (.). Spaces are not '
-                    'allowed. Names must start and end with a number or '
-                    'letter.')
-        else:
-            _raise_no_traceback_name_error('Store name must be specified.')
-        return name
-
-    def initialize(self):
-        """Initializes the OCI store object on the cloud.
-
-        Initialization involves fetching bucket if exists, or creating it if
-        it does not.
-
-        Raises:
-          StorageBucketCreateError: If bucket creation fails
-          StorageBucketGetError: If fetching existing bucket fails
-          StorageInitError: If general initialization fails.
-        """
-        # pylint: disable=import-outside-toplevel
-        from sky.clouds.utils import oci_utils
-        from sky.provision.oci.query_utils import query_helper
-
-        self.oci_config_file = oci.get_config_file()
-        self.config_profile = oci_utils.oci_config.get_profile()
-
-        ## pylint: disable=line-too-long
-        # What's compartment? See thttps://docs.oracle.com/en/cloud/foundation/cloud_architecture/governance/compartments.html
-        self.compartment = query_helper.find_compartment(self.region)
-        self.client = oci.get_object_storage_client(region=self.region,
-                                                    profile=self.config_profile)
-        self.namespace = self.client.get_namespace(
-            compartment_id=oci.get_oci_config()['tenancy']).data
-
-        self.bucket, is_new_bucket = self._get_bucket()
-        if self.is_sky_managed is None:
-            # If is_sky_managed is not specified, then this is a new storage
-            # object (i.e., did not exist in global_user_state) and we should
-            # set the is_sky_managed property.
-            # If is_sky_managed is specified, then we take no action.
-            self.is_sky_managed = is_new_bucket
-
-    def upload(self):
-        """Uploads source to store bucket.
-
-        Upload must be called by the Storage handler - it is not called on
-        Store initialization.
-
-        Raises:
-            StorageUploadError: if upload fails.
-        """
-        try:
-            if isinstance(self.source, list):
-                self.batch_oci_rsync(self.source, create_dirs=True)
-            elif self.source is not None:
-                if self.source.startswith('oci://'):
-                    pass
-                else:
-                    self.batch_oci_rsync([self.source])
-        except exceptions.StorageUploadError:
-            raise
-        except Exception as e:
-            raise exceptions.StorageUploadError(
-                f'Upload failed for store {self.name}') from e
-
-    def delete(self) -> None:
-        deleted_by_skypilot = self._delete_oci_bucket(self.name)
-        if deleted_by_skypilot:
-            msg_str = f'Deleted OCI bucket {self.name}.'
-        else:
-            msg_str = (f'OCI bucket {self.name} may have been deleted '
-                       f'externally. Removing from local state.')
-        logger.info(f'{colorama.Fore.GREEN}{msg_str}'
-                    f'{colorama.Style.RESET_ALL}')
-
-    def get_handle(self) -> StorageHandle:
-        return self.client.get_bucket(namespace_name=self.namespace,
-                                      bucket_name=self.name).data
-
-    def batch_oci_rsync(self,
-                        source_path_list: List[Path],
-                        create_dirs: bool = False) -> None:
-        """Invokes oci sync to batch upload a list of local paths to Bucket
-
-        Use OCI bulk operation to batch process the file upload
-
-        Args:
-            source_path_list: List of paths to local files or directories
-            create_dirs: If the local_path is a directory and this is set to
-                False, the contents of the directory are directly uploaded to
-                root of the bucket. If the local_path is a directory and this is
-                set to True, the directory is created in the bucket root and
-                contents are uploaded to it.
-        """
-        sub_path = (f'{self._bucket_sub_path}/'
-                    if self._bucket_sub_path else '')
-
-        @oci.with_oci_env
-        def get_file_sync_command(base_dir_path, file_names):
-            includes = ' '.join(
-                [f'--include "{file_name}"' for file_name in file_names])
-            prefix_arg = ''
-            if sub_path:
-                prefix_arg = f'--object-prefix "{sub_path.strip("/")}"'
-            sync_command = (
-                'oci os object bulk-upload --no-follow-symlinks --overwrite '
-                f'--bucket-name {self.name} --namespace-name {self.namespace} '
-                f'--region {self.region} --src-dir "{base_dir_path}" '
-                f'{prefix_arg} '
-                f'{includes}')
-
-            return sync_command
-
-        @oci.with_oci_env
-        def get_dir_sync_command(src_dir_path, dest_dir_name):
-            if dest_dir_name and not str(dest_dir_name).endswith('/'):
-                dest_dir_name = f'{dest_dir_name}/'
-
-            excluded_list = storage_utils.get_excluded_files(src_dir_path)
-            excluded_list.append('.git/*')
-            excludes = ' '.join([
-                f'--exclude {shlex.quote(file_name)}'
-                for file_name in excluded_list
-            ])
-
-            # we exclude .git directory from the sync
-            sync_command = (
-                'oci os object bulk-upload --no-follow-symlinks --overwrite '
-                f'--bucket-name {self.name} --namespace-name {self.namespace} '
-                f'--region {self.region} '
-                f'--object-prefix "{sub_path}{dest_dir_name}" '
-                f'--src-dir "{src_dir_path}" {excludes}')
-
-            return sync_command
-
-        # Generate message for upload
-        if len(source_path_list) > 1:
-            source_message = f'{len(source_path_list)} paths'
-        else:
-            source_message = source_path_list[0]
-
-        log_path = sky_logging.generate_tmp_logging_file_path(
-            _STORAGE_LOG_FILE_NAME)
-        sync_path = f'{source_message} -> oci://{self.name}/{sub_path}'
-        with rich_utils.safe_status(
-                ux_utils.spinner_message(f'Syncing {sync_path}',
-                                         log_path=log_path)):
-            data_utils.parallel_upload(
-                source_path_list=source_path_list,
-                filesync_command_generator=get_file_sync_command,
-                dirsync_command_generator=get_dir_sync_command,
-                log_path=log_path,
-                bucket_name=self.name,
-                access_denied_message=self._ACCESS_DENIED_MESSAGE,
-                create_dirs=create_dirs,
-                max_concurrent_uploads=1)
-
-            logger.info(
-                ux_utils.finishing_message(f'Storage synced: {sync_path}',
-                                           log_path))
-
-    def _get_bucket(self) -> Tuple[StorageHandle, bool]:
-        """Obtains the OCI bucket.
-        If the bucket exists, this method will connect to the bucket.
-
-        If the bucket does not exist, there are three cases:
-          1) Raise an error if the bucket source starts with oci://
-          2) Return None if bucket has been externally deleted and
-             sync_on_reconstruction is False
-          3) Create and return a new bucket otherwise
-
-        Return tuple (Bucket, Boolean): The first item is the bucket
-        json payload from the OCI API call, the second item indicates
-        if this is a new created bucket(True) or an existing bucket(False).
-
-        Raises:
-            StorageBucketCreateError: If creating the bucket fails
-            StorageBucketGetError: If fetching a bucket fails
-        """
-        try:
-            get_bucket_response = self.client.get_bucket(
-                namespace_name=self.namespace, bucket_name=self.name)
-            bucket = get_bucket_response.data
-            return bucket, False
-        except oci.service_exception() as e:
-            if e.status == 404:  # Not Found
-                if isinstance(self.source,
-                              str) and self.source.startswith('oci://'):
-                    with ux_utils.print_exception_no_traceback():
-                        raise exceptions.StorageBucketGetError(
-                            'Attempted to connect to a non-existent bucket: '
-                            f'{self.source}') from e
-                else:
-                    # If bucket cannot be found (i.e., does not exist), it is
-                    # to be created by Sky. However, creation is skipped if
-                    # Store object is being reconstructed for deletion.
-                    if self.sync_on_reconstruction:
-                        bucket = self._create_oci_bucket(self.name)
-                        return bucket, True
-                    else:
-                        return None, False
-            elif e.status == 401:  # Unauthorized
-                # AccessDenied error for buckets that are private and not
-                # owned by user.
-                command = (
-                    f'oci os object list --namespace-name {self.namespace} '
-                    f'--bucket-name {self.name}')
-                with ux_utils.print_exception_no_traceback():
-                    raise exceptions.StorageBucketGetError(
-                        _BUCKET_FAIL_TO_CONNECT_MESSAGE.format(name=self.name) +
-                        f' To debug, consider running `{command}`.') from e
-            else:
-                # Unknown / unexpected error happened. This might happen when
-                # Object storage service itself functions not normal (e.g.
-                # maintainance event causes internal server error or request
-                # timeout, etc).
-                with ux_utils.print_exception_no_traceback():
-                    raise exceptions.StorageBucketGetError(
-                        f'Failed to connect to OCI bucket {self.name}') from e
-
-    def mount_command(self, mount_path: str) -> str:
-        """Returns the command to mount the bucket to the mount_path.
-
-        Uses Rclone to mount the bucket.
-
-        Args:
-          mount_path: str; Path to mount the bucket to.
-        """
-        install_cmd = mounting_utils.get_rclone_install_cmd()
-        mount_cmd = mounting_utils.get_oci_mount_cmd(
-            mount_path=mount_path,
-            store_name=self.name,
-            region=str(self.region),
-            namespace=self.namespace,
-            compartment=self.bucket.compartment_id,
-            config_file=self.oci_config_file,
-            config_profile=self.config_profile)
-        version_check_cmd = mounting_utils.get_rclone_version_check_cmd()
-
-        return mounting_utils.get_mounting_command(mount_path, install_cmd,
-                                                   mount_cmd, version_check_cmd)
-
-    def _download_file(self, remote_path: str, local_path: str) -> None:
-        """Downloads file from remote to local on OCI bucket
-
-        Args:
-          remote_path: str; Remote path on OCI bucket
-          local_path: str; Local path on user's device
-        """
-        if remote_path.startswith(f'/{self.name}'):
-            # If the remote path is /bucket_name, we need to
-            # remove the leading /
-            remote_path = remote_path.lstrip('/')
-
-        filename = os.path.basename(remote_path)
-        if not local_path.endswith(filename):
-            local_path = os.path.join(local_path, filename)
-
-        @oci.with_oci_env
-        def get_file_download_command(remote_path, local_path):
-            download_command = (f'oci os object get --bucket-name {self.name} '
-                                f'--namespace-name {self.namespace} '
-                                f'--region {self.region} --name {remote_path} '
-                                f'--file {local_path}')
-
-            return download_command
-
-        download_command = get_file_download_command(remote_path, local_path)
-
-        try:
-            with rich_utils.safe_status(
-                    f'[bold cyan]Downloading: {remote_path} -> {local_path}[/]'
-            ):
-                subprocess.check_output(download_command,
-                                        stderr=subprocess.STDOUT,
-                                        shell=True)
-        except subprocess.CalledProcessError as e:
-            logger.error(f'Download failed: {remote_path} -> {local_path}.\n'
-                         f'Detail errors: {e.output}')
-            with ux_utils.print_exception_no_traceback():
-                raise exceptions.StorageBucketDeleteError(
-                    f'Failed download file {self.name}:{remote_path}.') from e
-
-    def _create_oci_bucket(self, bucket_name: str) -> StorageHandle:
-        """Creates OCI bucket with specific name in specific region
-
-        Args:
-          bucket_name: str; Name of bucket
-          region: str; Region name, e.g. us-central1, us-west1
-        """
-        logger.debug(f'_create_oci_bucket: {bucket_name}')
-        try:
-            create_bucket_response = self.client.create_bucket(
-                namespace_name=self.namespace,
-                create_bucket_details=oci.oci.object_storage.models.
-                CreateBucketDetails(
-                    name=bucket_name,
-                    compartment_id=self.compartment,
-                ))
-            bucket = create_bucket_response.data
-            return bucket
-        except oci.service_exception() as e:
-            with ux_utils.print_exception_no_traceback():
-                raise exceptions.StorageBucketCreateError(
-                    f'Failed to create OCI bucket: {self.name}') from e
-
-    def _delete_oci_bucket(self, bucket_name: str) -> bool:
-        """Deletes OCI bucket, including all objects in bucket
-
-        Args:
-          bucket_name: str; Name of bucket
-
-        Returns:
-         bool; True if bucket was deleted, False if it was deleted externally.
-        """
-        logger.debug(f'_delete_oci_bucket: {bucket_name}')
-
-        @oci.with_oci_env
-        def get_bucket_delete_command(bucket_name):
-            remove_command = (f'oci os bucket delete --bucket-name '
-                              f'--region {self.region} '
-                              f'{bucket_name} --empty --force')
-
-            return remove_command
-
-        remove_command = get_bucket_delete_command(bucket_name)
-
-        try:
-            with rich_utils.safe_status(
-                    f'[bold cyan]Deleting OCI bucket {bucket_name}[/]'):
-                subprocess.check_output(remove_command.split(' '),
-                                        stderr=subprocess.STDOUT)
-        except subprocess.CalledProcessError as e:
-            if 'BucketNotFound' in e.output.decode('utf-8'):
-                logger.debug(
-                    _BUCKET_EXTERNALLY_DELETED_DEBUG_MESSAGE.format(
-                        bucket_name=bucket_name))
-                return False
-            else:
-                logger.error(e.output)
-                with ux_utils.print_exception_no_traceback():
-                    raise exceptions.StorageBucketDeleteError(
-                        f'Failed to delete OCI bucket {bucket_name}.')
-        return True
+        # Region is from the specified name in <bucket>@<region> format.
+        # Another case is name can also be set by the source, for example:
+        #   /datasets-storage:
+        #       source: oci://RAGData@us-sanjose-1
+        # The name in above mount will be set to RAGData@us-sanjose-1
+        region_in_name = None
+        if name is not None and '@' in name:
+            self._validate_bucket_expr(name)
+            name, region_in_name = name.split('@')
 
+        # Region is from the specified source in oci://<bucket>@<region> format
+        region_in_source = None
+        if isinstance(source,
+                      str) and source.startswith('oci://') and '@' in source:
+            self._validate_bucket_expr(source)
+            source, region_in_source = source.split('@')
 
-class NebiusStore(AbstractStore):
-    """NebiusStore inherits from Storage Object and represents the backend
-    for S3 buckets.
-    """
+        if region_in_name is not None and region_in_source is not None:
+            # This should never happen because name and source will never be
+            # the remote bucket at the same time.
+            assert region_in_name == region_in_source, (
+                f'Mismatch region specified. Region in name {region_in_name}, '
+                f'but region in source is {region_in_source}')
 
-    _ACCESS_DENIED_MESSAGE = 'Access Denied'
-    _TIMEOUT_TO_PROPAGATES = 20
+        if region_in_name is not None:
+            region = region_in_name
+        elif region_in_source is not None:
+            region = region_in_source
+
+        # Default region set to what specified in oci config.
+        if region is None:
+            region = oci.get_oci_config()['region']
+
+        # So far from now on, the name and source are canonical, means there
+        # is no region (@<region> suffix) associated with them anymore.
 
-    def __init__(self,
-                 name: str,
-                 source: str,
-                 region: Optional[str] = None,
-                 is_sky_managed: Optional[bool] = None,
-                 sync_on_reconstruction: bool = True,
-                 _bucket_sub_path: Optional[str] = None):
-        self.client: 'mypy_boto3_s3.Client'
-        self.bucket: 'StorageHandle'
         super().__init__(name, source, region, is_sky_managed,
                          sync_on_reconstruction, _bucket_sub_path)
+        # TODO(zpoint): add _bucket_sub_path to the sync/mount/delete commands
+
+    def _validate_bucket_expr(self, bucket_expr: str):
+        pattern = r'^(\w+://)?[A-Za-z0-9-._]+(@\w{2}-\w+-\d{1})$'
+        if not re.match(pattern, bucket_expr):
+            raise ValueError(
+                'The format for the bucket portion is <bucket>@<region> '
+                'when specify a region with a bucket.')
 
     def _validate(self):
         if self.source is not None and isinstance(self.source, str):
-            if self.source.startswith('s3://'):
-                assert self.name == data_utils.split_s3_path(self.source)[0], (
-                    'S3 Bucket is specified as path, the name should be the'
-                    ' same as S3 bucket.')
-            elif self.source.startswith('gs://'):
-                assert self.name == data_utils.split_gcs_path(self.source)[0], (
-                    'GCS Bucket is specified as path, the name should be '
-                    'the same as GCS bucket.')
-                assert data_utils.verify_gcs_bucket(self.name), (
-                    f'Source specified as {self.source}, a GCS bucket. ',
-                    'GCS Bucket should exist.')
-            elif data_utils.is_az_container_endpoint(self.source):
-                storage_account_name, container_name, _ = (
-                    data_utils.split_az_path(self.source))
-                assert self.name == container_name, (
-                    'Azure bucket is specified as path, the name should be '
-                    'the same as Azure bucket.')
-                assert data_utils.verify_az_bucket(
-                    storage_account_name, self.name), (
-                        f'Source specified as {self.source}, an Azure bucket. '
-                        'Azure bucket should exist.')
-            elif self.source.startswith('r2://'):
-                assert self.name == data_utils.split_r2_path(self.source)[0], (
-                    'R2 Bucket is specified as path, the name should be '
-                    'the same as R2 bucket.')
-                assert data_utils.verify_r2_bucket(self.name), (
-                    f'Source specified as {self.source}, a R2 bucket. ',
-                    'R2 Bucket should exist.')
-            elif self.source.startswith('nebius://'):
-                assert self.name == data_utils.split_nebius_path(
-                    self.source)[0], (
-                        'Nebius Object Storage is specified as path, the name '
-                        'should be the same as Nebius Object Storage bucket.')
-            elif self.source.startswith('cos://'):
-                assert self.name == data_utils.split_cos_path(self.source)[0], (
-                    'COS Bucket is specified as path, the name should be '
-                    'the same as COS bucket.')
-                assert data_utils.verify_ibm_cos_bucket(self.name), (
-                    f'Source specified as {self.source}, a COS bucket. ',
-                    'COS Bucket should exist.')
-            elif self.source.startswith('oci://'):
+            if self.source.startswith('oci://'):
+                assert self.name == data_utils.split_oci_path(self.source)[0], (
+                    'OCI Bucket is specified as path, the name should be '
+                    'the same as OCI bucket.')
+            elif not re.search(r'^\w+://', self.source):
+                # Treat it as local path.
+                pass
+            else:
                 raise NotImplementedError(
-                    'Moving data from OCI to S3 is currently not supported.')
-        # Validate name
-        self.name = S3Store.validate_name(self.name)
+                    f'Moving data from {self.source} to OCI is not supported.')
 
+        # Validate name
+        self.name = self.validate_name(self.name)
         # Check if the storage is enabled
-        if not _is_storage_cloud_enabled(str(clouds.Nebius())):
+        if not _is_storage_cloud_enabled(str(clouds.OCI())):
             with ux_utils.print_exception_no_traceback():
-                raise exceptions.ResourcesUnavailableError((
-                    'Storage \'store: nebius\' specified, but '
-                    'Nebius access is disabled. To fix, enable '
-                    'Nebius by running `sky check`. More info: '
-                    'https://docs.skypilot.co/en/latest/getting-started/installation.html.'  # pylint: disable=line-too-long
-                ))
+                raise exceptions.ResourcesUnavailableError(
+                    'Storage \'store: oci\' specified, but ' \
+                    'OCI access is disabled. To fix, enable '\
+                    'OCI by running `sky check`. '\
+                    'More info: https://skypilot.readthedocs.io/en/latest/getting-started/installation.html.' # pylint: disable=line-too-long
+                    )
+
+    @classmethod
+    def validate_name(cls, name) -> str:
+        """Validates the name of the OCI store.
+
+        Source for rules: https://docs.oracle.com/en-us/iaas/Content/Object/Tasks/managingbuckets.htm#Managing_Buckets # pylint: disable=line-too-long
+        """
+
+        def _raise_no_traceback_name_error(err_str):
+            with ux_utils.print_exception_no_traceback():
+                raise exceptions.StorageNameError(err_str)
+
+        if name is not None and isinstance(name, str):
+            # Check for overall length
+            if not 1 <= len(name) <= 256:
+                _raise_no_traceback_name_error(
+                    f'Invalid store name: name {name} must contain 1-256 '
+                    'characters.')
+
+            # Check for valid characters and start/end with a number or letter
+            pattern = r'^[A-Za-z0-9-._]+$'
+            if not re.match(pattern, name):
+                _raise_no_traceback_name_error(
+                    f'Invalid store name: name {name} can only contain '
+                    'upper or lower case letters, numeric characters, hyphens '
+                    '(-), underscores (_), and dots (.). Spaces are not '
+                    'allowed. Names must start and end with a number or '
+                    'letter.')
+        else:
+            _raise_no_traceback_name_error('Store name must be specified.')
+        return name
 
     def initialize(self):
-        """Initializes the Nebius Object Storage on the cloud.
+        """Initializes the OCI store object on the cloud.
 
         Initialization involves fetching bucket if exists, or creating it if
         it does not.
@@ -4780,7 +4090,21 @@ class NebiusStore(AbstractStore):
           StorageBucketGetError: If fetching existing bucket fails
           StorageInitError: If general initialization fails.
         """
-        self.client = data_utils.create_nebius_client()
+        # pylint: disable=import-outside-toplevel
+        from sky.clouds.utils import oci_utils
+        from sky.provision.oci.query_utils import query_helper
+
+        self.oci_config_file = oci.get_config_file()
+        self.config_profile = oci_utils.oci_config.get_profile()
+
+        ## pylint: disable=line-too-long
+        # What's compartment? See thttps://docs.oracle.com/en/cloud/foundation/cloud_architecture/governance/compartments.html
+        self.compartment = query_helper.find_compartment(self.region)
+        self.client = oci.get_object_storage_client(region=self.region,
+                                                    profile=self.config_profile)
+        self.namespace = self.client.get_namespace(
+            compartment_id=oci.get_oci_config()['tenancy']).data
+
         self.bucket, is_new_bucket = self._get_bucket()
         if self.is_sky_managed is None:
             # If is_sky_managed is not specified, then this is a new storage
@@ -4800,20 +4124,12 @@ class NebiusStore(AbstractStore):
         """
         try:
             if isinstance(self.source, list):
-                self.batch_aws_rsync(self.source, create_dirs=True)
+                self.batch_oci_rsync(self.source, create_dirs=True)
             elif self.source is not None:
-                if self.source.startswith('nebius://'):
+                if self.source.startswith('oci://'):
                     pass
-                elif self.source.startswith('s3://'):
-                    self._transfer_to_nebius()
-                elif self.source.startswith('gs://'):
-                    self._transfer_to_nebius()
-                elif self.source.startswith('r2://'):
-                    self._transfer_to_nebius()
-                elif self.source.startswith('oci://'):
-                    self._transfer_to_nebius()
                 else:
-                    self.batch_aws_rsync([self.source])
+                    self.batch_oci_rsync([self.source])
         except exceptions.StorageUploadError:
             raise
         except Exception as e:
@@ -4821,45 +4137,25 @@ class NebiusStore(AbstractStore):
                 f'Upload failed for store {self.name}') from e
 
     def delete(self) -> None:
-        if self._bucket_sub_path is not None and not self.is_sky_managed:
-            return self._delete_sub_path()
-
-        deleted_by_skypilot = self._delete_nebius_bucket(self.name)
+        deleted_by_skypilot = self._delete_oci_bucket(self.name)
         if deleted_by_skypilot:
-            msg_str = f'Deleted Nebius bucket {self.name}.'
+            msg_str = f'Deleted OCI bucket {self.name}.'
         else:
-            msg_str = (f'Nebius bucket {self.name} may have been deleted '
+            msg_str = (f'OCI bucket {self.name} may have been deleted '
                        f'externally. Removing from local state.')
         logger.info(f'{colorama.Fore.GREEN}{msg_str}'
                     f'{colorama.Style.RESET_ALL}')
 
-    def _delete_sub_path(self) -> None:
-        assert self._bucket_sub_path is not None, 'bucket_sub_path is not set'
-        deleted_by_skypilot = self._delete_nebius_bucket_sub_path(
-            self.name, self._bucket_sub_path)
-        if deleted_by_skypilot:
-            msg_str = (f'Removed objects from S3 bucket '
-                       f'{self.name}/{self._bucket_sub_path}.')
-        else:
-            msg_str = (f'Failed to remove objects from S3 bucket '
-                       f'{self.name}/{self._bucket_sub_path}.')
-        logger.info(f'{colorama.Fore.GREEN}{msg_str}'
-                    f'{colorama.Style.RESET_ALL}')
-
     def get_handle(self) -> StorageHandle:
-        return nebius.resource('s3').Bucket(self.name)
+        return self.client.get_bucket(namespace_name=self.namespace,
+                                      bucket_name=self.name).data
 
-    def batch_aws_rsync(self,
+    def batch_oci_rsync(self,
                         source_path_list: List[Path],
                         create_dirs: bool = False) -> None:
-        """Invokes aws s3 sync to batch upload a list of local paths to S3
-
-        AWS Sync by default uses 10 threads to upload files to the bucket.  To
-        increase parallelism, modify max_concurrent_requests in your aws config
-        file (Default path: ~/.aws/config).
+        """Invokes oci sync to batch upload a list of local paths to Bucket
 
-        Since aws s3 sync does not support batch operations, we construct
-        multiple commands to be run in parallel.
+        Use OCI bulk operation to batch process the file upload
 
         Args:
             source_path_list: List of paths to local files or directories
@@ -4869,34 +4165,45 @@ class NebiusStore(AbstractStore):
                 set to True, the directory is created in the bucket root and
                 contents are uploaded to it.
         """
-        sub_path = (f'/{self._bucket_sub_path}'
+        sub_path = (f'{self._bucket_sub_path}/'
                     if self._bucket_sub_path else '')
 
+        @oci.with_oci_env
         def get_file_sync_command(base_dir_path, file_names):
-            includes = ' '.join([
-                f'--include {shlex.quote(file_name)}'
-                for file_name in file_names
-            ])
-            base_dir_path = shlex.quote(base_dir_path)
-            sync_command = ('aws s3 sync --no-follow-symlinks --exclude="*" '
-                            f'{includes} {base_dir_path} '
-                            f's3://{self.name}{sub_path} '
-                            f'--profile={nebius.NEBIUS_PROFILE_NAME}')
+            includes = ' '.join(
+                [f'--include "{file_name}"' for file_name in file_names])
+            prefix_arg = ''
+            if sub_path:
+                prefix_arg = f'--object-prefix "{sub_path.strip("/")}"'
+            sync_command = (
+                'oci os object bulk-upload --no-follow-symlinks --overwrite '
+                f'--bucket-name {self.name} --namespace-name {self.namespace} '
+                f'--region {self.region} --src-dir "{base_dir_path}" '
+                f'{prefix_arg} '
+                f'{includes}')
+
             return sync_command
 
+        @oci.with_oci_env
         def get_dir_sync_command(src_dir_path, dest_dir_name):
-            # we exclude .git directory from the sync
+            if dest_dir_name and not str(dest_dir_name).endswith('/'):
+                dest_dir_name = f'{dest_dir_name}/'
+
             excluded_list = storage_utils.get_excluded_files(src_dir_path)
             excluded_list.append('.git/*')
             excludes = ' '.join([
                 f'--exclude {shlex.quote(file_name)}'
                 for file_name in excluded_list
             ])
-            src_dir_path = shlex.quote(src_dir_path)
-            sync_command = (f'aws s3 sync --no-follow-symlinks {excludes} '
-                            f'{src_dir_path} '
-                            f's3://{self.name}{sub_path}/{dest_dir_name} '
-                            f'--profile={nebius.NEBIUS_PROFILE_NAME}')
+
+            # we exclude .git directory from the sync
+            sync_command = (
+                'oci os object bulk-upload --no-follow-symlinks --overwrite '
+                f'--bucket-name {self.name} --namespace-name {self.namespace} '
+                f'--region {self.region} '
+                f'--object-prefix "{sub_path}{dest_dir_name}" '
+                f'--src-dir "{src_dir_path}" {excludes}')
+
             return sync_command
 
         # Generate message for upload
@@ -4907,210 +4214,347 @@ class NebiusStore(AbstractStore):
 
         log_path = sky_logging.generate_tmp_logging_file_path(
             _STORAGE_LOG_FILE_NAME)
-        sync_path = f'{source_message} -> nebius://{self.name}{sub_path}/'
+        sync_path = f'{source_message} -> oci://{self.name}/{sub_path}'
         with rich_utils.safe_status(
                 ux_utils.spinner_message(f'Syncing {sync_path}',
                                          log_path=log_path)):
             data_utils.parallel_upload(
-                source_path_list,
-                get_file_sync_command,
-                get_dir_sync_command,
-                log_path,
-                self.name,
-                self._ACCESS_DENIED_MESSAGE,
+                source_path_list=source_path_list,
+                filesync_command_generator=get_file_sync_command,
+                dirsync_command_generator=get_dir_sync_command,
+                log_path=log_path,
+                bucket_name=self.name,
+                access_denied_message=self._ACCESS_DENIED_MESSAGE,
                 create_dirs=create_dirs,
-                max_concurrent_uploads=_MAX_CONCURRENT_UPLOADS)
-        logger.info(
-            ux_utils.finishing_message(f'Storage synced: {sync_path}',
-                                       log_path))
+                max_concurrent_uploads=1)
 
-    def _transfer_to_nebius(self) -> None:
-        assert isinstance(self.source, str), self.source
-        if self.source.startswith('gs://'):
-            data_transfer.gcs_to_nebius(self.name, self.name)
-        elif self.source.startswith('r2://'):
-            data_transfer.r2_to_nebius(self.name, self.name)
-        elif self.source.startswith('s3://'):
-            data_transfer.s3_to_nebius(self.name, self.name)
+            logger.info(
+                ux_utils.finishing_message(f'Storage synced: {sync_path}',
+                                           log_path))
 
     def _get_bucket(self) -> Tuple[StorageHandle, bool]:
-        """Obtains the S3 bucket.
+        """Obtains the OCI bucket.
+        If the bucket exists, this method will connect to the bucket.
 
-        If the bucket exists, this method will return the bucket.
         If the bucket does not exist, there are three cases:
-          1) Raise an error if the bucket source starts with s3://
+          1) Raise an error if the bucket source starts with oci://
           2) Return None if bucket has been externally deleted and
              sync_on_reconstruction is False
           3) Create and return a new bucket otherwise
 
+        Return tuple (Bucket, Boolean): The first item is the bucket
+        json payload from the OCI API call, the second item indicates
+        if this is a new created bucket(True) or an existing bucket(False).
+
         Raises:
-            StorageSpecError: If externally created bucket is attempted to be
-                mounted without specifying storage source.
             StorageBucketCreateError: If creating the bucket fails
             StorageBucketGetError: If fetching a bucket fails
-            StorageExternalDeletionError: If externally deleted storage is
-                attempted to be fetched while reconstructing the storage for
-                'sky storage delete' or 'sky start'
         """
-        nebius_s = nebius.resource('s3')
-        bucket = nebius_s.Bucket(self.name)
         try:
-            # Try Public bucket case.
-            # This line does not error out if the bucket is an external public
-            # bucket or if it is a user's bucket that is publicly
-            # accessible.
-            self.client.head_bucket(Bucket=self.name)
-            self._validate_existing_bucket()
+            get_bucket_response = self.client.get_bucket(
+                namespace_name=self.namespace, bucket_name=self.name)
+            bucket = get_bucket_response.data
             return bucket, False
-        except aws.botocore_exceptions().ClientError as e:
-            error_code = e.response['Error']['Code']
-            # AccessDenied error for buckets that are private and not owned by
-            # user.
-            if error_code == '403':
-                command = (f'aws s3 ls s3://{self.name} '
-                           f'--profile={nebius.NEBIUS_PROFILE_NAME}')
+        except oci.service_exception() as e:
+            if e.status == 404:  # Not Found
+                if isinstance(self.source,
+                              str) and self.source.startswith('oci://'):
+                    with ux_utils.print_exception_no_traceback():
+                        raise exceptions.StorageBucketGetError(
+                            'Attempted to connect to a non-existent bucket: '
+                            f'{self.source}') from e
+                else:
+                    # If bucket cannot be found (i.e., does not exist), it is
+                    # to be created by Sky. However, creation is skipped if
+                    # Store object is being reconstructed for deletion.
+                    if self.sync_on_reconstruction:
+                        bucket = self._create_oci_bucket(self.name)
+                        return bucket, True
+                    else:
+                        return None, False
+            elif e.status == 401:  # Unauthorized
+                # AccessDenied error for buckets that are private and not
+                # owned by user.
+                command = (
+                    f'oci os object list --namespace-name {self.namespace} '
+                    f'--bucket-name {self.name}')
                 with ux_utils.print_exception_no_traceback():
                     raise exceptions.StorageBucketGetError(
                         _BUCKET_FAIL_TO_CONNECT_MESSAGE.format(name=self.name) +
                         f' To debug, consider running `{command}`.') from e
+            else:
+                # Unknown / unexpected error happened. This might happen when
+                # Object storage service itself functions not normal (e.g.
+                # maintainance event causes internal server error or request
+                # timeout, etc).
+                with ux_utils.print_exception_no_traceback():
+                    raise exceptions.StorageBucketGetError(
+                        f'Failed to connect to OCI bucket {self.name}') from e
 
-        if isinstance(self.source, str) and self.source.startswith('nebius://'):
-            with ux_utils.print_exception_no_traceback():
-                raise exceptions.StorageBucketGetError(
-                    'Attempted to use a non-existent bucket as a source: '
-                    f'{self.source}. Consider using `aws s3 ls '
-                    f's3://{self.name} '
-                    f'--profile={nebius.NEBIUS_PROFILE_NAME}` to debug.')
+    def mount_command(self, mount_path: str) -> str:
+        """Returns the command to mount the bucket to the mount_path.
 
-        # If bucket cannot be found in both private and public settings,
-        # the bucket is to be created by Sky. However, creation is skipped if
-        # Store object is being reconstructed for deletion or re-mount with
-        # sky start, and error is raised instead.
-        if self.sync_on_reconstruction:
-            bucket = self._create_nebius_bucket(self.name)
-            return bucket, True
-        else:
-            # Raised when Storage object is reconstructed for sky storage
-            # delete or to re-mount Storages with sky start but the storage
-            # is already removed externally.
-            raise exceptions.StorageExternalDeletionError(
-                'Attempted to fetch a non-existent bucket: '
-                f'{self.name}')
+        Uses Rclone to mount the bucket.
+
+        Args:
+          mount_path: str; Path to mount the bucket to.
+        """
+        install_cmd = mounting_utils.get_rclone_install_cmd()
+        mount_cmd = mounting_utils.get_oci_mount_cmd(
+            mount_path=mount_path,
+            store_name=self.name,
+            region=str(self.region),
+            namespace=self.namespace,
+            compartment=self.bucket.compartment_id,
+            config_file=self.oci_config_file,
+            config_profile=self.config_profile)
+        version_check_cmd = mounting_utils.get_rclone_version_check_cmd()
+
+        return mounting_utils.get_mounting_command(mount_path, install_cmd,
+                                                   mount_cmd, version_check_cmd)
 
     def _download_file(self, remote_path: str, local_path: str) -> None:
-        """Downloads file from remote to local on s3 bucket
-        using the boto3 API
+        """Downloads file from remote to local on OCI bucket
 
         Args:
-          remote_path: str; Remote path on S3 bucket
+          remote_path: str; Remote path on OCI bucket
           local_path: str; Local path on user's device
         """
-        self.bucket.download_file(remote_path, local_path)
+        if remote_path.startswith(f'/{self.name}'):
+            # If the remote path is /bucket_name, we need to
+            # remove the leading /
+            remote_path = remote_path.lstrip('/')
 
-    def mount_command(self, mount_path: str) -> str:
-        """Returns the command to mount the bucket to the mount_path.
+        filename = os.path.basename(remote_path)
+        if not local_path.endswith(filename):
+            local_path = os.path.join(local_path, filename)
+
+        @oci.with_oci_env
+        def get_file_download_command(remote_path, local_path):
+            download_command = (f'oci os object get --bucket-name {self.name} '
+                                f'--namespace-name {self.namespace} '
+                                f'--region {self.region} --name {remote_path} '
+                                f'--file {local_path}')
 
-        Uses goofys to mount the bucket.
+            return download_command
 
-        Args:
-          mount_path: str; Path to mount the bucket to.
-        """
-        install_cmd = mounting_utils.get_s3_mount_install_cmd()
-        nebius_profile_name = nebius.NEBIUS_PROFILE_NAME
-        endpoint_url = self.client.meta.endpoint_url
-        mount_cmd = mounting_utils.get_nebius_mount_cmd(nebius_profile_name,
-                                                        self.bucket.name,
-                                                        endpoint_url,
-                                                        mount_path,
-                                                        self._bucket_sub_path)
-        return mounting_utils.get_mounting_command(mount_path, install_cmd,
-                                                   mount_cmd)
+        download_command = get_file_download_command(remote_path, local_path)
+
+        try:
+            with rich_utils.safe_status(
+                    f'[bold cyan]Downloading: {remote_path} -> {local_path}[/]'
+            ):
+                subprocess.check_output(download_command,
+                                        stderr=subprocess.STDOUT,
+                                        shell=True)
+        except subprocess.CalledProcessError as e:
+            logger.error(f'Download failed: {remote_path} -> {local_path}.\n'
+                         f'Detail errors: {e.output}')
+            with ux_utils.print_exception_no_traceback():
+                raise exceptions.StorageBucketDeleteError(
+                    f'Failed download file {self.name}:{remote_path}.') from e
 
-    def _create_nebius_bucket(self, bucket_name: str) -> StorageHandle:
-        """Creates S3 bucket with specific name
+    def _create_oci_bucket(self, bucket_name: str) -> StorageHandle:
+        """Creates OCI bucket with specific name in specific region
 
         Args:
           bucket_name: str; Name of bucket
-        Raises:
-          StorageBucketCreateError: If bucket creation fails.
+          region: str; Region name, e.g. us-central1, us-west1
         """
-        nebius_client = self.client
+        logger.debug(f'_create_oci_bucket: {bucket_name}')
         try:
-            nebius_client.create_bucket(Bucket=bucket_name)
-        except aws.botocore_exceptions().ClientError as e:
+            create_bucket_response = self.client.create_bucket(
+                namespace_name=self.namespace,
+                create_bucket_details=oci.oci.object_storage.models.
+                CreateBucketDetails(
+                    name=bucket_name,
+                    compartment_id=self.compartment,
+                ))
+            bucket = create_bucket_response.data
+            return bucket
+        except oci.service_exception() as e:
             with ux_utils.print_exception_no_traceback():
                 raise exceptions.StorageBucketCreateError(
-                    f'Attempted to create a bucket '
-                    f'{self.name} but failed.') from e
-        return nebius.resource('s3').Bucket(bucket_name)
+                    f'Failed to create OCI bucket: {self.name}') from e
+
+    def _delete_oci_bucket(self, bucket_name: str) -> bool:
+        """Deletes OCI bucket, including all objects in bucket
+
+        Args:
+          bucket_name: str; Name of bucket
+
+        Returns:
+         bool; True if bucket was deleted, False if it was deleted externally.
+        """
+        logger.debug(f'_delete_oci_bucket: {bucket_name}')
+
+        @oci.with_oci_env
+        def get_bucket_delete_command(bucket_name):
+            remove_command = (f'oci os bucket delete --bucket-name '
+                              f'--region {self.region} '
+                              f'{bucket_name} --empty --force')
+
+            return remove_command
+
+        remove_command = get_bucket_delete_command(bucket_name)
 
-    def _execute_nebius_remove_command(self, command: str, bucket_name: str,
-                                       hint_operating: str,
-                                       hint_failed: str) -> bool:
         try:
             with rich_utils.safe_status(
-                    ux_utils.spinner_message(hint_operating)):
-                subprocess.check_output(command.split(' '),
+                    f'[bold cyan]Deleting OCI bucket {bucket_name}[/]'):
+                subprocess.check_output(remove_command.split(' '),
                                         stderr=subprocess.STDOUT)
         except subprocess.CalledProcessError as e:
-            if 'NoSuchBucket' in e.output.decode('utf-8'):
+            if 'BucketNotFound' in e.output.decode('utf-8'):
                 logger.debug(
                     _BUCKET_EXTERNALLY_DELETED_DEBUG_MESSAGE.format(
                         bucket_name=bucket_name))
                 return False
             else:
+                logger.error(e.output)
                 with ux_utils.print_exception_no_traceback():
                     raise exceptions.StorageBucketDeleteError(
-                        f'{hint_failed}'
-                        f'Detailed error: {e.output}')
+                        f'Failed to delete OCI bucket {bucket_name}.')
         return True
 
-    def _delete_nebius_bucket(self, bucket_name: str) -> bool:
-        """Deletes S3 bucket, including all objects in bucket
 
-        Args:
-          bucket_name: str; Name of bucket
+@register_s3_compatible_store
+class S3Store(S3CompatibleStore):
+    """S3Store inherits from S3CompatibleStore and represents the backend
+    for S3 buckets.
+    """
 
-        Returns:
-         bool; True if bucket was deleted, False if it was deleted externally.
+    _DEFAULT_REGION = 'us-east-1'
+    _CUSTOM_ENDPOINT_REGIONS = [
+        'ap-east-1', 'me-south-1', 'af-south-1', 'eu-south-1', 'eu-south-2',
+        'ap-south-2', 'ap-southeast-3', 'ap-southeast-4', 'me-central-1',
+        'il-central-1'
+    ]
 
-        Raises:
-            StorageBucketDeleteError: If deleting the bucket fails.
-        """
-        # Deleting objects is very slow programatically
-        # (i.e. bucket.objects.all().delete() is slow).
-        # In addition, standard delete operations (i.e. via `aws s3 rm`)
-        # are slow, since AWS puts deletion markers.
-        # https://stackoverflow.com/questions/49239351/why-is-it-so-much-slower-to-delete-objects-in-aws-s3-than-it-is-to-create-them
-        # The fastest way to delete is to run `aws s3 rb --force`,
-        # which removes the bucket by force.
-        remove_command = (f'aws s3 rb s3://{bucket_name} --force '
-                          f'--profile={nebius.NEBIUS_PROFILE_NAME}')
-
-        success = self._execute_nebius_remove_command(
-            remove_command, bucket_name,
-            f'Deleting Nebius bucket {bucket_name}',
-            f'Failed to delete Nebius bucket {bucket_name}.')
-        if not success:
-            return False
+    def __init__(self,
+                 name: str,
+                 source: str,
+                 region: Optional[str] = None,
+                 is_sky_managed: Optional[bool] = None,
+                 sync_on_reconstruction: bool = True,
+                 _bucket_sub_path: Optional[str] = None):
+        # TODO(romilb): This is purely a stopgap fix for
+        #  https://github.com/skypilot-org/skypilot/issues/3405
+        # We should eventually make all opt-in regions also work for S3 by
+        # passing the right endpoint flags.
+        if region in self._CUSTOM_ENDPOINT_REGIONS:
+            logger.warning('AWS opt-in regions are not supported for S3. '
+                           f'Falling back to default region '
+                           f'{self._DEFAULT_REGION} for bucket {name!r}.')
+            region = self._DEFAULT_REGION
+        super().__init__(name, source, region, is_sky_managed,
+                         sync_on_reconstruction, _bucket_sub_path)
 
-        # Wait until bucket deletion propagates on Nebius servers
-        start_time = time.time()
-        while data_utils.verify_nebius_bucket(bucket_name):
-            if time.time() - start_time > self._TIMEOUT_TO_PROPAGATES:
-                raise TimeoutError(
-                    f'Timeout while verifying {bucket_name} Nebius bucket.')
-            time.sleep(0.1)
-        return True
+    @classmethod
+    def get_config(cls) -> S3CompatibleConfig:
+        """Return the configuration for AWS S3."""
+        return S3CompatibleConfig(
+            store_type='S3',
+            url_prefix='s3://',
+            client_factory=data_utils.create_s3_client,
+            resource_factory=lambda name: aws.resource('s3').Bucket(name),
+            split_path=data_utils.split_s3_path,
+            verify_bucket=data_utils.verify_s3_bucket,
+            cloud_name=str(clouds.AWS()),
+            default_region=cls._DEFAULT_REGION,
+            mount_cmd_factory=mounting_utils.get_s3_mount_cmd,
+        )
+
+    def mount_cached_command(self, mount_path: str) -> str:
+        install_cmd = mounting_utils.get_rclone_install_cmd()
+        rclone_profile_name = (
+            data_utils.Rclone.RcloneStores.S3.get_profile_name(self.name))
+        rclone_config = data_utils.Rclone.RcloneStores.S3.get_config(
+            rclone_profile_name=rclone_profile_name)
+        mount_cached_cmd = mounting_utils.get_mount_cached_cmd(
+            rclone_config, rclone_profile_name, self.bucket.name, mount_path)
+        return mounting_utils.get_mounting_command(mount_path, install_cmd,
+                                                   mount_cached_cmd)
+
+
+@register_s3_compatible_store
+class R2Store(S3CompatibleStore):
+    """R2Store inherits from S3CompatibleStore and represents the backend
+    for R2 buckets.
+    """
+
+    def __init__(self,
+                 name: str,
+                 source: str,
+                 region: Optional[str] = 'auto',
+                 is_sky_managed: Optional[bool] = None,
+                 sync_on_reconstruction: bool = True,
+                 _bucket_sub_path: Optional[str] = None):
+        super().__init__(name, source, region, is_sky_managed,
+                         sync_on_reconstruction, _bucket_sub_path)
+
+    @classmethod
+    def get_config(cls) -> S3CompatibleConfig:
+        """Return the configuration for Cloudflare R2."""
+        return S3CompatibleConfig(
+            store_type='R2',
+            url_prefix='r2://',
+            client_factory=lambda region: data_utils.create_r2_client(region or
+                                                                      'auto'),
+            resource_factory=lambda name: cloudflare.resource('s3').Bucket(name
+                                                                          ),
+            split_path=data_utils.split_r2_path,
+            verify_bucket=data_utils.verify_r2_bucket,
+            credentials_file=cloudflare.R2_CREDENTIALS_PATH,
+            aws_profile=cloudflare.R2_PROFILE_NAME,
+            get_endpoint_url=lambda: cloudflare.create_endpoint(),  # pylint: disable=unnecessary-lambda
+            extra_cli_args=['--checksum-algorithm', 'CRC32'],  # R2 specific
+            cloud_name=cloudflare.NAME,
+            default_region='auto',
+            mount_cmd_factory=mounting_utils.get_r2_mount_cmd,
+        )
+
+    def mount_cached_command(self, mount_path: str) -> str:
+        """R2-specific cached mount implementation using rclone."""
+        install_cmd = mounting_utils.get_rclone_install_cmd()
+        rclone_profile_name = (
+            data_utils.Rclone.RcloneStores.R2.get_profile_name(self.name))
+        rclone_config = data_utils.Rclone.RcloneStores.R2.get_config(
+            rclone_profile_name=rclone_profile_name)
+        mount_cached_cmd = mounting_utils.get_mount_cached_cmd(
+            rclone_config, rclone_profile_name, self.bucket.name, mount_path)
+        return mounting_utils.get_mounting_command(mount_path, install_cmd,
+                                                   mount_cached_cmd)
+
+
+@register_s3_compatible_store
+class NebiusStore(S3CompatibleStore):
+    """NebiusStore inherits from S3CompatibleStore and represents the backend
+    for Nebius Object Storage buckets.
+    """
 
-    def _delete_nebius_bucket_sub_path(self, bucket_name: str,
-                                       sub_path: str) -> bool:
-        """Deletes the sub path from the bucket."""
-        remove_command = (
-            f'aws s3 rm s3://{bucket_name}/{sub_path}/ --recursive '
-            f'--profile={nebius.NEBIUS_PROFILE_NAME}')
-        return self._execute_nebius_remove_command(
-            remove_command, bucket_name, f'Removing objects from '
-            f'Nebius bucket {bucket_name}/{sub_path}',
-            f'Failed to remove objects from '
-            f'Nebius bucket {bucket_name}/{sub_path}.')
+    @classmethod
+    def get_config(cls) -> S3CompatibleConfig:
+        """Return the configuration for Nebius Object Storage."""
+        return S3CompatibleConfig(
+            store_type='NEBIUS',
+            url_prefix='nebius://',
+            client_factory=lambda region: data_utils.create_nebius_client(),
+            resource_factory=lambda name: nebius.resource('s3').Bucket(name),
+            split_path=data_utils.split_nebius_path,
+            verify_bucket=data_utils.verify_nebius_bucket,
+            aws_profile=nebius.NEBIUS_PROFILE_NAME,
+            cloud_name=str(clouds.Nebius()),
+            mount_cmd_factory=cls._get_nebius_mount_cmd,
+        )
+
+    @classmethod
+    def _get_nebius_mount_cmd(cls, bucket_name: str, mount_path: str,
+                              bucket_sub_path: Optional[str]) -> str:
+        """Factory method for Nebius mount command."""
+        # We need to get the endpoint URL, but since this is a static method,
+        # we'll need to create a client to get it
+        client = data_utils.create_nebius_client()
+        endpoint_url = client.meta.endpoint_url
+        return mounting_utils.get_nebius_mount_cmd(nebius.NEBIUS_PROFILE_NAME,
+                                                   bucket_name, endpoint_url,
+                                                   mount_path, bucket_sub_path)