[Deprecate] Deprecate sky local up ip-list (#8065)

* deprecate local up ip list

* bump api server version

Author: kyuds

sky/client/cli/command.py

@@ -6239,33 +6239,6 @@ def local():
               is_flag=True,
               help='Launch cluster without GPU support even '
               'if GPUs are detected on the host.')
-@click.option(
-    '--ips',
-    type=str,
-    required=False,
-    help='Path to the file containing IP addresses of remote machines.')
-@click.option('--ssh-user',
-              type=str,
-              required=False,
-              help='SSH username for accessing remote machines.')
-@click.option('--ssh-key-path',
-              type=str,
-              required=False,
-              help='Path to the SSH private key.')
-@click.option('--cleanup',
-              is_flag=True,
-              help='Clean up the remote cluster instead of deploying it.')
-@click.option(
-    '--context-name',
-    type=str,
-    required=False,
-    help='Name to use for the kubeconfig context. Defaults to "default". '
-    'Used with the ip list.')
-@click.option('--password',
-              type=str,
-              required=False,
-              help='Password for the ssh-user to execute sudo commands. '
-              'Required only if passwordless sudo is not setup.')
 @click.option(
     '--name',
     type=str,
@@ -6282,56 +6255,10 @@ def local():
 @flags.config_option(expose_value=False)
 @_add_click_options(flags.COMMON_OPTIONS)
 @usage_lib.entrypoint
-def local_up(gpus: bool, ips: str, ssh_user: str, ssh_key_path: str,
-             cleanup: bool, context_name: Optional[str],
-             password: Optional[str], name: Optional[str],
-             port_start: Optional[int], async_call: bool):
-    """Creates a local or remote cluster."""
-
-    def _validate_args(ips, ssh_user, ssh_key_path, cleanup):
-        # If any of --ips, --ssh-user, or --ssh-key-path is specified,
-        # all must be specified
-        if bool(ips) or bool(ssh_user) or bool(ssh_key_path):
-            if not (ips and ssh_user and ssh_key_path):
-                raise click.BadParameter(
-                    'All --ips, --ssh-user, and --ssh-key-path '
-                    'must be specified together.')
-
-        # --cleanup can only be used if --ips, --ssh-user and --ssh-key-path
-        # are all provided
-        if cleanup and not (ips and ssh_user and ssh_key_path):
-            raise click.BadParameter('--cleanup can only be used with '
-                                     '--ips, --ssh-user and --ssh-key-path.')
-
-    _validate_args(ips, ssh_user, ssh_key_path, cleanup)
-
-    # If remote deployment arguments are specified, run remote up script
-    ip_list = None
-    ssh_key = None
-    if ips and ssh_user and ssh_key_path:
-        # Read and validate IP file
-        try:
-            with open(os.path.expanduser(ips), 'r', encoding='utf-8') as f:
-                ip_list = f.read().strip().splitlines()
-            if not ip_list:
-                raise click.BadParameter(f'IP file is empty: {ips}')
-        except (IOError, OSError) as e:
-            raise click.BadParameter(f'Failed to read IP file {ips}: {str(e)}')
-
-        # Read and validate SSH key file
-        try:
-            with open(os.path.expanduser(ssh_key_path), 'r',
-                      encoding='utf-8') as f:
-                ssh_key = f.read()
-            if not ssh_key:
-                raise click.BadParameter(
-                    f'SSH key file is empty: {ssh_key_path}')
-        except (IOError, OSError) as e:
-            raise click.BadParameter(
-                f'Failed to read SSH key file {ssh_key_path}: {str(e)}')
-
-    request_id = sdk.local_up(gpus, ip_list, ssh_user, ssh_key, cleanup,
-                              context_name, password, name, port_start)
+def local_up(gpus: bool, name: Optional[str], port_start: Optional[int],
+             async_call: bool):
+    """Creates a local cluster."""
+    request_id = sdk.local_up(gpus, name, port_start)
     _async_call_or_wait(request_id, async_call, request_name='local up')
 
 
@@ -6344,12 +6271,7 @@ def _validate_args(ips, ssh_user, ssh_key_path, cleanup):
 @_add_click_options(flags.COMMON_OPTIONS)
 @usage_lib.entrypoint
 def local_down(name: Optional[str], async_call: bool):
-    """Deletes a local cluster.
-
-    This will only delete a local cluster started without the ip list.
-    To clean up the local cluster started with a ip list, use `sky local up`
-    with the cleanup flag.
-    """
+    """Deletes a local cluster."""
     request_id = sdk.local_down(name)
     _async_call_or_wait(request_id, async_call, request_name='sky.local.down')
 

sky/client/sdk.py

@@ -1712,12 +1712,6 @@ def storage_delete(name: str) -> server_common.RequestId[None]:
 @server_common.check_server_healthy_or_start
 @annotations.client_api
 def local_up(gpus: bool,
-             ips: Optional[List[str]],
-             ssh_user: Optional[str],
-             ssh_key: Optional[str],
-             cleanup: bool,
-             context_name: Optional[str] = None,
-             password: Optional[str] = None,
              name: Optional[str] = None,
              port_start: Optional[int] = None) -> server_common.RequestId[None]:
     """Launches a Kubernetes cluster on local machines.
@@ -1733,15 +1727,7 @@ def local_up(gpus: bool,
             raise ValueError('`sky local up` is only supported when '
                              'running SkyPilot locally.')
 
-    body = payloads.LocalUpBody(gpus=gpus,
-                                ips=ips,
-                                ssh_user=ssh_user,
-                                ssh_key=ssh_key,
-                                cleanup=cleanup,
-                                context_name=context_name,
-                                password=password,
-                                name=name,
-                                port_start=port_start)
+    body = payloads.LocalUpBody(gpus=gpus, name=name, port_start=port_start)
     response = server_common.make_authenticated_request(
         'POST', '/local_up', json=json.loads(body.model_dump_json()))
     return server_common.get_request_id(response)

sky/client/sdk_async.py

@@ -656,19 +656,13 @@ async def storage_delete(
 @annotations.client_api
 async def local_up(
         gpus: bool,
-        ips: Optional[List[str]],
-        ssh_user: Optional[str],
-        ssh_key: Optional[str],
-        cleanup: bool,
-        context_name: Optional[str] = None,
         name: Optional[str] = None,
-        password: Optional[str] = None,
+        port_start: Optional[int] = None,
         stream_logs: Optional[StreamConfig] = DEFAULT_STREAM_CONFIG) -> None:
     """Async version of local_up() that launches a Kubernetes cluster on
     local machines."""
-    request_id = await context_utils.to_thread(sdk.local_up, gpus, ips,
-                                               ssh_user, ssh_key, cleanup,
-                                               context_name, name, password)
+    request_id = await context_utils.to_thread(sdk.local_up, gpus, name,
+                                               port_start)
     if stream_logs is not None:
         return await _stream_and_get(request_id, stream_logs)
     else:

sky/core.py

@@ -1293,44 +1293,10 @@ def _realtime_kubernetes_gpu_availability_single(
 # =================
 @usage_lib.entrypoint
 def local_up(gpus: bool,
-             ips: Optional[List[str]],
-             ssh_user: Optional[str],
-             ssh_key: Optional[str],
-             cleanup: bool,
-             context_name: Optional[str] = None,
-             password: Optional[str] = None,
              name: Optional[str] = None,
              port_start: Optional[int] = None) -> None:
-    """Creates a local or remote cluster."""
-
-    def _validate_args(ips, ssh_user, ssh_key, cleanup):
-        # If any of --ips, --ssh-user, or --ssh-key-path is specified,
-        # all must be specified
-        if bool(ips) or bool(ssh_user) or bool(ssh_key):
-            if not (ips and ssh_user and ssh_key):
-                with ux_utils.print_exception_no_traceback():
-                    raise ValueError(
-                        'All ips, ssh_user, and ssh_key must be specified '
-                        'together.')
-
-        # --cleanup can only be used if --ips, --ssh-user and --ssh-key-path
-        # are all provided
-        if cleanup and not (ips and ssh_user and ssh_key):
-            with ux_utils.print_exception_no_traceback():
-                raise ValueError(
-                    'cleanup can only be used with ips, ssh_user and ssh_key.')
-
-    _validate_args(ips, ssh_user, ssh_key, cleanup)
-
-    # If remote deployment arguments are specified, run remote up script
-    if ips:
-        assert ssh_user is not None and ssh_key is not None
-        kubernetes_deploy_utils.deploy_remote_cluster(ips, ssh_user, ssh_key,
-                                                      cleanup, context_name,
-                                                      password)
-    else:
-        # Run local deployment (kind) if no remote args are specified
-        kubernetes_deploy_utils.deploy_local_cluster(name, port_start, gpus)
+    """Creates a local cluster."""
+    kubernetes_deploy_utils.deploy_local_cluster(name, port_start, gpus)
 
 
 def local_down(name: Optional[str] = None) -> None:

sky/server/constants.py

@@ -10,7 +10,7 @@
 # based on version info is needed.
 # For more details and code guidelines, refer to:
 # https://docs.skypilot.co/en/latest/developers/CONTRIBUTING.html#backward-compatibility-guidelines
-API_VERSION = 23
+API_VERSION = 24
 
 # The minimum peer API version that the code should still work with.
 # Notes (dev):

sky/server/requests/payloads.py

@@ -695,12 +695,6 @@ class ListAcceleratorCountsBody(RequestBody):
 class LocalUpBody(RequestBody):
     """The request body for the local up endpoint."""
     gpus: bool = True
-    ips: Optional[List[str]] = None
-    ssh_user: Optional[str] = None
-    ssh_key: Optional[str] = None
-    cleanup: bool = False
-    context_name: Optional[str] = None
-    password: Optional[str] = None
     name: Optional[str] = None
     port_start: Optional[int] = None
 

sky/utils/kubernetes/kubernetes_deploy_utils.py

@@ -170,94 +170,6 @@ def deploy_ssh_cluster(cleanup: bool = False,
                     is_local=True))
 
 
-def deploy_remote_cluster(ip_list: List[str],
-                          ssh_user: str,
-                          ssh_key: str,
-                          cleanup: bool,
-                          context_name: Optional[str] = None,
-                          password: Optional[str] = None):
-    success = False
-    path_to_package = os.path.dirname(__file__)
-    up_script_path = os.path.join(path_to_package, 'deploy_remote_cluster.py')
-    # Get directory of script and run it from there
-    cwd = os.path.dirname(os.path.abspath(up_script_path))
-
-    # Create temporary files for the IPs and SSH key
-    with tempfile.NamedTemporaryFile(mode='w') as ip_file, \
-         tempfile.NamedTemporaryFile(mode='w') as key_file:
-
-        # Write IPs and SSH key to temporary files
-        ip_file.write('\n'.join(ip_list))
-        ip_file.flush()
-
-        key_file.write(ssh_key)
-        key_file.flush()
-        os.chmod(key_file.name, 0o600)
-
-        # Use the legacy mode command line arguments for backward compatibility
-        deploy_command = [
-            sys.executable, up_script_path, '--ips-file', ip_file.name,
-            '--user', ssh_user, '--ssh-key', key_file.name
-        ]
-
-        if context_name is not None:
-            deploy_command.extend(['--context-name', context_name])
-        if password is not None:
-            deploy_command.extend(['--password', password])
-        if cleanup:
-            deploy_command.append('--cleanup')
-
-        # Setup logging paths
-        run_timestamp = sky_logging.get_run_timestamp()
-        log_path = os.path.join(constants.SKY_LOGS_DIRECTORY, run_timestamp,
-                                'local_up.log')
-
-        if cleanup:
-            msg_str = 'Cleaning up remote cluster...'
-        else:
-            msg_str = 'Deploying remote cluster...'
-
-        # Create environment with PYTHONUNBUFFERED=1 to ensure unbuffered output
-        env = os.environ.copy()
-        env['PYTHONUNBUFFERED'] = '1'
-
-        with rich_utils.safe_status(
-                ux_utils.spinner_message(msg_str,
-                                         log_path=log_path,
-                                         is_local=True)):
-            returncode, _, stderr = log_lib.run_with_log(
-                cmd=deploy_command,
-                log_path=log_path,
-                require_outputs=True,
-                stream_logs=False,
-                line_processor=log_utils.SkyRemoteUpLineProcessor(
-                    log_path=log_path, is_local=True),
-                cwd=cwd,
-                env=env)
-        if returncode == 0:
-            success = True
-        else:
-            with ux_utils.print_exception_no_traceback():
-                log_hint = ux_utils.log_path_hint(log_path, is_local=True)
-                raise RuntimeError('Failed to deploy remote cluster. '
-                                   f'Full log: {log_hint}'
-                                   f'\nError: {stderr}')
-
-        if success:
-            if cleanup:
-                logger.info(
-                    ux_utils.finishing_message(
-                        '🎉 Remote cluster cleaned up successfully.',
-                        log_path=log_path,
-                        is_local=True))
-            else:
-                logger.info(
-                    ux_utils.finishing_message(
-                        '🎉 Remote cluster deployed successfully.',
-                        log_path=log_path,
-                        is_local=True))
-
-
 def generate_kind_config(port_start: int,
                          num_nodes: int = 1,
                          gpus: bool = False) -> str: