skypilot-nightly 1.0.0.dev20250624__py3-none-any.whl → 1.0.0.dev20250626__py3-none-any.whl

sky/__init__.py

@@ -5,7 +5,7 @@ from typing import Optional
 import urllib.request
 
 # Replaced with the current commit when building the wheels.
-_SKYPILOT_COMMIT_SHA = '0b29731d6bfe91381de57805e1fc1dd723e4b3a0'
+_SKYPILOT_COMMIT_SHA = '512c53be5771c003cd9d94b5b89c23638a5e735e'
 
 
 def _get_git_commit():
@@ -35,7 +35,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20250624'
+__version__ = '1.0.0.dev20250626'
 __root_dir__ = os.path.dirname(os.path.abspath(__file__))
 
 

sky/adaptors/kubernetes.py

@@ -133,12 +133,7 @@ def _load_config(context: Optional[str] = None):
                     '\nHint: Kubernetes attempted to query the current-context '
                     'set in kubeconfig. Check if the current-context is valid.')
             with ux_utils.print_exception_no_traceback():
-                if is_ssh_node_pool:
-                    # For SSH Node Pool, we don't want to surface k8s errors
-                    # (e.g., missing context) unless debug flag is set.
-                    logging.debug(f'Kubernetes error: {suffix}')
-                else:
-                    raise ValueError(err_str) from None
+                raise ValueError(err_str) from None
 
     if context == in_cluster_context_name() or context is None:
         try:

sky/backends/backend_utils.py

@@ -66,6 +66,7 @@ if typing.TYPE_CHECKING:
     from sky import task as task_lib
     from sky.backends import cloud_vm_ray_backend
     from sky.backends import local_docker_backend
+    from sky.volumes import volume as volume_lib
 else:
     yaml = adaptors_common.LazyImport('yaml')
     requests = adaptors_common.LazyImport('requests')
@@ -541,16 +542,18 @@ def get_expirable_clouds(
 # TODO: too many things happening here - leaky abstraction. Refactor.
 @timeline.event
 def write_cluster_config(
-        to_provision: 'resources_lib.Resources',
-        num_nodes: int,
-        cluster_config_template: str,
-        cluster_name: str,
-        local_wheel_path: pathlib.Path,
-        wheel_hash: str,
-        region: clouds.Region,
-        zones: Optional[List[clouds.Zone]] = None,
-        dryrun: bool = False,
-        keep_launch_fields_in_existing_config: bool = True) -> Dict[str, str]:
+    to_provision: 'resources_lib.Resources',
+    num_nodes: int,
+    cluster_config_template: str,
+    cluster_name: str,
+    local_wheel_path: pathlib.Path,
+    wheel_hash: str,
+    region: clouds.Region,
+    zones: Optional[List[clouds.Zone]] = None,
+    dryrun: bool = False,
+    keep_launch_fields_in_existing_config: bool = True,
+    volume_mounts: Optional[List['volume_lib.VolumeMount']] = None,
+) -> Dict[str, str]:
     """Fills in cluster configuration templates and writes them out.
 
     Returns:
@@ -598,7 +601,7 @@ def write_cluster_config(
         resources_utils.ClusterName(
             cluster_name,
             cluster_name_on_cloud,
-        ), region, zones, num_nodes, dryrun)
+        ), region, zones, num_nodes, dryrun, volume_mounts)
     config_dict = {}
 
     specific_reservations = set(
@@ -731,6 +734,15 @@ def write_cluster_config(
     high_availability_specified = controller_utils.high_availability_specified(
         cluster_name)
 
+    volume_mount_vars = []
+    if volume_mounts is not None:
+        for vol in volume_mounts:
+            volume_mount_vars.append({
+                'name': vol.volume_name,
+                'path': vol.path,
+                'volume_name_on_cloud': vol.volume_config.name_on_cloud,
+            })
+
     # Use a tmp file path to avoid incomplete YAML file being re-used in the
     # future.
     tmp_yaml_path = yaml_path + '.tmp'
@@ -821,6 +833,9 @@ def write_cluster_config(
 
                 # High availability
                 'high_availability': high_availability_specified,
+
+                # Volume mounts
+                'volume_mounts': volume_mount_vars,
             }),
         output_path=tmp_yaml_path)
     config_dict['cluster_name'] = cluster_name

sky/backends/cloud_vm_ray_backend.py

@@ -73,6 +73,7 @@ from sky.utils import status_lib
 from sky.utils import subprocess_utils
 from sky.utils import timeline
 from sky.utils import ux_utils
+from sky.volumes import volume as volume_lib
 
 if typing.TYPE_CHECKING:
     from sky import dag
@@ -1327,6 +1328,7 @@ class RetryingVmProvisioner(object):
         prev_handle: Optional['CloudVmRayResourceHandle'],
         prev_cluster_ever_up: bool,
         skip_if_config_hash_matches: Optional[str],
+        volume_mounts: Optional[List[volume_lib.VolumeMount]],
     ) -> Dict[str, Any]:
         """The provision retry loop.
 
@@ -1432,7 +1434,9 @@ class RetryingVmProvisioner(object):
                     region=region,
                     zones=zones,
                     dryrun=dryrun,
-                    keep_launch_fields_in_existing_config=cluster_exists)
+                    keep_launch_fields_in_existing_config=cluster_exists,
+                    volume_mounts=volume_mounts,
+                )
             except exceptions.ResourcesUnavailableError as e:
                 # Failed due to catalog issue, e.g. image not found, or
                 # GPUs are requested in a Kubernetes cluster but the cluster
@@ -2081,7 +2085,9 @@ class RetryingVmProvisioner(object):
                     prev_cluster_status=prev_cluster_status,
                     prev_handle=prev_handle,
                     prev_cluster_ever_up=prev_cluster_ever_up,
-                    skip_if_config_hash_matches=skip_if_config_hash_matches)
+                    skip_if_config_hash_matches=skip_if_config_hash_matches,
+                    volume_mounts=task.volume_mounts,
+                )
                 if dryrun:
                     return config_dict
             except (exceptions.InvalidClusterNameError,
@@ -2435,9 +2441,14 @@ class CloudVmRayResourceHandle(backends.backend.ResourceHandle):
             zip(cluster_internal_ips, cluster_feasible_ips))
 
         # Ensure head node is the first element, then sort based on the
-        # external IPs for stableness
-        stable_internal_external_ips = [internal_external_ips[0]] + sorted(
-            internal_external_ips[1:], key=lambda x: x[1])
+        # external IPs for stableness. Skip for k8s nodes since pods
+        # worker ids are already mapped.
+        if (cluster_info is not None and
+                cluster_info.provider_name == 'kubernetes'):
+            stable_internal_external_ips = internal_external_ips
+        else:
+            stable_internal_external_ips = [internal_external_ips[0]] + sorted(
+                internal_external_ips[1:], key=lambda x: x[1])
         self.stable_internal_external_ips = stable_internal_external_ips
 
     @context_utils.cancellation_guard

sky/client/cli/command.py

@@ -81,6 +81,8 @@ from sky.utils import subprocess_utils
 from sky.utils import timeline
 from sky.utils import ux_utils
 from sky.utils.cli_utils import status_utils
+from sky.volumes import utils as volumes_utils
+from sky.volumes.client import sdk as volumes_sdk
 
 if typing.TYPE_CHECKING:
     import types
@@ -202,13 +204,14 @@ def _get_cluster_records_and_set_ssh_config(
 
 
 def _get_glob_matches(candidate_names: List[str],
-                      glob_patterns: List[str]) -> List[str]:
+                      glob_patterns: List[str],
+                      resource_type: str = 'Storage') -> List[str]:
     """Returns a list of names that match the glob pattern."""
     glob_storages = []
     for glob_pattern in glob_patterns:
         glob_storage = fnmatch.filter(candidate_names, glob_pattern)
         if not glob_storage:
-            click.echo(f'Storage {glob_pattern} not found.')
+            click.echo(f'{resource_type} {glob_pattern} not found.')
         glob_storages.extend(glob_storage)
     return list(set(glob_storages))
 
@@ -290,6 +293,19 @@ def _complete_storage_name(ctx: click.Context, param: click.Parameter,
     return response.json()
 
 
+def _complete_volume_name(ctx: click.Context, param: click.Parameter,
+                          incomplete: str) -> List[str]:
+    """Handle shell completion for volume names."""
+    del ctx, param  # Unused.
+    response = requests_lib.get(
+        f'{server_common.get_server_url()}'
+        f'/api/completion/volume_name?incomplete={incomplete}',
+        timeout=2.0,
+    )
+    response.raise_for_status()
+    return response.json()
+
+
 def _complete_file_name(ctx: click.Context, param: click.Parameter,
                         incomplete: str) -> List[str]:
     """Handle shell completion for file names.
@@ -531,8 +547,9 @@ def _parse_override_params(
     return override_params
 
 
-def _check_yaml(entrypoint: str) -> Tuple[bool, Optional[Dict[str, Any]]]:
-    """Checks if entrypoint is a readable YAML file.
+def _check_yaml_only(
+        entrypoint: str) -> Tuple[bool, Optional[Dict[str, Any]], bool, str]:
+    """Checks if entrypoint is a readable YAML file without confirmation.
 
     Args:
         entrypoint: Path to a YAML file.
@@ -580,6 +597,17 @@ def _check_yaml(entrypoint: str) -> Tuple[bool, Optional[Dict[str, Any]]]:
                 invalid_reason = ('yaml.safe_load() failed. Please check if the'
                                   ' path is correct.')
         is_yaml = False
+    return is_yaml, result, yaml_file_provided, invalid_reason
+
+
+def _check_yaml(entrypoint: str) -> Tuple[bool, Optional[Dict[str, Any]]]:
+    """Checks if entrypoint is a readable YAML file.
+
+    Args:
+        entrypoint: Path to a YAML file.
+    """
+    is_yaml, result, yaml_file_provided, invalid_reason = _check_yaml_only(
+        entrypoint)
     if not is_yaml:
         if yaml_file_provided:
             click.confirm(
@@ -3767,6 +3795,196 @@ def storage_delete(names: List[str], all: bool, yes: bool, async_call: bool):  #
                          f'{colorama.Style.RESET_ALL}')
 
 
+@cli.group(cls=_NaturalOrderGroup)
+def volumes():
+    """SkyPilot Volumes CLI."""
+    pass
+
+
+@volumes.command('apply', cls=_DocumentedCodeCommand)
+@flags.config_option(expose_value=False)
+@click.argument('entrypoint',
+                required=False,
+                type=str,
+                nargs=-1,
+                **_get_shell_complete_args(_complete_file_name))
+@click.option('--name',
+              '-n',
+              required=False,
+              type=str,
+              help='Volume name. Override the name defined in the YAML.')
+@click.option('--infra',
+              required=False,
+              type=str,
+              help='Infra. Format: k8s, k8s/context-name. '
+              'Override the infra defined in the YAML.')
+@click.option(
+    '--type',
+    required=False,
+    type=str,
+    help='Volume type. Format: pvc. Override the type defined in the YAML.')
+@click.option('--size',
+              required=False,
+              type=str,
+              help='Volume size. Override the size defined in the YAML.')
+@click.option('--yes',
+              '-y',
+              is_flag=True,
+              default=False,
+              required=False,
+              help='Skip confirmation prompt.')
+@_add_click_options(flags.COMMON_OPTIONS)
+@usage_lib.entrypoint
+def volumes_apply(
+        entrypoint: Optional[Tuple[str, ...]],
+        name: Optional[str],
+        infra: Optional[str],
+        type: Optional[str],  # pylint: disable=redefined-builtin
+        size: Optional[str],
+        yes: bool,
+        async_call: bool):
+    """Apply a volume.
+
+    Examples:
+
+    .. code-block:: bash
+
+        # Apply a volume from a YAML file.
+        sky volumes apply volume.yaml
+        \b
+        # Apply a volume from a command.
+        sky volumes apply --name pvc1 --infra k8s --type pvc --size 100Gi
+    """
+    # pylint: disable=import-outside-toplevel
+    from sky.volumes import volume as volume_lib
+
+    volume_config_dict: Dict[str, Any] = {}
+    if entrypoint is not None and len(entrypoint) > 0:
+        entrypoint_str = ' '.join(entrypoint)
+        is_yaml, yaml_config, yaml_file_provided, invalid_reason = (
+            _check_yaml_only(entrypoint_str))
+        if not is_yaml:
+            if yaml_file_provided:
+                raise click.BadParameter(f'{entrypoint_str!r} looks like a '
+                                         f'yaml path but {invalid_reason}')
+            else:
+                raise click.BadParameter(
+                    f'{entrypoint_str!r} needs to be a YAML file')
+        if yaml_config is not None:
+            volume_config_dict = yaml_config.copy()
+
+    # Create Volume instance
+    volume = volume_lib.Volume.from_dict(volume_config_dict)
+
+    # Normalize the volume config with CLI options
+    volume.normalize_config(name=name, infra=infra, type=type, size=size)
+
+    logger.debug(f'Volume config: {volume.to_dict()}')
+
+    if not yes:
+        click.confirm(f'Proceed to create volume {volume.name!r}?',
+                      default=True,
+                      abort=True,
+                      show_default=True)
+
+    # Call SDK to create volume
+    try:
+        request_id = volumes_sdk.apply(volume)
+        _async_call_or_wait(request_id, async_call, 'sky.volumes.apply')
+    except RuntimeError as e:
+        logger.error(f'{colorama.Fore.RED}Error applying volume: '
+                     f'{common_utils.format_exception(e, use_bracket=True)}'
+                     f'{colorama.Style.RESET_ALL}')
+
+
+@volumes.command('ls', cls=_DocumentedCodeCommand)
+@flags.config_option(expose_value=False)
+@click.option('--verbose',
+              '-v',
+              default=False,
+              is_flag=True,
+              required=False,
+              help='Show all information in full.')
+@usage_lib.entrypoint
+def volumes_ls(verbose: bool):
+    """List volumes managed by SkyPilot."""
+    request_id = volumes_sdk.ls()
+    all_volumes = sdk.stream_and_get(request_id)
+    volume_table = volumes_utils.format_volume_table(all_volumes,
+                                                     show_all=verbose)
+    click.echo(volume_table)
+
+
+@volumes.command('delete', cls=_DocumentedCodeCommand)
+@flags.config_option(expose_value=False)
+@click.argument('names',
+                required=False,
+                type=str,
+                nargs=-1,
+                **_get_shell_complete_args(_complete_volume_name))
+@click.option('--all',
+              '-a',
+              default=False,
+              is_flag=True,
+              required=False,
+              help='Delete all volumes.')
+@click.option('--yes',
+              '-y',
+              default=False,
+              is_flag=True,
+              required=False,
+              help='Skip confirmation prompt.')
+@_add_click_options(flags.COMMON_OPTIONS)
+@usage_lib.entrypoint
+def volumes_delete(names: List[str], all: bool, yes: bool, async_call: bool):  # pylint: disable=redefined-builtin
+    """Delete volumes.
+
+    Examples:
+
+    .. code-block:: bash
+
+        # Delete two volumes.
+        sky volumes delete pvc1 pvc2
+        \b
+        # Delete all volumes matching glob pattern 'pvc*'.
+        sky volumes delete "pvc*"
+        \b
+        # Delete all volumes.
+        sky volumes delete -a
+    """
+    if sum([bool(names), all]) != 1:
+        raise click.UsageError('Either --all or a name must be specified.')
+    all_volumes = sdk.get(volumes_sdk.ls())
+    if all:
+        if not all_volumes:
+            click.echo('No volumes to delete.')
+            return
+        names = [volume['name'] for volume in all_volumes]
+    else:
+        existing_volume_names = [volume['name'] for volume in all_volumes]
+        names = _get_glob_matches(existing_volume_names,
+                                  names,
+                                  resource_type='Volume')
+    if names:
+        if not yes:
+            volume_names = ', '.join(names)
+            volume_str = 'volumes' if len(names) > 1 else 'volume'
+            click.confirm(
+                f'Deleting {len(names)} {volume_str}: '
+                f'{volume_names}. Proceed?',
+                default=True,
+                abort=True,
+                show_default=True)
+
+        try:
+            _async_call_or_wait(volumes_sdk.delete(names), async_call,
+                                'sky.volumes.delete')
+        except Exception as e:  # pylint: disable=broad-except
+            logger.error(f'{colorama.Fore.RED}Error deleting volumes {names}: '
+                         f'{common_utils.format_exception(e, use_bracket=True)}'
+                         f'{colorama.Style.RESET_ALL}')
+
+
 @cli.group(cls=_NaturalOrderGroup)
 def jobs():
     """Managed Jobs CLI (jobs with auto-recovery)."""
@@ -5186,13 +5404,18 @@ def ssh():
               is_flag=True,
               hidden=True,
               help='Run the command asynchronously.')
-def ssh_up(infra: Optional[str], async_call: bool):
-    """Set up a cluster using SSH targets from ~/.sky/ssh_node_pools.yaml.
+@click.option('--file',
+              '-f',
+              required=False,
+              help='The file containing the SSH targets.')
+def ssh_up(infra: Optional[str], async_call: bool, file: Optional[str]):
+    """Set up a cluster using SSH targets from a file. If not specified,
+    ~/.sky/ssh_node_pools.yaml will be used.
 
-    This command sets up a Kubernetes cluster on the machines specified in
-    ~/.sky/ssh_node_pools.yaml and configures SkyPilot to use it.
+    This command sets up a Kubernetes cluster on the machines specified in the
+    config file and configures SkyPilot to use it.
     """
-    request_id = sdk.ssh_up(infra=infra)
+    request_id = sdk.ssh_up(infra=infra, file=file)
     if async_call:
         print(f'Request submitted with ID: {request_id}')
     else: