skypilot-nightly 1.0.0.dev20250523__py3-none-any.whl → 1.0.0.dev20250526__py3-none-any.whl

sky/server/server.py

@@ -6,6 +6,7 @@ import base64
 import contextlib
 import dataclasses
 import datetime
+import hashlib
 import json
 import logging
 import multiprocessing
@@ -31,6 +32,7 @@ from sky import core
 from sky import exceptions
 from sky import execution
 from sky import global_user_state
+from sky import models
 from sky import sky_logging
 from sky.clouds import service_catalog
 from sky.data import storage_utils
@@ -56,6 +58,7 @@ from sky.utils import dag_utils
 from sky.utils import env_options
 from sky.utils import status_lib
 from sky.utils import subprocess_utils
+from sky.workspaces import server as workspaces_rest
 
 # pylint: disable=ungrouped-imports
 if sys.version_info >= (3, 10):
@@ -110,6 +113,38 @@ class RequestIDMiddleware(starlette.middleware.base.BaseHTTPMiddleware):
         return response
 
 
+def _get_auth_user_header(request: fastapi.Request) -> Optional[models.User]:
+    if 'X-Auth-Request-Email' not in request.headers:
+        return None
+    user_name = request.headers['X-Auth-Request-Email']
+    user_hash = hashlib.md5(
+        user_name.encode()).hexdigest()[:common_utils.USER_HASH_LENGTH]
+    return models.User(id=user_hash, name=user_name)
+
+
+class AuthProxyMiddleware(starlette.middleware.base.BaseHTTPMiddleware):
+    """Middleware to handle auth proxy."""
+
+    async def dispatch(self, request: fastapi.Request, call_next):
+        auth_user = _get_auth_user_header(request)
+        body = await request.body()
+        if auth_user and body:
+            try:
+                original_json = await request.json()
+            except json.JSONDecodeError as e:
+                logger.error(f'Error parsing request JSON: {e}')
+            else:
+                logger.debug(f'Overriding user for {request.state.request_id}: '
+                             f'{auth_user.name}, {auth_user.id}')
+                if 'env_vars' in original_json:
+                    original_json['env_vars'][
+                        constants.USER_ID_ENV_VAR] = auth_user.id
+                    original_json['env_vars'][
+                        constants.USER_ENV_VAR] = auth_user.name
+                request._body = json.dumps(original_json).encode('utf-8')  # pylint: disable=protected-access
+        return await call_next(request)
+
+
 # Default expiration time for upload ids before cleanup.
 _DEFAULT_UPLOAD_EXPIRATION_TIME = datetime.timedelta(hours=1)
 # Key: (upload_id, user_hash), Value: the time when the upload id needs to be
@@ -216,15 +251,29 @@ app.add_middleware(
     allow_headers=['*'],
     # TODO(syang): remove X-Request-ID when v0.10.0 is released.
     expose_headers=['X-Request-ID', 'X-Skypilot-Request-ID'])
+app.add_middleware(AuthProxyMiddleware)
 app.add_middleware(RequestIDMiddleware)
 app.include_router(jobs_rest.router, prefix='/jobs', tags=['jobs'])
 app.include_router(serve_rest.router, prefix='/serve', tags=['serve'])
+app.include_router(workspaces_rest.router,
+                   prefix='/workspaces',
+                   tags=['workspaces'])
 
 
 @app.get('/token')
 async def token(request: fastapi.Request) -> fastapi.responses.HTMLResponse:
+    # If we have auth info, save this user to the database.
+    user = _get_auth_user_header(request)
+    if user is not None:
+        global_user_state.add_or_update_user(user)
+
+    token_data = {
+        'v': 1,  # Token version number, bump for backwards incompatible.
+        'user': user.id if user is not None else None,
+        'cookies': request.cookies,
+    }
     # Use base64 encoding to avoid having to escape anything in the HTML.
-    json_bytes = json.dumps(request.cookies).encode('utf-8')
+    json_bytes = json.dumps(token_data).encode('utf-8')
     base64_str = base64.b64encode(json_bytes).decode('utf-8')
 
     html_dir = pathlib.Path(__file__).parent / 'html'
@@ -236,8 +285,10 @@ async def token(request: fastapi.Request) -> fastapi.responses.HTMLResponse:
         raise fastapi.HTTPException(
             status_code=500, detail='Token page template not found.') from e
 
+    user_info_string = f'Logged in as {user.name}' if user is not None else ''
     html_content = html_content.replace(
-        'SKYPILOT_API_SERVER_USER_TOKEN_PLACEHOLDER', base64_str)
+        'SKYPILOT_API_SERVER_USER_TOKEN_PLACEHOLDER',
+        base64_str).replace('USER_PLACEHOLDER', user_info_string)
 
     return fastapi.responses.HTMLResponse(
         content=html_content,
@@ -263,12 +314,13 @@ async def check(request: fastapi.Request,
 
 
 @app.get('/enabled_clouds')
-async def enabled_clouds(request: fastapi.Request) -> None:
+async def enabled_clouds(request: fastapi.Request,
+                         workspace: Optional[str] = None) -> None:
     """Gets enabled clouds on the server."""
     executor.schedule_request(
         request_id=request.state.request_id,
         request_name='enabled_clouds',
-        request_body=payloads.RequestBody(),
+        request_body=payloads.EnabledCloudsBody(workspace=workspace),
         func=core.enabled_clouds,
         schedule_type=requests_lib.ScheduleType.SHORT,
     )
@@ -1113,7 +1165,7 @@ async def api_status(
 
 
 @app.get('/api/health')
-async def health() -> Dict[str, str]:
+async def health(request: fastapi.Request) -> Dict[str, Any]:
     """Checks the health of the API server.
 
     Returns:
@@ -1125,12 +1177,14 @@ async def health() -> Dict[str, str]:
           disk, which can be used to warn about restarting the API server
         - commit: str; The commit hash of SkyPilot used for API server.
     """
+    user = _get_auth_user_header(request)
     return {
         'status': common.ApiServerStatus.HEALTHY.value,
         'api_version': server_constants.API_VERSION,
         'version': sky.__version__,
         'version_on_disk': common.get_skypilot_version_on_disk(),
         'commit': sky.__commit__,
+        'user': user.to_dict() if user is not None else None,
     }
 
 

sky/setup_files/dependencies.py

@@ -56,6 +56,7 @@ install_requires = [
     'aiofiles',
     'httpx',
     'setproctitle',
+    'sqlalchemy',
 ]
 
 local_ray = [

sky/skylet/constants.py

@@ -378,7 +378,8 @@ OVERRIDEABLE_CONFIG_KEYS_IN_TASK: List[Tuple[str, ...]] = [
 # we skip the following keys because they are meant to be client-side configs.
 SKIPPED_CLIENT_OVERRIDE_KEYS: List[Tuple[str, ...]] = [('admin_policy',),
                                                        ('api_server',),
-                                                       ('allowed_clouds',)]
+                                                       ('allowed_clouds',),
+                                                       ('workspaces',)]
 
 # Constants for Azure blob storage
 WAIT_FOR_STORAGE_ACCOUNT_CREATION = 60
@@ -405,3 +406,5 @@ SKY_USER_FILE_PATH = '~/.sky/generated'
 
 # Environment variable that is set to 'true' if this is a skypilot server.
 ENV_VAR_IS_SKYPILOT_SERVER = 'IS_SKYPILOT_SERVER'
+
+SKYPILOT_DEFAULT_WORKSPACE = 'default'

sky/skypilot_config.py

@@ -57,6 +57,8 @@ import threading
 import typing
 from typing import Any, Dict, Iterator, List, Optional, Tuple
 
+import filelock
+
 from sky import exceptions
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
@@ -66,6 +68,7 @@ from sky.utils import config_utils
 from sky.utils import context
 from sky.utils import schemas
 from sky.utils import ux_utils
+from sky.utils.kubernetes import config_map_utils
 
 if typing.TYPE_CHECKING:
     import yaml
@@ -120,8 +123,17 @@ class ConfigContext:
 
 
 # The global loaded config.
+_active_workspace_context = threading.local()
 _global_config_context = ConfigContext()
-_reload_config_lock = threading.Lock()
+
+SKYPILOT_CONFIG_LOCK_PATH = '~/.sky/locks/.skypilot_config.lock'
+
+
+def get_skypilot_config_lock_path() -> str:
+    """Get the path for the SkyPilot config lock file."""
+    lock_path = os.path.expanduser(SKYPILOT_CONFIG_LOCK_PATH)
+    os.makedirs(os.path.dirname(lock_path), exist_ok=True)
+    return lock_path
 
 
 def _get_config_context() -> ConfigContext:
@@ -194,8 +206,7 @@ def get_user_config() -> config_utils.Config:
 
     # 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)
+        user_config = parse_and_validate_config_file(user_config_path)
     else:
         user_config = config_utils.Config()
     return user_config
@@ -223,8 +234,7 @@ def _get_project_config() -> config_utils.Config:
 
     # 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)
+        project_config = parse_and_validate_config_file(project_config_path)
     else:
         project_config = config_utils.Config()
     return project_config
@@ -252,8 +262,7 @@ def get_server_config() -> config_utils.Config:
 
     # 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)
+        server_config = parse_and_validate_config_file(server_config_path)
     else:
         server_config = config_utils.Config()
     return server_config
@@ -287,6 +296,60 @@ def get_nested(keys: Tuple[str, ...],
         disallowed_override_keys=None)
 
 
+def get_workspace_cloud(cloud: str,
+                        workspace: Optional[str] = None) -> config_utils.Config:
+    """Returns the workspace config."""
+    if workspace is None:
+        workspace = get_active_workspace()
+    clouds = get_nested(keys=(
+        'workspaces',
+        workspace,
+    ), default_value=None)
+    if clouds is None:
+        return config_utils.Config()
+    return clouds.get(cloud.lower(), config_utils.Config())
+
+
+@contextlib.contextmanager
+def local_active_workspace_ctx(workspace: str) -> Iterator[None]:
+    """Temporarily set the active workspace IN CURRENT THREAD.
+
+    Note: having this function thread-local is error-prone, as wrapping some
+    operations with this will not have the underlying threads to get the
+    correct active workspace. However, we cannot make it global either, as
+    backend_utils.refresh_cluster_status() will be called in multiple threads,
+    and they may have different active workspaces for different threads.
+
+    # TODO(zhwu): make this function global by default and able to be set
+    # it to thread-local with an argument.
+
+    Args:
+        workspace: The workspace to set as active.
+
+    Raises:
+        RuntimeError: If called from a non-main thread.
+    """
+    original_workspace = get_active_workspace()
+    if original_workspace == workspace:
+        # No change, do nothing.
+        yield
+        return
+    _active_workspace_context.workspace = workspace
+    logger.debug(f'Set context workspace: {workspace}')
+    yield
+    logger.debug(f'Reset context workspace: {original_workspace}')
+    _active_workspace_context.workspace = original_workspace
+
+
+def get_active_workspace(force_user_workspace: bool = False) -> str:
+    context_workspace = getattr(_active_workspace_context, 'workspace', None)
+    if not force_user_workspace and context_workspace is not None:
+        logger.debug(f'Get context workspace: {context_workspace}')
+        return context_workspace
+    return get_nested(keys=('active_workspace',),
+                      default_value=constants.SKYPILOT_DEFAULT_WORKSPACE)
+
+
 def set_nested(keys: Tuple[str, ...], value: Any) -> Dict[str, Any]:
     """Returns a deep-copied config with the nested key set to value.
 
@@ -336,7 +399,7 @@ def overlay_skypilot_config(
 
 def safe_reload_config() -> None:
     """Reloads the config, safe to be called concurrently."""
-    with _reload_config_lock:
+    with filelock.FileLock(get_skypilot_config_lock_path()):
         _reload_config()
 
 
@@ -357,7 +420,7 @@ def _reload_config() -> None:
         _reload_config_as_client()
 
 
-def parse_config_file(config_path: str) -> config_utils.Config:
+def parse_and_validate_config_file(config_path: str) -> config_utils.Config:
     config = config_utils.Config()
     try:
         config_dict = common_utils.read_yaml(config_path)
@@ -413,7 +476,7 @@ def _reload_config_from_internal_file(internal_config_path: str) -> None:
                 '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}')
-    _set_loaded_config(parse_config_file(config_path))
+    _set_loaded_config(parse_and_validate_config_file(config_path))
     _set_loaded_config_path(config_path)
 
 
@@ -512,6 +575,19 @@ def override_skypilot_config(
         override_configs=dict(override_configs),
         allowed_override_keys=None,
         disallowed_override_keys=constants.SKIPPED_CLIENT_OVERRIDE_KEYS)
+    workspace = config.get_nested(
+        keys=('active_workspace',),
+        default_value=constants.SKYPILOT_DEFAULT_WORKSPACE)
+    if (workspace != constants.SKYPILOT_DEFAULT_WORKSPACE and workspace
+            not in get_nested(keys=('workspaces',), default_value={})):
+        raise ValueError(f'Workspace {workspace} does not exist. '
+                         'Use `sky check` to see if it is defined on the API '
+                         'server and try again.')
+    # Initialize the active workspace context to the workspace specified, so
+    # that a new request is not affected by the previous request's workspace.
+    global _active_workspace_context
+    _active_workspace_context = threading.local()
+
     try:
         common_utils.validate_schema(
             config,
@@ -592,7 +668,7 @@ def _compose_cli_config(cli_config: Optional[List[str]]) -> config_utils.Config:
                     'Cannot use multiple --config flags with a config file.')
             config_source = maybe_config_path
             # cli_config is a path to a config file
-            parsed_config = parse_config_file(maybe_config_path)
+            parsed_config = parse_and_validate_config_file(maybe_config_path)
         else:  # cli_config is a comma-separated list of key-value pairs
             parsed_config = _parse_dotlist(cli_config)
         _validate_config(parsed_config, config_source)
@@ -623,3 +699,23 @@ def apply_cli_config(cli_config: Optional[List[str]]) -> Dict[str, Any]:
         overlay_skypilot_config(original_config=_get_loaded_config(),
                                 override_configs=parsed_config))
     return parsed_config
+
+
+def update_config_no_lock(config: config_utils.Config) -> None:
+    """Dumps the new config to a file and syncs to ConfigMap if in Kubernetes.
+
+    Args:
+        config: The config to save and sync.
+    """
+    global_config_path = os.path.expanduser(get_user_config_path())
+
+    # Always save to the local file (PVC in Kubernetes, local file otherwise)
+    common_utils.dump_yaml(global_config_path, dict(config))
+
+    if config_map_utils.is_running_in_kubernetes():
+        # In Kubernetes, sync the PVC config to ConfigMap for user convenience
+        # PVC file is the source of truth, ConfigMap is just a mirror for easy
+        # access
+        config_map_utils.patch_configmap_with_config(config, global_config_path)
+
+    _reload_config()

sky/utils/cli_utils/status_utils.py

@@ -48,7 +48,8 @@ class StatusColumn:
 def show_status_table(cluster_records: List[_ClusterRecord],
                       show_all: bool,
                       show_user: bool,
-                      query_clusters: Optional[List[str]] = None) -> int:
+                      query_clusters: Optional[List[str]] = None,
+                      show_workspaces: bool = False) -> int:
     """Compute cluster table values and display.
 
     Returns:
@@ -56,7 +57,6 @@ def show_status_table(cluster_records: List[_ClusterRecord],
         STOPPED.
     """
     # TODO(zhwu): Update the information for autostop clusters.
-
     status_columns = [
         StatusColumn('NAME', _get_name),
     ]
@@ -66,6 +66,9 @@ def show_status_table(cluster_records: List[_ClusterRecord],
             StatusColumn('USER_ID', _get_user_hash, show_by_default=False))
 
     status_columns += [
+        StatusColumn('WORKSPACE',
+                     _get_workspace,
+                     show_by_default=show_workspaces),
         StatusColumn('INFRA', _get_infra, truncate=not show_all),
         StatusColumn('RESOURCES', _get_resources, truncate=not show_all),
         StatusColumn('STATUS', _get_status_colored),
@@ -106,12 +109,13 @@ def show_status_table(cluster_records: List[_ClusterRecord],
             for cluster in query_clusters
             if cluster not in cluster_names
         ]
-        cluster_str = 'Cluster'
-        if len(not_found_clusters) > 1:
-            cluster_str += 's'
-        cluster_str += ' '
-        cluster_str += ', '.join(not_found_clusters)
-        click.echo(f'{cluster_str} not found.')
+        if not_found_clusters:
+            cluster_str = 'Cluster'
+            if len(not_found_clusters) > 1:
+                cluster_str += 's'
+            cluster_str += ' '
+            cluster_str += ', '.join(not_found_clusters)
+            click.echo(f'{cluster_str} not found.')
     elif not cluster_records:
         click.echo('No existing clusters.')
     return num_pending_autostop
@@ -243,6 +247,12 @@ def _get_status(cluster_record: _ClusterRecord,
     return cluster_record['status']
 
 
+def _get_workspace(cluster_record: _ClusterRecord,
+                   truncate: bool = True) -> str:
+    del truncate
+    return cluster_record['workspace']
+
+
 def _get_status_colored(cluster_record: _ClusterRecord,
                         truncate: bool = True) -> str:
     del truncate

sky/utils/db_utils.py

@@ -1,9 +1,17 @@
 """Utils for sky databases."""
 import contextlib
+import enum
 import sqlite3
 import threading
+import typing
 from typing import Any, Callable, Optional
 
+import sqlalchemy
+from sqlalchemy import exc as sqlalchemy_exc
+
+if typing.TYPE_CHECKING:
+    from sqlalchemy.orm import Session
+
 # This parameter (passed to sqlite3.connect) controls how long we will wait to
 # obtains a database lock (not necessarily during connection, but whenever it is
 # needed). It is not a connection timeout.
@@ -21,6 +29,11 @@ from typing import Any, Callable, Optional
 _DB_TIMEOUT_S = 60
 
 
+class SQLAlchemyDialect(enum.Enum):
+    SQLITE = 'sqlite'
+    POSTGRESQL = 'postgresql'
+
+
 @contextlib.contextmanager
 def safe_cursor(db_path: str):
     """A newly created, auto-committing, auto-closing cursor."""
@@ -71,6 +84,46 @@ def add_column_to_table(
     conn.commit()
 
 
+def add_column_to_table_sqlalchemy(
+    session: 'Session',
+    table_name: str,
+    column_name: str,
+    column_type: str,
+    copy_from: Optional[str] = None,
+    value_to_replace_existing_entries: Optional[Any] = None,
+):
+    """Add a column to a table."""
+    dialect = session.bind.dialect
+    if dialect.name == SQLAlchemyDialect.SQLITE.value:
+        try:
+            session.execute(
+                sqlalchemy.text(f'ALTER TABLE {table_name} '
+                                f'ADD COLUMN {column_name} {column_type}'))
+            if copy_from is not None:
+                session.execute(
+                    sqlalchemy.text(f'UPDATE {table_name} '
+                                    f'SET {column_name} = {copy_from}'))
+            if value_to_replace_existing_entries is not None:
+                session.execute(
+                    sqlalchemy.text(f'UPDATE {table_name} '
+                                    f'SET {column_name} = :replacement_value '
+                                    f'WHERE {column_name} IS NULL'),
+                    {'replacement_value': value_to_replace_existing_entries})
+        except sqlalchemy_exc.OperationalError as e:
+            if 'duplicate column name' in str(e):
+                pass
+            else:
+                raise
+    elif dialect.name == SQLAlchemyDialect.POSTGRESQL.value:
+        # TODO(syang) support postgres dialect
+        session.rollback()
+        raise ValueError('Unsupported database dialect')
+    else:
+        session.rollback()
+        raise ValueError('Unsupported database dialect')
+    session.commit()
+
+
 def rename_column(
     cursor: 'sqlite3.Cursor',
     conn: 'sqlite3.Connection',

sky/utils/kubernetes/config_map_utils.py

@@ -0,0 +1,133 @@
+"""Utilities for Kubernetes ConfigMap operations in SkyPilot."""
+import os
+
+from sky import sky_logging
+from sky import skypilot_config
+from sky.adaptors import kubernetes
+from sky.utils import common_utils
+
+logger = sky_logging.init_logger(__name__)
+
+# Kubernetes ConfigMap sync constants
+_KUBE_SERVICE_ACCOUNT_PATH = '/var/run/secrets/kubernetes.io/serviceaccount'
+_CONFIGMAP_SYNC_TIMEOUT = 10  # seconds
+
+
+def is_running_in_kubernetes() -> bool:
+    """Check if we're running inside a Kubernetes pod."""
+    return os.path.exists(f'{_KUBE_SERVICE_ACCOUNT_PATH}/token')
+
+
+def _get_kubernetes_namespace() -> str:
+    """Get the current Kubernetes namespace from the service account."""
+    try:
+        namespace_file = f'{_KUBE_SERVICE_ACCOUNT_PATH}/namespace'
+        if os.path.exists(namespace_file):
+            with open(namespace_file, encoding='utf-8') as f:
+                return f.read().strip()
+    except (OSError, IOError):
+        pass
+    return 'default'
+
+
+def _get_configmap_name() -> str:
+    """Get the ConfigMap name for the SkyPilot config."""
+    release_name = (os.getenv('HELM_RELEASE_NAME') or
+                    os.getenv('SKYPILOT_RELEASE_NAME') or 'skypilot')
+    return f'{release_name}-config'
+
+
+def initialize_configmap_sync_on_startup(config_file_path: str) -> None:
+    """Initialize ConfigMap sync on API server startup.
+
+    This syncs existing PVC config to ConfigMap if ConfigMap doesn't exist.
+    This handles the upgrade scenario where an existing deployment has
+    workspace configs on PVC but no ConfigMap exists.
+
+    Args:
+        config_file_path: Path to the config file to sync.
+    """
+    config_file_path = os.path.expanduser(config_file_path)
+    if not is_running_in_kubernetes() or not os.path.exists(config_file_path):
+        return
+
+    try:
+        namespace = _get_kubernetes_namespace()
+        configmap_name = _get_configmap_name()
+
+        # Check if ConfigMap exists
+        try:
+            kubernetes.core_api().read_namespaced_config_map(
+                name=configmap_name, namespace=namespace)
+            # ConfigMap exists, don't overwrite it
+            logger.debug(f'ConfigMap {configmap_name} already exists')
+            return
+        except kubernetes.kubernetes.client.rest.ApiException as e:
+            if e.status != 404:
+                raise
+            # ConfigMap doesn't exist, create it
+
+        current_config = skypilot_config.parse_and_validate_config_file(
+            config_file_path)
+        config_yaml = common_utils.dump_yaml_str(dict(current_config))
+
+        configmap_body = {
+            'apiVersion': 'v1',
+            'kind': 'ConfigMap',
+            'metadata': {
+                'name': configmap_name,
+                'namespace': namespace,
+                'labels': {
+                    'app.kubernetes.io/name': 'skypilot',
+                    'app.kubernetes.io/component': 'config'
+                }
+            },
+            'data': {
+                'config.yaml': config_yaml
+            }
+        }
+
+        kubernetes.core_api().create_namespaced_config_map(
+            namespace=namespace,
+            body=configmap_body,
+            _request_timeout=_CONFIGMAP_SYNC_TIMEOUT)
+
+        logger.info(f'Synced PVC config to new ConfigMap {configmap_name}')
+
+    except Exception as e:  # pylint: disable=broad-except
+        logger.warning(f'Failed to initialize ConfigMap sync: {e}')
+
+
+def patch_configmap_with_config(config, config_file_path: str) -> None:
+    """Patch the Kubernetes ConfigMap with the updated config.
+
+    Args:
+        config: The updated config to sync to the ConfigMap.
+        config_file_path: Path to the config file for fallback sync.
+    """
+    if not is_running_in_kubernetes():
+        return
+
+    try:
+        namespace = _get_kubernetes_namespace()
+        configmap_name = _get_configmap_name()
+        config_yaml = common_utils.dump_yaml_str(dict(config))
+        patch_body = {'data': {'config.yaml': config_yaml}}
+
+        try:
+            kubernetes.core_api().patch_namespaced_config_map(
+                name=configmap_name,
+                namespace=namespace,
+                body=patch_body,
+                _request_timeout=_CONFIGMAP_SYNC_TIMEOUT)
+            logger.debug(f'Synced config to ConfigMap {configmap_name}')
+        except kubernetes.kubernetes.client.rest.ApiException as e:
+            if e.status == 404:
+                # ConfigMap doesn't exist, create it
+                logger.info(f'ConfigMap {configmap_name} not found, creating')
+                initialize_configmap_sync_on_startup(config_file_path)
+            else:
+                raise
+
+    except Exception as e:  # pylint: disable=broad-except
+        logger.warning(f'Failed to sync config to ConfigMap: {e}')