skypilot-nightly 1.0.0.dev20250509__py3-none-any.whl → 1.0.0.dev20251107__py3-none-any.whl

sky/utils/kubernetes/cleanup-tunnel.sh

@@ -0,0 +1,62 @@
+#!/bin/bash
+# cleanup-tunnel.sh - Script to clean up SSH tunnels for a Kubernetes context
+
+# Usage: cleanup-tunnel.sh CONTEXT_NAME
+
+CONTEXT="${1:-default}"
+TUNNEL_DIR="$HOME/.sky/ssh_node_pools_info"
+PID_FILE="$TUNNEL_DIR/$CONTEXT-tunnel.pid"
+LOG_FILE="$TUNNEL_DIR/$CONTEXT-tunnel.log"
+LOCK_FILE="$TUNNEL_DIR/$CONTEXT-tunnel.lock"
+
+# Get the port from kubeconfig if available
+KUBE_PORT=$(kubectl config view --minify --context="$CONTEXT" -o jsonpath='{.clusters[0].cluster.server}' 2>/dev/null | grep -o ":[0-9]\+" | tr -d ":" || echo "")
+
+if [[ -z "$KUBE_PORT" ]]; then
+    # Default to 6443 if we can't determine the port
+    KUBE_PORT=6443
+    echo "$(date): Could not determine port from kubeconfig, using default port $KUBE_PORT" >> "$LOG_FILE"
+else
+    echo "$(date): Found port $KUBE_PORT in kubeconfig for context $CONTEXT" >> "$LOG_FILE"
+fi
+
+# Check if PID file exists
+if [[ -f "$PID_FILE" ]]; then
+    OLD_PID=$(cat "$PID_FILE")
+    
+    # Log the cleanup attempt
+    echo "$(date): Attempting to clean up tunnel for context $CONTEXT (PID: $OLD_PID, Port: $KUBE_PORT)" >> "$LOG_FILE"
+    
+    # Try to kill the process
+    if kill -0 "$OLD_PID" 2>/dev/null; then
+        # Process exists, kill it
+        kill "$OLD_PID" 2>/dev/null
+        
+        # Wait a moment and check if it's really gone
+        sleep 1
+        if kill -0 "$OLD_PID" 2>/dev/null; then
+            # Still running, force kill
+            kill -9 "$OLD_PID" 2>/dev/null
+            echo "$(date): Forcefully terminated tunnel process $OLD_PID" >> "$LOG_FILE"
+        else
+            echo "$(date): Successfully terminated tunnel process $OLD_PID" >> "$LOG_FILE"
+        fi
+    else
+        echo "$(date): No running process found with PID $OLD_PID" >> "$LOG_FILE"
+    fi
+    
+    # Remove PID file
+    rm -f "$PID_FILE"
+else
+    echo "$(date): No PID file found for context $CONTEXT. Nothing to clean up." >> "$LOG_FILE"
+fi
+
+# Clean up lock file if it exists
+rm -f "$LOCK_FILE"
+
+# Check if port is still in use
+if nc -z localhost "$KUBE_PORT" 2>/dev/null; then
+    echo "$(date): Warning: Port $KUBE_PORT is still in use after cleanup. Another process might be using it." >> "$LOG_FILE"
+fi
+
+echo "$(date): Cleanup complete for context $CONTEXT" >> "$LOG_FILE" 

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 yaml_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 = yaml_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 = yaml_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}')

sky/utils/kubernetes/create_cluster.sh

@@ -1,22 +1,19 @@
 #!/bin/bash
 # Creates a local Kubernetes cluster using kind with optional GPU support
-# Usage: ./create_cluster.sh [--gpus]
-# Invokes generate_kind_config.py to generate a kind-cluster.yaml with NodePort mappings
+# Usage: ./create_cluster.sh [name] [yaml_path] [--gpus]
 set -e
 
 # Images
 IMAGE="us-central1-docker.pkg.dev/skypilot-375900/skypilotk8s/skypilot:latest"
 IMAGE_GPU="us-central1-docker.pkg.dev/skypilot-375900/skypilotk8s/skypilot-gpu:latest"
 
-# Limit port range to speed up kind cluster creation
-PORT_RANGE_START=30000
-PORT_RANGE_END=30100
-
-USER_HASH=$1
+# Arguments
+NAME=$1
+YAML_PATH=$2
 
 # Check for GPU flag
 ENABLE_GPUS=false
-if [[ "$2" == "--gpus" ]]; then
+if [[ "$3" == "--gpus" ]]; then
     ENABLE_GPUS=true
 fi
 
@@ -82,27 +79,16 @@ fi
 # ====== End of dependency checks =======
 
 # Check if the local cluster already exists
-if kind get clusters | grep -q skypilot; then
-    echo "Local cluster already exists. Exiting."
+if kind get clusters | grep -q $NAME; then
+    echo "Local cluster $NAME already exists. Exiting."
     # Switch context to the local cluster
-    kubectl config use-context kind-skypilot
+    kind export kubeconfig --name $NAME
+    kubectl config use-context kind-$NAME
     exit 100
 fi
 
-# Generate cluster YAML
-YAML_PATH="/tmp/skypilot-kind-$USER_HASH.yaml"
-echo "Generating $YAML_PATH"
-
-# Add GPUs flag to the generate_kind_config.py command if GPUs are enabled
-if $ENABLE_GPUS; then
-    python -m sky.utils.kubernetes.generate_kind_config --path $YAML_PATH --port-start ${PORT_RANGE_START} --port-end ${PORT_RANGE_END} --gpus
-else
-  python -m sky.utils.kubernetes.generate_kind_config --path $YAML_PATH --port-start ${PORT_RANGE_START} --port-end ${PORT_RANGE_END}
-fi
-
-kind create cluster --config $YAML_PATH --name skypilot
-
-echo "Kind cluster created."
+kind create cluster --config $YAML_PATH --name $NAME
+echo "Kind cluster $NAME created."
 
 # Function to wait for GPU operator to be correctly installed
 wait_for_gpu_operator_installation() {
@@ -156,7 +142,7 @@ if $ENABLE_GPUS; then
     echo "Enabling GPU support..."
     # Run patch for missing ldconfig.real
     # https://github.com/NVIDIA/nvidia-docker/issues/614#issuecomment-423991632
-    docker exec -ti skypilot-control-plane /bin/bash -c '[ ! -f /sbin/ldconfig.real ] && ln -s /sbin/ldconfig /sbin/ldconfig.real || echo "/sbin/ldconfig.real already exists"'
+    docker exec -ti $NAME-control-plane /bin/bash -c '[ ! -f /sbin/ldconfig.real ] && ln -s /sbin/ldconfig /sbin/ldconfig.real || echo "/sbin/ldconfig.real already exists"'
 
     echo "Installing NVIDIA GPU operator..."
     # Install the NVIDIA GPU operator
@@ -184,4 +170,4 @@ if $ENABLE_GPUS; then
         echo "GPU support is enabled. Run 'sky show-gpus --cloud kubernetes' to see the GPUs available on the cluster."
     fi
 fi
-echo "Number of CPUs available on the local cluster: $NUM_CPUS"
+echo "Number of CPUs available on the local cluster $NAME: $NUM_CPUS"

sky/utils/kubernetes/delete_cluster.sh

@@ -1,9 +1,12 @@
 #!/bin/bash
-# Deletes the local kind cluster
-# Usage: ./delete_cluster.sh
-# Raises error code 100 if the local cluster does not exist
+# Deletes the local kind cluster of [name]
+# Usage: ./delete_cluster.sh [name]
+# Raises error code 100 if the specified local cluster does not exist
 
 set -e
+
+NAME="${1:-skypilot}"
+
 # Check if docker is running
 if ! docker info > /dev/null 2>&1; then
     >&2 echo "Docker is not running. Please start Docker and try again."
@@ -17,13 +20,13 @@ if ! kind version > /dev/null 2>&1; then
 fi
 
 # Check if the local cluster exists
-if ! kind get clusters | grep -q skypilot; then
-    echo "Local cluster does not exist. Exiting."
+if ! kind get clusters | grep -q $NAME; then
+    echo "Local cluster $NAME does not exist. Exiting."
     exit 100
 fi
 
-kind delete cluster --name skypilot
-echo "Local cluster deleted!"
+kind delete cluster --name $NAME
+echo "Local cluster $NAME deleted!"
 
 # Switch to the first available context
 AVAILABLE_CONTEXT=$(kubectl config get-contexts -o name | head -n 1)