skypilot-nightly 1.0.0.dev20250502__py3-none-any.whl → 1.0.0.dev20251203__py3-none-any.whl

sky/provision/kubernetes/manifests/fusermount-server-daemonset.yaml

@@ -23,8 +23,7 @@ spec:
         effect: NoExecute
       containers:
       - name: server
-        # TODO(aylei): version strategy of our addon images
-        image: berkeleyskypilot/fusermount-server:latest
+        image: berkeleyskypilot/fusermount-server:0.2.1
         securityContext:
           privileged: true
         volumeMounts:

sky/provision/kubernetes/network.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional
 from sky import sky_logging
 from sky.adaptors import kubernetes
 from sky.provision import common
+from sky.provision import constants as provision_constants
 from sky.provision.kubernetes import network_utils
 from sky.provision.kubernetes import utils as kubernetes_utils
 from sky.utils import kubernetes_enums
@@ -22,8 +23,9 @@ def open_ports(
 ) -> None:
     """See sky/provision/__init__.py"""
     assert provider_config is not None, 'provider_config is required'
+    context = kubernetes_utils.get_context_from_config(provider_config)
     port_mode = network_utils.get_port_mode(
-        provider_config.get('port_mode', None))
+        provider_config.get('port_mode', None), context)
     ports = list(port_ranges_to_set(ports))
     if port_mode == kubernetes_enums.KubernetesPortMode.LOADBALANCER:
         _open_ports_using_loadbalancer(
@@ -46,11 +48,15 @@ def _open_ports_using_loadbalancer(
 ) -> None:
     service_name = _LOADBALANCER_SERVICE_NAME.format(
         cluster_name_on_cloud=cluster_name_on_cloud)
+    context = kubernetes_utils.get_context_from_config(provider_config)
+    namespace = kubernetes_utils.get_namespace_from_config(provider_config)
+
     content = network_utils.fill_loadbalancer_template(
-        namespace=provider_config.get('namespace', 'default'),
+        namespace=namespace,
+        context=context,
         service_name=service_name,
         ports=ports,
-        selector_key='skypilot-cluster',
+        selector_key=provision_constants.TAG_SKYPILOT_CLUSTER_NAME,
         selector_value=cluster_name_on_cloud,
     )
 
@@ -59,7 +65,7 @@ def _open_ports_using_loadbalancer(
 
     network_utils.create_or_replace_namespaced_service(
         namespace=kubernetes_utils.get_namespace_from_config(provider_config),
-        context=kubernetes_utils.get_context_from_config(provider_config),
+        context=context,
         service_name=service_name,
         service_spec=content['service_spec'])
 
@@ -70,6 +76,7 @@ def _open_ports_using_ingress(
     provider_config: Dict[str, Any],
 ) -> None:
     context = kubernetes_utils.get_context_from_config(provider_config)
+    namespace = kubernetes_utils.get_namespace_from_config(provider_config)
     # Check if an ingress controller exists
     if not network_utils.ingress_controller_exists(context):
         raise Exception(
@@ -99,10 +106,11 @@ def _open_ports_using_ingress(
     # To avoid this, we change ingress creation into one object containing
     # multiple rules.
     content = network_utils.fill_ingress_template(
-        namespace=provider_config.get('namespace', 'default'),
+        namespace=namespace,
+        context=context,
         service_details=service_details,
         ingress_name=f'{cluster_name_on_cloud}-skypilot-ingress',
-        selector_key='skypilot-cluster',
+        selector_key=provision_constants.TAG_SKYPILOT_CLUSTER_NAME,
         selector_value=cluster_name_on_cloud,
     )
 
@@ -111,9 +119,8 @@ def _open_ports_using_ingress(
         # Update metadata from config
         kubernetes_utils.merge_custom_metadata(service_spec['metadata'])
         network_utils.create_or_replace_namespaced_service(
-            namespace=kubernetes_utils.get_namespace_from_config(
-                provider_config),
-            context=kubernetes_utils.get_context_from_config(provider_config),
+            namespace=namespace,
+            context=context,
             service_name=service_name,
             service_spec=service_spec,
         )
@@ -121,8 +128,8 @@ def _open_ports_using_ingress(
     kubernetes_utils.merge_custom_metadata(content['ingress_spec']['metadata'])
     # Create or update the single ingress for all services
     network_utils.create_or_replace_namespaced_ingress(
-        namespace=kubernetes_utils.get_namespace_from_config(provider_config),
-        context=kubernetes_utils.get_context_from_config(provider_config),
+        namespace=namespace,
+        context=context,
         ingress_name=f'{cluster_name_on_cloud}-skypilot-ingress',
         ingress_spec=content['ingress_spec'],
     )
@@ -135,8 +142,9 @@ def cleanup_ports(
 ) -> None:
     """See sky/provision/__init__.py"""
     assert provider_config is not None, 'provider_config is required'
+    context = kubernetes_utils.get_context_from_config(provider_config)
     port_mode = network_utils.get_port_mode(
-        provider_config.get('port_mode', None))
+        provider_config.get('port_mode', None), context)
     ports = list(port_ranges_to_set(ports))
     if port_mode == kubernetes_enums.KubernetesPortMode.LOADBALANCER:
         _cleanup_ports_for_loadbalancer(
@@ -160,9 +168,10 @@ def _cleanup_ports_for_loadbalancer(
     # TODO(aylei): test coverage
     context = provider_config.get(
         'context', kubernetes_utils.get_current_kube_config_context_name())
+    namespace = kubernetes_utils.get_namespace_from_config(provider_config)
     network_utils.delete_namespaced_service(
         context=context,
-        namespace=provider_config.get('namespace', 'default'),
+        namespace=namespace,
         service_name=service_name,
     )
 
@@ -175,19 +184,19 @@ def _cleanup_ports_for_ingress(
     # Delete services for each port
     context = provider_config.get(
         'context', kubernetes_utils.get_current_kube_config_context_name())
+    namespace = kubernetes_utils.get_namespace_from_config(provider_config)
     for port in ports:
         service_name = f'{cluster_name_on_cloud}--skypilot-svc--{port}'
         network_utils.delete_namespaced_service(
             context=context,
-            namespace=provider_config.get('namespace',
-                                          kubernetes_utils.DEFAULT_NAMESPACE),
+            namespace=namespace,
             service_name=service_name,
         )
 
     # Delete the single ingress used for all ports
     ingress_name = f'{cluster_name_on_cloud}-skypilot-ingress'
     network_utils.delete_namespaced_ingress(
-        namespace=kubernetes_utils.get_namespace_from_config(provider_config),
+        namespace=namespace,
         context=kubernetes_utils.get_context_from_config(provider_config),
         ingress_name=ingress_name,
     )
@@ -202,8 +211,9 @@ def query_ports(
     """See sky/provision/__init__.py"""
     del head_ip  # unused
     assert provider_config is not None, 'provider_config is required'
+    context = kubernetes_utils.get_context_from_config(provider_config)
     port_mode = network_utils.get_port_mode(
-        provider_config.get('port_mode', None))
+        provider_config.get('port_mode', None), context)
     ports = list(port_ranges_to_set(ports))
 
     try:

sky/provision/kubernetes/network_utils.py

@@ -4,22 +4,21 @@ import time
 import typing
 from typing import Dict, List, Optional, Tuple, Union
 
-import sky
 from sky import exceptions
 from sky import sky_logging
 from sky import skypilot_config
 from sky.adaptors import common as adaptors_common
 from sky.adaptors import kubernetes
 from sky.provision.kubernetes import utils as kubernetes_utils
+from sky.utils import directory_utils
 from sky.utils import kubernetes_enums
 from sky.utils import ux_utils
+from sky.utils import yaml_utils
 
 if typing.TYPE_CHECKING:
     import jinja2
-    import yaml
 else:
     jinja2 = adaptors_common.LazyImport('jinja2')
-    yaml = adaptors_common.LazyImport('yaml')
 
 logger = sky_logging.init_logger(__name__)
 
@@ -28,7 +27,8 @@ _LOADBALANCER_TEMPLATE_NAME = 'kubernetes-loadbalancer.yml.j2'
 
 
 def get_port_mode(
-        mode_str: Optional[str] = None) -> kubernetes_enums.KubernetesPortMode:
+        mode_str: Optional[str],
+        context: Optional[str]) -> kubernetes_enums.KubernetesPortMode:
     """Get the port mode from the provider config."""
 
     curr_kube_config = kubernetes_utils.get_current_kube_config_context_name()
@@ -38,9 +38,11 @@ def get_port_mode(
         # If running in kind (`sky local up`), use ingress mode
         return kubernetes_enums.KubernetesPortMode.INGRESS
 
-    mode_str = mode_str or skypilot_config.get_nested(
-        ('kubernetes', 'ports'),
-        kubernetes_enums.KubernetesPortMode.LOADBALANCER.value)
+    mode_str = mode_str or skypilot_config.get_effective_region_config(
+        cloud='kubernetes',
+        region=context,
+        keys=('ports',),
+        default_value=kubernetes_enums.KubernetesPortMode.LOADBALANCER.value)
     try:
         port_mode = kubernetes_enums.KubernetesPortMode(mode_str)
     except ValueError as e:
@@ -53,27 +55,10 @@ def get_port_mode(
     return port_mode
 
 
-def get_networking_mode(
-    mode_str: Optional[str] = None
-) -> kubernetes_enums.KubernetesNetworkingMode:
-    """Get the networking mode from the provider config."""
-    mode_str = mode_str or skypilot_config.get_nested(
-        ('kubernetes', 'networking_mode'),
-        kubernetes_enums.KubernetesNetworkingMode.PORTFORWARD.value)
-    try:
-        networking_mode = kubernetes_enums.KubernetesNetworkingMode.from_str(
-            mode_str)
-    except ValueError as e:
-        with ux_utils.print_exception_no_traceback():
-            raise ValueError(str(e) +
-                             ' Please check: ~/.sky/config.yaml.') from None
-    return networking_mode
-
-
-def fill_loadbalancer_template(namespace: str, service_name: str,
-                               ports: List[int], selector_key: str,
-                               selector_value: str) -> Dict:
-    template_path = os.path.join(sky.__root_dir__, 'templates',
+def fill_loadbalancer_template(namespace: str, context: Optional[str],
+                               service_name: str, ports: List[int],
+                               selector_key: str, selector_value: str) -> Dict:
+    template_path = os.path.join(directory_utils.get_sky_dir(), 'templates',
                                  _LOADBALANCER_TEMPLATE_NAME)
     if not os.path.exists(template_path):
         raise FileNotFoundError(
@@ -81,10 +66,18 @@ def fill_loadbalancer_template(namespace: str, service_name: str,
 
     with open(template_path, 'r', encoding='utf-8') as fin:
         template = fin.read()
-    annotations = skypilot_config.get_nested(
-        ('kubernetes', 'custom_metadata', 'annotations'), {})
-    labels = skypilot_config.get_nested(
-        ('kubernetes', 'custom_metadata', 'labels'), {})
+    context, cloud_str = kubernetes_utils.get_cleaned_context_and_cloud_str(
+        context)
+    annotations = skypilot_config.get_effective_region_config(
+        cloud=cloud_str,
+        region=context,
+        keys=('custom_metadata', 'annotations'),
+        default_value={})
+    labels = skypilot_config.get_effective_region_config(
+        cloud=cloud_str,
+        region=context,
+        keys=('custom_metadata', 'labels'),
+        default_value={})
     j2_template = jinja2.Template(template)
     cont = j2_template.render(
         namespace=namespace,
@@ -95,25 +88,33 @@ def fill_loadbalancer_template(namespace: str, service_name: str,
         annotations=annotations,
         labels=labels,
     )
-    content = yaml.safe_load(cont)
+    content = yaml_utils.safe_load(cont)
     return content
 
 
-def fill_ingress_template(namespace: str, service_details: List[Tuple[str, int,
-                                                                      str]],
-                          ingress_name: str, selector_key: str,
-                          selector_value: str) -> Dict:
-    template_path = os.path.join(sky.__root_dir__, 'templates',
+def fill_ingress_template(namespace: str, context: Optional[str],
+                          service_details: List[Tuple[str, int,
+                                                      str]], ingress_name: str,
+                          selector_key: str, selector_value: str) -> Dict:
+    template_path = os.path.join(directory_utils.get_sky_dir(), 'templates',
                                  _INGRESS_TEMPLATE_NAME)
     if not os.path.exists(template_path):
         raise FileNotFoundError(
             f'Template "{_INGRESS_TEMPLATE_NAME}" does not exist.')
     with open(template_path, 'r', encoding='utf-8') as fin:
         template = fin.read()
-    annotations = skypilot_config.get_nested(
-        ('kubernetes', 'custom_metadata', 'annotations'), {})
-    labels = skypilot_config.get_nested(
-        ('kubernetes', 'custom_metadata', 'labels'), {})
+    context, cloud_str = kubernetes_utils.get_cleaned_context_and_cloud_str(
+        context)
+    annotations = skypilot_config.get_effective_region_config(
+        cloud=cloud_str,
+        region=context,
+        keys=('custom_metadata', 'annotations'),
+        default_value={})
+    labels = skypilot_config.get_effective_region_config(
+        cloud=cloud_str,
+        region=context,
+        keys=('custom_metadata', 'labels'),
+        default_value={})
     j2_template = jinja2.Template(template)
     cont = j2_template.render(
         namespace=namespace,
@@ -128,7 +129,7 @@ def fill_ingress_template(namespace: str, service_details: List[Tuple[str, int,
         annotations=annotations,
         labels=labels,
     )
-    content = yaml.safe_load(cont)
+    content = yaml_utils.safe_load(cont)
 
     # Return a dictionary containing both specs
     return {