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

sky/data/storage.py

@@ -1,5 +1,6 @@
 """Storage and Store Classes for Sky Data."""
 import enum
+import hashlib
 import os
 import re
 import shlex
@@ -16,19 +17,23 @@ from sky import clouds
 from sky import exceptions
 from sky import global_user_state
 from sky import sky_logging
-from sky import status_lib
+from sky import skypilot_config
 from sky.adaptors import aws
+from sky.adaptors import azure
 from sky.adaptors import cloudflare
 from sky.adaptors import gcp
 from sky.adaptors import ibm
+from sky.adaptors import oci
 from sky.data import data_transfer
 from sky.data import data_utils
 from sky.data import mounting_utils
 from sky.data import storage_utils
 from sky.data.data_utils import Rclone
+from sky.skylet import constants
 from sky.utils import common_utils
 from sky.utils import rich_utils
 from sky.utils import schemas
+from sky.utils import status_lib
 from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
@@ -49,7 +54,10 @@ SourceType = Union[Path, List[Path]]
 STORE_ENABLED_CLOUDS: List[str] = [
     str(clouds.AWS()),
     str(clouds.GCP()),
-    str(clouds.IBM()), cloudflare.NAME
+    str(clouds.Azure()),
+    str(clouds.IBM()),
+    str(clouds.OCI()),
+    cloudflare.NAME,
 ]
 
 # Maximum number of concurrent rsync upload processes
@@ -67,6 +75,8 @@ _BUCKET_EXTERNALLY_DELETED_DEBUG_MESSAGE = (
     'Bucket {bucket_name!r} does not exist. '
     'It may have been deleted externally.')
 
+_STORAGE_LOG_FILE_NAME = 'storage_sync.log'
+
 
 def get_cached_enabled_storage_clouds_or_refresh(
         raise_if_no_cloud_access: bool = False) -> List[str]:
@@ -108,6 +118,7 @@ class StoreType(enum.Enum):
     AZURE = 'AZURE'
     R2 = 'R2'
     IBM = 'IBM'
+    OCI = 'OCI'
 
     @classmethod
     def from_cloud(cls, cloud: str) -> 'StoreType':
@@ -120,8 +131,9 @@ class StoreType(enum.Enum):
         elif cloud.lower() == cloudflare.NAME.lower():
             return StoreType.R2
         elif cloud.lower() == str(clouds.Azure()).lower():
-            with ux_utils.print_exception_no_traceback():
-                raise ValueError('Azure Blob Storage is not supported yet.')
+            return StoreType.AZURE
+        elif cloud.lower() == str(clouds.OCI()).lower():
+            return StoreType.OCI
         elif cloud.lower() == str(clouds.Lambda()).lower():
             with ux_utils.print_exception_no_traceback():
                 raise ValueError('Lambda Cloud does not provide cloud storage.')
@@ -137,10 +149,14 @@ class StoreType(enum.Enum):
             return StoreType.S3
         elif 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
         else:
             with ux_utils.print_exception_no_traceback():
                 raise ValueError(f'Unknown store type: {store}')
@@ -150,17 +166,73 @@ class StoreType(enum.Enum):
             return 's3://'
         elif 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.AZURE:
-            with ux_utils.print_exception_no_traceback():
-                raise ValueError('Azure Blob Storage is not supported yet.')
+        elif self == StoreType.OCI:
+            return 'oci://'
         else:
             with ux_utils.print_exception_no_traceback():
                 raise ValueError(f'Unknown store type: {self}')
 
+    @classmethod
+    def get_endpoint_url(cls, store: 'AbstractStore', path: str) -> str:
+        """Generates the endpoint URL for a given store and path.
+
+        Args:
+            store: Store object implementing AbstractStore.
+            path: Path within the store.
+
+        Returns:
+            Endpoint URL of the bucket as a string.
+        """
+        store_type = cls.from_store(store)
+        if store_type == StoreType.AZURE:
+            assert isinstance(store, AzureBlobStore)
+            storage_account_name = store.storage_account_name
+            bucket_endpoint_url = data_utils.AZURE_CONTAINER_URL.format(
+                storage_account_name=storage_account_name, container_name=path)
+        else:
+            bucket_endpoint_url = f'{store_type.store_prefix()}{path}'
+        return bucket_endpoint_url
+
+    @classmethod
+    def get_fields_from_store_url(
+        cls, store_url: str
+    ) -> Tuple['StoreType', str, str, Optional[str], Optional[str]]:
+        """Returns the store type, bucket name, and sub path from
+        a store URL, and the storage account name and region if applicable.
+
+        Args:
+            store_url: str; The store URL.
+        """
+        # The full path from the user config of IBM COS contains the region,
+        # and Azure Blob Storage contains the storage account name, we need to
+        # pass these information to the store constructor.
+        storage_account_name = None
+        region = None
+        for store_type in StoreType:
+            if store_url.startswith(store_type.store_prefix()):
+                if store_type == StoreType.AZURE:
+                    storage_account_name, bucket_name, sub_path = \
+                        data_utils.split_az_path(store_url)
+                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)
+                return store_type, bucket_name, \
+                    sub_path, storage_account_name, region
+        raise ValueError(f'Unknown store URL: {store_url}')
+
 
 class StorageMode(enum.Enum):
     MOUNT = 'MOUNT'
@@ -187,25 +259,29 @@ class AbstractStore:
                      name: str,
                      source: Optional[SourceType],
                      region: Optional[str] = None,
-                     is_sky_managed: Optional[bool] = None):
+                     is_sky_managed: Optional[bool] = None,
+                     _bucket_sub_path: Optional[str] = None):
             self.name = name
             self.source = source
             self.region = region
             self.is_sky_managed = is_sky_managed
+            self._bucket_sub_path = _bucket_sub_path
 
         def __repr__(self):
             return (f'StoreMetadata('
                     f'\n\tname={self.name},'
                     f'\n\tsource={self.source},'
                     f'\n\tregion={self.region},'
-                    f'\n\tis_sky_managed={self.is_sky_managed})')
+                    f'\n\tis_sky_managed={self.is_sky_managed},'
+                    f'\n\t_bucket_sub_path={self._bucket_sub_path})')
 
     def __init__(self,
                  name: str,
                  source: Optional[SourceType],
                  region: Optional[str] = None,
                  is_sky_managed: Optional[bool] = None,
-                 sync_on_reconstruction: Optional[bool] = True):
+                 sync_on_reconstruction: Optional[bool] = True,
+                 _bucket_sub_path: Optional[str] = None):  # pylint: disable=invalid-name
         """Initialize AbstractStore
 
         Args:
@@ -219,7 +295,11 @@ class AbstractStore:
               there. This is set to false when the Storage object is created not
               for direct use, e.g. for 'sky storage delete', or the storage is
               being re-used, e.g., for `sky start` on a stopped cluster.
-
+            _bucket_sub_path: str; The prefix of the bucket directory to be
+              created in the store, e.g. if _bucket_sub_path=my-dir, the files
+              will be uploaded to s3://<bucket>/my-dir/.
+              This only works if source is a local directory.
+              # TODO(zpoint): Add support for non-local source.
         Raises:
             StorageBucketCreateError: If bucket creation fails
             StorageBucketGetError: If fetching existing bucket fails
@@ -230,10 +310,29 @@ class AbstractStore:
         self.region = region
         self.is_sky_managed = is_sky_managed
         self.sync_on_reconstruction = sync_on_reconstruction
+
+        # To avoid mypy error
+        self._bucket_sub_path: Optional[str] = None
+        # Trigger the setter to strip any leading/trailing slashes.
+        self.bucket_sub_path = _bucket_sub_path
         # Whether sky is responsible for the lifecycle of the Store.
         self._validate()
         self.initialize()
 
+    @property
+    def bucket_sub_path(self) -> Optional[str]:
+        """Get the bucket_sub_path."""
+        return self._bucket_sub_path
+
+    @bucket_sub_path.setter
+    # pylint: disable=invalid-name
+    def bucket_sub_path(self, bucket_sub_path: Optional[str]) -> None:
+        """Set the bucket_sub_path, stripping any leading/trailing slashes."""
+        if bucket_sub_path is not None:
+            self._bucket_sub_path = bucket_sub_path.strip('/')
+        else:
+            self._bucket_sub_path = None
+
     @classmethod
     def from_metadata(cls, metadata: StoreMetadata, **override_args):
         """Create a Store from a StoreMetadata object.
@@ -241,19 +340,27 @@ class AbstractStore:
         Used when reconstructing Storage and Store objects from
         global_user_state.
         """
-        return cls(name=override_args.get('name', metadata.name),
-                   source=override_args.get('source', metadata.source),
-                   region=override_args.get('region', metadata.region),
-                   is_sky_managed=override_args.get('is_sky_managed',
-                                                    metadata.is_sky_managed),
-                   sync_on_reconstruction=override_args.get(
-                       'sync_on_reconstruction', True))
+        return cls(
+            name=override_args.get('name', metadata.name),
+            source=override_args.get('source', metadata.source),
+            region=override_args.get('region', metadata.region),
+            is_sky_managed=override_args.get('is_sky_managed',
+                                             metadata.is_sky_managed),
+            sync_on_reconstruction=override_args.get('sync_on_reconstruction',
+                                                     True),
+            # Backward compatibility
+            # TODO: remove the hasattr check after v0.11.0
+            _bucket_sub_path=override_args.get(
+                '_bucket_sub_path',
+                metadata._bucket_sub_path  # pylint: disable=protected-access
+            ) if hasattr(metadata, '_bucket_sub_path') else None)
 
     def get_metadata(self) -> StoreMetadata:
         return self.StoreMetadata(name=self.name,
                                   source=self.source,
                                   region=self.region,
-                                  is_sky_managed=self.is_sky_managed)
+                                  is_sky_managed=self.is_sky_managed,
+                                  _bucket_sub_path=self._bucket_sub_path)
 
     def initialize(self):
         """Initializes the Store object on the cloud.
@@ -281,7 +388,11 @@ class AbstractStore:
         raise NotImplementedError
 
     def delete(self) -> None:
-        """Removes the Storage object from the cloud."""
+        """Removes the Storage from the cloud."""
+        raise NotImplementedError
+
+    def _delete_sub_path(self) -> None:
+        """Removes objects from the sub path in the bucket."""
         raise NotImplementedError
 
     def get_handle(self) -> StorageHandle:
@@ -338,8 +449,9 @@ class AbstractStore:
             # externally created buckets, users must provide the
             # bucket's URL as 'source'.
             if handle is None:
+                source_endpoint = StoreType.get_endpoint_url(store=self,
+                                                             path=self.name)
                 with ux_utils.print_exception_no_traceback():
-                    store_prefix = StoreType.from_store(self).store_prefix()
                     raise exceptions.StorageSpecError(
                         'Attempted to mount a non-sky managed bucket '
                         f'{self.name!r} without specifying the storage source.'
@@ -350,7 +462,7 @@ class AbstractStore:
                         'specify the bucket URL in the source field '
                         'instead of its name. I.e., replace '
                         f'`name: {self.name}` with '
-                        f'`source: {store_prefix}{self.name}`.')
+                        f'`source: {source_endpoint}`.')
 
 
 class Storage(object):
@@ -424,13 +536,19 @@ class Storage(object):
             if storetype in self.sky_stores:
                 del self.sky_stores[storetype]
 
-    def __init__(self,
-                 name: Optional[str] = None,
-                 source: Optional[SourceType] = None,
-                 stores: Optional[Dict[StoreType, AbstractStore]] = None,
-                 persistent: Optional[bool] = True,
-                 mode: StorageMode = StorageMode.MOUNT,
-                 sync_on_reconstruction: bool = True) -> None:
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        source: Optional[SourceType] = None,
+        stores: Optional[List[StoreType]] = None,
+        persistent: Optional[bool] = True,
+        mode: StorageMode = StorageMode.MOUNT,
+        sync_on_reconstruction: bool = True,
+        # pylint: disable=invalid-name
+        _is_sky_managed: Optional[bool] = None,
+        # pylint: disable=invalid-name
+        _bucket_sub_path: Optional[str] = None
+    ) -> None:
         """Initializes a Storage object.
 
         Three fields are required: the name of the storage, the source
@@ -468,25 +586,60 @@ class Storage(object):
             there. This is set to false when the Storage object is created not
             for direct use, e.g. for 'sky storage delete', or the storage is
             being re-used, e.g., for `sky start` on a stopped cluster.
+          _is_sky_managed: Optional[bool]; Indicates if the storage is managed
+            by Sky. Without this argument, the controller's behavior differs
+            from the local machine. For example, if a bucket does not exist:
+            Local Machine (is_sky_managed=True) →
+            Controller (is_sky_managed=False).
+            With this argument, the controller aligns with the local machine,
+            ensuring it retains the is_sky_managed information from the YAML.
+            During teardown, if is_sky_managed is True, the controller should
+            delete the bucket. Otherwise, it might mistakenly delete only the
+            sub-path, assuming is_sky_managed is False.
+          _bucket_sub_path: Optional[str]; The subdirectory to use for the
+            storage object.
         """
-        self.name: str
+        self.name = name
         self.source = source
         self.persistent = persistent
         self.mode = mode
         assert mode in StorageMode
+        self.stores: Dict[StoreType, Optional[AbstractStore]] = {}
+        if stores is not None:
+            for store in stores:
+                self.stores[store] = None
         self.sync_on_reconstruction = sync_on_reconstruction
+        self._is_sky_managed = _is_sky_managed
+        self._bucket_sub_path = _bucket_sub_path
 
+        self._constructed = False
         # TODO(romilb, zhwu): This is a workaround to support storage deletion
-        # for spot. Once sky storage supports forced management for external
-        # buckets, this can be deprecated.
+        # for managed jobs. Once sky storage supports forced management for
+        # external buckets, this can be deprecated.
         self.force_delete = False
 
-        # Validate and correct inputs if necessary
-        self._validate_storage_spec(name)
+    def construct(self):
+        """Constructs the storage object.
+
+        The Storage object is lazily initialized, so that when a user
+        initializes a Storage object on client side, it does not trigger the
+        actual storage creation on the client side.
+
+        Instead, once the specification of the storage object is uploaded to the
+        SkyPilot API server side, the server side should use this construct()
+        method to actually create the storage object. The construct() method
+        will:
+
+        1. Set the stores field if not specified
+        2. Create the bucket or check the existence of the bucket
+        3. Sync the data from the source to the bucket if necessary
+        """
+        if self._constructed:
+            return
+        self._constructed = True
 
-        # Sky optimizer either adds a storage object instance or selects
-        # from existing ones
-        self.stores = {} if stores is None else stores
+        # Validate and correct inputs if necessary
+        self._validate_storage_spec(self.name)
 
         # Logic to rebuild Storage if it is in global user state
         handle = global_user_state.get_handle_from_storage_name(self.name)
@@ -497,6 +650,28 @@ class Storage(object):
                          f'loading Storage: {self.name}')
             self._add_store_from_metadata(self.handle.sky_stores)
 
+            # When a storage object is reconstructed from global_user_state,
+            # the user may have specified a new store type in the yaml file that
+            # was not used with the storage object. We should error out in this
+            # case, as we don't support having multiple stores for the same
+            # storage object.
+            if any(s is None for s in self.stores.values()):
+                new_store_type = None
+                previous_store_type = None
+                for store_type, store in self.stores.items():
+                    if store is not None:
+                        previous_store_type = store_type
+                    else:
+                        new_store_type = store_type
+                with ux_utils.print_exception_no_traceback():
+                    raise exceptions.StorageBucketCreateError(
+                        f'Bucket {self.name} was previously created for '
+                        f'{previous_store_type.value.lower()!r}, but a new '
+                        f'store type {new_store_type.value.lower()!r} is '
+                        'requested. This is not supported yet. Please specify '
+                        'the same store type: '
+                        f'{previous_store_type.value.lower()!r}.')
+
             # TODO(romilb): This logic should likely be in add_store to move
             # syncing to file_mount stage..
             if self.sync_on_reconstruction:
@@ -510,15 +685,16 @@ class Storage(object):
 
         else:
             # Storage does not exist in global_user_state, create new stores
-            sky_managed_stores = {
-                t: s.get_metadata()
-                for t, s in self.stores.items()
-                if s.is_sky_managed
-            }
+            # Sky optimizer either adds a storage object instance or selects
+            # from existing ones
+            input_stores = self.stores
+            self.stores = {}
             self.handle = self.StorageMetadata(storage_name=self.name,
                                                source=self.source,
-                                               mode=self.mode,
-                                               sky_stores=sky_managed_stores)
+                                               mode=self.mode)
+
+            for store in input_stores:
+                self.add_store(store)
 
             if self.source is not None:
                 # If source is a pre-existing bucket, connect to the bucket
@@ -528,10 +704,20 @@ class Storage(object):
                         self.add_store(StoreType.S3)
                     elif 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)
+
+    def get_bucket_sub_path_prefix(self, blob_path: str) -> str:
+        """Adds the bucket sub path prefix to the blob path."""
+        if self._bucket_sub_path is not None:
+            return f'{blob_path}/{self._bucket_sub_path}'
+        return blob_path
 
     @staticmethod
     def _validate_source(
@@ -612,15 +798,16 @@ class Storage(object):
                             'using a bucket by writing <destination_path>: '
                             f'{source} in the file_mounts section of your YAML')
                 is_local_source = True
-            elif split_path.scheme in ['s3', 'gs', 'r2', 'cos']:
+            elif split_path.scheme in ['s3', 'gs', 'https', 'r2', 'cos', 'oci']:
                 is_local_source = False
                 # Storage mounting does not support mounting specific files from
                 # cloud store - ensure path points to only a directory
                 if mode == StorageMode.MOUNT:
-                    if ((not split_path.scheme == 'cos' and
-                         split_path.path.strip('/') != '') or
-                        (split_path.scheme == 'cos' and
-                         not re.match(r'^/[-\w]+(/\s*)?$', split_path.path))):
+                    if (split_path.scheme != 'https' and
+                        ((split_path.scheme != 'cos' and
+                          split_path.path.strip('/') != '') or
+                         (split_path.scheme == 'cos' and
+                          not re.match(r'^/[-\w]+(/\s*)?$', split_path.path)))):
                         # regex allows split_path.path to include /bucket
                         # or /bucket/optional_whitespaces while considering
                         # cos URI's regions (cos://region/bucket_name)
@@ -634,8 +821,8 @@ class Storage(object):
             else:
                 with ux_utils.print_exception_no_traceback():
                     raise exceptions.StorageSourceError(
-                        f'Supported paths: local, s3://, gs://, '
-                        f'r2://, cos://. Got: {source}')
+                        f'Supported paths: local, s3://, gs://, https://, '
+                        f'r2://, cos://, oci://. Got: {source}')
         return source, is_local_source
 
     def _validate_storage_spec(self, name: Optional[str]) -> None:
@@ -650,7 +837,7 @@ class Storage(object):
             """
             prefix = name.split('://')[0]
             prefix = prefix.lower()
-            if prefix in ['s3', 'gs', 'r2', 'cos']:
+            if prefix in ['s3', 'gs', 'https', 'r2', 'cos', 'oci']:
                 with ux_utils.print_exception_no_traceback():
                     raise exceptions.StorageNameError(
                         'Prefix detected: `name` cannot start with '
@@ -701,6 +888,8 @@ class Storage(object):
                     if source.startswith('cos://'):
                         # cos url requires custom parsing
                         name = data_utils.split_cos_path(source)[0]
+                    elif data_utils.is_az_container_endpoint(source):
+                        _, name, _ = data_utils.split_az_path(source)
                     else:
                         name = urllib.parse.urlsplit(source).netloc
                     assert name is not None, source
@@ -740,33 +929,59 @@ class Storage(object):
                     store = S3Store.from_metadata(
                         s_metadata,
                         source=self.source,
-                        sync_on_reconstruction=self.sync_on_reconstruction)
+                        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,
                         source=self.source,
-                        sync_on_reconstruction=self.sync_on_reconstruction)
+                        sync_on_reconstruction=self.sync_on_reconstruction,
+                        _bucket_sub_path=self._bucket_sub_path)
+                elif s_type == StoreType.AZURE:
+                    assert isinstance(s_metadata,
+                                      AzureBlobStore.AzureBlobStoreMetadata)
+                    store = AzureBlobStore.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)
+                        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,
                         source=self.source,
-                        sync_on_reconstruction=self.sync_on_reconstruction)
+                        sync_on_reconstruction=self.sync_on_reconstruction,
+                        _bucket_sub_path=self._bucket_sub_path)
+                elif s_type == StoreType.OCI:
+                    store = OciStore.from_metadata(
+                        s_metadata,
+                        source=self.source,
+                        sync_on_reconstruction=self.sync_on_reconstruction,
+                        _bucket_sub_path=self._bucket_sub_path)
                 else:
                     with ux_utils.print_exception_no_traceback():
                         raise ValueError(f'Unknown store type: {s_type}')
-            # Following error is raised from _get_bucket and caught only when
-            # an externally removed storage is attempted to be fetched.
-            except exceptions.StorageExternalDeletionError:
-                logger.debug(f'Storage object {self.name!r} was attempted to '
-                             'be reconstructed while the corresponding bucket'
-                             ' was externally deleted.')
+            # Following error is caught when an externally removed storage
+            # is attempted to be fetched.
+            except exceptions.StorageExternalDeletionError as e:
+                if isinstance(e, exceptions.NonExistentStorageAccountError):
+                    assert isinstance(s_metadata,
+                                      AzureBlobStore.AzureBlobStoreMetadata)
+                    logger.debug(f'Storage object {self.name!r} was attempted '
+                                 'to be reconstructed while the corresponding '
+                                 'storage account '
+                                 f'{s_metadata.storage_account_name!r} does '
+                                 'not exist.')
+                else:
+                    logger.debug(f'Storage object {self.name!r} was attempted '
+                                 'to be reconstructed while the corresponding '
+                                 'bucket was externally deleted.')
                 continue
-
             self._add_store(store, is_reconstructed=True)
 
     @classmethod
@@ -810,41 +1025,60 @@ class Storage(object):
           region: str; Region to place the bucket in. Caller must ensure that
             the region is valid for the chosen store_type.
         """
+        assert self._constructed, self
+        assert self.name is not None, self
+
         if isinstance(store_type, str):
             store_type = StoreType(store_type)
 
-        if store_type in self.stores:
-            logger.info(f'Storage type {store_type} already exists.')
-            return self.stores[store_type]
+        if self.stores.get(store_type) is not None:
+            if store_type == StoreType.AZURE:
+                azure_store_obj = self.stores[store_type]
+                assert isinstance(azure_store_obj, AzureBlobStore)
+                storage_account_name = azure_store_obj.storage_account_name
+                logger.info(f'Storage type {store_type} already exists under '
+                            f'storage account {storage_account_name!r}.')
+            else:
+                logger.info(f'Storage type {store_type} already exists.')
+            store = self.stores[store_type]
+            assert store is not None, self
+            return store
 
         store_cls: Type[AbstractStore]
         if store_type == StoreType.S3:
             store_cls = S3Store
         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
         else:
             with ux_utils.print_exception_no_traceback():
                 raise exceptions.StorageSpecError(
                     f'{store_type} not supported as a Store.')
-
-        # Initialize store object and get/create bucket
         try:
             store = store_cls(
                 name=self.name,
                 source=self.source,
                 region=region,
-                sync_on_reconstruction=self.sync_on_reconstruction)
+                sync_on_reconstruction=self.sync_on_reconstruction,
+                is_sky_managed=self._is_sky_managed,
+                _bucket_sub_path=self._bucket_sub_path)
         except exceptions.StorageBucketCreateError:
             # Creation failed, so this must be sky managed store. Add failure
             # to state.
             logger.error(f'Could not create {store_type} store '
                          f'with name {self.name}.')
-            global_user_state.set_storage_status(self.name,
-                                                 StorageStatus.INIT_FAILED)
+            try:
+                global_user_state.set_storage_status(self.name,
+                                                     StorageStatus.INIT_FAILED)
+            except ValueError as e:
+                logger.error(f'Error setting storage status: {e}')
             raise
         except exceptions.StorageBucketGetError:
             # Bucket get failed, so this is not sky managed. Do not update state
@@ -876,6 +1110,7 @@ class Storage(object):
         if store.is_sky_managed:
             self.handle.add_store(store)
             if not is_reconstructed:
+                assert self.name is not None, self
                 global_user_state.add_or_update_storage(self.name, self.handle,
                                                         StorageStatus.INIT)
 
@@ -891,9 +1126,12 @@ class Storage(object):
         """
         if not self.stores:
             logger.info('No backing stores found. Deleting storage.')
+            assert self.name is not None
             global_user_state.remove_storage(self.name)
-        if store_type:
+        if store_type is not None:
+            assert self.name is not None
             store = self.stores[store_type]
+            assert store is not None, self
             is_sky_managed = store.is_sky_managed
             # We delete a store from the cloud if it's sky managed. Else just
             # remove handle and return
@@ -902,8 +1140,12 @@ class Storage(object):
                 store.delete()
                 # Check remaining stores - if none is sky managed, remove
                 # the storage from global_user_state.
-                delete = all(
-                    s.is_sky_managed is False for s in self.stores.values())
+                delete = True
+                for store in self.stores.values():
+                    assert store is not None, self
+                    if store.is_sky_managed:
+                        delete = False
+                        break
                 if delete:
                     global_user_state.remove_storage(self.name)
                 else:
@@ -914,6 +1156,7 @@ class Storage(object):
             del self.stores[store_type]
         else:
             for _, store in self.stores.items():
+                assert store is not None, self
                 if store.is_sky_managed:
                     self.handle.remove_store(store)
                     store.delete()
@@ -921,15 +1164,19 @@ class Storage(object):
                     store.delete()
             self.stores = {}
             # Remove storage from global_user_state if present
-            global_user_state.remove_storage(self.name)
+            if self.name is not None:
+                global_user_state.remove_storage(self.name)
 
     def sync_all_stores(self):
         """Syncs the source and destinations of all stores in the Storage"""
         for _, store in self.stores.items():
+            assert store is not None, self
             self._sync_store(store)
 
     def _sync_store(self, store: AbstractStore):
         """Runs the upload routine for the store and handles failures"""
+        assert self._constructed, self
+        assert self.name is not None, self
 
         def warn_for_git_dir(source: str):
             if os.path.isdir(os.path.join(source, '.git')):
@@ -960,12 +1207,15 @@ class Storage(object):
     def from_yaml_config(cls, config: Dict[str, Any]) -> 'Storage':
         common_utils.validate_schema(config, schemas.get_storage_schema(),
                                      'Invalid storage YAML: ')
-
         name = config.pop('name', None)
         source = config.pop('source', None)
         store = config.pop('store', None)
         mode_str = config.pop('mode', None)
         force_delete = config.pop('_force_delete', None)
+        # pylint: disable=invalid-name
+        _is_sky_managed = config.pop('_is_sky_managed', None)
+        # pylint: disable=invalid-name
+        _bucket_sub_path = config.pop('_bucket_sub_path', None)
         if force_delete is None:
             force_delete = False
 
@@ -982,18 +1232,23 @@ class Storage(object):
         assert not config, f'Invalid storage args: {config.keys()}'
 
         # Validation of the config object happens on instantiation.
+        if store is not None:
+            stores = [StoreType(store.upper())]
+        else:
+            stores = None
         storage_obj = cls(name=name,
                           source=source,
                           persistent=persistent,
-                          mode=mode)
-        if store is not None:
-            storage_obj.add_store(StoreType(store.upper()))
+                          mode=mode,
+                          stores=stores,
+                          _is_sky_managed=_is_sky_managed,
+                          _bucket_sub_path=_bucket_sub_path)
 
         # Add force deletion flag
         storage_obj.force_delete = force_delete
         return storage_obj
 
-    def to_yaml_config(self) -> Dict[str, str]:
+    def to_yaml_config(self) -> Dict[str, Any]:
         config = {}
 
         def add_if_not_none(key: str, value: Optional[Any]):
@@ -1009,13 +1264,20 @@ class Storage(object):
         add_if_not_none('source', self.source)
 
         stores = None
-        if len(self.stores) > 0:
+        is_sky_managed = self._is_sky_managed
+        if self.stores:
             stores = ','.join([store.value for store in self.stores])
+            store = list(self.stores.values())[0]
+            if store is not None:
+                is_sky_managed = store.is_sky_managed
         add_if_not_none('store', stores)
+        add_if_not_none('_is_sky_managed', is_sky_managed)
         add_if_not_none('persistent', self.persistent)
         add_if_not_none('mode', self.mode.value)
         if self.force_delete:
             config['_force_delete'] = True
+        if self._bucket_sub_path is not None:
+            config['_bucket_sub_path'] = self._bucket_sub_path
         return config
 
 
@@ -1024,18 +1286,34 @@ class S3Store(AbstractStore):
     for S3 buckets.
     """
 
+    _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] = 'us-east-2',
+                 region: Optional[str] = _DEFAULT_REGION,
                  is_sky_managed: Optional[bool] = None,
-                 sync_on_reconstruction: bool = True):
+                 sync_on_reconstruction: bool = True,
+                 _bucket_sub_path: Optional[str] = None):
         self.client: 'boto3.client.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
         super().__init__(name, source, region, is_sky_managed,
-                         sync_on_reconstruction)
+                         sync_on_reconstruction, _bucket_sub_path)
 
     def _validate(self):
         if self.source is not None and isinstance(self.source, str):
@@ -1050,6 +1328,16 @@ class S3Store(AbstractStore):
                 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 '
@@ -1064,6 +1352,9 @@ class S3Store(AbstractStore):
                 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.')
         # Validate name
         self.name = self.validate_name(self.name)
 
@@ -1074,11 +1365,11 @@ class S3Store(AbstractStore):
                     'Storage \'store: s3\' specified, but ' \
                     'AWS access is disabled. To fix, enable '\
                     'AWS by running `sky check`. More info: '\
-                    'https://skypilot.readthedocs.io/en/latest/getting-started/installation.html.' # pylint: disable=line-too-long
+                    'https://docs.skypilot.co/en/latest/getting-started/installation.html.' # pylint: disable=line-too-long
                     )
 
     @classmethod
-    def validate_name(cls, name) -> str:
+    def validate_name(cls, name: str) -> str:
         """Validates the name of the S3 store.
 
         Source for rules: https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html # pylint: disable=line-too-long
@@ -1175,6 +1466,8 @@ class S3Store(AbstractStore):
                     self._transfer_to_s3()
                 elif self.source.startswith('r2://'):
                     self._transfer_to_s3()
+                elif self.source.startswith('oci://'):
+                    self._transfer_to_s3()
                 else:
                     self.batch_aws_rsync([self.source])
         except exceptions.StorageUploadError:
@@ -1184,6 +1477,9 @@ class S3Store(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_s3_bucket(self.name)
         if deleted_by_skypilot:
             msg_str = f'Deleted S3 bucket {self.name}.'
@@ -1193,6 +1489,19 @@ class S3Store(AbstractStore):
         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}')
+
     def get_handle(self) -> StorageHandle:
         return aws.resource('s3').Bucket(self.name)
 
@@ -1216,6 +1525,8 @@ class S3Store(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}'
+                    if self._bucket_sub_path else '')
 
         def get_file_sync_command(base_dir_path, file_names):
             includes = ' '.join([
@@ -1225,13 +1536,12 @@ class S3Store(AbstractStore):
             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}')
+                            f's3://{self.name}{sub_path}')
             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_from_gitignore(
-                src_dir_path)
+            excluded_list = storage_utils.get_excluded_files(src_dir_path)
             excluded_list.append('.git/*')
             excludes = ' '.join([
                 f'--exclude {shlex.quote(file_name)}'
@@ -1240,7 +1550,7 @@ class S3Store(AbstractStore):
             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}/{dest_dir_name}')
+                            f's3://{self.name}{sub_path}/{dest_dir_name}')
             return sync_command
 
         # Generate message for upload
@@ -1249,17 +1559,24 @@ class S3Store(AbstractStore):
         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} -> s3://{self.name}{sub_path}/'
         with rich_utils.safe_status(
-                f'[bold cyan]Syncing '
-                f'[green]{source_message}[/] to [green]s3://{self.name}/[/]'):
+                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 _transfer_to_s3(self) -> None:
         assert isinstance(self.source, str), self.source
@@ -1351,13 +1668,14 @@ class S3Store(AbstractStore):
         """
         install_cmd = mounting_utils.get_s3_mount_install_cmd()
         mount_cmd = mounting_utils.get_s3_mount_cmd(self.bucket.name,
-                                                    mount_path)
+                                                    mount_path,
+                                                    self._bucket_sub_path)
         return mounting_utils.get_mounting_command(mount_path, install_cmd,
                                                    mount_cmd)
 
     def _create_s3_bucket(self,
                           bucket_name: str,
-                          region='us-east-2') -> StorageHandle:
+                          region=_DEFAULT_REGION) -> StorageHandle:
         """Creates S3 bucket with specific name in specific region
 
         Args:
@@ -1368,26 +1686,60 @@ class S3Store(AbstractStore):
         """
         s3_client = self.client
         try:
-            if region is None:
-                s3_client.create_bucket(Bucket=bucket_name)
-            else:
-                if region == 'us-east-1':
-                    # If default us-east-1 region is used, the
-                    # LocationConstraint must not be specified.
-                    # https://stackoverflow.com/a/51912090
-                    s3_client.create_bucket(Bucket=bucket_name)
-                else:
-                    location = {'LocationConstraint': region}
-                    s3_client.create_bucket(Bucket=bucket_name,
-                                            CreateBucketConfiguration=location)
-                logger.info(f'Created S3 bucket {bucket_name} in {region}')
+            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':
+                create_bucket_config['CreateBucketConfiguration'] = {
+                    'LocationConstraint': region
+                }
+            s3_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}')
+
+            # Add AWS tags configured in config.yaml to the bucket.
+            # This is useful for cost tracking and external cleanup.
+            bucket_tags = skypilot_config.get_nested(('aws', 'labels'), {})
+            if bucket_tags:
+                s3_client.put_bucket_tagging(
+                    Bucket=bucket_name,
+                    Tagging={
+                        'TagSet': [{
+                            'Key': k,
+                            '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 '
-                    f'{self.name} but failed.') from e
+                    f'Attempted to create a bucket {self.name} but failed.'
+                ) from e
         return aws.resource('s3').Bucket(bucket_name)
 
+    def _execute_s3_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)
+        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_s3_bucket(self, bucket_name: str) -> bool:
         """Deletes S3 bucket, including all objects in bucket
 
@@ -1396,6 +1748,9 @@ class S3Store(AbstractStore):
 
         Returns:
          bool; True if bucket was deleted, False if it was deleted externally.
+
+        Raises:
+            StorageBucketDeleteError: If deleting the bucket fails.
         """
         # Deleting objects is very slow programatically
         # (i.e. bucket.objects.all().delete() is slow).
@@ -1405,28 +1760,28 @@ class S3Store(AbstractStore):
         # 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'
-        try:
-            with rich_utils.safe_status(
-                    f'[bold cyan]Deleting S3 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'):
-                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 S3 bucket {bucket_name}.')
+        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
 
         # Wait until bucket deletion propagates on AWS servers
         while data_utils.verify_s3_bucket(bucket_name):
             time.sleep(0.1)
         return True
 
+    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}.'
+        )
+
 
 class GcsStore(AbstractStore):
     """GcsStore inherits from Storage Object and represents the backend
@@ -1440,47 +1795,53 @@ class GcsStore(AbstractStore):
                  source: str,
                  region: Optional[str] = 'us-central1',
                  is_sky_managed: Optional[bool] = None,
-                 sync_on_reconstruction: Optional[bool] = True):
+                 sync_on_reconstruction: Optional[bool] = True,
+                 _bucket_sub_path: Optional[str] = None):
         self.client: 'storage.Client'
         self.bucket: StorageHandle
         super().__init__(name, source, region, is_sky_managed,
-                         sync_on_reconstruction)
+                         sync_on_reconstruction, _bucket_sub_path)
 
     def _validate(self):
-        if self.source is not None:
-            if 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}, an 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.')
-                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('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 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}, an 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.')
+            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('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://'):
+                raise NotImplementedError(
+                    'Moving data from OCI to GCS is currently not supported.')
         # Validate name
         self.name = self.validate_name(self.name)
         # Check if the storage is enabled
@@ -1490,10 +1851,10 @@ class GcsStore(AbstractStore):
                     'Storage \'store: gcs\' specified, but '
                     'GCP access is disabled. To fix, enable '
                     'GCP by running `sky check`. '
-                    'More info: https://skypilot.readthedocs.io/en/latest/getting-started/installation.html.')  # pylint: disable=line-too-long
+                    'More info: https://docs.skypilot.co/en/latest/getting-started/installation.html.')  # pylint: disable=line-too-long
 
     @classmethod
-    def validate_name(cls, name) -> str:
+    def validate_name(cls, name: str) -> str:
         """Validates the name of the GCS store.
 
         Source for rules: https://cloud.google.com/storage/docs/buckets#naming
@@ -1589,6 +1950,8 @@ class GcsStore(AbstractStore):
                     self._transfer_to_gcs()
                 elif self.source.startswith('r2://'):
                     self._transfer_to_gcs()
+                elif self.source.startswith('oci://'):
+                    self._transfer_to_gcs()
                 else:
                     # If a single directory is specified in source, upload
                     # contents to root of bucket by suffixing /*.
@@ -1600,6 +1963,9 @@ class GcsStore(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_gcs_bucket(self.name)
         if deleted_by_skypilot:
             msg_str = f'Deleted GCS bucket {self.name}.'
@@ -1609,6 +1975,19 @@ class GcsStore(AbstractStore):
         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_gcs_bucket(self.name,
+                                                      self._bucket_sub_path)
+        if deleted_by_skypilot:
+            msg_str = f'Deleted objects in GCS bucket ' \
+                      f'{self.name}/{self._bucket_sub_path}.'
+        else:
+            msg_str = f'GCS bucket {self.name} may have ' \
+                      'been deleted externally.'
+        logger.info(f'{colorama.Fore.GREEN}{msg_str}'
+                    f'{colorama.Style.RESET_ALL}')
+
     def get_handle(self) -> StorageHandle:
         return self.client.get_bucket(self.name)
 
@@ -1641,15 +2020,23 @@ class GcsStore(AbstractStore):
         copy_list = '\n'.join(
             os.path.abspath(os.path.expanduser(p)) for p in source_path_list)
         gsutil_alias, alias_gen = data_utils.get_gsutil_command()
+        sub_path = (f'/{self._bucket_sub_path}'
+                    if self._bucket_sub_path else '')
         sync_command = (f'{alias_gen}; echo "{copy_list}" | {gsutil_alias} '
-                        f'cp -e -n -r -I gs://{self.name}')
-
+                        f'cp -e -n -r -I gs://{self.name}{sub_path}')
+        log_path = sky_logging.generate_tmp_logging_file_path(
+            _STORAGE_LOG_FILE_NAME)
+        sync_path = f'{source_message} -> gs://{self.name}{sub_path}/'
         with rich_utils.safe_status(
-                f'[bold cyan]Syncing '
-                f'[green]{source_message}[/] to [green]gs://{self.name}/[/]'):
+                ux_utils.spinner_message(f'Syncing {sync_path}',
+                                         log_path=log_path)):
             data_utils.run_upload_cli(sync_command,
                                       self._ACCESS_DENIED_MESSAGE,
-                                      bucket_name=self.name)
+                                      bucket_name=self.name,
+                                      log_path=log_path)
+        logger.info(
+            ux_utils.finishing_message(f'Storage synced: {sync_path}',
+                                       log_path))
 
     def batch_gsutil_rsync(self,
                            source_path_list: List[Path],
@@ -1671,6 +2058,8 @@ class GcsStore(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}'
+                    if self._bucket_sub_path else '')
 
         def get_file_sync_command(base_dir_path, file_names):
             sync_format = '|'.join(file_names)
@@ -1678,12 +2067,11 @@ class GcsStore(AbstractStore):
             base_dir_path = shlex.quote(base_dir_path)
             sync_command = (f'{alias_gen}; {gsutil_alias} '
                             f'rsync -e -x \'^(?!{sync_format}$).*\' '
-                            f'{base_dir_path} gs://{self.name}')
+                            f'{base_dir_path} gs://{self.name}{sub_path}')
             return sync_command
 
         def get_dir_sync_command(src_dir_path, dest_dir_name):
-            excluded_list = storage_utils.get_excluded_files_from_gitignore(
-                src_dir_path)
+            excluded_list = storage_utils.get_excluded_files(src_dir_path)
             # we exclude .git directory from the sync
             excluded_list.append(r'^\.git/.*$')
             excludes = '|'.join(excluded_list)
@@ -1691,7 +2079,7 @@ class GcsStore(AbstractStore):
             src_dir_path = shlex.quote(src_dir_path)
             sync_command = (f'{alias_gen}; {gsutil_alias} '
                             f'rsync -e -r -x \'({excludes})\' {src_dir_path} '
-                            f'gs://{self.name}/{dest_dir_name}')
+                            f'gs://{self.name}{sub_path}/{dest_dir_name}')
             return sync_command
 
         # Generate message for upload
@@ -1700,17 +2088,24 @@ class GcsStore(AbstractStore):
         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} -> gs://{self.name}{sub_path}/'
         with rich_utils.safe_status(
-                f'[bold cyan]Syncing '
-                f'[green]{source_message}[/] to [green]gs://{self.name}/[/]'):
+                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 _transfer_to_gcs(self) -> None:
         if isinstance(self.source, str) and self.source.startswith('s3://'):
@@ -1789,7 +2184,8 @@ class GcsStore(AbstractStore):
         """
         install_cmd = mounting_utils.get_gcs_mount_install_cmd()
         mount_cmd = mounting_utils.get_gcs_mount_cmd(self.bucket.name,
-                                                     mount_path)
+                                                     mount_path,
+                                                     self._bucket_sub_path)
         version_check_cmd = (
             f'gcsfuse --version | grep -q {mounting_utils.GCSFUSE_VERSION}')
         return mounting_utils.get_mounting_command(mount_path, install_cmd,
@@ -1824,22 +2220,43 @@ class GcsStore(AbstractStore):
                     f'Attempted to create a bucket {self.name} but failed.'
                 ) from e
         logger.info(
-            f'Created GCS bucket {new_bucket.name} in {new_bucket.location} '
-            f'with storage class {new_bucket.storage_class}')
+            f'  {colorama.Style.DIM}Created GCS bucket {new_bucket.name!r} in '
+            f'{new_bucket.location} with storage class '
+            f'{new_bucket.storage_class}{colorama.Style.RESET_ALL}')
         return new_bucket
 
-    def _delete_gcs_bucket(self, bucket_name: str) -> bool:
-        """Deletes GCS bucket, including all objects in bucket
+    def _delete_gcs_bucket(
+        self,
+        bucket_name: str,
+        # pylint: disable=invalid-name
+        _bucket_sub_path: Optional[str] = None
+    ) -> bool:
+        """Deletes objects in GCS bucket
 
         Args:
           bucket_name: str; Name of bucket
+          _bucket_sub_path: str; Sub path in the bucket, if provided only
+            objects in the sub path will be deleted, else the whole bucket will
+            be deleted
 
         Returns:
          bool; True if bucket was deleted, False if it was deleted externally.
-        """
 
+        Raises:
+            StorageBucketDeleteError: If deleting the bucket fails.
+            PermissionError: If the bucket is external and the user is not
+                allowed to delete it.
+        """
+        if _bucket_sub_path is not None:
+            command_suffix = f'/{_bucket_sub_path}'
+            hint_text = 'objects in '
+        else:
+            command_suffix = ''
+            hint_text = ''
         with rich_utils.safe_status(
-                f'[bold cyan]Deleting GCS bucket {bucket_name}[/]'):
+                ux_utils.spinner_message(
+                    f'Deleting {hint_text}GCS bucket '
+                    f'[green]{bucket_name}{command_suffix}[/]')):
             try:
                 self.client.get_bucket(bucket_name)
             except gcp.forbidden_exception() as e:
@@ -1857,37 +2274,126 @@ class GcsStore(AbstractStore):
                 return False
             try:
                 gsutil_alias, alias_gen = data_utils.get_gsutil_command()
-                remove_obj_command = (f'{alias_gen};{gsutil_alias} '
-                                      f'rm -r gs://{bucket_name}')
+                remove_obj_command = (
+                    f'{alias_gen};{gsutil_alias} '
+                    f'rm -r gs://{bucket_name}{command_suffix}')
                 subprocess.check_output(remove_obj_command,
                                         stderr=subprocess.STDOUT,
                                         shell=True,
                                         executable='/bin/bash')
                 return True
             except subprocess.CalledProcessError as e:
-                logger.error(e.output)
                 with ux_utils.print_exception_no_traceback():
                     raise exceptions.StorageBucketDeleteError(
-                        f'Failed to delete GCS bucket {bucket_name}.')
+                        f'Failed to delete {hint_text}GCS bucket '
+                        f'{bucket_name}{command_suffix}.'
+                        f'Detailed error: {e.output}')
 
 
-class R2Store(AbstractStore):
-    """R2Store inherits from S3Store Object and represents the backend
-    for R2 buckets.
-    """
+class AzureBlobStore(AbstractStore):
+    """Represents the backend for Azure Blob Storage Container."""
 
     _ACCESS_DENIED_MESSAGE = 'Access Denied'
+    DEFAULT_RESOURCE_GROUP_NAME = 'sky{user_hash}'
+    # Unlike resource group names, which only need to be unique within the
+    # subscription, storage account names must be globally unique across all of
+    # Azure users. Hence, the storage account name includes the subscription
+    # hash as well to ensure its uniqueness.
+    DEFAULT_STORAGE_ACCOUNT_NAME = (
+        'sky{region_hash}{user_hash}{subscription_hash}')
+    _SUBSCRIPTION_HASH_LENGTH = 4
+    _REGION_HASH_LENGTH = 4
+
+    class AzureBlobStoreMetadata(AbstractStore.StoreMetadata):
+        """A pickle-able representation of Azure Blob Store.
+
+        Allows store objects to be written to and reconstructed from
+        global_user_state.
+        """
+
+        def __init__(self,
+                     *,
+                     name: str,
+                     storage_account_name: str,
+                     source: Optional[SourceType],
+                     region: Optional[str] = None,
+                     is_sky_managed: Optional[bool] = None):
+            self.storage_account_name = storage_account_name
+            super().__init__(name=name,
+                             source=source,
+                             region=region,
+                             is_sky_managed=is_sky_managed)
+
+        def __repr__(self):
+            return (f'AzureBlobStoreMetadata('
+                    f'\n\tname={self.name},'
+                    f'\n\tstorage_account_name={self.storage_account_name},'
+                    f'\n\tsource={self.source},'
+                    f'\n\tregion={self.region},'
+                    f'\n\tis_sky_managed={self.is_sky_managed})')
 
     def __init__(self,
                  name: str,
                  source: str,
-                 region: Optional[str] = 'auto',
+                 storage_account_name: str = '',
+                 region: Optional[str] = 'eastus',
                  is_sky_managed: Optional[bool] = None,
-                 sync_on_reconstruction: Optional[bool] = True):
-        self.client: 'boto3.client.Client'
-        self.bucket: 'StorageHandle'
+                 sync_on_reconstruction: bool = True,
+                 _bucket_sub_path: Optional[str] = None):
+        self.storage_client: 'storage.Client'
+        self.resource_client: 'storage.Client'
+        self.container_name: str
+        # storage_account_name is not None when initializing only
+        # when it is being reconstructed from the handle(metadata).
+        self.storage_account_name = storage_account_name
+        self.storage_account_key: Optional[str] = None
+        self.resource_group_name: Optional[str] = None
+        if region is None:
+            region = 'eastus'
         super().__init__(name, source, region, is_sky_managed,
-                         sync_on_reconstruction)
+                         sync_on_reconstruction, _bucket_sub_path)
+
+    @classmethod
+    def from_metadata(cls, metadata: AbstractStore.StoreMetadata,
+                      **override_args) -> 'AzureBlobStore':
+        """Creates AzureBlobStore from a AzureBlobStoreMetadata object.
+
+        Used when reconstructing Storage and Store objects from
+        global_user_state.
+
+        Args:
+            metadata: Metadata object containing AzureBlobStore information.
+
+        Returns:
+            An instance of AzureBlobStore.
+        """
+        assert isinstance(metadata, AzureBlobStore.AzureBlobStoreMetadata)
+        # TODO: this needs to be kept in sync with the abstract
+        # AbstractStore.from_metadata.
+        return cls(
+            name=override_args.get('name', metadata.name),
+            storage_account_name=override_args.get(
+                'storage_account', metadata.storage_account_name),
+            source=override_args.get('source', metadata.source),
+            region=override_args.get('region', metadata.region),
+            is_sky_managed=override_args.get('is_sky_managed',
+                                             metadata.is_sky_managed),
+            sync_on_reconstruction=override_args.get('sync_on_reconstruction',
+                                                     True),
+            # Backward compatibility
+            # TODO: remove the hasattr check after v0.11.0
+            _bucket_sub_path=override_args.get(
+                '_bucket_sub_path',
+                metadata._bucket_sub_path  # pylint: disable=protected-access
+            ) if hasattr(metadata, '_bucket_sub_path') else None)
+
+    def get_metadata(self) -> AzureBlobStoreMetadata:
+        return self.AzureBlobStoreMetadata(
+            name=self.name,
+            storage_account_name=self.storage_account_name,
+            source=self.source,
+            region=self.region,
+            is_sky_managed=self.is_sky_managed)
 
     def _validate(self):
         if self.source is not None and isinstance(self.source, str):
@@ -1905,42 +2411,108 @@ class R2Store(AbstractStore):
                 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):
+                _, 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.')
             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('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 AZureBlob is not supported.')
         # Validate name
-        self.name = S3Store.validate_name(self.name)
+        self.name = self.validate_name(self.name)
+
         # Check if the storage is enabled
-        if not _is_storage_cloud_enabled(cloudflare.NAME):
+        if not _is_storage_cloud_enabled(str(clouds.Azure())):
             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://skypilot.readthedocs.io/en/latest/getting-started/installation.html.'  # pylint: disable=line-too-long
-                    )
+                    'Storage "store: azure" specified, but '
+                    'Azure access is disabled. To fix, enable '
+                    'Azure by running `sky check`. More info: '
+                    'https://docs.skypilot.co/en/latest/getting-started/installation.html.'  # pylint: disable=line-too-long
+                )
+
+    @classmethod
+    def validate_name(cls, name: str) -> str:
+        """Validates the name of the AZ Container.
+
+        Source for rules: https://learn.microsoft.com/en-us/rest/api/storageservices/Naming-and-Referencing-Containers--Blobs--and-Metadata#container-names # pylint: disable=line-too-long
+
+        Args:
+            name: Name of the container
+
+        Returns:
+            Name of the container
+
+        Raises:
+            StorageNameError: if the given container name does not follow the
+                naming convention
+        """
+
+        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 {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 {name} can consist only of '
+                    'lowercase letters, numbers, and hyphens (-). '
+                    'It must begin and end with a letter or number.')
+
+            # Check for two adjacent hyphens
+            if '--' in name:
+                _raise_no_traceback_name_error(
+                    f'Invalid store name: name {name} must not contain '
+                    'two adjacent hyphens.')
+
+        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 AZ Container object on the cloud.
 
-        Initialization involves fetching bucket if exists, or creating it if
-        it does not.
+        Initialization involves fetching container if exists, or creating it if
+        it does not. Also, it checks for the existence of the storage account
+        if provided by the user and the resource group is inferred from it.
+        If not provided, both are created with a default naming conventions.
 
         Raises:
-          StorageBucketCreateError: If bucket creation fails
-          StorageBucketGetError: If fetching existing bucket fails
-          StorageInitError: If general initialization fails.
+            StorageBucketCreateError: If container creation fails or storage
+                account attempted to be created already exists.
+            StorageBucketGetError: If fetching existing container fails.
+            StorageInitError: If general initialization fails.
+            NonExistentStorageAccountError: When storage account provided
+                either through config.yaml or local db does not exist under
+                user's subscription ID.
         """
-        self.client = data_utils.create_r2_client(self.region)
-        self.bucket, is_new_bucket = self._get_bucket()
+        self.storage_client = data_utils.create_az_client('storage')
+        self.resource_client = data_utils.create_az_client('resource')
+        self._update_storage_account_name_and_resource()
+
+        self.container_name, 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
@@ -1948,14 +2520,723 @@ class R2Store(AbstractStore):
             # 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.
+    def _update_storage_account_name_and_resource(self):
+        self.storage_account_name, self.resource_group_name = (
+            self._get_storage_account_and_resource_group())
+
+        # resource_group_name is set to None when using non-sky-managed
+        # public container or private container without authorization.
+        if self.resource_group_name is not None:
+            self.storage_account_key = data_utils.get_az_storage_account_key(
+                self.storage_account_name, self.resource_group_name,
+                self.storage_client, self.resource_client)
+
+    def update_storage_attributes(self, **kwargs: Dict[str, Any]):
+        assert 'storage_account_name' in kwargs, (
+            'only storage_account_name supported')
+        assert isinstance(kwargs['storage_account_name'],
+                          str), ('storage_account_name must be a string')
+        self.storage_account_name = kwargs['storage_account_name']
+        self._update_storage_account_name_and_resource()
 
-        Upload must be called by the Storage handler - it is not called on
-        Store initialization.
+    @staticmethod
+    def get_default_storage_account_name(region: Optional[str]) -> str:
+        """Generates a unique default storage account name.
+
+        The subscription ID is included to avoid conflicts when user switches
+        subscriptions. The length of region_hash, user_hash, and
+        subscription_hash are adjusted to ensure the storage account name
+        adheres to the 24-character limit, as some region names can be very
+        long. Using a 4-character hash for the region helps keep the name
+        concise and prevents potential conflicts.
+        Reference: https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/resource-name-rules#microsoftstorage # pylint: disable=line-too-long
+
+        Args:
+            region: Name of the region to create the storage account/container.
+
+        Returns:
+            Name of the default storage account.
+        """
+        assert region is not None
+        subscription_id = azure.get_subscription_id()
+        subscription_hash_obj = hashlib.md5(subscription_id.encode('utf-8'))
+        subscription_hash = subscription_hash_obj.hexdigest(
+        )[:AzureBlobStore._SUBSCRIPTION_HASH_LENGTH]
+        region_hash_obj = hashlib.md5(region.encode('utf-8'))
+        region_hash = region_hash_obj.hexdigest()[:AzureBlobStore.
+                                                  _REGION_HASH_LENGTH]
+
+        storage_account_name = (
+            AzureBlobStore.DEFAULT_STORAGE_ACCOUNT_NAME.format(
+                region_hash=region_hash,
+                user_hash=common_utils.get_user_hash(),
+                subscription_hash=subscription_hash))
+
+        return storage_account_name
+
+    def _get_storage_account_and_resource_group(
+            self) -> Tuple[str, Optional[str]]:
+        """Get storage account and resource group to be used for AzureBlobStore
+
+        Storage account name and resource group name of the container to be
+        used for AzureBlobStore object is obtained from this function. These
+        are determined by either through the metadata, source, config.yaml, or
+        default name:
+
+        1) If self.storage_account_name already has a set value, this means we
+        are reconstructing the storage object using metadata from the local
+        state.db to reuse sky managed storage.
+
+        2) Users provide externally created non-sky managed storage endpoint
+        as a source from task yaml. Then, storage account is read from it and
+        the resource group is inferred from it.
+
+        3) Users provide the storage account, which they want to create the
+        sky managed storage, through config.yaml. Then, resource group is
+        inferred from it.
+
+        4) If none of the above are true, default naming conventions are used
+        to create the resource group and storage account for the users.
+
+        Returns:
+            str: The storage account name.
+            Optional[str]: The resource group name, or None if not found.
 
         Raises:
-            StorageUploadError: if upload fails.
+            StorageBucketCreateError: If storage account attempted to be
+                created already exists.
+            NonExistentStorageAccountError: When storage account provided
+                either through config.yaml or local db does not exist under
+                user's subscription ID.
+        """
+        # self.storage_account_name already has a value only when it is being
+        # reconstructed with metadata from local db.
+        if self.storage_account_name:
+            resource_group_name = azure.get_az_resource_group(
+                self.storage_account_name)
+            if resource_group_name is None:
+                # If the storage account does not exist, the containers under
+                # the account does not exist as well.
+                with ux_utils.print_exception_no_traceback():
+                    raise exceptions.NonExistentStorageAccountError(
+                        f'The storage account {self.storage_account_name!r} '
+                        'read from local db does not exist under your '
+                        'subscription ID. The account may have been externally'
+                        ' deleted.')
+            storage_account_name = self.storage_account_name
+        # Using externally created container
+        elif (isinstance(self.source, str) and
+              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
+            resource_group_name = azure.get_az_resource_group(
+                storage_account_name)
+        # Creates new resource group and storage account or use the
+        # storage_account provided by the user through config.yaml
+        else:
+            config_storage_account = skypilot_config.get_nested(
+                ('azure', 'storage_account'), None)
+            if config_storage_account is not None:
+                # using user provided storage account from config.yaml
+                storage_account_name = config_storage_account
+                resource_group_name = azure.get_az_resource_group(
+                    storage_account_name)
+                # when the provided storage account does not exist under user's
+                # subscription id.
+                if resource_group_name is None:
+                    with ux_utils.print_exception_no_traceback():
+                        raise exceptions.NonExistentStorageAccountError(
+                            'The storage account '
+                            f'{storage_account_name!r} specified in '
+                            'config.yaml does not exist under the user\'s '
+                            'subscription ID. Provide a storage account '
+                            'through config.yaml only when creating a '
+                            'container under an already existing storage '
+                            'account within your subscription ID.')
+            else:
+                # If storage account name is not provided from config, then
+                # use default resource group and storage account names.
+                storage_account_name = self.get_default_storage_account_name(
+                    self.region)
+                resource_group_name = (self.DEFAULT_RESOURCE_GROUP_NAME.format(
+                    user_hash=common_utils.get_user_hash()))
+                try:
+                    # obtains detailed information about resource group under
+                    # the user's subscription. Used to check if the name
+                    # already exists
+                    self.resource_client.resource_groups.get(
+                        resource_group_name)
+                except azure.exceptions().ResourceNotFoundError:
+                    with rich_utils.safe_status(
+                            ux_utils.spinner_message(
+                                f'Setting up resource group: '
+                                f'{resource_group_name}')):
+                        self.resource_client.resource_groups.create_or_update(
+                            resource_group_name, {'location': self.region})
+                    logger.info('  Created Azure resource group '
+                                f'{resource_group_name!r}.')
+                # check if the storage account name already exists under the
+                # given resource group name.
+                try:
+                    self.storage_client.storage_accounts.get_properties(
+                        resource_group_name, storage_account_name)
+                except azure.exceptions().ResourceNotFoundError:
+                    with rich_utils.safe_status(
+                            ux_utils.spinner_message(
+                                f'Setting up storage account: '
+                                f'{storage_account_name}')):
+                        self._create_storage_account(resource_group_name,
+                                                     storage_account_name)
+                        # wait until new resource creation propagates to Azure.
+                        time.sleep(1)
+                    logger.info('  Created Azure storage account '
+                                f'{storage_account_name!r}.')
+
+        return storage_account_name, resource_group_name
+
+    def _create_storage_account(self, resource_group_name: str,
+                                storage_account_name: str) -> None:
+        """Creates new storage account and assign Storage Blob Data Owner role.
+
+        Args:
+            resource_group_name: Name of the resource group which the storage
+                account will be created under.
+            storage_account_name: Name of the storage account to be created.
+
+        Raises:
+            StorageBucketCreateError: If storage account attempted to be
+                created already exists or fails to assign role to the create
+                storage account.
+        """
+        try:
+            creation_response = (
+                self.storage_client.storage_accounts.begin_create(
+                    resource_group_name, storage_account_name, {
+                        'sku': {
+                            'name': 'Standard_GRS'
+                        },
+                        'kind': 'StorageV2',
+                        'location': self.region,
+                        'encryption': {
+                            'services': {
+                                'blob': {
+                                    'key_type': 'Account',
+                                    'enabled': True
+                                }
+                            },
+                            'key_source': 'Microsoft.Storage'
+                        },
+                    }).result())
+        except azure.exceptions().ResourceExistsError as error:
+            with ux_utils.print_exception_no_traceback():
+                raise exceptions.StorageBucketCreateError(
+                    'Failed to create storage account '
+                    f'{storage_account_name!r}. You may be '
+                    'attempting to create a storage account '
+                    'already being in use. Details: '
+                    f'{common_utils.format_exception(error, use_bracket=True)}')
+
+        # It may take some time for the created storage account to propagate
+        # to Azure, we reattempt to assign the role for several times until
+        # storage account creation fully propagates.
+        role_assignment_start = time.time()
+        retry = 0
+
+        while (time.time() - role_assignment_start <
+               constants.WAIT_FOR_STORAGE_ACCOUNT_CREATION):
+            try:
+                azure.assign_storage_account_iam_role(
+                    storage_account_name=storage_account_name,
+                    storage_account_id=creation_response.id)
+                return
+            except AttributeError as e:
+                if 'signed_session' in str(e):
+                    if retry % 5 == 0:
+                        logger.info(
+                            'Retrying role assignment due to propagation '
+                            'delay of the newly created storage account. '
+                            f'Retry count: {retry}.')
+                    time.sleep(1)
+                    retry += 1
+                    continue
+                with ux_utils.print_exception_no_traceback():
+                    role_assignment_failure_error_msg = (
+                        constants.ROLE_ASSIGNMENT_FAILURE_ERROR_MSG.format(
+                            storage_account_name=storage_account_name))
+                    raise exceptions.StorageBucketCreateError(
+                        f'{role_assignment_failure_error_msg}'
+                        'Details: '
+                        f'{common_utils.format_exception(e, use_bracket=True)}')
+
+    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_az_blob_sync(self.source, create_dirs=True)
+            elif self.source is not None:
+                error_message = (
+                    'Moving data directly from {cloud} to Azure is currently '
+                    'not supported. Please specify a local source for the '
+                    'storage object.')
+                if data_utils.is_az_container_endpoint(self.source):
+                    pass
+                elif self.source.startswith('s3://'):
+                    raise NotImplementedError(error_message.format('S3'))
+                elif self.source.startswith('gs://'):
+                    raise NotImplementedError(error_message.format('GCS'))
+                elif self.source.startswith('r2://'):
+                    raise NotImplementedError(error_message.format('R2'))
+                elif self.source.startswith('cos://'):
+                    raise NotImplementedError(error_message.format('IBM COS'))
+                elif self.source.startswith('oci://'):
+                    raise NotImplementedError(error_message.format('OCI'))
+                else:
+                    self.batch_az_blob_sync([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:
+        """Deletes the storage."""
+        if self._bucket_sub_path is not None and not self.is_sky_managed:
+            return self._delete_sub_path()
+
+        deleted_by_skypilot = self._delete_az_bucket(self.name)
+        if deleted_by_skypilot:
+            msg_str = (f'Deleted AZ Container {self.name!r} under storage '
+                       f'account {self.storage_account_name!r}.')
+        else:
+            msg_str = (f'AZ Container {self.name} may have '
+                       'been deleted 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'
+        try:
+            container_url = data_utils.AZURE_CONTAINER_URL.format(
+                storage_account_name=self.storage_account_name,
+                container_name=self.name)
+            container_client = data_utils.create_az_client(
+                client_type='container',
+                container_url=container_url,
+                storage_account_name=self.storage_account_name,
+                resource_group_name=self.resource_group_name)
+            # List and delete blobs in the specified directory
+            blobs = container_client.list_blobs(
+                name_starts_with=self._bucket_sub_path + '/')
+            for blob in blobs:
+                container_client.delete_blob(blob.name)
+            logger.info(
+                f'Deleted objects from sub path {self._bucket_sub_path} '
+                f'in container {self.name}.')
+        except Exception as e:  # pylint: disable=broad-except
+            logger.error(
+                f'Failed to delete objects from sub path '
+                f'{self._bucket_sub_path} in container {self.name}. '
+                f'Details: {common_utils.format_exception(e, use_bracket=True)}'
+            )
+
+    def get_handle(self) -> StorageHandle:
+        """Returns the Storage Handle object."""
+        return self.storage_client.blob_containers.get(
+            self.resource_group_name, self.storage_account_name, self.name)
+
+    def batch_az_blob_sync(self,
+                           source_path_list: List[Path],
+                           create_dirs: bool = False) -> None:
+        """Invokes az storage blob sync to batch upload a list of local paths.
+
+        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.
+        """
+        container_path = (f'{self.container_name}/{self._bucket_sub_path}'
+                          if self._bucket_sub_path else self.container_name)
+
+        def get_file_sync_command(base_dir_path, file_names) -> str:
+            # shlex.quote is not used for file_names as 'az storage blob sync'
+            # already handles file names with empty spaces when used with
+            # '--include-pattern' option.
+            includes_list = ';'.join(file_names)
+            includes = f'--include-pattern "{includes_list}"'
+            base_dir_path = shlex.quote(base_dir_path)
+            sync_command = (f'az storage blob sync '
+                            f'--account-name {self.storage_account_name} '
+                            f'--account-key {self.storage_account_key} '
+                            f'{includes} '
+                            '--delete-destination false '
+                            f'--source {base_dir_path} '
+                            f'--container {container_path}')
+            return sync_command
+
+        def get_dir_sync_command(src_dir_path, dest_dir_name) -> str:
+            # we exclude .git directory from the sync
+            excluded_list = storage_utils.get_excluded_files(src_dir_path)
+            excluded_list.append('.git/')
+            excludes_list = ';'.join(
+                [file_name.rstrip('*') for file_name in excluded_list])
+            excludes = f'--exclude-path "{excludes_list}"'
+            src_dir_path = shlex.quote(src_dir_path)
+            if dest_dir_name:
+                dest_dir_name = f'/{dest_dir_name}'
+            else:
+                dest_dir_name = ''
+            sync_command = (f'az storage blob sync '
+                            f'--account-name {self.storage_account_name} '
+                            f'--account-key {self.storage_account_key} '
+                            f'{excludes} '
+                            '--delete-destination false '
+                            f'--source {src_dir_path} '
+                            f'--container {container_path}{dest_dir_name}')
+            return sync_command
+
+        # Generate message for upload
+        assert source_path_list
+        if len(source_path_list) > 1:
+            source_message = f'{len(source_path_list)} paths'
+        else:
+            source_message = source_path_list[0]
+        container_endpoint = data_utils.AZURE_CONTAINER_URL.format(
+            storage_account_name=self.storage_account_name,
+            container_name=container_path)
+        log_path = sky_logging.generate_tmp_logging_file_path(
+            _STORAGE_LOG_FILE_NAME)
+        sync_path = f'{source_message} -> {container_endpoint}/'
+        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[str, bool]:
+        """Obtains the AZ Container.
+
+        Buckets for Azure Blob Storage are referred as Containers.
+        If the container exists, this method will return the container.
+        If the container does not exist, there are three cases:
+          1) Raise an error if the container source starts with https://
+          2) Return None if container has been externally deleted and
+             sync_on_reconstruction is False
+          3) Create and return a new container otherwise
+
+        Returns:
+            str: name of the bucket(container)
+            bool: represents either or not the bucket is managed by skypilot
+
+        Raises:
+            StorageBucketCreateError: If creating the container fails
+            StorageBucketGetError: If fetching a container fails
+            StorageExternalDeletionError: If externally deleted container is
+                attempted to be fetched while reconstructing the Storage for
+                'sky storage delete' or 'sky start'
+        """
+        try:
+            container_url = data_utils.AZURE_CONTAINER_URL.format(
+                storage_account_name=self.storage_account_name,
+                container_name=self.name)
+            try:
+                container_client = data_utils.create_az_client(
+                    client_type='container',
+                    container_url=container_url,
+                    storage_account_name=self.storage_account_name,
+                    resource_group_name=self.resource_group_name)
+            except azure.exceptions().ClientAuthenticationError as e:
+                if 'ERROR: AADSTS50020' in str(e):
+                    # Caught when failing to obtain container client due to
+                    # lack of permission to passed given private container.
+                    if self.resource_group_name is None:
+                        with ux_utils.print_exception_no_traceback():
+                            raise exceptions.StorageBucketGetError(
+                                _BUCKET_FAIL_TO_CONNECT_MESSAGE.format(
+                                    name=self.name))
+                raise
+            if container_client.exists():
+                is_private = (True if
+                              container_client.get_container_properties().get(
+                                  'public_access', None) is None else False)
+                # when user attempts to use private container without
+                # access rights
+                if self.resource_group_name is None and is_private:
+                    with ux_utils.print_exception_no_traceback():
+                        raise exceptions.StorageBucketGetError(
+                            _BUCKET_FAIL_TO_CONNECT_MESSAGE.format(
+                                name=self.name))
+                self._validate_existing_bucket()
+                return container_client.container_name, False
+            # when the container name does not exist under the provided
+            # storage account name and credentials, and user has the rights to
+            # access the storage account.
+            else:
+                # when this if statement is not True, we let it to proceed
+                # farther and create the container.
+                if (isinstance(self.source, str) and
+                        self.source.startswith('https://')):
+                    with ux_utils.print_exception_no_traceback():
+                        raise exceptions.StorageBucketGetError(
+                            'Attempted to use a non-existent container as a '
+                            f'source: {self.source}. Please check if the '
+                            'container name is correct.')
+        except azure.exceptions().ServiceRequestError as e:
+            # raised when storage account name to be used does not exist.
+            error_message = e.message
+            if 'Name or service not known' in error_message:
+                with ux_utils.print_exception_no_traceback():
+                    raise exceptions.StorageBucketGetError(
+                        'Attempted to fetch the container from non-existent '
+                        'storage account '
+                        f'name: {self.storage_account_name}. Please check '
+                        'if the name is correct.')
+            else:
+                with ux_utils.print_exception_no_traceback():
+                    raise exceptions.StorageBucketGetError(
+                        'Failed to fetch the container from storage account '
+                        f'{self.storage_account_name!r}.'
+                        'Details: '
+                        f'{common_utils.format_exception(e, use_bracket=True)}')
+
+        # If the container cannot be found in both private and public settings,
+        # the container 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:
+            container = self._create_az_bucket(self.name)
+            return container.name, True
+
+        # 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.
+        with ux_utils.print_exception_no_traceback():
+            raise exceptions.StorageExternalDeletionError(
+                f'Attempted to fetch a non-existent container: {self.name}')
+
+    def mount_command(self, mount_path: str) -> str:
+        """Returns the command to mount the container to the mount_path.
+
+        Uses blobfuse2 to mount the container.
+
+        Args:
+            mount_path: Path to mount the container to
+
+        Returns:
+            str: a heredoc used to setup the AZ Container mount
+        """
+        install_cmd = mounting_utils.get_az_mount_install_cmd()
+        mount_cmd = mounting_utils.get_az_mount_cmd(self.container_name,
+                                                    self.storage_account_name,
+                                                    mount_path,
+                                                    self.storage_account_key,
+                                                    self._bucket_sub_path)
+        return mounting_utils.get_mounting_command(mount_path, install_cmd,
+                                                   mount_cmd)
+
+    def _create_az_bucket(self, container_name: str) -> StorageHandle:
+        """Creates AZ Container.
+
+        Args:
+            container_name: Name of bucket(container)
+
+        Returns:
+            StorageHandle: Handle to interact with the container
+
+        Raises:
+            StorageBucketCreateError: If container creation fails.
+        """
+        try:
+            # Container is created under the region which the storage account
+            # belongs to.
+            container = self.storage_client.blob_containers.create(
+                self.resource_group_name,
+                self.storage_account_name,
+                container_name,
+                blob_container={})
+            logger.info(f'  {colorama.Style.DIM}Created AZ Container '
+                        f'{container_name!r} in {self.region!r} under storage '
+                        f'account {self.storage_account_name!r}.'
+                        f'{colorama.Style.RESET_ALL}')
+        except azure.exceptions().ResourceExistsError as e:
+            if 'container is being deleted' in e.error.message:
+                with ux_utils.print_exception_no_traceback():
+                    raise exceptions.StorageBucketCreateError(
+                        f'The container {self.name!r} is currently being '
+                        'deleted. Please wait for the deletion to complete'
+                        'before attempting to create a container with the '
+                        'same name. This may take a few minutes.')
+            else:
+                with ux_utils.print_exception_no_traceback():
+                    raise exceptions.StorageBucketCreateError(
+                        f'Failed to create the container {self.name!r}. '
+                        'Details: '
+                        f'{common_utils.format_exception(e, use_bracket=True)}')
+        return container
+
+    def _delete_az_bucket(self, container_name: str) -> bool:
+        """Deletes AZ Container, including all objects in Container.
+
+        Args:
+            container_name: Name of bucket(container).
+
+        Returns:
+            bool: True if container was deleted, False if it's deleted
+                externally.
+
+        Raises:
+            StorageBucketDeleteError: If deletion fails for reasons other than
+                the container not existing.
+        """
+        try:
+            with rich_utils.safe_status(
+                    ux_utils.spinner_message(
+                        f'Deleting Azure container {container_name}')):
+                # Check for the existance of the container before deletion.
+                self.storage_client.blob_containers.get(
+                    self.resource_group_name,
+                    self.storage_account_name,
+                    container_name,
+                )
+                self.storage_client.blob_containers.delete(
+                    self.resource_group_name,
+                    self.storage_account_name,
+                    container_name,
+                )
+        except azure.exceptions().ResourceNotFoundError as e:
+            if 'Code: ContainerNotFound' in str(e):
+                logger.debug(
+                    _BUCKET_EXTERNALLY_DELETED_DEBUG_MESSAGE.format(
+                        bucket_name=container_name))
+                return False
+            else:
+                with ux_utils.print_exception_no_traceback():
+                    raise exceptions.StorageBucketDeleteError(
+                        f'Failed to delete Azure container {container_name}. '
+                        f'Detailed error: {e}')
+        return True
+
+
+class R2Store(AbstractStore):
+    """R2Store inherits from S3Store Object and represents the backend
+    for R2 buckets.
+    """
+
+    _ACCESS_DENIED_MESSAGE = 'Access Denied'
+
+    def __init__(self,
+                 name: str,
+                 source: str,
+                 region: Optional[str] = 'auto',
+                 is_sky_managed: Optional[bool] = None,
+                 sync_on_reconstruction: Optional[bool] = True,
+                 _bucket_sub_path: Optional[str] = None):
+        self.client: 'boto3.client.Client'
+        self.bucket: 'StorageHandle'
+        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.')
+            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 '
+                    '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):
+            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
+                    )
+
+    def initialize(self):
+        """Initializes the R2 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.
+        """
+        self.client = data_utils.create_r2_client(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 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):
@@ -1967,6 +3248,8 @@ class R2Store(AbstractStore):
                     self._transfer_to_r2()
                 elif self.source.startswith('r2://'):
                     pass
+                elif self.source.startswith('oci://'):
+                    self._transfer_to_r2()
                 else:
                     self.batch_aws_rsync([self.source])
         except exceptions.StorageUploadError:
@@ -1976,6 +3259,9 @@ class R2Store(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_r2_bucket(self.name)
         if deleted_by_skypilot:
             msg_str = f'Deleted R2 bucket {self.name}.'
@@ -1985,6 +3271,19 @@ class R2Store(AbstractStore):
         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_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}')
+
     def get_handle(self) -> StorageHandle:
         return cloudflare.resource('s3').Bucket(self.name)
 
@@ -2008,6 +3307,8 @@ class R2Store(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}'
+                    if self._bucket_sub_path else '')
 
         def get_file_sync_command(base_dir_path, file_names):
             includes = ' '.join([
@@ -2020,15 +3321,14 @@ class R2Store(AbstractStore):
                             f'{cloudflare.R2_CREDENTIALS_PATH} '
                             'aws s3 sync --no-follow-symlinks --exclude="*" '
                             f'{includes} {base_dir_path} '
-                            f's3://{self.name} '
+                            f's3://{self.name}{sub_path} '
                             f'--endpoint {endpoint_url} '
                             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_from_gitignore(
-                src_dir_path)
+            excluded_list = storage_utils.get_excluded_files(src_dir_path)
             excluded_list.append('.git/*')
             excludes = ' '.join([
                 f'--exclude {shlex.quote(file_name)}'
@@ -2040,7 +3340,7 @@ class R2Store(AbstractStore):
                             f'{cloudflare.R2_CREDENTIALS_PATH} '
                             f'aws s3 sync --no-follow-symlinks {excludes} '
                             f'{src_dir_path} '
-                            f's3://{self.name}/{dest_dir_name} '
+                            f's3://{self.name}{sub_path}/{dest_dir_name} '
                             f'--endpoint {endpoint_url} '
                             f'--profile={cloudflare.R2_PROFILE_NAME}')
             return sync_command
@@ -2051,17 +3351,24 @@ class R2Store(AbstractStore):
         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} -> r2://{self.name}{sub_path}/'
         with rich_utils.safe_status(
-                f'[bold cyan]Syncing '
-                f'[green]{source_message}[/] to [green]r2://{self.name}/[/]'):
+                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 _transfer_to_r2(self) -> None:
         assert isinstance(self.source, str), self.source
@@ -2164,11 +3471,9 @@ class R2Store(AbstractStore):
         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)
+        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)
 
@@ -2191,7 +3496,9 @@ class R2Store(AbstractStore):
                 location = {'LocationConstraint': region}
                 r2_client.create_bucket(Bucket=bucket_name,
                                         CreateBucketConfiguration=location)
-                logger.info(f'Created R2 bucket {bucket_name} in {region}')
+                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:
             with ux_utils.print_exception_no_traceback():
                 raise exceptions.StorageBucketCreateError(
@@ -2199,6 +3506,43 @@ class R2Store(AbstractStore):
                     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
 
@@ -2207,6 +3551,9 @@ class R2Store(AbstractStore):
 
         Returns:
          bool; True if bucket was deleted, False if it was deleted externally.
+
+        Raises:
+            StorageBucketDeleteError: If deleting the bucket fails.
         """
         # Deleting objects is very slow programatically
         # (i.e. bucket.objects.all().delete() is slow).
@@ -2214,30 +3561,19 @@ class R2Store(AbstractStore):
         # 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}')
-        try:
-            with rich_utils.safe_status(
-                    f'[bold cyan]Deleting R2 bucket {bucket_name}[/]'):
-                subprocess.check_output(remove_command,
-                                        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:
-                logger.error(e.output)
-                with ux_utils.print_exception_no_traceback():
-                    raise exceptions.StorageBucketDeleteError(
-                        f'Failed to delete R2 bucket {bucket_name}.')
+        # 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
 
         # Wait until bucket deletion propagates on AWS servers
         while data_utils.verify_r2_bucket(bucket_name):
@@ -2256,11 +3592,12 @@ class IBMCosStore(AbstractStore):
                  source: str,
                  region: Optional[str] = 'us-east',
                  is_sky_managed: Optional[bool] = None,
-                 sync_on_reconstruction: bool = True):
+                 sync_on_reconstruction: bool = True,
+                 _bucket_sub_path: Optional[str] = None):
         self.client: 'storage.Client'
         self.bucket: 'StorageHandle'
         super().__init__(name, source, region, is_sky_managed,
-                         sync_on_reconstruction)
+                         sync_on_reconstruction, _bucket_sub_path)
         self.bucket_rclone_profile = \
           Rclone.generate_rclone_bucket_profile_name(
             self.name, Rclone.RcloneClouds.IBM)
@@ -2281,6 +3618,16 @@ class IBMCosStore(AbstractStore):
                 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 '
@@ -2296,7 +3643,7 @@ class IBMCosStore(AbstractStore):
         self.name = IBMCosStore.validate_name(self.name)
 
     @classmethod
-    def validate_name(cls, name) -> str:
+    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
@@ -2395,10 +3742,22 @@ class IBMCosStore(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()
+
         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)
 
@@ -2418,6 +3777,8 @@ class IBMCosStore(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}'
+                    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
@@ -2442,7 +3803,8 @@ class IBMCosStore(AbstractStore):
             sync_command = (
                 'rclone copy --exclude ".git/*" '
                 f'{src_dir_path} '
-                f'{self.bucket_rclone_profile}:{self.name}/{dest_dir_name}')
+                f'{self.bucket_rclone_profile}:{self.name}{sub_path}'
+                f'/{dest_dir_name}')
             return sync_command
 
         def get_file_sync_command(base_dir_path, file_names) -> str:
@@ -2468,9 +3830,10 @@ class IBMCosStore(AbstractStore):
                 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.bucket_rclone_profile}:{self.name}')
+            sync_command = (
+                'rclone copy '
+                f'{includes} {base_dir_path} '
+                f'{self.bucket_rclone_profile}:{self.name}{sub_path}')
             return sync_command
 
         # Generate message for upload
@@ -2479,18 +3842,25 @@ class IBMCosStore(AbstractStore):
         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(
-                f'[bold cyan]Syncing '
-                f'[green]{source_message}[/] to '
-                f'[green]cos://{self.region}/{self.name}/[/]'):
+                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.
@@ -2549,6 +3919,7 @@ class IBMCosStore(AbstractStore):
             Rclone.RcloneClouds.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
@@ -2595,7 +3966,8 @@ class IBMCosStore(AbstractStore):
                                                      Rclone.RCLONE_CONFIG_PATH,
                                                      self.bucket_rclone_profile,
                                                      self.bucket.name,
-                                                     mount_path)
+                                                     mount_path,
+                                                     self._bucket_sub_path)
         return mounting_utils.get_mounting_command(mount_path, install_cmd,
                                                    mount_cmd)
 
@@ -2616,8 +3988,10 @@ class IBMCosStore(AbstractStore):
                 CreateBucketConfiguration={
                     'LocationConstraint': f'{region}-smart'
                 })
-            logger.info(f'Created IBM COS bucket {bucket_name} in {region} '
-                        f'with storage class smart tier')
+            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
@@ -2631,18 +4005,492 @@ class IBMCosStore(AbstractStore):
 
         return self.bucket
 
-    def _delete_cos_bucket(self):
-        bucket = self.s3_resource.Bucket(self.name)
-        try:
-            bucket_versioning = self.s3_resource.BucketVersioning(self.name)
-            if bucket_versioning.status == 'Enabled':
+    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}')
+        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')
         Rclone.delete_rclone_bucket_profile(self.name, Rclone.RcloneClouds.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