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

sky/utils/kubernetes/deploy_remote_cluster.py

@@ -14,6 +14,8 @@ from typing import Any, Dict, List, Optional, Set
 
 import yaml
 
+from sky.utils import ux_utils
+
 # Colors for nicer UX
 RED = '\033[0;31m'
 GREEN = '\033[0;32m'
@@ -117,21 +119,19 @@ def parse_args():
 def load_ssh_targets(file_path: str) -> Dict[str, Any]:
     """Load SSH targets from YAML file."""
     if not os.path.exists(file_path):
-        print(f'{RED}Error: SSH Node Pools file not found: {file_path}{NC}',
-              file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(f'SSH Node Pools file not found: {file_path}')
 
     try:
         with open(file_path, 'r', encoding='utf-8') as f:
             targets = yaml.load(f, Loader=UniqueKeySafeLoader)
         return targets
     except yaml.constructor.ConstructorError as e:
-        print(f'{RED}{e.note}{NC}', file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(e.note) from e
     except (yaml.YAMLError, IOError, OSError) as e:
-        print(f'{RED}Error loading SSH Node Pools file: {e}{NC}',
-              file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(f'Error loading SSH Node Pools file: {e}') from e
 
 
 def check_host_in_ssh_config(hostname: str) -> bool:
@@ -181,31 +181,28 @@ def get_cluster_config(targets: Dict[str, Any],
                        file_path: Optional[str] = None) -> Dict[str, Any]:
     """Get configuration for specific clusters or all clusters."""
     if not targets:
-        print(
-            f'{RED}Error: No clusters defined in SSH Node Pools '
-            f'file {file_path}{NC}',
-            file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(
+                f'No clusters defined in SSH Node Pools file {file_path}')
 
     if cluster_name:
         if cluster_name not in targets:
-            print(
-                f'{RED}Error: Cluster {cluster_name!r} not found in '
-                f'SSH Node Pools file {file_path}{NC}',
-                file=sys.stderr)
-            sys.exit(1)
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(f'Cluster {cluster_name!r} not found in '
+                                 f'SSH Node Pools file {file_path}')
         return {cluster_name: targets[cluster_name]}
 
     # Return all clusters if no specific cluster is specified
     return targets
 
 
-def prepare_hosts_info(cluster_config: Dict[str, Any]) -> List[Dict[str, str]]:
+def prepare_hosts_info(cluster_name: str,
+                       cluster_config: Dict[str, Any]) -> List[Dict[str, str]]:
     """Prepare list of hosts with resolved user, identity_file, and password."""
     if 'hosts' not in cluster_config or not cluster_config['hosts']:
-        print(f'{RED}Error: No hosts defined in cluster configuration{NC}',
-              file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise ValueError(
+                f'No hosts defined in cluster {cluster_name} configuration')
 
     # Get cluster-level defaults
     cluster_user = cluster_config.get('user', '')
@@ -627,6 +624,9 @@ def main():
     kubeconfig_path = os.path.expanduser(args.kubeconfig_path)
     global_use_ssh_config = args.use_ssh_config
 
+    failed_clusters = []
+    successful_clusters = []
+
     # Print cleanup mode marker if applicable
     if args.cleanup:
         print('SKYPILOT_CLEANUP_MODE: Cleanup mode activated')
@@ -636,23 +636,20 @@ def main():
         # Using command line arguments - legacy mode
         if args.ssh_key and not os.path.isfile(
                 args.ssh_key) and not global_use_ssh_config:
-            print(f'{RED}Error: SSH key not found: {args.ssh_key}{NC}',
-                  file=sys.stderr)
-            sys.exit(1)
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(f'SSH key not found: {args.ssh_key}')
 
         if not os.path.isfile(args.ips_file):
-            print(f'{RED}Error: IPs file not found: {args.ips_file}{NC}',
-                  file=sys.stderr)
-            sys.exit(1)
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(f'IPs file not found: {args.ips_file}')
 
         with open(args.ips_file, 'r', encoding='utf-8') as f:
             hosts = [line.strip() for line in f if line.strip()]
 
         if not hosts:
-            print(
-                f'{RED}Error: Hosts file is empty or not formatted correctly.{NC}',
-                file=sys.stderr)
-            sys.exit(1)
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(
+                    'Hosts file is empty or not formatted correctly.')
 
         head_node = hosts[0]
         worker_nodes = hosts[1:]
@@ -688,108 +685,132 @@ def main():
 
         # Process each cluster
         for cluster_name, cluster_config in clusters_config.items():
-            print(f'SKYPILOT_CURRENT_CLUSTER: {cluster_name}')
-            print(f'{YELLOW}==== Deploying cluster: {cluster_name} ====${NC}')
-            hosts_info = prepare_hosts_info(cluster_config)
-
-            if not hosts_info:
+            try:
+                print(f'SKYPILOT_CURRENT_CLUSTER: {cluster_name}')
                 print(
-                    f'{RED}Error: No valid hosts found for cluster {cluster_name!r}. Skipping.{NC}'
-                )
-                continue
-
-            # Generate a unique context name for each cluster
-            context_name = args.context_name
-            if context_name == 'default':
-                context_name = 'ssh-' + cluster_name
-
-            # Check cluster history
-            os.makedirs(NODE_POOLS_INFO_DIR, exist_ok=True)
-            history_yaml_file = os.path.join(NODE_POOLS_INFO_DIR,
-                                             f'{context_name}-history.yaml')
-
-            history = None
-            if os.path.exists(history_yaml_file):
-                print(f'{YELLOW}Loading history from {history_yaml_file}{NC}')
-                with open(history_yaml_file, 'r', encoding='utf-8') as f:
-                    history = yaml.safe_load(f)
-            else:
-                print(f'{YELLOW}No history found for {context_name}.{NC}')
-
-            history_workers_info = None
-            history_worker_nodes = None
-            history_use_ssh_config = None
-            # Do not support changing anything besides hosts for now
-            if history is not None:
-                for key in ['user', 'identity_file', 'password']:
-                    if history.get(key) != cluster_config.get(key):
+                    f'{YELLOW}==== Deploying cluster: {cluster_name} ====${NC}')
+                hosts_info = prepare_hosts_info(cluster_name, cluster_config)
+
+                if not hosts_info:
+                    print(
+                        f'{RED}Error: No valid hosts found for cluster {cluster_name!r}. Skipping.{NC}'
+                    )
+                    continue
+
+                # Generate a unique context name for each cluster
+                context_name = args.context_name
+                if context_name == 'default':
+                    context_name = 'ssh-' + cluster_name
+
+                # Check cluster history
+                os.makedirs(NODE_POOLS_INFO_DIR, exist_ok=True)
+                history_yaml_file = os.path.join(
+                    NODE_POOLS_INFO_DIR, f'{context_name}-history.yaml')
+
+                history = None
+                if os.path.exists(history_yaml_file):
+                    print(
+                        f'{YELLOW}Loading history from {history_yaml_file}{NC}')
+                    with open(history_yaml_file, 'r', encoding='utf-8') as f:
+                        history = yaml.safe_load(f)
+                else:
+                    print(f'{YELLOW}No history found for {context_name}.{NC}')
+
+                history_workers_info = None
+                history_worker_nodes = None
+                history_use_ssh_config = None
+                # Do not support changing anything besides hosts for now
+                if history is not None:
+                    for key in ['user', 'identity_file', 'password']:
+                        if history.get(key) != cluster_config.get(key):
+                            raise ValueError(
+                                f'Cluster configuration has changed for field {key!r}. '
+                                f'Previous value: {history.get(key)}, '
+                                f'Current value: {cluster_config.get(key)}')
+                    history_hosts_info = prepare_hosts_info(
+                        cluster_name, history)
+                    if history_hosts_info[0] != hosts_info[0]:
                         raise ValueError(
-                            f'Cluster configuration has changed for field {key!r}. '
-                            f'Previous value: {history.get(key)}, '
-                            f'Current value: {cluster_config.get(key)}')
-                history_hosts_info = prepare_hosts_info(history)
-                if history_hosts_info[0] != hosts_info[0]:
-                    raise ValueError(
-                        f'Cluster configuration has changed for master node. '
-                        f'Previous value: {history_hosts_info[0]}, '
-                        f'Current value: {hosts_info[0]}')
-                history_workers_info = history_hosts_info[1:] if len(
-                    history_hosts_info) > 1 else []
-                history_worker_nodes = [h['ip'] for h in history_workers_info]
-                history_use_ssh_config = [
-                    h.get('use_ssh_config', False) for h in history_workers_info
+                            f'Cluster configuration has changed for master node. '
+                            f'Previous value: {history_hosts_info[0]}, '
+                            f'Current value: {hosts_info[0]}')
+                    history_workers_info = history_hosts_info[1:] if len(
+                        history_hosts_info) > 1 else []
+                    history_worker_nodes = [
+                        h['ip'] for h in history_workers_info
+                    ]
+                    history_use_ssh_config = [
+                        h.get('use_ssh_config', False)
+                        for h in history_workers_info
+                    ]
+
+                # Use the first host as the head node and the rest as worker nodes
+                head_host = hosts_info[0]
+                worker_hosts = hosts_info[1:] if len(hosts_info) > 1 else []
+
+                head_node = head_host['ip']
+                worker_nodes = [h['ip'] for h in worker_hosts]
+                ssh_user = head_host['user']
+                ssh_key = head_host['identity_file']
+                head_use_ssh_config = global_use_ssh_config or head_host.get(
+                    'use_ssh_config', False)
+                worker_use_ssh_config = [
+                    global_use_ssh_config or h.get('use_ssh_config', False)
+                    for h in worker_hosts
                 ]
+                password = head_host['password']
+
+                # Deploy this cluster
+                unsuccessful_workers = deploy_cluster(
+                    head_node,
+                    worker_nodes,
+                    ssh_user,
+                    ssh_key,
+                    context_name,
+                    password,
+                    head_use_ssh_config,
+                    worker_use_ssh_config,
+                    kubeconfig_path,
+                    args.cleanup,
+                    worker_hosts=worker_hosts,
+                    history_worker_nodes=history_worker_nodes,
+                    history_workers_info=history_workers_info,
+                    history_use_ssh_config=history_use_ssh_config)
+
+                if not args.cleanup:
+                    successful_hosts = []
+                    for host in cluster_config['hosts']:
+                        if isinstance(host, str):
+                            host_node = host
+                        else:
+                            host_node = host['ip']
+                        if host_node not in unsuccessful_workers:
+                            successful_hosts.append(host)
+                    cluster_config['hosts'] = successful_hosts
+                    with open(history_yaml_file, 'w', encoding='utf-8') as f:
+                        print(
+                            f'{YELLOW}Writing history to {history_yaml_file}{NC}'
+                        )
+                        yaml.dump(cluster_config, f)
 
-            # Use the first host as the head node and the rest as worker nodes
-            head_host = hosts_info[0]
-            worker_hosts = hosts_info[1:] if len(hosts_info) > 1 else []
-
-            head_node = head_host['ip']
-            worker_nodes = [h['ip'] for h in worker_hosts]
-            ssh_user = head_host['user']
-            ssh_key = head_host['identity_file']
-            head_use_ssh_config = global_use_ssh_config or head_host.get(
-                'use_ssh_config', False)
-            worker_use_ssh_config = [
-                global_use_ssh_config or h.get('use_ssh_config', False)
-                for h in worker_hosts
-            ]
-            password = head_host['password']
-
-            # Deploy this cluster
-            unsuccessful_workers = deploy_cluster(
-                head_node,
-                worker_nodes,
-                ssh_user,
-                ssh_key,
-                context_name,
-                password,
-                head_use_ssh_config,
-                worker_use_ssh_config,
-                kubeconfig_path,
-                args.cleanup,
-                worker_hosts=worker_hosts,
-                history_worker_nodes=history_worker_nodes,
-                history_workers_info=history_workers_info,
-                history_use_ssh_config=history_use_ssh_config)
-
-            if not args.cleanup:
-                successful_hosts = []
-                for host in cluster_config['hosts']:
-                    if isinstance(host, str):
-                        host_node = host
-                    else:
-                        host_node = host['ip']
-                    if host_node not in unsuccessful_workers:
-                        successful_hosts.append(host)
-                cluster_config['hosts'] = successful_hosts
-                with open(history_yaml_file, 'w', encoding='utf-8') as f:
-                    print(f'{YELLOW}Writing history to {history_yaml_file}{NC}')
-                    yaml.dump(cluster_config, f)
-
-            print(
-                f'{GREEN}==== Completed deployment for cluster: {cluster_name} ====${NC}'
-            )
+                print(
+                    f'{GREEN}==== Completed deployment for cluster: {cluster_name} ====${NC}'
+                )
+                successful_clusters.append(cluster_name)
+            except Exception as e:  # pylint: disable=broad-except
+                reason = str(e)
+                failed_clusters.append((cluster_name, reason))
+                print(
+                    f'{RED}Error deploying SSH Node Pool {cluster_name}: {reason}{NC}'
+                )  # Print for internal logging
+
+    if failed_clusters:
+        action = 'clean' if args.cleanup else 'deploy'
+        msg = f'{GREEN}Successfully {action}ed {len(successful_clusters)} cluster(s) ({", ".join(successful_clusters)}). {NC}'
+        msg += f'{RED}Failed to {action} {len(failed_clusters)} cluster(s): {NC}'
+        for cluster_name, reason in failed_clusters:
+            msg += f'\n  {cluster_name}: {reason}'
+        raise RuntimeError(msg)
 
 
 def deploy_cluster(head_node,
@@ -839,11 +860,11 @@ def deploy_cluster(head_node,
         # For SkySSHUpLineProcessor
         print_output=True)
     if result is None:
-        print(
-            f'{RED}Failed to SSH to head node ({head_node}). '
-            f'Please check the SSH configuration.{NC}',
-            file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise RuntimeError(
+                f'Failed to SSH to head node ({head_node}). '
+                f'Please check the SSH configuration and logs for more details.'
+            )
 
     # Checking history
     history_exists = (history_worker_nodes is not None and
@@ -981,10 +1002,10 @@ def deploy_cluster(head_node,
         print_output=True,
         use_shell=True)
     if result is None:
-        print(
-            f'{RED}Failed to setup TCP forwarding on head node ({head_node}). '
-            f'Please check the SSH configuration.{NC}',
-            file=sys.stderr)
+        with ux_utils.print_exception_no_traceback():
+            raise RuntimeError(
+                f'Failed to setup TCP forwarding on head node ({head_node}). '
+                f'Please check the SSH configuration.')
 
     # Get effective IP for master node if using SSH config - needed for workers to connect
     if head_use_ssh_config:
@@ -1024,9 +1045,9 @@ def deploy_cluster(head_node,
                         ssh_key,
                         use_ssh_config=head_use_ssh_config)
     if result is None:
-        print(f'{RED}Failed to deploy K3s on head node ({head_node}). {NC}',
-              file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise RuntimeError(
+                f'Failed to deploy K3s on head node ({head_node}).')
     success_message(f'K3s deployed on head node ({head_node}).')
 
     # Check if head node has a GPU
@@ -1045,11 +1066,9 @@ def deploy_cluster(head_node,
                              ssh_key,
                              use_ssh_config=head_use_ssh_config)
     if master_addr is None:
-        print(
-            f'{RED}Failed to SSH to head node ({head_node}). '
-            f'Please check the SSH configuration.{NC}',
-            file=sys.stderr)
-        sys.exit(1)
+        with ux_utils.print_exception_no_traceback():
+            raise RuntimeError(f'Failed to SSH to head node ({head_node}). '
+                               f'Please check the SSH configuration.')
     print(f'{GREEN}Master node internal IP: {master_addr}{NC}')
 
     # Step 2: Install k3s on worker nodes and join them to the master node

sky/utils/kubernetes/kubernetes_deploy_utils.py

@@ -26,6 +26,48 @@ logger = sky_logging.init_logger(__name__)
 DEFAULT_KUBECONFIG_PATH = os.path.expanduser('~/.kube/config')
 
 
+def check_ssh_cluster_dependencies(
+        raise_error: bool = True) -> Optional[List[str]]:
+    """Checks if the dependencies for ssh cluster are installed.
+
+    Args:
+        raise_error: set to true when the dependency needs 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.
+    """
+    # error message
+    jq_message = ('`jq` is required to setup ssh cluster.')
+
+    # save
+    reasons = []
+    required_binaries = []
+
+    # Ensure jq is installed
+    try:
+        subprocess.run(['jq', '--version'],
+                       stdout=subprocess.DEVNULL,
+                       stderr=subprocess.DEVNULL,
+                       check=True)
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        required_binaries.append('jq')
+        reasons.append(jq_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 deploy_ssh_cluster(cleanup: bool = False,
                        infra: Optional[str] = None,
                        kubeconfig_path: Optional[str] = None):
@@ -41,6 +83,8 @@ def deploy_ssh_cluster(cleanup: bool = False,
         kubeconfig_path: Path to save the Kubernetes configuration file.
             If None, the default ~/.kube/config will be used.
     """
+    check_ssh_cluster_dependencies()
+
     # Prepare command to call deploy_remote_cluster.py script
     # TODO(romilb): We should move this to a native python method/class call
     #  instead of invoking a script with subprocess.
@@ -81,9 +125,9 @@ def deploy_ssh_cluster(cleanup: bool = False,
             cmd=deploy_command,
             log_path=log_path,
             require_outputs=True,
-            stream_logs=False,  # TODO: Fixme to False after we fix the logging
+            stream_logs=False,
             line_processor=log_utils.SkySSHUpLineProcessor(log_path=log_path,
-                                                           is_local=True),
+                                                           is_local=False),
             cwd=cwd,
             env=env)
 
@@ -91,9 +135,9 @@ def deploy_ssh_cluster(cleanup: bool = False,
         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 SkyPilot on SSH targets. '
-                               f'Full log: {log_hint}'
+            log_hint = ux_utils.log_path_hint(log_path, is_local=False)
+            raise RuntimeError('Failed to deploy SkyPilot on some Node Pools. '
+                               f'{log_hint}'
                                f'\nError: {stderr}')
 
     if success:

sky/utils/kubernetes/ssh-tunnel.sh

@@ -188,14 +188,17 @@ generate_credentials_json() {
     debug_log "Key data length: $(echo -n "$client_key_data" | wc -c) bytes"
     
     # Check if we can create proper JSON with `jq`
-    if command -v jq &>/dev/null; then
-      debug_log "Using jq for JSON formatting"
-      
-      # Create a temporary file for the JSON output to avoid shell escaping issues
-      local TEMP_JSON_FILE=$(mktemp)
-      
-      # Write the JSON to the temporary file using jq for proper JSON formatting
-      cat > "$TEMP_JSON_FILE" << EOL
+    if ! command -v jq &>/dev/null; then
+      echo "jq is not installed. Please install jq to use this script." >&2
+      exit 1
+    fi
+    debug_log "Using jq for JSON formatting"
+    
+    # Create a temporary file for the JSON output to avoid shell escaping issues
+    local TEMP_JSON_FILE=$(mktemp)
+    
+    # Write the JSON to the temporary file using jq for proper JSON formatting
+    cat > "$TEMP_JSON_FILE" << EOL
 {
   "apiVersion": "client.authentication.k8s.io/v1beta1",
   "kind": "ExecCredential",
@@ -207,25 +210,14 @@ generate_credentials_json() {
 }
 EOL
       
-      # Read the JSON from the file
-      local json_response=$(cat "$TEMP_JSON_FILE")
-      
-      # Clean up
-      rm -f "$TEMP_JSON_FILE"
-      
-      # Output the JSON
-      echo "$json_response"
-    else
-      debug_log "jq is not available, using simpler formatting method"
-      
-      # Alternative approach: encode with base64 and use the token field instead
-      # This works because kubectl will decode token data properly
-      local combined_data=$(echo -n "${client_cert_data}:${client_key_data}" | base64 | tr -d '\n')
-      
-      echo "{\"apiVersion\":\"client.authentication.k8s.io/v1beta1\",\"kind\":\"ExecCredential\",\"status\":{\"token\":\"$combined_data\",\"expirationTimestamp\":\"$expiration_time\"}}"
-      
-      debug_log "Sent certificate data as encoded token instead of direct certificate fields"
-    fi
+    # Read the JSON from the file
+    local json_response=$(cat "$TEMP_JSON_FILE")
+    
+    # Clean up
+    rm -f "$TEMP_JSON_FILE"
+    
+    # Output the JSON
+    echo "$json_response"
   else
     # Fallback to token-based credential for tunnel-only authentication
     echo "{\"apiVersion\":\"client.authentication.k8s.io/v1beta1\",\"kind\":\"ExecCredential\",\"status\":{\"token\":\"k8s-ssh-tunnel-token\",\"expirationTimestamp\":\"$expiration_time\"}}"
@@ -384,4 +376,4 @@ fi
 
 # Return valid credential format with certificates if available
 generate_credentials_json
-exit 0 
+exit 0 

sky/utils/log_utils.py

@@ -497,6 +497,10 @@ class SkySSHUpLineProcessor(LineProcessor):
                 f'✗ Failed to setup TCP forwarding on head node {node_name}.'
                 f'{colorama.Style.RESET_ALL}')
 
+        if 'Error in deploying SSH Target' in log_line:
+            logger.info(f'{ux_utils.INDENT_LAST_SYMBOL}{colorama.Fore.RED}'
+                        f'{log_line.strip()}{colorama.Style.RESET_ALL}')
+
     def __exit__(self, except_type: Optional[Type[BaseException]],
                  except_value: Optional[BaseException],
                  traceback: Optional[types.TracebackType]) -> None:

sky/utils/schemas.py

@@ -1173,6 +1173,54 @@ def get_config_schema():
         }
     }
 
+    workspace_schema = {'type': 'string'}
+
+    allowed_workspace_cloud_names = list(
+        service_catalog.ALL_CLOUDS) + ['cloudflare']
+    # Create pattern for non-GCP clouds (all clouds except gcp)
+    non_gcp_clouds = [
+        cloud for cloud in allowed_workspace_cloud_names
+        if cloud.lower() != 'gcp'
+    ]
+    non_gcp_cloud_regex = '|'.join(non_gcp_clouds)
+    workspaces_schema = {
+        'type': 'object',
+        'required': [],
+        # each key is a workspace name
+        'additionalProperties': {
+            'type': 'object',
+            'additionalProperties': False,
+            'patternProperties': {
+                # Pattern for non-GCP clouds - only allows 'disabled' property
+                f'^({non_gcp_cloud_regex})$': {
+                    'type': 'object',
+                    'additionalProperties': False,
+                    'properties': {
+                        'disabled': {
+                            'type': 'boolean'
+                        }
+                    },
+                },
+            },
+            'properties': {
+                # Explicit definition for GCP allows both project_id and
+                # disabled
+                'gcp': {
+                    'type': 'object',
+                    'properties': {
+                        'project_id': {
+                            'type': 'string'
+                        },
+                        'disabled': {
+                            'type': 'boolean'
+                        }
+                    },
+                    'additionalProperties': False,
+                },
+            },
+        },
+    }
+
     provision_configs = {
         'type': 'object',
         'required': [],
@@ -1199,6 +1247,10 @@ def get_config_schema():
         'required': [],
         'additionalProperties': False,
         'properties': {
+            # TODO Replace this with whatever syang cooks up
+            'workspace': {
+                'type': 'string',
+            },
             'jobs': controller_resources_schema,
             'serve': controller_resources_schema,
             'allowed_clouds': allowed_clouds,
@@ -1206,6 +1258,8 @@ def get_config_schema():
             'docker': docker_configs,
             'nvidia_gpus': gpu_configs,
             'api_server': api_server,
+            'active_workspace': workspace_schema,
+            'workspaces': workspaces_schema,
             'provision': provision_configs,
             **cloud_configs,
         },