skypilot-nightly 1.0.0.dev20251001__py3-none-any.whl → 1.0.0.dev20251003__py3-none-any.whl

sky/templates/kubernetes-ssh-jump.yml.j2

@@ -1,94 +0,0 @@
-pod_spec:
-    apiVersion: v1
-    kind: Pod
-    metadata:
-        name: {{ name }}
-        labels:
-            component: {{ name }}
-            parent: skypilot
-    spec:
-        serviceAccountName: sky-ssh-jump-sa
-        volumes:
-          - name: secret-volume
-            secret:
-                secretName: {{ secret }}
-        containers:
-          - name: {{ name }}
-            imagePullPolicy: Always
-            image: {{ image }}
-            command: ["python3", "-u", "/skypilot/sky/utils/kubernetes/ssh_jump_lifecycle_manager.py"]
-            ports:
-              - containerPort: 22
-            volumeMounts:
-              - name: secret-volume
-                readOnly: true
-                mountPath: /etc/secret-volume
-            lifecycle:
-                postStart:
-                    exec:
-                        command: ["/bin/bash", "-c", "mkdir -p ~/.ssh && cat /etc/secret-volume/ssh-publickey* > ~/.ssh/authorized_keys && sudo service ssh restart"]
-            env:
-              - name: MY_POD_NAME
-                valueFrom:
-                    fieldRef:
-                        fieldPath: metadata.name
-              - name: MY_POD_NAMESPACE
-                valueFrom:
-                    fieldRef:
-                        fieldPath: metadata.namespace
-              - name: ALERT_THRESHOLD
-                # seconds
-                value: "600"
-              - name: RETRY_INTERVAL
-                # seconds
-                value: "60"
-        terminationGracePeriodSeconds: 0
-service_spec:
-    apiVersion: v1
-    kind: Service
-    metadata:
-        name: {{ name }}
-        labels:
-            parent: skypilot
-    spec:
-        type: {{ service_type }}
-        selector:
-            component: {{ name }}
-        ports:
-          - protocol: TCP
-            port: 22
-            targetPort: 22
-# The following ServiceAccount/Role/RoleBinding sets up an RBAC for life cycle
-# management of the jump pod/service
-service_account:
-    apiVersion: v1
-    kind: ServiceAccount
-    metadata:
-        name: sky-ssh-jump-sa
-        labels:
-          parent: skypilot
-role:
-    kind: Role
-    apiVersion: rbac.authorization.k8s.io/v1
-    metadata:
-        name: sky-ssh-jump-role
-        labels:
-          parent: skypilot
-    rules:
-      - apiGroups: [""]
-        resources: ["pods", "pods/status", "pods/exec", "services"]
-        verbs: ["get", "list", "create", "delete"]
-role_binding:
-    apiVersion: rbac.authorization.k8s.io/v1
-    kind: RoleBinding
-    metadata:
-        name: sky-ssh-jump-rb
-        labels:
-          parent: skypilot
-    subjects:
-    - kind: ServiceAccount
-      name: sky-ssh-jump-sa
-    roleRef:
-        kind: Role
-        name: sky-ssh-jump-role
-        apiGroup: rbac.authorization.k8s.io

sky/utils/kubernetes/ssh_jump_lifecycle_manager.py

@@ -1,191 +0,0 @@
-"""Manages lifecycle of ssh jump pod.
-
-This script runs inside ssh jump pod as the main process (PID 1).
-
-It terminates itself (by removing ssh jump service and pod via a call to
-kubeapi) if it does not see ray pods in the duration of 10 minutes. If the
-user re-launches a task before the duration is over, then ssh jump pod is being
-reused and will terminate itself when it sees that no ray clusters exist in
-that duration.
-
-To allow multiple users to the share the same SSH jump pod,
-this script also reloads SSH keys from the mounted secret volume on an
-interval and updates `~/.ssh/authorized_keys`.
-"""
-import datetime
-import os
-import subprocess
-import sys
-import threading
-import time
-
-from kubernetes import client
-from kubernetes import config
-
-# Load kube config
-config.load_incluster_config()
-
-v1 = client.CoreV1Api()
-
-current_name = os.getenv('MY_POD_NAME')
-current_namespace = os.getenv('MY_POD_NAMESPACE')
-
-# The amount of time in seconds where no Ray pods exist in which after that time
-# ssh jump pod terminates itself
-alert_threshold = int(os.getenv('ALERT_THRESHOLD', '600'))
-# The amount of time in seconds to wait between Ray pods existence checks
-retry_interval = int(os.getenv('RETRY_INTERVAL', '60'))
-# The amount of time in seconds to wait between SSH key reloads
-reload_interval = int(os.getenv('RELOAD_INTERVAL', '5'))
-
-# Ray pods are labeled with this value i.e., ssh jump name which is unique per
-# user (based on user hash)
-label_selector = f'skypilot-ssh-jump={current_name}'
-
-
-def poll(interval, leading=True):
-    """Decorator factory for polling function. To stop polling, return True.
-
-    Args:
-        interval (int): The amount of time to wait between function calls.
-        leading (bool): Whether to wait before (rather than after) calls.
-    """
-
-    def decorator(func):
-
-        def wrapper(*args, **kwargs):
-            while True:
-                if leading:
-                    time.sleep(interval)
-                done = func(*args, **kwargs)
-                if done:
-                    return
-                if not leading:
-                    time.sleep(interval)
-
-        return wrapper
-
-    return decorator
-
-
-# Flag to terminate the reload keys thread when the lifecycle thread
-# terminates.
-terminated = False
-
-
-@poll(interval=reload_interval, leading=False)
-def reload_keys():
-    """Reloads SSH keys from mounted secret volume."""
-
-    if terminated:
-        sys.stdout.write('[SSH Key Reloader] Terminated.\n')
-        return True
-
-    # Reload SSH keys from mounted secret volume if changed.
-    tmpfile = '/tmp/sky-ssh-keys'
-    try:
-        subprocess.check_output(
-            f'cat /etc/secret-volume/ssh-publickey* > {tmpfile}', shell=True)
-        try:
-            subprocess.check_output(f'diff {tmpfile} ~/.ssh/authorized_keys',
-                                    shell=True)
-            sys.stdout.write(
-                '[SSH Key Reloader] No keys changed, continuing.\n')
-        except subprocess.CalledProcessError as e:
-            if e.returncode == 1:
-                sys.stdout.write(
-                    '[SSH Key Reloader] Changes detected, reloading.\n')
-                subprocess.check_output(f'mv {tmpfile} ~/.ssh/authorized_keys',
-                                        shell=True)
-            else:
-                raise
-    except Exception as e:
-        sys.stdout.write(
-            f'[SSH Key Reloader][ERROR] Failed to reload SSH keys: {e}\n')
-        raise
-
-
-alert_delta = datetime.timedelta(seconds=alert_threshold)
-retry_interval_delta = datetime.timedelta(seconds=retry_interval)
-# Accumulated time of where no SkyPilot cluster exists. Compared
-# against alert_threshold.
-nocluster_delta = datetime.timedelta()
-
-
-@poll(interval=retry_interval)
-def manage_lifecycle():
-    """Manages lifecycle of ssh jump pod."""
-
-    global terminated, nocluster_delta
-
-    try:
-        ret = v1.list_namespaced_pod(current_namespace,
-                                     label_selector=label_selector)
-    except Exception as e:
-        sys.stdout.write('[Lifecycle] [ERROR] listing pods failed with '
-                         f'error: {e}\n')
-        raise
-
-    if not ret.items:
-        sys.stdout.write(
-            f'[Lifecycle] Did not find pods with label '
-            f'"{label_selector}" in namespace {current_namespace}\n')
-        nocluster_delta = nocluster_delta + retry_interval_delta
-        sys.stdout.write(
-            f'[Lifecycle] Time since no pods found: {nocluster_delta}, alert '
-            f'threshold: {alert_delta}\n')
-    else:
-        sys.stdout.write(
-            f'[Lifecycle] Found pods with label "{label_selector}" in '
-            f'namespace {current_namespace}\n')
-        # reset ..
-        nocluster_delta = datetime.timedelta()
-        sys.stdout.write(
-            f'[Lifecycle] nocluster_delta is reset: {nocluster_delta}\n')
-
-    if nocluster_delta >= alert_delta:
-        sys.stdout.write(
-            f'[Lifecycle] nocluster_delta: {nocluster_delta} crossed alert '
-            f'threshold: {alert_delta}. Time to terminate myself and my '
-            'service.\n')
-        try:
-            # ssh jump resources created under same name
-            v1.delete_namespaced_service(current_name, current_namespace)
-            v1.delete_namespaced_pod(current_name, current_namespace)
-        except Exception as e:
-            sys.stdout.write('[Lifecycle][ERROR] Deletion failed. Exiting '
-                             f'poll() with error: {e}\n')
-            raise
-
-        terminated = True
-        return True
-
-
-def main():
-    sys.stdout.write('SkyPilot SSH Jump Pod Lifecycle Manager\n')
-    sys.stdout.write(f'current_name: {current_name}\n')
-    sys.stdout.write(f'current_namespace: {current_namespace}\n')
-    sys.stdout.write(f'alert_threshold time: {alert_threshold}\n')
-    sys.stdout.write(f'retry_interval time: {retry_interval}\n')
-    sys.stdout.write(f'reload_interval time: {reload_interval}\n')
-    sys.stdout.write(f'label_selector: {label_selector}\n')
-
-    if not current_name or not current_namespace:
-        # Raise Exception with message to terminate pod
-        raise Exception('Missing environment variables MY_POD_NAME or '
-                        'MY_POD_NAMESPACE')
-
-    threads = [
-        threading.Thread(target=manage_lifecycle),
-        threading.Thread(target=reload_keys)
-    ]
-    sys.stdout.write(f'Polling with {len(threads)} threads.\n')
-    for t in threads:
-        t.start()
-    for t in threads:
-        t.join()
-    sys.stdout.write('Done.\n')
-
-
-if __name__ == '__main__':
-    main()

sky/volumes/utils.py

@@ -1,224 +0,0 @@
-"""Volume utils."""
-import abc
-from datetime import datetime
-from typing import Any, Dict, List, Optional
-
-import prettytable
-
-from sky import sky_logging
-from sky.skylet import constants
-from sky.utils import common_utils
-from sky.utils import log_utils
-from sky.utils import volume
-
-logger = sky_logging.init_logger(__name__)
-
-_BASIC_COLUMNS = [
-    'NAME',
-    'TYPE',
-    'INFRA',
-    'SIZE',
-    'USER',
-    'WORKSPACE',
-    'AGE',
-    'STATUS',
-    'LAST_USE',
-    'USED_BY',
-]
-
-
-def _get_infra_str(cloud: Optional[str], region: Optional[str],
-                   zone: Optional[str]) -> str:
-    """Get the infrastructure string for the volume."""
-    infra = ''
-    if cloud:
-        infra += cloud
-    if region:
-        infra += f'/{region}'
-    if zone:
-        infra += f'/{zone}'
-    return infra
-
-
-class VolumeTable(abc.ABC):
-    """The volume table."""
-
-    def __init__(self, volumes: List[Dict[str, Any]], show_all: bool = False):
-        super().__init__()
-        self.table = self._create_table(show_all)
-        self._add_rows(volumes, show_all)
-
-    def _get_row_base_columns(self,
-                              row: Dict[str, Any],
-                              show_all: bool = False) -> List[str]:
-        """Get the base columns for a row."""
-        # Convert last_attached_at timestamp to human readable string
-        last_attached_at = row.get('last_attached_at')
-        if last_attached_at is not None:
-            last_attached_at_str = datetime.fromtimestamp(
-                last_attached_at).strftime('%Y-%m-%d %H:%M:%S')
-        else:
-            last_attached_at_str = '-'
-        size = row.get('size', '')
-        if size:
-            size = f'{size}Gi'
-        usedby_str = '-'
-        usedby_clusters = row.get('usedby_clusters')
-        usedby_pods = row.get('usedby_pods')
-        if usedby_clusters:
-            usedby_str = f'{", ".join(usedby_clusters)}'
-        elif usedby_pods:
-            usedby_str = f'{", ".join(usedby_pods)}'
-        if show_all:
-            usedby = usedby_str
-        else:
-            usedby = common_utils.truncate_long_string(
-                usedby_str, constants.USED_BY_TRUNC_LENGTH)
-        infra = _get_infra_str(row.get('cloud'), row.get('region'),
-                               row.get('zone'))
-        return [
-            row.get('name', ''),
-            row.get('type', ''),
-            infra,
-            size,
-            row.get('user_name', '-'),
-            row.get('workspace', '-'),
-            log_utils.human_duration(row.get('launched_at', 0)),
-            row.get('status', ''),
-            last_attached_at_str,
-            usedby,
-        ]
-
-    def _create_table(self, show_all: bool = False) -> prettytable.PrettyTable:
-        """Create the volume table."""
-        raise NotImplementedError
-
-    def _add_rows(self,
-                  volumes: List[Dict[str, Any]],
-                  show_all: bool = False) -> None:
-        """Add rows to the volume table."""
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def format(self) -> str:
-        """Format the volume table for display."""
-        raise NotImplementedError
-
-
-class PVCVolumeTable(VolumeTable):
-    """The PVC volume table."""
-
-    def _create_table(self, show_all: bool = False) -> prettytable.PrettyTable:
-        """Create the PVC volume table."""
-        #  If show_all is False, show the table with the columns:
-        #   NAME, TYPE, INFRA, SIZE, USER, WORKSPACE,
-        #   AGE, STATUS, LAST_USE, USED_BY
-        #  If show_all is True, show the table with the columns:
-        #   NAME, TYPE, INFRA, SIZE, USER, WORKSPACE,
-        #   AGE, STATUS, LAST_USE, USED_BY, NAME_ON_CLOUD
-        #   STORAGE_CLASS, ACCESS_MODE
-
-        if show_all:
-            columns = _BASIC_COLUMNS + [
-                'NAME_ON_CLOUD',
-                'STORAGE_CLASS',
-                'ACCESS_MODE',
-            ]
-        else:
-            columns = _BASIC_COLUMNS
-
-        table = log_utils.create_table(columns)
-        return table
-
-    def _add_rows(self,
-                  volumes: List[Dict[str, Any]],
-                  show_all: bool = False) -> None:
-        """Add rows to the PVC volume table."""
-        for row in volumes:
-            table_row = self._get_row_base_columns(row, show_all)
-            if show_all:
-                table_row.append(row.get('name_on_cloud', ''))
-                table_row.append(
-                    row.get('config', {}).get('storage_class_name', '-'))
-                table_row.append(row.get('config', {}).get('access_mode', ''))
-
-            self.table.add_row(table_row)
-
-    def format(self) -> str:
-        """Format the PVC volume table for display."""
-        return 'Kubernetes PVCs:\n' + str(self.table)
-
-
-class RunPodVolumeTable(VolumeTable):
-    """The RunPod volume table."""
-
-    def _create_table(self, show_all: bool = False) -> prettytable.PrettyTable:
-        """Create the RunPod volume table."""
-        #  If show_all is False, show the table with the columns:
-        #   NAME, TYPE, INFRA, SIZE, USER, WORKSPACE,
-        #   AGE, STATUS, LAST_USE, USED_BY
-        #  If show_all is True, show the table with the columns:
-        #   NAME, TYPE, INFRA, SIZE, USER, WORKSPACE,
-        #   AGE, STATUS, LAST_USE, USED_BY, NAME_ON_CLOUD
-
-        if show_all:
-            columns = _BASIC_COLUMNS + ['NAME_ON_CLOUD']
-        else:
-            columns = _BASIC_COLUMNS
-
-        table = log_utils.create_table(columns)
-        return table
-
-    def _add_rows(self,
-                  volumes: List[Dict[str, Any]],
-                  show_all: bool = False) -> None:
-        """Add rows to the RunPod volume table."""
-        for row in volumes:
-            table_row = self._get_row_base_columns(row, show_all)
-            if show_all:
-                table_row.append(row.get('name_on_cloud', ''))
-
-            self.table.add_row(table_row)
-
-    def format(self) -> str:
-        """Format the RunPod volume table for display."""
-        return 'RunPod Network Volumes:\n' + str(self.table)
-
-
-def format_volume_table(volumes: List[Dict[str, Any]],
-                        show_all: bool = False) -> str:
-    """Format the volume table for display.
-
-    Args:
-        volume_table (dict): The volume table.
-
-    Returns:
-        str: The formatted volume table.
-    """
-    volumes_per_type: Dict[str, List[Dict[str, Any]]] = {}
-    supported_volume_types = [
-        volume_type.value for volume_type in volume.VolumeType
-    ]
-    for row in volumes:
-        volume_type = row.get('type', '')
-        if volume_type in supported_volume_types:
-            if volume_type not in volumes_per_type:
-                volumes_per_type[volume_type] = []
-            volumes_per_type[volume_type].append(row)
-        else:
-            logger.warning(f'Unknown volume type: {volume_type}')
-            continue
-    table_str = ''
-    for volume_type, volume_list in volumes_per_type.items():
-        if table_str:
-            table_str += '\n\n'
-        if volume_type == volume.VolumeType.PVC.value:
-            pvc_table = PVCVolumeTable(volume_list, show_all)
-            table_str += pvc_table.format()
-        elif volume_type == volume.VolumeType.RUNPOD_NETWORK_VOLUME.value:
-            runpod_table = RunPodVolumeTable(volume_list, show_all)
-            table_str += runpod_table.format()
-    if table_str:
-        return table_str
-    else:
-        return 'No existing volumes.'