skypilot-nightly 1.0.0.dev20250410__py3-none-any.whl → 1.0.0.dev20250412__py3-none-any.whl

sky/provision/kubernetes/utils.py

@@ -1454,14 +1454,14 @@ def is_kubeconfig_exec_auth(
 
 
     Using exec-based authentication is problematic when used in conjunction
-    with kubernetes.remote_identity = LOCAL_CREDENTIAL in ~/.sky/config.yaml.
+    with kubernetes.remote_identity = LOCAL_CREDENTIAL in ~/.sky/skyconfig.yaml.
     This is because the exec-based authentication may not have the relevant
     dependencies installed on the remote cluster or may have hardcoded paths
     that are not available on the remote cluster.
 
     Returns:
         bool: True if exec-based authentication is used and LOCAL_CREDENTIAL
-            mode is used for remote_identity in ~/.sky/config.yaml.
+            mode is used for remote_identity in ~/.sky/skyconfig.yaml.
         str: Error message if exec-based authentication is used, None otherwise
     """
     k8s = kubernetes.kubernetes
@@ -1514,7 +1514,7 @@ def is_kubeconfig_exec_auth(
                     'Managed Jobs or SkyServe controller on Kubernetes. '
                     'To fix, configure SkyPilot to create a service account '
                     'for running pods by setting the following in '
-                    '~/.sky/config.yaml:\n'
+                    '~/.sky/skyconfig.yaml:\n'
                     '    kubernetes:\n'
                     '      remote_identity: SERVICE_ACCOUNT\n'
                     '    More: https://docs.skypilot.co/en/latest/'
@@ -2148,32 +2148,35 @@ def fill_ssh_jump_template(ssh_key_secret: str, ssh_jump_image: str,
     return content
 
 
-def check_port_forward_mode_dependencies() -> None:
-    """Checks if 'socat' and 'nc' are installed"""
+def check_port_forward_mode_dependencies(
+        raise_error: bool = True) -> Optional[List[str]]:
+    """Checks if 'socat' and 'nc' are installed
 
-    # Construct runtime errors
-    socat_default_error = RuntimeError(
-        f'`socat` is required to setup Kubernetes cloud with '
+    Args:
+        raise_error: set to true when the dependencies need to be present.
+            set to false for `sky check`, where reason strings are compiled
+            at the end.
+
+    Returns: the reasons list if there are missing dependencies.
+    """
+
+    # errors
+    socat_message = (
+        '`socat` is required to setup Kubernetes cloud with '
         f'`{kubernetes_enums.KubernetesNetworkingMode.PORTFORWARD.value}` '  # pylint: disable=line-too-long
-        'default networking mode and it is not installed. '
-        'On Debian/Ubuntu, install it with:\n'
-        f'  $ sudo apt install socat\n'
-        f'On MacOS, install it with: \n'
-        f'  $ brew install socat')
-    netcat_default_error = RuntimeError(
-        f'`nc` is required to setup Kubernetes cloud with '
+        'default networking mode and it is not installed. ')
+    netcat_default_message = (
+        '`nc` is required to setup Kubernetes cloud with '
         f'`{kubernetes_enums.KubernetesNetworkingMode.PORTFORWARD.value}` '  # pylint: disable=line-too-long
-        'default networking mode and it is not installed. '
-        'On Debian/Ubuntu, install it with:\n'
-        f'  $ sudo apt install netcat\n'
-        f'On MacOS, install it with: \n'
-        f'  $ brew install netcat')
-    mac_installed_error = RuntimeError(
-        f'The default MacOS `nc` is installed. However, for '
+        'default networking mode and it is not installed. ')
+    netcat_macos_message = (
+        'The default MacOS `nc` is installed. However, for '
         f'`{kubernetes_enums.KubernetesNetworkingMode.PORTFORWARD.value}` '  # pylint: disable=line-too-long
-        'default networking mode, GNU netcat is required. '
-        f'On MacOS, install it with: \n'
-        f'  $ brew install netcat')
+        'default networking mode, GNU netcat is required. ')
+
+    # save
+    reasons = []
+    required_binaries = []
 
     # Ensure socat is installed
     try:
@@ -2182,8 +2185,8 @@ def check_port_forward_mode_dependencies() -> None:
                        stderr=subprocess.DEVNULL,
                        check=True)
     except (FileNotFoundError, subprocess.CalledProcessError):
-        with ux_utils.print_exception_no_traceback():
-            raise socat_default_error from None
+        required_binaries.append('socat')
+        reasons.append(socat_message)
 
     # Ensure netcat is installed
     #
@@ -2198,15 +2201,28 @@ def check_port_forward_mode_dependencies() -> None:
             netcat_output.stderr)
 
         if nc_mac_installed:
-            with ux_utils.print_exception_no_traceback():
-                raise mac_installed_error from None
+            required_binaries.append('netcat')
+            reasons.append(netcat_macos_message)
         elif netcat_output.returncode != 0:
-            with ux_utils.print_exception_no_traceback():
-                raise netcat_default_error from None
+            required_binaries.append('netcat')
+            reasons.append(netcat_default_message)
 
     except FileNotFoundError:
-        with ux_utils.print_exception_no_traceback():
-            raise netcat_default_error from None
+        required_binaries.append('netcat')
+        reasons.append(netcat_default_message)
+
+    if required_binaries:
+        reasons.extend([
+            'On Debian/Ubuntu, install the missing dependenc(ies) with:',
+            f'  $ sudo apt install {" ".join(required_binaries)}',
+            'On MacOS, install with: ',
+            f'  $ brew install {" ".join(required_binaries)}',
+        ])
+        if raise_error:
+            with ux_utils.print_exception_no_traceback():
+                raise RuntimeError('\n'.join(reasons))
+        return reasons
+    return None
 
 
 def get_endpoint_debug_message() -> str:
@@ -2236,7 +2252,7 @@ def combine_pod_config_fields(
     cluster_config_overrides: Dict[str, Any],
 ) -> None:
     """Adds or updates fields in the YAML with fields from the
-    ~/.sky/config.yaml's kubernetes.pod_spec dict.
+    ~/.sky/skyconfig.yaml's kubernetes.pod_spec dict.
     This can be used to add fields to the YAML that are not supported by
     SkyPilot yet, or require simple configuration (e.g., adding an
     imagePullSecrets field).
@@ -2296,7 +2312,7 @@ def combine_pod_config_fields(
 
 def combine_metadata_fields(cluster_yaml_path: str) -> None:
     """Updates the metadata for all Kubernetes objects created by SkyPilot with
-    fields from the ~/.sky/config.yaml's kubernetes.custom_metadata dict.
+    fields from the ~/.sky/skyconfig.yaml's kubernetes.custom_metadata dict.
 
     Obeys the same add or update semantics as combine_pod_config_fields().
     """

sky/serve/client/sdk.py

@@ -74,6 +74,7 @@ def up(
         f'{server_common.get_server_url()}/serve/up',
         json=json.loads(body.model_dump_json()),
         timeout=(5, None),
+        cookies=server_common.get_api_cookie_jar(),
     )
     return server_common.get_request_id(response)
 
@@ -132,6 +133,7 @@ def update(
         f'{server_common.get_server_url()}/serve/update',
         json=json.loads(body.model_dump_json()),
         timeout=(5, None),
+        cookies=server_common.get_api_cookie_jar(),
     )
     return server_common.get_request_id(response)
 
@@ -173,6 +175,7 @@ def down(
         f'{server_common.get_server_url()}/serve/down',
         json=json.loads(body.model_dump_json()),
         timeout=(5, None),
+        cookies=server_common.get_api_cookie_jar(),
     )
     return server_common.get_request_id(response)
 
@@ -207,6 +210,7 @@ def terminate_replica(service_name: str, replica_id: int,
         f'{server_common.get_server_url()}/serve/terminate-replica',
         json=json.loads(body.model_dump_json()),
         timeout=(5, None),
+        cookies=server_common.get_api_cookie_jar(),
     )
     return server_common.get_request_id(response)
 
@@ -279,6 +283,7 @@ def status(
         f'{server_common.get_server_url()}/serve/status',
         json=json.loads(body.model_dump_json()),
         timeout=(5, None),
+        cookies=server_common.get_api_cookie_jar(),
     )
     return server_common.get_request_id(response)
 
@@ -365,6 +370,7 @@ def tail_logs(service_name: str,
         json=json.loads(body.model_dump_json()),
         timeout=(5, None),
         stream=True,
+        cookies=server_common.get_api_cookie_jar(),
     )
     request_id = server_common.get_request_id(response)
     sdk.stream_response(request_id, response, output_stream)

sky/server/common.py

@@ -3,6 +3,7 @@
 import dataclasses
 import enum
 import functools
+from http.cookiejar import MozillaCookieJar
 import json
 import os
 import pathlib
@@ -80,6 +81,18 @@ class ApiServerInfo:
     api_version: ApiVersion
 
 
+def get_api_cookie_jar() -> requests.cookies.RequestsCookieJar:
+    """Returns the cookie jar used by the client to access the API server."""
+    cookie_file = os.environ.get(server_constants.API_COOKIE_FILE_ENV_VAR)
+    cookie_jar = requests.cookies.RequestsCookieJar()
+    if cookie_file and os.path.exists(cookie_file):
+        cookie_path = pathlib.Path(cookie_file).expanduser().resolve()
+        file_cookie_jar = MozillaCookieJar(cookie_path)
+        file_cookie_jar.load()
+        cookie_jar.update(file_cookie_jar)
+    return cookie_jar
+
+
 @annotations.lru_cache(scope='global')
 def get_server_url(host: Optional[str] = None) -> str:
     endpoint = DEFAULT_SERVER_URL
@@ -117,7 +130,9 @@ def get_api_server_status(endpoint: Optional[str] = None) -> ApiServerInfo:
     server_url = endpoint if endpoint is not None else get_server_url()
     while time_out_try_count <= RETRY_COUNT_ON_TIMEOUT:
         try:
-            response = requests.get(f'{server_url}/api/health', timeout=2.5)
+            response = requests.get(f'{server_url}/api/health',
+                                    timeout=2.5,
+                                    cookies=get_api_cookie_jar())
             if response.status_code == 200:
                 try:
                     result = response.json()

sky/server/constants.py

@@ -1,5 +1,7 @@
 """Constants for the API servers."""
 
+from sky.skylet import constants
+
 # API server version, whenever there is a change in API server that requires a
 # restart of the local API server or error out when the client does not match
 # the server version.
@@ -19,3 +21,6 @@ API_SERVER_REQUEST_DB_PATH = '~/.sky/api_server/requests.db'
 # The interval (seconds) for the cluster status to be refreshed in the
 # background.
 CLUSTER_REFRESH_DAEMON_INTERVAL_SECONDS = 60
+
+# Environment variable for a file path to the API cookie file.
+API_COOKIE_FILE_ENV_VAR = f'{constants.SKYPILOT_ENV_VAR_PREFIX}API_COOKIE_FILE'

sky/server/requests/payloads.py

@@ -47,6 +47,8 @@ def request_body_env_vars() -> dict:
     # Remove the path to config file, as the config content is included in the
     # request body and will be merged with the config on the server side.
     env_vars.pop(skypilot_config.ENV_VAR_SKYPILOT_CONFIG, None)
+    env_vars.pop(skypilot_config.ENV_VAR_USER_CONFIG, None)
+    env_vars.pop(skypilot_config.ENV_VAR_PROJECT_CONFIG, None)
     return env_vars
 
 

sky/setup_files/dependencies.py

@@ -131,7 +131,7 @@ extras_require: Dict[str, List[str]] = {
     'scp': local_ray,
     'oci': ['oci'] + local_ray,
     # Kubernetes 32.0.0 has an authentication bug: https://github.com/kubernetes-client/python/issues/2333 # pylint: disable=line-too-long
-    'kubernetes': ['kubernetes>=20.0.0,!=32.0.0'],
+    'kubernetes': ['kubernetes>=20.0.0,!=32.0.0', 'websockets'],
     'remote': remote,
     # For the container registry auth api. Reference:
     # https://github.com/runpod/runpod-python/releases/tag/1.6.1

sky/skylet/constants.py

@@ -117,7 +117,7 @@ RUNPOD_DOCKER_USERNAME_ENV_VAR = 'SKYPILOT_RUNPOD_DOCKER_USERNAME'
 
 # Commands for disable GPU ECC, which can improve the performance of the GPU
 # for some workloads by 30%. This will only be applied when a user specify
-# `nvidia_gpus.disable_ecc: true` in ~/.sky/config.yaml.
+# `nvidia_gpus.disable_ecc: true` in ~/.sky/skyconfig.yaml.
 # Running this command will reboot the machine, introducing overhead for
 # provisioning the machine.
 # https://portal.nutanix.com/page/documents/kbs/details?targetId=kA00e000000LKjOCAW
@@ -337,7 +337,7 @@ RCLONE_LOG_DIR = '~/.sky/rclone_log'
 RCLONE_CACHE_DIR = '~/.cache/rclone'
 RCLONE_CACHE_REFRESH_INTERVAL = 10
 
-# The keys that can be overridden in the `~/.sky/config.yaml` file. The
+# The keys that can be overridden in the `~/.sky/skyconfig.yaml` file. The
 # overrides are specified in task YAMLs.
 OVERRIDEABLE_CONFIG_KEYS_IN_TASK: List[Tuple[str, ...]] = [
     ('docker', 'run_options'),

sky/skypilot_config.py

@@ -1,7 +1,7 @@
 """Immutable user configurations (EXPERIMENTAL).
 
-On module import, we attempt to parse the config located at CONFIG_PATH
-(default: ~/.sky/config.yaml). Caller can then use
+On module import, we attempt to parse the config located at _USER_CONFIG_PATH
+(default: ~/.sky/skyconfig.yaml). Caller can then use
 
   >> skypilot_config.loaded()
 
@@ -35,14 +35,14 @@ Consider the following config contents:
 
 then:
 
-    # Assuming ~/.sky/config.yaml exists and can be loaded:
+    # Assuming ~/.sky/skyconfig.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/config.yaml doesn't exist or failed to be loaded:
+    # If ~/.sky/skyconfig.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,7 +52,6 @@ import contextlib
 import copy
 import os
 import pprint
-import tempfile
 import typing
 from typing import Any, Dict, Iterator, Optional, Tuple
 
@@ -72,26 +71,60 @@ else:
 
 logger = sky_logging.init_logger(__name__)
 
-# The config path is discovered in this order:
+# The config is generated as described below:
 #
-# (1) (Used internally) If env var {ENV_VAR_SKYPILOT_CONFIG} exists, use its
-#     path;
-# (2) If file {CONFIG_PATH} exists, use this file.
+# (*) (Used internally) If env var {ENV_VAR_SKYPILOT_CONFIG} exists, use its
+#     path as the config file. Do not use any other config files.
+#     This behavior is subject to change and should not be relied on by users.
+# Else,
+# (1) If env var {ENV_VAR_USER_CONFIG} exists, use its path as the user
+#     config file. Else, use the default path {_USER_CONFIG_PATH}.
+# (2) If env var {ENV_VAR_PROJECT_CONFIG} exists, use its path as the project
+#     config file. Else, use the default path {_PROJECT_CONFIG_PATH}.
+# (3) Override any config keys in (1) with the ones in (2).
+# (4) Validate the final config.
 #
-# If the path discovered by (1) fails to load, we do not attempt to go to step
-# 2 in the list.
+# (*) is used internally to implement the behavior of the jobs controller.
+#     It is not intended to be used by end users.
+# (1) and (2) are used by end users to set non-default user and project config
+#     files on clients.
 
 # (Used internally) An env var holding the path to the local config file. This
 # is only used by jobs controller tasks to ensure recoveries of the same job
 # use the same config file.
 ENV_VAR_SKYPILOT_CONFIG = f'{constants.SKYPILOT_ENV_VAR_PREFIX}CONFIG'
 
-# Path to the local config file.
-CONFIG_PATH = '~/.sky/config.yaml'
+# (Used by users) Environment variables for setting non-default user and
+# project config files on clients.
+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'
 
 # The loaded config.
 _dict = config_utils.Config()
 _loaded_config_path: Optional[str] = None
+_config_overridden: bool = False
+
+
+# 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
+    return _USER_CONFIG_PATH
 
 
 def get_nested(keys: Tuple[str, ...],
@@ -137,48 +170,156 @@ def to_dict() -> config_utils.Config:
     return copy.deepcopy(_dict)
 
 
+def _get_config_file_path(envvar: str) -> Optional[str]:
+    config_path_via_env_var = os.environ.get(envvar)
+    if config_path_via_env_var is not None:
+        return os.path.expanduser(config_path_via_env_var)
+    return None
+
+
+def _validate_config(config: Dict[str, Any], config_path: str) -> None:
+    """Validates the config."""
+    common_utils.validate_schema(
+        config,
+        schemas.get_config_schema(),
+        f'Invalid config YAML ({config_path}). See: '
+        'https://docs.skypilot.co/en/latest/reference/config.html. '  # pylint: disable=line-too-long
+        'Error: ',
+        skip_none=False)
+
+
+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."""
+    if original_config is None:
+        original_config = config_utils.Config()
+    config = original_config.get_nested(keys=tuple(),
+                                        default_value=None,
+                                        override_configs=override_configs,
+                                        allowed_override_keys=None,
+                                        disallowed_override_keys=None)
+    return config
+
+
 def _reload_config() -> None:
+    internal_config_path = os.environ.get(ENV_VAR_SKYPILOT_CONFIG)
+    if internal_config_path is not None:
+        # {ENV_VAR_SKYPILOT_CONFIG} is used internally.
+        # When this environment variable is set, the config loading
+        # behavior is not defined in the public interface.
+        # SkyPilot reserves the right to change the config loading behavior
+        # at any time when this environment variable is set.
+        _reload_config_from_internal_file(internal_config_path)
+        return
+
+    _reload_config_hierarchical()
+
+
+def _parse_config_file(config_path: str) -> config_utils.Config:
+    config = config_utils.Config()
+    try:
+        config_dict = common_utils.read_yaml(config_path)
+        config = config_utils.Config.from_dict(config_dict)
+        logger.debug(
+            f'Config loaded from {config_path}:\n{pprint.pformat(config)}')
+    except yaml.YAMLError as e:
+        logger.error(f'Error in loading config file ({config_path}):', e)
+    if config:
+        _validate_config(config, config_path)
+
+    logger.debug(f'Config syntax check passed for path: {config_path}')
+    return config
+
+
+def _reload_config_from_internal_file(internal_config_path: str) -> None:
     global _dict, _loaded_config_path
     # Reset the global variables, to avoid using stale values.
     _dict = config_utils.Config()
     _loaded_config_path = None
 
-    config_path_via_env_var = os.environ.get(ENV_VAR_SKYPILOT_CONFIG)
-    if config_path_via_env_var is not None:
-        config_path = os.path.expanduser(config_path_via_env_var)
-        if not os.path.exists(config_path):
+    config_path = os.path.expanduser(internal_config_path)
+    if not os.path.exists(config_path):
+        with ux_utils.print_exception_no_traceback():
+            raise FileNotFoundError(
+                'Config file specified by env var '
+                f'{ENV_VAR_SKYPILOT_CONFIG} ({config_path!r}) does not '
+                'exist. Please double check the path or unset the env var: '
+                f'unset {ENV_VAR_SKYPILOT_CONFIG}')
+    logger.debug(f'Using config path: {config_path}')
+    _dict = _parse_config_file(config_path)
+    _loaded_config_path = config_path
+
+
+def _reload_config_hierarchical() -> 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 = []
+
+    # 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_SKYPILOT_CONFIG} ({config_path!r}) does not '
-                    'exist. Please double check the path or unset the env var: '
-                    f'unset {ENV_VAR_SKYPILOT_CONFIG}')
+                    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:
-        config_path = CONFIG_PATH
-    config_path = os.path.expanduser(config_path)
-    if os.path.exists(config_path):
-        logger.debug(f'Using config path: {config_path}')
-        try:
-            config = common_utils.read_yaml(config_path)
-            _dict = config_utils.Config.from_dict(config)
-            _loaded_config_path = config_path
-            logger.debug(f'Config loaded:\n{pprint.pformat(_dict)}')
-        except yaml.YAMLError as e:
-            logger.error(f'Error in loading config file ({config_path}):', e)
-        if _dict:
-            common_utils.validate_schema(
-                _dict,
-                schemas.get_config_schema(),
-                f'Invalid config YAML ({config_path}). See: '
-                'https://docs.skypilot.co/en/latest/reference/config.html. '  # pylint: disable=line-too-long
-                'Error: ',
-                skip_none=False)
-
-        logger.debug('Config syntax check passed.')
+        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)
+
+    if os.path.exists(project_config_path):
+        project_config = _parse_config_file(project_config_path)
+        _validate_config(project_config, project_config_path)
+        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(
+            original_config=overlaid_client_config, override_configs=override)
+    logger.debug(f'final config: {overlaid_client_config}')
+    _dict = overlaid_client_config
 
 
 def loaded_config_path() -> Optional[str]:
-    """Returns the path to the loaded config file."""
+    """Returns the path to the loaded config file, or
+    '<overridden>' if the config is overridden."""
+    if _config_overridden:
+        return '<overridden>'
     return _loaded_config_path
 
 
@@ -195,31 +336,30 @@ def loaded() -> bool:
 def override_skypilot_config(
         override_configs: Optional[Dict[str, Any]]) -> Iterator[None]:
     """Overrides the user configurations."""
+    global _dict, _config_overridden
     # TODO(SKY-1215): allow admin user to extend the disallowed keys or specify
     # allowed keys.
     if not override_configs:
         # If no override configs (None or empty dict), do nothing.
         yield
         return
-    original_env_config_path = _loaded_config_path
-    original_config = dict(_dict)
+    original_config = _dict
     config = _dict.get_nested(
         keys=tuple(),
         default_value=None,
         override_configs=override_configs,
         allowed_override_keys=None,
         disallowed_override_keys=constants.SKIPPED_CLIENT_OVERRIDE_KEYS)
-    with tempfile.NamedTemporaryFile(
-            mode='w',
-            prefix='skypilot_config',
-            # Have to avoid deleting the file as the underlying function needs
-            # to read the config file, and we need to close the file mode='w'
-            # to enable reading.
-            delete=False) as f:
-        common_utils.dump_yaml(f.name, dict(config))
-        os.environ[ENV_VAR_SKYPILOT_CONFIG] = f.name
     try:
-        _reload_config()
+        common_utils.validate_schema(
+            config,
+            schemas.get_config_schema(),
+            'Invalid config. See: '
+            'https://docs.skypilot.co/en/latest/reference/config.html. '  # pylint: disable=line-too-long
+            'Error: ',
+            skip_none=False)
+        _config_overridden = True
+        _dict = config
         yield
     except exceptions.InvalidSkyPilotConfigError as e:
         with ux_utils.print_exception_no_traceback():
@@ -227,23 +367,10 @@ def override_skypilot_config(
                 'Failed to override the SkyPilot config on API '
                 'server with your local SkyPilot config:\n'
                 '=== SkyPilot config on API server ===\n'
-                f'{common_utils.dump_yaml_str(original_config)}\n'
+                f'{common_utils.dump_yaml_str(dict(original_config))}\n'
                 '=== Your local SkyPilot config ===\n'
                 f'{common_utils.dump_yaml_str(override_configs)}\n'
                 f'Details: {e}') from e
-
     finally:
-        if original_env_config_path is not None:
-            os.environ[ENV_VAR_SKYPILOT_CONFIG] = original_env_config_path
-        else:
-            os.environ.pop(ENV_VAR_SKYPILOT_CONFIG, None)
-        # Reload the config to restore the original config to avoid the next
-        # request reusing the same process to use the config for the current
-        # request.
-        _reload_config()
-
-        try:
-            os.remove(f.name)
-        except Exception:  # pylint: disable=broad-except
-            # Failing to delete the file is not critical.
-            pass
+        _dict = original_config
+        _config_overridden = False