skypilot-nightly 1.0.0.dev20240909__py3-none-any.whl → 1.0.0.dev20240911__py3-none-any.whl

sky/clouds/kubernetes.py

@@ -145,11 +145,6 @@ class Kubernetes(clouds.Cloud):
     def __repr__(self):
         return self._REPR
 
-    @classmethod
-    def get_port(cls, svc_name) -> int:
-        ns = kubernetes_utils.get_current_kube_config_context_namespace()
-        return kubernetes_utils.get_port(svc_name, ns)
-
     @classmethod
     def get_default_instance_type(
             cls,
@@ -338,6 +333,12 @@ class Kubernetes(clouds.Cloud):
             'image_id': image_id,
         }
 
+        # Add kubecontext if it is set. It may be None if SkyPilot is running
+        # inside a pod with in-cluster auth.
+        curr_context = kubernetes_utils.get_current_kube_config_context_name()
+        if curr_context is not None:
+            deploy_vars['k8s_context'] = curr_context
+
         return deploy_vars
 
     def _get_feasible_launchable_resources(
@@ -441,21 +442,33 @@ class Kubernetes(clouds.Cloud):
                              ' Cluster used is determined by the kubeconfig.')
         return region, zone
 
+    @staticmethod
+    def get_identity_from_context(context):
+        if 'namespace' in context['context']:
+            namespace = context['context']['namespace']
+        else:
+            namespace = kubernetes_utils.DEFAULT_NAMESPACE
+        user = context['context']['user']
+        cluster = context['context']['cluster']
+        identity_str = f'{cluster}_{user}_{namespace}'
+        return identity_str
+
     @classmethod
-    def get_current_user_identity(cls) -> Optional[List[str]]:
+    def get_user_identities(cls) -> Optional[List[List[str]]]:
         k8s = kubernetes.kubernetes
+        identities = []
         try:
-            _, current_context = k8s.config.list_kube_config_contexts()
-            if 'namespace' in current_context['context']:
-                namespace = current_context['context']['namespace']
-            else:
-                namespace = kubernetes_utils.DEFAULT_NAMESPACE
-
-            user = current_context['context']['user']
-            cluster = current_context['context']['cluster']
-            return [f'{cluster}_{user}_{namespace}']
+            all_contexts, current_context = (
+                k8s.config.list_kube_config_contexts())
         except k8s.config.config_exception.ConfigException:
             return None
+        # Add current context at the head of the list
+        current_identity = [cls.get_identity_from_context(current_context)]
+        identities.append(current_identity)
+        for context in all_contexts:
+            identity = [cls.get_identity_from_context(context)]
+            identities.append(identity)
+        return identities
 
     @classmethod
     def is_label_valid(cls, label_key: str,

sky/clouds/lambda_cloud.py

@@ -258,8 +258,8 @@ class Lambda(clouds.Cloud):
         }
 
     @classmethod
-    def get_current_user_identity(cls) -> Optional[List[str]]:
-        # TODO(ewzeng): Implement get_current_user_identity for Lambda
+    def get_user_identities(cls) -> Optional[List[List[str]]]:
+        # TODO(ewzeng): Implement get_user_identities for Lambda
         return None
 
     def instance_type_exists(self, instance_type: str) -> bool:

sky/clouds/oci.py

@@ -455,7 +455,7 @@ class OCI(clouds.Cloud):
         return file_mounts
 
     @classmethod
-    def get_current_user_identity(cls) -> Optional[List[str]]:
+    def get_user_identities(cls) -> Optional[List[List[str]]]:
         # NOTE: used for very advanced SkyPilot functionality
         # Can implement later if desired
         # If the user switches the compartment_ocid, the existing clusters

sky/clouds/paperspace.py

@@ -280,7 +280,7 @@ class Paperspace(clouds.Cloud):
         }
 
     @classmethod
-    def get_current_user_identity(cls) -> Optional[List[str]]:
+    def get_user_identities(cls) -> Optional[List[List[str]]]:
         # NOTE: used for very advanced SkyPilot functionality
         # Can implement later if desired
         return None

sky/clouds/runpod.py

@@ -268,7 +268,7 @@ class RunPod(clouds.Cloud):
         }
 
     @classmethod
-    def get_current_user_identity(cls) -> Optional[List[str]]:
+    def get_user_identities(cls) -> Optional[List[List[str]]]:
         # NOTE: used for very advanced SkyPilot functionality
         # Can implement later if desired
         return None

sky/clouds/scp.py

@@ -337,8 +337,8 @@ class SCP(clouds.Cloud):
         }
 
     @classmethod
-    def get_current_user_identity(cls) -> Optional[List[str]]:
-        # TODO(jgoo1): Implement get_current_user_identity for SCP
+    def get_user_identities(cls) -> Optional[List[List[str]]]:
+        # TODO(jgoo1): Implement get_user_identities for SCP
         return None
 
     def instance_type_exists(self, instance_type: str) -> bool:

sky/clouds/service_catalog/aws_catalog.py

@@ -123,7 +123,7 @@ def _fetch_and_apply_az_mapping(df: common.LazyDataFrame) -> 'pd.DataFrame':
         with the zone name (e.g. us-east-1a).
     """
     try:
-        user_identity_list = aws.AWS.get_current_user_identity()
+        user_identity_list = aws.AWS.get_active_user_identity()
         assert user_identity_list, user_identity_list
         user_identity = user_identity_list[0]
         aws_user_hash = hashlib.md5(user_identity.encode()).hexdigest()[:8]

sky/clouds/vsphere.py

@@ -308,7 +308,7 @@ class Vsphere(clouds.Cloud):
         }
 
     @classmethod
-    def get_current_user_identity(cls) -> Optional[List[str]]:
+    def get_user_identities(cls) -> Optional[List[List[str]]]:
         # NOTE: used for very advanced SkyPilot functionality
         # Can implement later if desired
         return None

sky/provision/kubernetes/config.py

@@ -23,14 +23,16 @@ def bootstrap_instances(
         region: str, cluster_name: str,
         config: common.ProvisionConfig) -> common.ProvisionConfig:
     del region, cluster_name  # unused
-    namespace = kubernetes_utils.get_current_kube_config_context_namespace()
+    namespace = kubernetes_utils.get_namespace_from_config(
+        config.provider_config)
+    context = kubernetes_utils.get_context_from_config(config.provider_config)
 
-    _configure_services(namespace, config.provider_config)
+    _configure_services(namespace, context, config.provider_config)
 
     networking_mode = network_utils.get_networking_mode(
         config.provider_config.get('networking_mode'))
     if networking_mode == kubernetes_enums.KubernetesNetworkingMode.NODEPORT:
-        config = _configure_ssh_jump(namespace, config)
+        config = _configure_ssh_jump(namespace, context, config)
 
     requested_service_account = config.node_config['spec']['serviceAccountName']
     if (requested_service_account ==
@@ -40,16 +42,20 @@ def bootstrap_instances(
         # necessary roles and role bindings.
         # If not, set up the roles and bindings for skypilot-service-account
         # here.
-        _configure_autoscaler_service_account(namespace, config.provider_config)
+        _configure_autoscaler_service_account(namespace, context,
+                                              config.provider_config)
         _configure_autoscaler_role(namespace,
+                                   context,
                                    config.provider_config,
                                    role_field='autoscaler_role')
         _configure_autoscaler_role_binding(
             namespace,
+            context,
             config.provider_config,
             binding_field='autoscaler_role_binding')
-        _configure_autoscaler_cluster_role(namespace, config.provider_config)
-        _configure_autoscaler_cluster_role_binding(namespace,
+        _configure_autoscaler_cluster_role(namespace, context,
+                                           config.provider_config)
+        _configure_autoscaler_cluster_role_binding(namespace, context,
                                                    config.provider_config)
         # SkyPilot system namespace is required for FUSE mounting. Here we just
         # create the namespace and set up the necessary permissions.
@@ -71,10 +77,12 @@ def bootstrap_instances(
                         'and role binding.')
             try:
                 _configure_autoscaler_role(namespace,
+                                           context,
                                            config.provider_config,
                                            role_field='autoscaler_ingress_role')
                 _configure_autoscaler_role_binding(
                     namespace,
+                    context,
                     config.provider_config,
                     binding_field='autoscaler_ingress_role_binding')
             except kubernetes.api_exception() as e:
@@ -239,7 +247,7 @@ def _get_resource(container_resources: Dict[str, Any], resource_name: str,
 
 
 def _configure_autoscaler_service_account(
-        namespace: str, provider_config: Dict[str, Any]) -> None:
+        namespace: str, context: str, provider_config: Dict[str, Any]) -> None:
     account_field = 'autoscaler_service_account'
     if account_field not in provider_config:
         logger.info('_configure_autoscaler_service_account: '
@@ -254,7 +262,7 @@ def _configure_autoscaler_service_account(
 
     name = account['metadata']['name']
     field_selector = f'metadata.name={name}'
-    accounts = (kubernetes.core_api().list_namespaced_service_account(
+    accounts = (kubernetes.core_api(context).list_namespaced_service_account(
         namespace, field_selector=field_selector).items)
     if len(accounts) > 0:
         assert len(accounts) == 1
@@ -267,12 +275,14 @@ def _configure_autoscaler_service_account(
 
     logger.info('_configure_autoscaler_service_account: '
                 f'{not_found_msg(account_field, name)}')
-    kubernetes.core_api().create_namespaced_service_account(namespace, account)
+    kubernetes.core_api(context).create_namespaced_service_account(
+        namespace, account)
     logger.info('_configure_autoscaler_service_account: '
                 f'{created_msg(account_field, name)}')
 
 
-def _configure_autoscaler_role(namespace: str, provider_config: Dict[str, Any],
+def _configure_autoscaler_role(namespace: str, context: str,
+                               provider_config: Dict[str, Any],
                                role_field: str) -> None:
     """ Reads the role from the provider config, creates if it does not exist.
 
@@ -295,7 +305,7 @@ def _configure_autoscaler_role(namespace: str, provider_config: Dict[str, Any],
 
     name = role['metadata']['name']
     field_selector = f'metadata.name={name}'
-    roles = (kubernetes.auth_api().list_namespaced_role(
+    roles = (kubernetes.auth_api(context).list_namespaced_role(
         namespace, field_selector=field_selector).items)
     if len(roles) > 0:
         assert len(roles) == 1
@@ -308,17 +318,19 @@ def _configure_autoscaler_role(namespace: str, provider_config: Dict[str, Any],
             return
         logger.info('_configure_autoscaler_role: '
                     f'{updating_existing_msg(role_field, name)}')
-        kubernetes.auth_api().patch_namespaced_role(name, namespace, role)
+        kubernetes.auth_api(context).patch_namespaced_role(
+            name, namespace, role)
         return
 
     logger.info('_configure_autoscaler_role: '
                 f'{not_found_msg(role_field, name)}')
-    kubernetes.auth_api().create_namespaced_role(namespace, role)
+    kubernetes.auth_api(context).create_namespaced_role(namespace, role)
     logger.info(f'_configure_autoscaler_role: {created_msg(role_field, name)}')
 
 
 def _configure_autoscaler_role_binding(
         namespace: str,
+        context: str,
         provider_config: Dict[str, Any],
         binding_field: str,
         override_name: Optional[str] = None,
@@ -359,7 +371,7 @@ def _configure_autoscaler_role_binding(
     name = binding['metadata']['name']
 
     field_selector = f'metadata.name={name}'
-    role_bindings = (kubernetes.auth_api().list_namespaced_role_binding(
+    role_bindings = (kubernetes.auth_api(context).list_namespaced_role_binding(
         rb_namespace, field_selector=field_selector).items)
     if len(role_bindings) > 0:
         assert len(role_bindings) == 1
@@ -372,18 +384,19 @@ def _configure_autoscaler_role_binding(
             return
         logger.info('_configure_autoscaler_role_binding: '
                     f'{updating_existing_msg(binding_field, name)}')
-        kubernetes.auth_api().patch_namespaced_role_binding(
+        kubernetes.auth_api(context).patch_namespaced_role_binding(
             name, rb_namespace, binding)
         return
 
     logger.info('_configure_autoscaler_role_binding: '
                 f'{not_found_msg(binding_field, name)}')
-    kubernetes.auth_api().create_namespaced_role_binding(rb_namespace, binding)
+    kubernetes.auth_api(context).create_namespaced_role_binding(
+        rb_namespace, binding)
     logger.info('_configure_autoscaler_role_binding: '
                 f'{created_msg(binding_field, name)}')
 
 
-def _configure_autoscaler_cluster_role(namespace,
+def _configure_autoscaler_cluster_role(namespace, context,
                                        provider_config: Dict[str, Any]) -> None:
     role_field = 'autoscaler_cluster_role'
     if role_field not in provider_config:
@@ -399,7 +412,7 @@ def _configure_autoscaler_cluster_role(namespace,
 
     name = role['metadata']['name']
     field_selector = f'metadata.name={name}'
-    cluster_roles = (kubernetes.auth_api().list_cluster_role(
+    cluster_roles = (kubernetes.auth_api(context).list_cluster_role(
         field_selector=field_selector).items)
     if len(cluster_roles) > 0:
         assert len(cluster_roles) == 1
@@ -411,18 +424,18 @@ def _configure_autoscaler_cluster_role(namespace,
             return
         logger.info('_configure_autoscaler_cluster_role: '
                     f'{updating_existing_msg(role_field, name)}')
-        kubernetes.auth_api().patch_cluster_role(name, role)
+        kubernetes.auth_api(context).patch_cluster_role(name, role)
         return
 
     logger.info('_configure_autoscaler_cluster_role: '
                 f'{not_found_msg(role_field, name)}')
-    kubernetes.auth_api().create_cluster_role(role)
+    kubernetes.auth_api(context).create_cluster_role(role)
     logger.info(
         f'_configure_autoscaler_cluster_role: {created_msg(role_field, name)}')
 
 
 def _configure_autoscaler_cluster_role_binding(
-        namespace, provider_config: Dict[str, Any]) -> None:
+        namespace, context, provider_config: Dict[str, Any]) -> None:
     binding_field = 'autoscaler_cluster_role_binding'
     if binding_field not in provider_config:
         logger.info('_configure_autoscaler_cluster_role_binding: '
@@ -444,7 +457,7 @@ def _configure_autoscaler_cluster_role_binding(
 
     name = binding['metadata']['name']
     field_selector = f'metadata.name={name}'
-    cr_bindings = (kubernetes.auth_api().list_cluster_role_binding(
+    cr_bindings = (kubernetes.auth_api(context).list_cluster_role_binding(
         field_selector=field_selector).items)
     if len(cr_bindings) > 0:
         assert len(cr_bindings) == 1
@@ -458,17 +471,17 @@ def _configure_autoscaler_cluster_role_binding(
             return
         logger.info('_configure_autoscaler_cluster_role_binding: '
                     f'{updating_existing_msg(binding_field, name)}')
-        kubernetes.auth_api().patch_cluster_role_binding(name, binding)
+        kubernetes.auth_api(context).patch_cluster_role_binding(name, binding)
         return
 
     logger.info('_configure_autoscaler_cluster_role_binding: '
                 f'{not_found_msg(binding_field, name)}')
-    kubernetes.auth_api().create_cluster_role_binding(binding)
+    kubernetes.auth_api(context).create_cluster_role_binding(binding)
     logger.info('_configure_autoscaler_cluster_role_binding: '
                 f'{created_msg(binding_field, name)}')
 
 
-def _configure_ssh_jump(namespace, config: common.ProvisionConfig):
+def _configure_ssh_jump(namespace, context, config: common.ProvisionConfig):
     """Creates a SSH jump pod to connect to the cluster.
 
     Also updates config['auth']['ssh_proxy_command'] to use the newly created
@@ -499,7 +512,7 @@ def _configure_ssh_jump(namespace, config: common.ProvisionConfig):
     #  service is missing, we should raise an error.
 
     kubernetes_utils.setup_ssh_jump_pod(ssh_jump_name, ssh_jump_image,
-                                        ssh_key_secret_name, namespace)
+                                        ssh_key_secret_name, namespace, context)
     return config
 
 
@@ -512,12 +525,14 @@ def _configure_skypilot_system_namespace(
     """
     svc_account_namespace = provider_config['namespace']
     skypilot_system_namespace = provider_config['skypilot_system_namespace']
-    kubernetes_utils.create_namespace(skypilot_system_namespace)
+    context = kubernetes_utils.get_context_from_config(provider_config)
+    kubernetes_utils.create_namespace(skypilot_system_namespace, context)
 
     # Note - this must be run only after the service account has been
     # created in the cluster (in bootstrap_instances).
     # Create the role in the skypilot-system namespace if it does not exist.
     _configure_autoscaler_role(skypilot_system_namespace,
+                               context,
                                provider_config,
                                role_field='autoscaler_skypilot_system_role')
     # We must create a unique role binding per-namespace that SkyPilot is
@@ -532,6 +547,7 @@ def _configure_skypilot_system_namespace(
     # account is created in.
     _configure_autoscaler_role_binding(
         skypilot_system_namespace,
+        context,
         provider_config,
         binding_field='autoscaler_skypilot_system_role_binding',
         override_name=override_name,
@@ -555,6 +571,7 @@ def _configure_fuse_mounting(provider_config: Dict[str, Any]) -> None:
     logger.info('_configure_fuse_mounting: Setting up FUSE device manager.')
 
     fuse_device_manager_namespace = provider_config['skypilot_system_namespace']
+    context = kubernetes_utils.get_context_from_config(provider_config)
 
     # Read the device manager YAMLs from the manifests directory
     root_dir = os.path.dirname(os.path.dirname(__file__))
@@ -567,7 +584,7 @@ def _configure_fuse_mounting(provider_config: Dict[str, Any]) -> None:
         config_map = yaml.safe_load(file)
     kubernetes_utils.merge_custom_metadata(config_map['metadata'])
     try:
-        kubernetes.core_api().create_namespaced_config_map(
+        kubernetes.core_api(context).create_namespaced_config_map(
             fuse_device_manager_namespace, config_map)
     except kubernetes.api_exception() as e:
         if e.status == 409:
@@ -587,7 +604,7 @@ def _configure_fuse_mounting(provider_config: Dict[str, Any]) -> None:
         daemonset = yaml.safe_load(file)
     kubernetes_utils.merge_custom_metadata(daemonset['metadata'])
     try:
-        kubernetes.apps_api().create_namespaced_daemon_set(
+        kubernetes.apps_api(context).create_namespaced_daemon_set(
             fuse_device_manager_namespace, daemonset)
     except kubernetes.api_exception() as e:
         if e.status == 409:
@@ -603,8 +620,8 @@ def _configure_fuse_mounting(provider_config: Dict[str, Any]) -> None:
                 f'in namespace {fuse_device_manager_namespace!r}')
 
 
-def _configure_services(namespace: str, provider_config: Dict[str,
-                                                              Any]) -> None:
+def _configure_services(namespace: str, context: str,
+                        provider_config: Dict[str, Any]) -> None:
     service_field = 'services'
     if service_field not in provider_config:
         logger.info(f'_configure_services: {not_provided_msg(service_field)}')
@@ -619,7 +636,7 @@ def _configure_services(namespace: str, provider_config: Dict[str,
 
         name = service['metadata']['name']
         field_selector = f'metadata.name={name}'
-        services = (kubernetes.core_api().list_namespaced_service(
+        services = (kubernetes.core_api(context).list_namespaced_service(
             namespace, field_selector=field_selector).items)
         if len(services) > 0:
             assert len(services) == 1
@@ -633,12 +650,13 @@ def _configure_services(namespace: str, provider_config: Dict[str,
             else:
                 logger.info('_configure_services: '
                             f'{updating_existing_msg("service", name)}')
-                kubernetes.core_api().patch_namespaced_service(
+                kubernetes.core_api(context).patch_namespaced_service(
                     name, namespace, service)
         else:
             logger.info(
                 f'_configure_services: {not_found_msg("service", name)}')
-            kubernetes.core_api().create_namespaced_service(namespace, service)
+            kubernetes.core_api(context).create_namespaced_service(
+                namespace, service)
             logger.info(f'_configure_services: {created_msg("service", name)}')