skypilot-nightly 1.0.0.dev20241011__py3-none-any.whl → 1.0.0.dev20241013__py3-none-any.whl

sky/backends/local_docker_backend.py

@@ -14,6 +14,7 @@ from sky.backends import backend_utils
 from sky.backends import docker_utils
 from sky.data import storage as storage_lib
 from sky.utils import rich_utils
+from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
     from sky import resources
@@ -159,7 +160,8 @@ class LocalDockerBackend(backends.Backend['LocalDockerResourceHandle']):
         handle = LocalDockerResourceHandle(cluster_name)
         logger.info(f'Building docker image for task {task.name}. '
                     'This might take some time.')
-        with rich_utils.safe_status('[bold cyan]Building Docker image[/]'):
+        with rich_utils.safe_status(
+                ux_utils.spinner_message('Building Docker image')):
             image_tag, metadata = docker_utils.build_dockerimage_from_task(task)
         self.images[handle] = (image_tag, metadata)
         logger.info(f'Image {image_tag} built.')

sky/benchmark/benchmark_utils.py

@@ -595,7 +595,8 @@ def update_benchmark_state(benchmark: str) -> None:
     remote_dir = os.path.join(bucket_name, benchmark)
     local_dir = os.path.join(_SKY_LOCAL_BENCHMARK_DIR, benchmark)
     os.makedirs(local_dir, exist_ok=True)
-    with rich_utils.safe_status('[bold cyan]Downloading benchmark logs[/]'):
+    with rich_utils.safe_status(
+            ux_utils.spinner_message('Downloading benchmark logs')):
         _download_remote_dir(remote_dir, local_dir, bucket_type)
 
     # Update the benchmark results in parallel.
@@ -604,9 +605,9 @@ def update_benchmark_state(benchmark: str) -> None:
     progress = rich_progress.Progress(transient=True,
                                       redirect_stdout=False,
                                       redirect_stderr=False)
-    task = progress.add_task(
-        f'[bold cyan]Processing {num_candidates} benchmark result{plural}[/]',
-        total=num_candidates)
+    task = progress.add_task(ux_utils.spinner_message(
+        f'Processing {num_candidates} benchmark result{plural}'),
+                             total=num_candidates)
 
     def _update_with_progress_bar(arg: Any) -> None:
         message = _update_benchmark_result(arg)

sky/cli.py

@@ -1458,6 +1458,79 @@ def _get_services(service_names: Optional[List[str]],
     return num_services, msg
 
 
+def _status_kubernetes(show_all: bool):
+    """Show all SkyPilot resources in the current Kubernetes context.
+
+    Args:
+        show_all (bool): Show all job information (e.g., start time, failures).
+    """
+    context = kubernetes_utils.get_current_kube_config_context_name()
+    try:
+        pods = kubernetes_utils.get_skypilot_pods(context)
+    except exceptions.ResourcesUnavailableError as e:
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError('Failed to get SkyPilot pods from '
+                             f'Kubernetes: {str(e)}') from e
+    all_clusters, jobs_controllers, serve_controllers = (
+        status_utils.process_skypilot_pods(pods, context))
+    all_jobs = []
+    with rich_utils.safe_status(
+            '[bold cyan]Checking in-progress managed jobs[/]') as spinner:
+        for i, (_, job_controller_info) in enumerate(jobs_controllers.items()):
+            user = job_controller_info['user']
+            pod = job_controller_info['pods'][0]
+            status_message = ('[bold cyan]Checking managed jobs controller')
+            if len(jobs_controllers) > 1:
+                status_message += f's ({i+1}/{len(jobs_controllers)})'
+            spinner.update(f'{status_message}[/]')
+            try:
+                job_list = managed_jobs.queue_from_kubernetes_pod(
+                    pod.metadata.name)
+            except RuntimeError as e:
+                logger.warning('Failed to get managed jobs from controller '
+                               f'{pod.metadata.name}: {str(e)}')
+                job_list = []
+            # Add user field to jobs
+            for job in job_list:
+                job['user'] = user
+            all_jobs.extend(job_list)
+    # Reconcile cluster state between managed jobs and clusters:
+    # To maintain a clear separation between regular SkyPilot clusters
+    # and those from managed jobs, we need to exclude the latter from
+    # the main cluster list.
+    # We do this by reconstructing managed job cluster names from each
+    # job's name and ID. We then use this set to filter out managed
+    # clusters from the main cluster list. This is necessary because there
+    # are no identifiers distinguishing clusters from managed jobs from
+    # regular clusters.
+    managed_job_cluster_names = set()
+    for job in all_jobs:
+        # Managed job cluster name is <job_name>-<job_id>
+        managed_cluster_name = f'{job["job_name"]}-{job["job_id"]}'
+        managed_job_cluster_names.add(managed_cluster_name)
+    unmanaged_clusters = [
+        c for c in all_clusters
+        if c['cluster_name'] not in managed_job_cluster_names
+    ]
+    click.echo(f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
+               f'Kubernetes cluster state (context: {context})'
+               f'{colorama.Style.RESET_ALL}')
+    status_utils.show_kubernetes_cluster_status_table(unmanaged_clusters,
+                                                      show_all)
+    if all_jobs:
+        click.echo(f'\n{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
+                   f'Managed jobs'
+                   f'{colorama.Style.RESET_ALL}')
+        msg = managed_jobs.format_job_table(all_jobs, show_all=show_all)
+        click.echo(msg)
+    if serve_controllers:
+        # TODO: Parse serve controllers and show services separately.
+        #  Currently we show a hint that services are shown as clusters.
+        click.echo(f'\n{colorama.Style.DIM}Hint: SkyServe replica pods are '
+                   'shown in the "SkyPilot clusters" section.'
+                   f'{colorama.Style.RESET_ALL}')
+
+
 @cli.command()
 @click.option('--all',
               '-a',
@@ -1503,6 +1576,14 @@ def _get_services(service_names: Optional[List[str]],
               is_flag=True,
               required=False,
               help='Also show sky serve services, if any.')
+@click.option(
+    '--kubernetes',
+    '--k8s',
+    default=False,
+    is_flag=True,
+    required=False,
+    help='[Experimental] Show all SkyPilot resources (including from other '
+    'users) in the current Kubernetes context.')
 @click.argument('clusters',
                 required=False,
                 type=str,
@@ -1512,7 +1593,7 @@ def _get_services(service_names: Optional[List[str]],
 # pylint: disable=redefined-builtin
 def status(all: bool, refresh: bool, ip: bool, endpoints: bool,
            endpoint: Optional[int], show_managed_jobs: bool,
-           show_services: bool, clusters: List[str]):
+           show_services: bool, kubernetes: bool, clusters: List[str]):
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
     """Show clusters.
 
@@ -1571,6 +1652,9 @@ def status(all: bool, refresh: bool, ip: bool, endpoints: bool,
       or for autostop-enabled clusters, use ``--refresh`` to query the latest
       cluster statuses from the cloud providers.
     """
+    if kubernetes:
+        _status_kubernetes(all)
+        return
     # Using a pool with 2 worker to run the managed job query and sky serve
     # service query in parallel to speed up. The pool provides a AsyncResult
     # object that can be used as a future.
@@ -1730,7 +1814,8 @@ def status(all: bool, refresh: bool, ip: bool, endpoints: bool,
         if show_managed_jobs:
             click.echo(f'\n{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
                        f'Managed jobs{colorama.Style.RESET_ALL}')
-            with rich_utils.safe_status('[cyan]Checking managed jobs[/]'):
+            with rich_utils.safe_status(
+                    ux_utils.spinner_message('Checking managed jobs')):
                 managed_jobs_query_interrupted, result = _try_get_future_result(
                     managed_jobs_future)
                 if managed_jobs_query_interrupted:
@@ -1771,7 +1856,8 @@ def status(all: bool, refresh: bool, ip: bool, endpoints: bool,
                 # The pool is terminated, so we cannot run the service query.
                 msg = 'KeyboardInterrupt'
             else:
-                with rich_utils.safe_status('[cyan]Checking services[/]'):
+                with rich_utils.safe_status(
+                        ux_utils.spinner_message('Checking services')):
                     interrupted, result = _try_get_future_result(
                         services_future)
                     if interrupted:
@@ -2467,8 +2553,8 @@ def start(
                                'is currently not supported.\n'
                                'Please start the former independently.')
     if controllers:
-        bold = backend_utils.BOLD
-        reset_bold = backend_utils.RESET_BOLD
+        bold = ux_utils.BOLD
+        reset_bold = ux_utils.RESET_BOLD
         if len(controllers) != 1:
             raise click.UsageError(
                 'Starting multiple controllers is currently not supported.\n'
@@ -2589,7 +2675,7 @@ def _hint_or_raise_for_down_jobs_controller(controller_name: str):
     assert controller is not None, controller_name
 
     with rich_utils.safe_status(
-            '[bold cyan]Checking for in-progress managed jobs[/]'):
+            ux_utils.spinner_message('Checking for in-progress managed jobs')):
         try:
             managed_jobs_ = managed_jobs.queue(refresh=False,
                                                skip_finished=True)
@@ -2641,7 +2727,8 @@ def _hint_or_raise_for_down_sky_serve_controller(controller_name: str):
     """
     controller = controller_utils.Controllers.from_name(controller_name)
     assert controller is not None, controller_name
-    with rich_utils.safe_status('[bold cyan]Checking for live services[/]'):
+    with rich_utils.safe_status(
+            ux_utils.spinner_message('Checking for live services')):
         try:
             services = serve_lib.status()
         except exceptions.ClusterNotUpError as e:
@@ -2825,9 +2912,9 @@ def _down_or_stop_clusters(
     progress = rich_progress.Progress(transient=True,
                                       redirect_stdout=False,
                                       redirect_stderr=False)
-    task = progress.add_task(
-        f'[bold cyan]{operation} {len(clusters)} cluster{plural}[/]',
-        total=len(clusters))
+    task = progress.add_task(ux_utils.spinner_message(
+        f'{operation} {len(clusters)} cluster{plural}'),
+                             total=len(clusters))
 
     def _down_or_stop(name: str):
         success_progress = False
@@ -3113,7 +3200,12 @@ def show_gpus(
             print_section_titles = False
             # If cloud is kubernetes, we want to show real-time capacity
             if kubernetes_is_enabled and (cloud is None or cloud_is_kubernetes):
-                context = region
+                if region:
+                    context = region
+                else:
+                    # If region is not specified, we use the current context
+                    context = (
+                        kubernetes_utils.get_current_kube_config_context_name())
                 try:
                     # If --cloud kubernetes is not specified, we want to catch
                     # the case where no GPUs are available on the cluster and
@@ -3128,7 +3220,7 @@ def show_gpus(
                 else:
                     print_section_titles = True
                     yield (f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
-                           f'Kubernetes GPUs (Context: {context})'
+                           f'Kubernetes GPUs (context: {context})'
                            f'{colorama.Style.RESET_ALL}\n')
                     yield from k8s_realtime_table.get_string()
                     k8s_node_table = _get_kubernetes_node_info_table(context)
@@ -3591,7 +3683,7 @@ def jobs_launch(
     dag_utils.fill_default_config_in_dag_for_job_launch(dag)
 
     click.secho(f'Managed job {dag.name!r} will be launched on (estimated):',
-                fg='yellow')
+                fg='cyan')
     dag = sky.optimize(dag)
 
     if not yes:
@@ -3685,7 +3777,8 @@ def jobs_queue(all: bool, refresh: bool, skip_finished: bool):
 
     """
     click.secho('Fetching managed job statuses...', fg='yellow')
-    with rich_utils.safe_status('[cyan]Checking managed jobs[/]'):
+    with rich_utils.safe_status(
+            ux_utils.spinner_message('Checking managed jobs')):
         _, msg = _get_managed_jobs(refresh=refresh,
                                    skip_finished=skip_finished,
                                    show_all=all,
@@ -3736,10 +3829,12 @@ def jobs_cancel(name: Optional[str], job_ids: Tuple[int], all: bool, yes: bool):
       # Cancel managed jobs with IDs 1, 2, 3
       $ sky jobs cancel 1 2 3
     """
-    backend_utils.is_controller_accessible(
-        controller=controller_utils.Controllers.JOBS_CONTROLLER,
-        stopped_message='All managed jobs should have finished.',
-        exit_if_not_accessible=True)
+    with rich_utils.safe_status(
+            ux_utils.spinner_message('Checking managed jobs')):
+        backend_utils.is_controller_accessible(
+            controller=controller_utils.Controllers.JOBS_CONTROLLER,
+            stopped_message='All managed jobs should have finished.',
+            exit_if_not_accessible=True)
 
     job_id_str = ','.join(map(str, job_ids))
     if sum([len(job_ids) > 0, name is not None, all]) != 1:
@@ -4301,7 +4396,7 @@ def serve_status(all: bool, endpoint: bool, service_names: List[str]):
       sky serve status my-service
     """
     # This won't pollute the output of --endpoint.
-    with rich_utils.safe_status('[cyan]Checking services[/]'):
+    with rich_utils.safe_status(ux_utils.spinner_message('Checking services')):
         _, msg = _get_services(service_names,
                                show_all=all,
                                show_endpoint=endpoint,
@@ -4725,11 +4820,11 @@ def benchmark_launch(
             f'\n{colorama.Fore.CYAN}Benchmark name: '
             f'{colorama.Style.BRIGHT}{benchmark}{colorama.Style.RESET_ALL}'
             '\nTo see the benchmark results: '
-            f'{backend_utils.BOLD}sky bench show '
-            f'{benchmark}{backend_utils.RESET_BOLD}'
+            f'{ux_utils.BOLD}sky bench show '
+            f'{benchmark}{ux_utils.RESET_BOLD}'
             '\nTo teardown the clusters: '
-            f'{backend_utils.BOLD}sky bench down '
-            f'{benchmark}{backend_utils.RESET_BOLD}')
+            f'{ux_utils.BOLD}sky bench down '
+            f'{benchmark}{ux_utils.RESET_BOLD}')
         subprocess_utils.run('sky bench ls')
     else:
         logger.error('No benchmarking clusters are created.')
@@ -5020,9 +5115,9 @@ def benchmark_delete(benchmarks: Tuple[str], all: Optional[bool],
     progress = rich_progress.Progress(transient=True,
                                       redirect_stdout=False,
                                       redirect_stderr=False)
-    task = progress.add_task(
-        f'[bold cyan]Deleting {len(to_delete)} benchmark{plural}: ',
-        total=len(to_delete))
+    task = progress.add_task(ux_utils.spinner_message(
+        f'Deleting {len(to_delete)} benchmark{plural}'),
+                             total=len(to_delete))
 
     def _delete_benchmark(benchmark: str) -> None:
         clusters = benchmark_state.get_benchmark_clusters(benchmark)
@@ -5037,8 +5132,8 @@ def benchmark_delete(benchmarks: Tuple[str], all: Optional[bool],
             message = (f'{colorama.Fore.YELLOW}Benchmark {benchmark} '
                        f'has {num_clusters} un-terminated cluster{plural}. '
                        f'Terminate the cluster{plural} with '
-                       f'{backend_utils.BOLD} sky bench down {benchmark} '
-                       f'{backend_utils.RESET_BOLD} '
+                       f'{ux_utils.BOLD} sky bench down {benchmark} '
+                       f'{ux_utils.RESET_BOLD} '
                        'before deleting the benchmark report.')
             success = False
         else:
@@ -5139,7 +5234,7 @@ def _deploy_local_cluster(gpus: bool):
                 f'Full log: {log_path}'
                 f'\nError: {style.BRIGHT}{stderr}{style.RESET_ALL}')
     # Run sky check
-    with rich_utils.safe_status('[bold cyan]Running sky check...'):
+    with rich_utils.safe_status(ux_utils.spinner_message('Running sky check')):
         sky_check.check(clouds=['kubernetes'], quiet=True)
     if cluster_created:
         # Prepare completion message which shows CPU and GPU count
@@ -5336,7 +5431,8 @@ def local_down():
                             'local_down.log')
     tail_cmd = 'tail -n100 -f ' + log_path
 
-    with rich_utils.safe_status('[bold cyan]Removing local cluster...'):
+    with rich_utils.safe_status(
+            ux_utils.spinner_message('Removing local cluster')):
         style = colorama.Style
         click.echo('To view detailed progress: '
                    f'{style.BRIGHT}{tail_cmd}{style.RESET_ALL}')
@@ -5359,7 +5455,8 @@ def local_down():
                     f'\nError: {style.BRIGHT}{stderr}{style.RESET_ALL}')
     if cluster_removed:
         # Run sky check
-        with rich_utils.safe_status('[bold cyan]Running sky check...'):
+        with rich_utils.safe_status(
+                ux_utils.spinner_message('Running sky check')):
             sky_check.check(clouds=['kubernetes'], quiet=True)
         click.echo(
             f'{colorama.Fore.GREEN}Local cluster removed.{style.RESET_ALL}')

sky/clouds/service_catalog/aws_catalog.py

@@ -10,8 +10,6 @@ import threading
 import typing
 from typing import Dict, List, Optional, Tuple
 
-import colorama
-
 from sky import exceptions
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
@@ -21,6 +19,8 @@ from sky.clouds.service_catalog import config
 from sky.clouds.service_catalog.data_fetchers import fetch_aws
 from sky.utils import common_utils
 from sky.utils import resources_utils
+from sky.utils import rich_utils
+from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
     import pandas as pd
@@ -82,11 +82,10 @@ def _get_az_mappings(aws_user_hash: str) -> Optional['pd.DataFrame']:
         az_mappings = None
         if aws_user_hash != 'default':
             # Fetch az mapping from AWS.
-            print(
-                f'\r{colorama.Style.DIM}AWS: Fetching availability zones '
-                f'mapping...{colorama.Style.RESET_ALL}',
-                end='')
-            az_mappings = fetch_aws.fetch_availability_zone_mappings()
+            with rich_utils.safe_status(
+                    ux_utils.spinner_message('AWS: Fetching availability '
+                                             'zones mapping')):
+                az_mappings = fetch_aws.fetch_availability_zone_mappings()
         else:
             return None
         az_mappings.to_csv(az_mapping_path, index=False)

sky/clouds/service_catalog/common.py

@@ -198,9 +198,10 @@ def read_catalog(filename: str,
                 if pull_frequency_hours is not None:
                     update_frequency_str = (
                         f' (every {pull_frequency_hours} hours)')
-                with rich_utils.safe_status((f'Updating {cloud} catalog: '
-                                             f'{filename}'
-                                             f'{update_frequency_str}')):
+                with rich_utils.safe_status(
+                        ux_utils.spinner_message(
+                            f'Updating {cloud} catalog: {filename}') +
+                        f'{update_frequency_str}'):
                     try:
                         r = requests.get(url)
                         r.raise_for_status()

sky/clouds/service_catalog/cudo_catalog.py

@@ -14,6 +14,9 @@ _PULL_FREQUENCY_HOURS = 1
 _df = common.read_catalog(cudo_mt.VMS_CSV,
                           pull_frequency_hours=_PULL_FREQUENCY_HOURS)
 
+_DEFAULT_NUM_VCPUS = 8
+_DEFAULT_MEMORY_CPU_RATIO = 2
+
 
 def instance_type_exists(instance_type: str) -> bool:
     return common.instance_type_exists_impl(_df, instance_type)
@@ -52,7 +55,14 @@ def get_default_instance_type(cpus: Optional[str] = None,
     del disk_tier
     # NOTE: After expanding catalog to multiple entries, you may
     # want to specify a default instance type or family.
-    return common.get_instance_type_for_cpus_mem_impl(_df, cpus, memory)
+    if cpus is None and memory is None:
+        cpus = f'{_DEFAULT_NUM_VCPUS}+'
+
+    memory_gb_or_ratio = memory
+    if memory is None:
+        memory_gb_or_ratio = f'{_DEFAULT_MEMORY_CPU_RATIO}x'
+    return common.get_instance_type_for_cpus_mem_impl(_df, cpus,
+                                                      memory_gb_or_ratio)
 
 
 def get_accelerators_from_instance_type(

sky/core.py

@@ -21,6 +21,7 @@ from sky.usage import usage_lib
 from sky.utils import controller_utils
 from sky.utils import rich_utils
 from sky.utils import subprocess_utils
+from sky.utils import ux_utils
 
 if typing.TYPE_CHECKING:
     from sky import resources as resources_lib
@@ -127,8 +128,9 @@ def endpoints(cluster: str,
         RuntimeError: if the cluster has no ports to be exposed or no endpoints
             are exposed yet.
     """
-    with rich_utils.safe_status('[bold cyan]Fetching endpoints for cluster '
-                                f'{cluster}...[/]'):
+    with rich_utils.safe_status(
+            ux_utils.spinner_message(
+                f'Fetching endpoints for cluster {cluster}')):
         return backend_utils.get_endpoints(cluster=cluster, port=port)
 
 

sky/data/storage.py

@@ -1317,8 +1317,8 @@ class S3Store(AbstractStore):
             source_message = source_path_list[0]
 
         with rich_utils.safe_status(
-                f'[bold cyan]Syncing '
-                f'[green]{source_message}[/] to [green]s3://{self.name}/[/]'):
+                ux_utils.spinner_message(f'Syncing {source_message} -> '
+                                         f's3://{self.name}/')):
             data_utils.parallel_upload(
                 source_path_list,
                 get_file_sync_command,
@@ -1445,7 +1445,8 @@ class S3Store(AbstractStore):
                 }
             s3_client.create_bucket(**create_bucket_config)
             logger.info(
-                f'Created S3 bucket {bucket_name!r} in {region or "us-east-1"}')
+                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.
@@ -1486,7 +1487,8 @@ class S3Store(AbstractStore):
         remove_command = f'aws s3 rb s3://{bucket_name} --force'
         try:
             with rich_utils.safe_status(
-                    f'[bold cyan]Deleting S3 bucket {bucket_name}[/]'):
+                    ux_utils.spinner_message(
+                        f'Deleting S3 bucket [green]{bucket_name}')):
                 subprocess.check_output(remove_command.split(' '),
                                         stderr=subprocess.STDOUT)
         except subprocess.CalledProcessError as e:
@@ -1726,8 +1728,8 @@ class GcsStore(AbstractStore):
                         f'cp -e -n -r -I gs://{self.name}')
 
         with rich_utils.safe_status(
-                f'[bold cyan]Syncing '
-                f'[green]{source_message}[/] to [green]gs://{self.name}/[/]'):
+                ux_utils.spinner_message(f'Syncing {source_message} -> '
+                                         f'gs://{self.name}/')):
             data_utils.run_upload_cli(sync_command,
                                       self._ACCESS_DENIED_MESSAGE,
                                       bucket_name=self.name)
@@ -1781,8 +1783,8 @@ class GcsStore(AbstractStore):
             source_message = source_path_list[0]
 
         with rich_utils.safe_status(
-                f'[bold cyan]Syncing '
-                f'[green]{source_message}[/] to [green]gs://{self.name}/[/]'):
+                ux_utils.spinner_message(f'Syncing {source_message} -> '
+                                         f'gs://{self.name}/')):
             data_utils.parallel_upload(
                 source_path_list,
                 get_file_sync_command,
@@ -1904,8 +1906,9 @@ 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:
@@ -1919,7 +1922,8 @@ class GcsStore(AbstractStore):
         """
 
         with rich_utils.safe_status(
-                f'[bold cyan]Deleting GCS bucket {bucket_name}[/]'):
+                ux_utils.spinner_message(
+                    f'Deleting GCS bucket [green]{bucket_name}')):
             try:
                 self.client.get_bucket(bucket_name)
             except gcp.forbidden_exception() as e:
@@ -2306,11 +2310,12 @@ class AzureBlobStore(AbstractStore):
                         resource_group_name)
                 except azure.exceptions().ResourceNotFoundError:
                     with rich_utils.safe_status(
-                            '[bold cyan]Setting up resource group: '
-                            f'{resource_group_name}'):
+                            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 '
+                    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.
@@ -2319,13 +2324,14 @@ class AzureBlobStore(AbstractStore):
                         resource_group_name, storage_account_name)
                 except azure.exceptions().ResourceNotFoundError:
                     with rich_utils.safe_status(
-                            '[bold cyan]Setting up storage account: '
-                            f'{storage_account_name}'):
+                            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 '
+                    logger.info('  Created Azure storage account '
                                 f'{storage_account_name!r}.')
 
         return storage_account_name, resource_group_name
@@ -2514,9 +2520,9 @@ class AzureBlobStore(AbstractStore):
         container_endpoint = data_utils.AZURE_CONTAINER_URL.format(
             storage_account_name=self.storage_account_name,
             container_name=self.name)
-        with rich_utils.safe_status(f'[bold cyan]Syncing '
-                                    f'[green]{source_message}[/] to '
-                                    f'[green]{container_endpoint}/[/]'):
+        with rich_utils.safe_status(
+                ux_utils.spinner_message(
+                    f'Syncing {source_message} -> {container_endpoint}/')):
             data_utils.parallel_upload(
                 source_path_list,
                 get_file_sync_command,
@@ -2665,9 +2671,10 @@ class AzureBlobStore(AbstractStore):
                 self.storage_account_name,
                 container_name,
                 blob_container={})
-            logger.info('Created AZ 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'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():
@@ -2700,7 +2707,8 @@ class AzureBlobStore(AbstractStore):
         """
         try:
             with rich_utils.safe_status(
-                    f'[bold cyan]Deleting Azure container {container_name}[/]'):
+                    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,
@@ -2916,8 +2924,8 @@ class R2Store(AbstractStore):
             source_message = source_path_list[0]
 
         with rich_utils.safe_status(
-                f'[bold cyan]Syncing '
-                f'[green]{source_message}[/] to [green]r2://{self.name}/[/]'):
+                ux_utils.spinner_message(
+                    f'Syncing {source_message} -> r2://{self.name}/')):
             data_utils.parallel_upload(
                 source_path_list,
                 get_file_sync_command,
@@ -3055,7 +3063,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(
@@ -3087,7 +3097,8 @@ class R2Store(AbstractStore):
             f'--profile={cloudflare.R2_PROFILE_NAME}')
         try:
             with rich_utils.safe_status(
-                    f'[bold cyan]Deleting R2 bucket {bucket_name}[/]'):
+                    ux_utils.spinner_message(
+                        f'Deleting R2 bucket {bucket_name}')):
                 subprocess.check_output(remove_command,
                                         stderr=subprocess.STDOUT,
                                         shell=True)
@@ -3354,9 +3365,8 @@ class IBMCosStore(AbstractStore):
             source_message = source_path_list[0]
 
         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 {source_message} -> '
+                                         f'cos://{self.region}/{self.name}/')):
             data_utils.parallel_upload(
                 source_path_list,
                 get_file_sync_command,
@@ -3490,8 +3500,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