skypilot-nightly 1.0.0.dev20250413__py3-none-any.whl → 1.0.0.dev20250417__py3-none-any.whl

sky/skypilot_config.py

@@ -1,7 +1,7 @@
 """Immutable user configurations (EXPERIMENTAL).
 
 On module import, we attempt to parse the config located at _USER_CONFIG_PATH
-(default: ~/.sky/skyconfig.yaml). Caller can then use
+(default: ~/.sky/config.yaml). Caller can then use
 
   >> skypilot_config.loaded()
 
@@ -35,14 +35,14 @@ Consider the following config contents:
 
 then:
 
-    # Assuming ~/.sky/skyconfig.yaml exists and can be loaded:
+    # Assuming ~/.sky/config.yaml exists and can be loaded:
     skypilot_config.loaded()  # ==> True
 
     skypilot_config.get_nested(('a', 'nested'), None)    # ==> 1
     skypilot_config.get_nested(('a', 'nonexist'), None)  # ==> None
     skypilot_config.get_nested(('a',), None)             # ==> {'nested': 1}
 
-    # If ~/.sky/skyconfig.yaml doesn't exist or failed to be loaded:
+    # If ~/.sky/config.yaml doesn't exist or failed to be loaded:
     skypilot_config.loaded()  # ==> False
     skypilot_config.get_nested(('a', 'nested'), None)    # ==> None
     skypilot_config.get_nested(('a', 'nonexist'), None)  # ==> None
@@ -52,8 +52,11 @@ import contextlib
 import copy
 import os
 import pprint
+import threading
 import typing
-from typing import Any, Dict, Iterator, Optional, Tuple
+from typing import Any, Dict, Iterator, List, Optional, Tuple
+
+from omegaconf import OmegaConf
 
 from sky import exceptions
 from sky import sky_logging
@@ -99,34 +102,115 @@ ENV_VAR_SKYPILOT_CONFIG = f'{constants.SKYPILOT_ENV_VAR_PREFIX}CONFIG'
 ENV_VAR_USER_CONFIG = f'{constants.SKYPILOT_ENV_VAR_PREFIX}USER_CONFIG'
 ENV_VAR_PROJECT_CONFIG = f'{constants.SKYPILOT_ENV_VAR_PREFIX}PROJECT_CONFIG'
 
-# Path to the local config files.
-_LEGACY_USER_CONFIG_PATH = '~/.sky/config.yaml'
-_USER_CONFIG_PATH = '~/.sky/skyconfig.yaml'
-_PROJECT_CONFIG_PATH = 'skyconfig.yaml'
+# (Used by server) Environment variable for setting the server config file.
+ENV_VAR_SERVER_CONFIG = f'{constants.SKYPILOT_ENV_VAR_PREFIX}SERVER_CONFIG'
+
+# Path to the client config files.
+_USER_CONFIG_PATH = '~/.sky/config.yaml'
+_PROJECT_CONFIG_PATH = '.sky.yaml'
+
+# Path to the server config file.
+_SERVER_CONFIG_PATH = _USER_CONFIG_PATH
 
 # The loaded config.
 _dict = config_utils.Config()
 _loaded_config_path: Optional[str] = None
 _config_overridden: bool = False
+_reload_config_lock = threading.Lock()
 
 
-# This function exists solely to maintain backward compatibility with the
-# legacy user config file located at ~/.sky/config.yaml.
 def get_user_config_path() -> str:
-    """Returns the path to the user config file.
-
-    If only the legacy user config file exists, return
-    the legacy user config path.
-    Otherwise, return the new user config path.
-    """
-    user_config_path = os.path.expanduser(_USER_CONFIG_PATH)
-    legacy_user_config_path = os.path.expanduser(_LEGACY_USER_CONFIG_PATH)
-    if (os.path.exists(legacy_user_config_path) and
-            not os.path.exists(user_config_path)):
-        return _LEGACY_USER_CONFIG_PATH
+    """Returns the path to the user config file."""
     return _USER_CONFIG_PATH
 
 
+def get_user_config() -> config_utils.Config:
+    """Returns the user config."""
+    # find the user config file
+    user_config_path = _get_config_file_path(ENV_VAR_USER_CONFIG)
+    if user_config_path:
+        logger.debug('using user config file specified by '
+                     f'{ENV_VAR_USER_CONFIG}: {user_config_path}')
+        user_config_path = os.path.expanduser(user_config_path)
+        if not os.path.exists(user_config_path):
+            with ux_utils.print_exception_no_traceback():
+                raise FileNotFoundError(
+                    'Config file specified by env var '
+                    f'{ENV_VAR_USER_CONFIG} ({user_config_path!r}) '
+                    'does not exist. Please double check the path or unset the '
+                    f'env var: unset {ENV_VAR_USER_CONFIG}')
+    else:
+        user_config_path = get_user_config_path()
+        logger.debug(f'using default user config file: {user_config_path}')
+        user_config_path = os.path.expanduser(user_config_path)
+
+    # load the user config file
+    if os.path.exists(user_config_path):
+        user_config = _parse_config_file(user_config_path)
+        _validate_config(user_config, user_config_path)
+    else:
+        user_config = config_utils.Config()
+    return user_config
+
+
+def _get_project_config() -> config_utils.Config:
+    # find the project config file
+    project_config_path = _get_config_file_path(ENV_VAR_PROJECT_CONFIG)
+    if project_config_path:
+        logger.debug('using project config file specified by '
+                     f'{ENV_VAR_PROJECT_CONFIG}: {project_config_path}')
+        project_config_path = os.path.expanduser(project_config_path)
+        if not os.path.exists(project_config_path):
+            with ux_utils.print_exception_no_traceback():
+                raise FileNotFoundError(
+                    'Config file specified by env var '
+                    f'{ENV_VAR_PROJECT_CONFIG} ({project_config_path!r}) '
+                    'does not exist. Please double check the path or unset the '
+                    f'env var: unset {ENV_VAR_PROJECT_CONFIG}')
+    else:
+        logger.debug(
+            f'using default project config file: {_PROJECT_CONFIG_PATH}')
+        project_config_path = _PROJECT_CONFIG_PATH
+        project_config_path = os.path.expanduser(project_config_path)
+
+    # load the project config file
+    if os.path.exists(project_config_path):
+        project_config = _parse_config_file(project_config_path)
+        _validate_config(project_config, project_config_path)
+    else:
+        project_config = config_utils.Config()
+    return project_config
+
+
+def get_server_config() -> config_utils.Config:
+    """Returns the server config."""
+    # find the server config file
+    server_config_path = _get_config_file_path(ENV_VAR_SERVER_CONFIG)
+    if server_config_path:
+        logger.debug('using server config file specified by '
+                     f'{ENV_VAR_SERVER_CONFIG}: {server_config_path}')
+        server_config_path = os.path.expanduser(server_config_path)
+        if not os.path.exists(server_config_path):
+            with ux_utils.print_exception_no_traceback():
+                raise FileNotFoundError(
+                    'Config file specified by env var '
+                    f'{ENV_VAR_SERVER_CONFIG} ({server_config_path!r}) '
+                    'does not exist. Please double check the path or unset the '
+                    f'env var: unset {ENV_VAR_SERVER_CONFIG}')
+    else:
+        server_config_path = _SERVER_CONFIG_PATH
+        logger.debug(f'using default server config file: {server_config_path}')
+        server_config_path = os.path.expanduser(server_config_path)
+
+    # load the server config file
+    if os.path.exists(server_config_path):
+        server_config = _parse_config_file(server_config_path)
+        _validate_config(server_config, server_config_path)
+    else:
+        server_config = config_utils.Config()
+    return server_config
+
+
 def get_nested(keys: Tuple[str, ...],
                default_value: Any,
                override_configs: Optional[Dict[str, Any]] = None) -> Any:
@@ -177,18 +261,18 @@ def _get_config_file_path(envvar: str) -> Optional[str]:
     return None
 
 
-def _validate_config(config: Dict[str, Any], config_path: str) -> None:
+def _validate_config(config: Dict[str, Any], config_source: str) -> None:
     """Validates the config."""
     common_utils.validate_schema(
         config,
         schemas.get_config_schema(),
-        f'Invalid config YAML ({config_path}). See: '
+        f'Invalid config YAML from ({config_source}). See: '
         'https://docs.skypilot.co/en/latest/reference/config.html. '  # pylint: disable=line-too-long
         'Error: ',
         skip_none=False)
 
 
-def _overlay_skypilot_config(
+def overlay_skypilot_config(
         original_config: Optional[config_utils.Config],
         override_configs: Optional[config_utils.Config]) -> config_utils.Config:
     """Overlays the override configs on the original configs."""
@@ -202,6 +286,12 @@ def _overlay_skypilot_config(
     return config
 
 
+def safe_reload_config() -> None:
+    """Reloads the config, safe to be called concurrently."""
+    with _reload_config_lock:
+        _reload_config()
+
+
 def _reload_config() -> None:
     internal_config_path = os.environ.get(ENV_VAR_SKYPILOT_CONFIG)
     if internal_config_path is not None:
@@ -213,7 +303,10 @@ def _reload_config() -> None:
         _reload_config_from_internal_file(internal_config_path)
         return
 
-    _reload_config_hierarchical()
+    if os.environ.get(constants.ENV_VAR_IS_SKYPILOT_SERVER) is not None:
+        _reload_config_as_server()
+    else:
+        _reload_config_as_client()
 
 
 def _parse_config_file(config_path: str) -> config_utils.Config:
@@ -251,67 +344,44 @@ def _reload_config_from_internal_file(internal_config_path: str) -> None:
     _loaded_config_path = config_path
 
 
-def _reload_config_hierarchical() -> None:
+def _reload_config_as_server() -> None:
     global _dict
     # Reset the global variables, to avoid using stale values.
     _dict = config_utils.Config()
 
-    # find the user config file
-    user_config_path = _get_config_file_path(ENV_VAR_USER_CONFIG)
-    if user_config_path:
-        logger.debug('using user config file specified by '
-                     f'{ENV_VAR_USER_CONFIG}: {user_config_path}')
-        user_config_path = os.path.expanduser(user_config_path)
-        if not os.path.exists(user_config_path):
-            with ux_utils.print_exception_no_traceback():
-                raise FileNotFoundError(
-                    'Config file specified by env var '
-                    f'{ENV_VAR_USER_CONFIG} ({user_config_path!r}) '
-                    'does not exist. Please double check the path or unset the '
-                    f'env var: unset {ENV_VAR_USER_CONFIG}')
-    else:
-        user_config_path = get_user_config_path()
-        logger.debug(f'using default user config file: {user_config_path}')
-        user_config_path = os.path.expanduser(user_config_path)
+    overrides: List[config_utils.Config] = []
+    server_config = get_server_config()
+    if server_config:
+        overrides.append(server_config)
 
-    overrides = []
+    # layer the configs on top of each other based on priority
+    overlaid_server_config: config_utils.Config = config_utils.Config()
+    for override in overrides:
+        overlaid_server_config = overlay_skypilot_config(
+            original_config=overlaid_server_config, override_configs=override)
+    logger.debug(f'final server config: {overlaid_server_config}')
+    _dict = overlaid_server_config
 
-    # find the project config file
-    project_config_path = _get_config_file_path(ENV_VAR_PROJECT_CONFIG)
-    if project_config_path:
-        logger.debug('using project config file specified by '
-                     f'{ENV_VAR_PROJECT_CONFIG}: {project_config_path}')
-        project_config_path = os.path.expanduser(project_config_path)
-        if not os.path.exists(project_config_path):
-            with ux_utils.print_exception_no_traceback():
-                raise FileNotFoundError(
-                    'Config file specified by env var '
-                    f'{ENV_VAR_PROJECT_CONFIG} ({project_config_path!r}) '
-                    'does not exist. Please double check the path or unset the '
-                    f'env var: unset {ENV_VAR_PROJECT_CONFIG}')
-    else:
-        logger.debug(
-            f'using default project config file: {_PROJECT_CONFIG_PATH}')
-        project_config_path = _PROJECT_CONFIG_PATH
-        project_config_path = os.path.expanduser(project_config_path)
 
-    # load the user config file
-    if os.path.exists(user_config_path):
-        user_config = _parse_config_file(user_config_path)
-        _validate_config(user_config, user_config_path)
-        overrides.append(user_config)
+def _reload_config_as_client() -> None:
+    global _dict
+    # Reset the global variables, to avoid using stale values.
+    _dict = config_utils.Config()
 
-    if os.path.exists(project_config_path):
-        project_config = _parse_config_file(project_config_path)
-        _validate_config(project_config, project_config_path)
+    overrides: List[config_utils.Config] = []
+    user_config = get_user_config()
+    if user_config:
+        overrides.append(user_config)
+    project_config = _get_project_config()
+    if project_config:
         overrides.append(project_config)
 
     # layer the configs on top of each other based on priority
     overlaid_client_config: config_utils.Config = config_utils.Config()
     for override in overrides:
-        overlaid_client_config = _overlay_skypilot_config(
+        overlaid_client_config = overlay_skypilot_config(
             original_config=overlaid_client_config, override_configs=override)
-    logger.debug(f'final config: {overlaid_client_config}')
+    logger.debug(f'final client config: {overlaid_client_config}')
     _dict = overlaid_client_config
 
 
@@ -323,7 +393,7 @@ def loaded_config_path() -> Optional[str]:
     return _loaded_config_path
 
 
-# Load on import.
+# Load on import, synchronization is guaranteed by python interpreter.
 _reload_config()
 
 
@@ -374,3 +444,54 @@ def override_skypilot_config(
     finally:
         _dict = original_config
         _config_overridden = False
+
+
+def _compose_cli_config(cli_config: Optional[str],) -> config_utils.Config:
+    """Composes the skypilot CLI config.
+    CLI config can either be:
+    - A path to a config file
+    - A comma-separated list of key-value pairs
+    """
+
+    if not cli_config:
+        return config_utils.Config()
+
+    config_source = 'CLI'
+    maybe_config_path = os.path.expanduser(cli_config)
+    try:
+        if os.path.isfile(maybe_config_path):
+            config_source = maybe_config_path
+            # cli_config is a path to a config file
+            parsed_config = OmegaConf.to_object(
+                OmegaConf.load(maybe_config_path))
+        else:  # cli_config is a comma-separated list of key-value pairs
+            variables: List[str] = []
+            variables = cli_config.split(',')
+            parsed_config = OmegaConf.to_object(
+                OmegaConf.from_dotlist(variables))
+        _validate_config(parsed_config, config_source)
+    except ValueError as e:
+        raise ValueError(f'Invalid config override: {cli_config}. '
+                         f'Check if config file exists or if the dotlist '
+                         f'is formatted as: key1=value1,key2=value2') from e
+    logger.debug('CLI overrides config syntax check passed.')
+
+    return parsed_config
+
+
+def apply_cli_config(cli_config: Optional[str]) -> Dict[str, Any]:
+    """Applies the CLI provided config.
+    SAFETY:
+    This function directly modifies the global _dict variable.
+    This is considered fine in CLI context because the program will exit after
+    a single CLI command is executed.
+    Args:
+        cli_config: A path to a config file or a comma-separated
+        list of key-value pairs.
+    """
+    global _dict
+    parsed_config = _compose_cli_config(cli_config)
+    logger.debug(f'applying following CLI overrides: {parsed_config}')
+    _dict = overlay_skypilot_config(original_config=_dict,
+                                    override_configs=parsed_config)
+    return parsed_config

sky/templates/kubernetes-ray.yml.j2

@@ -96,7 +96,7 @@ provider:
             name: skypilot-service-account-role
             apiGroup: rbac.authorization.k8s.io
 
-    # Role for the skypilot-system namespace to create FUSE device manager and
+    # Role for the skypilot-system namespace to create fusermount-server and
     # any other system components.
     autoscaler_skypilot_system_role:
         kind: Role

sky/utils/cli_utils/status_utils.py

@@ -6,8 +6,8 @@ import click
 import colorama
 
 from sky import backends
-from sky.skylet import constants
 from sky.utils import common_utils
+from sky.utils import controller_utils
 from sky.utils import log_utils
 from sky.utils import resources_utils
 from sky.utils import status_lib
@@ -198,12 +198,19 @@ def show_cost_report_table(cluster_records: List[_ClusterCostReportRecord],
 
     if cluster_records:
         if controller_name is not None:
-            autostop_minutes = constants.CONTROLLER_IDLE_MINUTES_TO_AUTOSTOP
+            controller = controller_utils.Controllers.from_name(controller_name)
+            if controller is None:
+                raise ValueError(f'Controller {controller_name} not found.')
+            autostop_minutes, _ = (
+                controller_utils.get_controller_autostop_config(
+                    controller=controller))
+            if autostop_minutes is not None:
+                autostop_str = (f'{colorama.Style.DIM} (will be autostopped if '
+                                f'idle for {autostop_minutes}min)'
+                                f'{colorama.Style.RESET_ALL}')
             click.echo(f'\n{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
                        f'{controller_name}{colorama.Style.RESET_ALL}'
-                       f'{colorama.Style.DIM} (will be autostopped if idle for '
-                       f'{autostop_minutes}min)'
-                       f'{colorama.Style.RESET_ALL}')
+                       f'{autostop_str}')
         else:
             click.echo(f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}Clusters'
                        f'{colorama.Style.RESET_ALL}')

sky/utils/config_utils.py

@@ -112,14 +112,39 @@ def _recursive_update(
         disallowed_override_keys: Optional[List[Tuple[str,
                                                       ...]]] = None) -> Config:
     """Recursively updates base configuration with override configuration"""
+
+    def _update_k8s_config(
+        base_config: Config,
+        override_config: Dict[str, Any],
+        allowed_override_keys: Optional[List[Tuple[str, ...]]] = None,
+        disallowed_override_keys: Optional[List[Tuple[str,
+                                                      ...]]] = None) -> Config:
+        """Updates the top-level k8s config with the override config."""
+        for key, value in override_config.items():
+            (next_allowed_override_keys, next_disallowed_override_keys
+            ) = _check_allowed_and_disallowed_override_keys(
+                key, allowed_override_keys, disallowed_override_keys)
+            if key in ['custom_metadata', 'pod_config'] and key in base_config:
+                merge_k8s_configs(base_config[key], value,
+                                  next_allowed_override_keys,
+                                  next_disallowed_override_keys)
+            elif (isinstance(value, dict) and key in base_config and
+                  isinstance(base_config[key], dict)):
+                _recursive_update(base_config[key], value,
+                                  next_allowed_override_keys,
+                                  next_disallowed_override_keys)
+            else:
+                base_config[key] = value
+        return base_config
+
     for key, value in override_config.items():
         (next_allowed_override_keys, next_disallowed_override_keys
         ) = _check_allowed_and_disallowed_override_keys(
             key, allowed_override_keys, disallowed_override_keys)
         if key == 'kubernetes' and key in base_config:
-            merge_k8s_configs(base_config[key], value,
-                              next_allowed_override_keys,
-                              next_disallowed_override_keys)
+            _update_k8s_config(base_config[key], value,
+                               next_allowed_override_keys,
+                               next_disallowed_override_keys)
         elif (isinstance(value, dict) and key in base_config and
               isinstance(base_config[key], dict)):
             _recursive_update(base_config[key], value,
@@ -185,19 +210,19 @@ def merge_k8s_configs(
                 merge_k8s_configs(base_config[key][0], value[0],
                                   next_allowed_override_keys,
                                   next_disallowed_override_keys)
-            elif key in ['volumes', 'volumeMounts']:
-                # If the key is 'volumes' or 'volumeMounts', we search for
-                # item with the same name and merge it.
-                for new_volume in value:
-                    new_volume_name = new_volume.get('name')
-                    if new_volume_name is not None:
-                        destination_volume = next(
+            elif key in ['volumes', 'volumeMounts', 'initContainers']:
+                # If the key is 'volumes', 'volumeMounts', or 'initContainers',
+                # we search for item with the same name and merge it.
+                for override_item in value:
+                    override_item_name = override_item.get('name')
+                    if override_item_name is not None:
+                        existing_base_item = next(
                             (v for v in base_config[key]
-                             if v.get('name') == new_volume_name), None)
-                        if destination_volume is not None:
-                            merge_k8s_configs(destination_volume, new_volume)
+                             if v.get('name') == override_item_name), None)
+                        if existing_base_item is not None:
+                            merge_k8s_configs(existing_base_item, override_item)
                         else:
-                            base_config[key].append(new_volume)
+                            base_config[key].append(override_item)
             else:
                 base_config[key].extend(value)
         else:

sky/utils/controller_utils.py

@@ -6,7 +6,7 @@ import getpass
 import os
 import tempfile
 import typing
-from typing import Any, Dict, Iterable, List, Optional, Set
+from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
 import uuid
 
 import colorama
@@ -46,7 +46,7 @@ logger = sky_logging.init_logger(__name__)
 # controller resources spec.
 CONTROLLER_RESOURCES_NOT_VALID_MESSAGE = (
     '{controller_type} controller resources is not valid, please check '
-    '~/.sky/skyconfig.yaml file and make sure '
+    '~/.sky/config.yaml file and make sure '
     '{controller_type}.controller.resources is a valid resources spec. '
     'Details:\n  {err}')
 
@@ -72,6 +72,7 @@ class _ControllerSpec:
     default_hint_if_non_existent: str
     connection_error_hint: str
     default_resources_config: Dict[str, Any]
+    default_autostop_config: Dict[str, Any]
 
     @property
     def decline_down_when_failed_to_fetch_status_hint(self) -> str:
@@ -118,7 +119,8 @@ class Controllers(enum.Enum):
         default_hint_if_non_existent='No in-progress managed jobs.',
         connection_error_hint=(
             'Failed to connect to jobs controller, please try again later.'),
-        default_resources_config=managed_job_constants.CONTROLLER_RESOURCES)
+        default_resources_config=managed_job_constants.CONTROLLER_RESOURCES,
+        default_autostop_config=managed_job_constants.CONTROLLER_AUTOSTOP)
     SKY_SERVE_CONTROLLER = _ControllerSpec(
         controller_type='serve',
         name='serve controller',
@@ -148,7 +150,8 @@ class Controllers(enum.Enum):
         default_hint_if_non_existent='No live services.',
         connection_error_hint=(
             'Failed to connect to serve controller, please try again later.'),
-        default_resources_config=serve_constants.CONTROLLER_RESOURCES)
+        default_resources_config=serve_constants.CONTROLLER_RESOURCES,
+        default_autostop_config=serve_constants.CONTROLLER_AUTOSTOP)
 
     @classmethod
     def from_name(cls, name: Optional[str]) -> Optional['Controllers']:
@@ -262,8 +265,9 @@ def _get_cloud_dependencies_installation_commands(
                 '  ARCH="amd64"; '
                 'fi && '
                 '(command -v kubectl &>/dev/null || '
-                '("https://dl.k8s.io/release/v1.31.6/bin/linux/$ARCH/kubectl" '
-                '&& sudo install -o root -g root -m 0755 '
+                '(curl -s -LO "https://dl.k8s.io/release/v1.31.6'
+                '/bin/linux/$ARCH/kubectl" && '
+                'sudo install -o root -g root -m 0755 '
                 'kubectl /usr/local/bin/kubectl))')
         elif isinstance(cloud, clouds.Cudo):
             step_prefix = prefix_str.replace('<step>', str(len(commands) + 1))
@@ -601,6 +605,40 @@ def get_controller_resources(
     return result
 
 
+def get_controller_autostop_config(
+        controller: Controllers) -> Tuple[Optional[int], bool]:
+    """Get the autostop config for the controller.
+
+    Returns:
+      A tuple of (idle_minutes_to_autostop, down), which correspond to the
+      values passed to execution.launch().
+    """
+    controller_autostop_config_copied: Dict[str, Any] = copy.copy(
+        controller.value.default_autostop_config)
+    if skypilot_config.loaded():
+        custom_controller_autostop_config = skypilot_config.get_nested(
+            (controller.value.controller_type, 'controller', 'autostop'), None)
+        if custom_controller_autostop_config is False:
+            # Disabled with `autostop: false` in config.
+            # To indicate autostop is disabled, we return None for
+            # idle_minutes_to_autostop.
+            return None, False
+        elif custom_controller_autostop_config is True:
+            # Enabled with default values. There is no change in behavior, but
+            # this is included by for completeness, since `False` is valid.
+            pass
+        elif custom_controller_autostop_config is not None:
+            # We have specific config values.
+            # Override the controller autostop config with the ones specified in
+            # the config.
+            assert isinstance(custom_controller_autostop_config, dict)
+            controller_autostop_config_copied.update(
+                custom_controller_autostop_config)
+
+    return (controller_autostop_config_copied['idle_minutes'],
+            controller_autostop_config_copied['down'])
+
+
 def _setup_proxy_command_on_controller(
         controller_launched_cloud: 'clouds.Cloud',
         user_config: Dict[str, Any]) -> config_utils.Config:

sky/utils/kubernetes/generate_kubeconfig.sh

@@ -328,9 +328,9 @@ cp kubeconfig ~/.kube/config
 # Verify that you can access the cluster
 kubectl get pods
 
-Also add this to your ~/.sky/skyconfig.yaml to use the new service account:
+Also add this to your ~/.sky/config.yaml to use the new service account:
 
-# ~/.sky/skyconfig.yaml
+# ~/.sky/config.yaml
 kubernetes:
   remote_identity: ${SKYPILOT_SA}
 "