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

sky/provision/kubernetes/instance.py

@@ -42,13 +42,7 @@ def to_label_selector(tags):
     return label_selector
 
 
-def _get_namespace(provider_config: Dict[str, Any]) -> str:
-    return provider_config.get(
-        'namespace',
-        kubernetes_utils.get_current_kube_config_context_namespace())
-
-
-def _filter_pods(namespace: str, tag_filters: Dict[str, str],
+def _filter_pods(namespace: str, context: str, tag_filters: Dict[str, str],
                  status_filters: Optional[List[str]]) -> Dict[str, Any]:
     """Filters pods by tags and status."""
     non_included_pod_statuses = POD_STATUSES.copy()
@@ -60,7 +54,7 @@ def _filter_pods(namespace: str, tag_filters: Dict[str, str],
             [f'status.phase!={status}' for status in non_included_pod_statuses])
 
     label_selector = to_label_selector(tag_filters)
-    pod_list = kubernetes.core_api().list_namespaced_pod(
+    pod_list = kubernetes.core_api(context).list_namespaced_pod(
         namespace, field_selector=field_selector, label_selector=label_selector)
 
     # Don't return pods marked for deletion,
@@ -85,7 +79,7 @@ def head_service_selector(cluster_name: str) -> Dict[str, str]:
     return {'component': f'{cluster_name}-head'}
 
 
-def _raise_pod_scheduling_errors(namespace, new_nodes):
+def _raise_pod_scheduling_errors(namespace, context, new_nodes):
     """Raise pod scheduling failure reason.
 
     When a pod fails to schedule in Kubernetes, the reasons for the failure
@@ -139,8 +133,8 @@ def _raise_pod_scheduling_errors(namespace, new_nodes):
         return msg
 
     for new_node in new_nodes:
-        pod = kubernetes.core_api().read_namespaced_pod(new_node.metadata.name,
-                                                        namespace)
+        pod = kubernetes.core_api(context).read_namespaced_pod(
+            new_node.metadata.name, namespace)
         pod_status = pod.status.phase
         # When there are multiple pods involved while launching instance,
         # there may be a single pod causing issue while others are
@@ -149,7 +143,7 @@ def _raise_pod_scheduling_errors(namespace, new_nodes):
         if pod_status != 'Pending':
             continue
         pod_name = pod._metadata._name  # pylint: disable=protected-access
-        events = kubernetes.core_api().list_namespaced_event(
+        events = kubernetes.core_api(context).list_namespaced_event(
             namespace,
             field_selector=(f'involvedObject.name={pod_name},'
                             'involvedObject.kind=Pod'))
@@ -223,7 +217,7 @@ def _raise_command_running_error(message: str, command: str, pod_name: str,
         f'code {rc}: {command!r}\nOutput: {stdout}.')
 
 
-def _wait_for_pods_to_schedule(namespace, new_nodes, timeout: int):
+def _wait_for_pods_to_schedule(namespace, context, new_nodes, timeout: int):
     """Wait for all pods to be scheduled.
 
     Wait for all pods including jump pod to be scheduled, and if it
@@ -245,7 +239,7 @@ def _wait_for_pods_to_schedule(namespace, new_nodes, timeout: int):
         all_pods_scheduled = True
         for node in new_nodes:
             # Iterate over each pod to check their status
-            pod = kubernetes.core_api().read_namespaced_pod(
+            pod = kubernetes.core_api(context).read_namespaced_pod(
                 node.metadata.name, namespace)
             if pod.status.phase == 'Pending':
                 # If container_statuses is None, then the pod hasn't
@@ -260,7 +254,7 @@ def _wait_for_pods_to_schedule(namespace, new_nodes, timeout: int):
 
     # Handle pod scheduling errors
     try:
-        _raise_pod_scheduling_errors(namespace, new_nodes)
+        _raise_pod_scheduling_errors(namespace, context, new_nodes)
     except config_lib.KubernetesError:
         raise
     except Exception as e:
@@ -270,7 +264,7 @@ def _wait_for_pods_to_schedule(namespace, new_nodes, timeout: int):
             f'Error: {common_utils.format_exception(e)}') from None
 
 
-def _wait_for_pods_to_run(namespace, new_nodes):
+def _wait_for_pods_to_run(namespace, context, new_nodes):
     """Wait for pods and their containers to be ready.
 
     Pods may be pulling images or may be in the process of container
@@ -306,7 +300,7 @@ def _wait_for_pods_to_run(namespace, new_nodes):
         all_pods_running = True
         # Iterate over each pod to check their status
         for node in new_nodes:
-            pod = kubernetes.core_api().read_namespaced_pod(
+            pod = kubernetes.core_api(context).read_namespaced_pod(
                 node.metadata.name, namespace)
 
             # Continue if pod and all the containers within the
@@ -344,7 +338,7 @@ def _wait_for_pods_to_run(namespace, new_nodes):
         time.sleep(1)
 
 
-def _set_env_vars_in_pods(namespace: str, new_pods: List):
+def _set_env_vars_in_pods(namespace: str, context: str, new_pods: List):
     """Setting environment variables in pods.
 
     Once all containers are ready, we can exec into them and set env vars.
@@ -364,7 +358,7 @@ def _set_env_vars_in_pods(namespace: str, new_pods: List):
 
     for new_pod in new_pods:
         runner = command_runner.KubernetesCommandRunner(
-            (namespace, new_pod.metadata.name))
+            ((namespace, context), new_pod.metadata.name))
         rc, stdout, _ = runner.run(set_k8s_env_var_cmd,
                                    require_outputs=True,
                                    stream_logs=False)
@@ -372,7 +366,8 @@ def _set_env_vars_in_pods(namespace: str, new_pods: List):
                                      new_pod.metadata.name, rc, stdout)
 
 
-def _check_user_privilege(namespace: str, new_nodes: List) -> None:
+def _check_user_privilege(namespace: str, context: str,
+                          new_nodes: List) -> None:
     # Checks if the default user has sufficient privilege to set up
     # the kubernetes instance pod.
     check_k8s_user_sudo_cmd = (
@@ -390,7 +385,7 @@ def _check_user_privilege(namespace: str, new_nodes: List) -> None:
 
     for new_node in new_nodes:
         runner = command_runner.KubernetesCommandRunner(
-            (namespace, new_node.metadata.name))
+            ((namespace, context), new_node.metadata.name))
         rc, stdout, stderr = runner.run(check_k8s_user_sudo_cmd,
                                         require_outputs=True,
                                         separate_stderr=True,
@@ -407,7 +402,7 @@ def _check_user_privilege(namespace: str, new_nodes: List) -> None:
                 'from the image.')
 
 
-def _setup_ssh_in_pods(namespace: str, new_nodes: List) -> None:
+def _setup_ssh_in_pods(namespace: str, context: str, new_nodes: List) -> None:
     # Setting up ssh for the pod instance. This is already setup for
     # the jump pod so it does not need to be run for it.
     set_k8s_ssh_cmd = (
@@ -440,7 +435,8 @@ def _setup_ssh_in_pods(namespace: str, new_nodes: List) -> None:
     # TODO(romilb): Parallelize the setup of SSH in pods for multi-node clusters
     for new_node in new_nodes:
         pod_name = new_node.metadata.name
-        runner = command_runner.KubernetesCommandRunner((namespace, pod_name))
+        runner = command_runner.KubernetesCommandRunner(
+            ((namespace, context), pod_name))
         logger.info(f'{"-"*20}Start: Set up SSH in pod {pod_name!r} {"-"*20}')
         rc, stdout, _ = runner.run(set_k8s_ssh_cmd,
                                    require_outputs=True,
@@ -450,9 +446,10 @@ def _setup_ssh_in_pods(namespace: str, new_nodes: List) -> None:
         logger.info(f'{"-"*20}End: Set up SSH in pod {pod_name!r} {"-"*20}')
 
 
-def _label_pod(namespace: str, pod_name: str, label: Dict[str, str]) -> None:
+def _label_pod(namespace: str, context: str, pod_name: str,
+               label: Dict[str, str]) -> None:
     """Label a pod."""
-    kubernetes.core_api().patch_namespaced_pod(
+    kubernetes.core_api(context).patch_namespaced_pod(
         pod_name,
         namespace, {'metadata': {
             'labels': label
@@ -464,7 +461,8 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
                  config: common.ProvisionConfig) -> common.ProvisionRecord:
     """Create pods based on the config."""
     provider_config = config.provider_config
-    namespace = _get_namespace(provider_config)
+    namespace = kubernetes_utils.get_namespace_from_config(provider_config)
+    context = kubernetes_utils.get_context_from_config(provider_config)
     pod_spec = copy.deepcopy(config.node_config)
     tags = {
         TAG_RAY_CLUSTER_NAME: cluster_name_on_cloud,
@@ -477,7 +475,7 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
     pod_spec['metadata']['labels'].update(
         {TAG_SKYPILOT_CLUSTER_NAME: cluster_name_on_cloud})
 
-    terminating_pods = _filter_pods(namespace, tags, ['Terminating'])
+    terminating_pods = _filter_pods(namespace, context, tags, ['Terminating'])
     start_time = time.time()
     while (len(terminating_pods) > 0 and
            time.time() - start_time < _TIMEOUT_FOR_POD_TERMINATION):
@@ -485,7 +483,8 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
                      'terminating pods. Waiting them to finish: '
                      f'{list(terminating_pods.keys())}')
         time.sleep(POLL_INTERVAL)
-        terminating_pods = _filter_pods(namespace, tags, ['Terminating'])
+        terminating_pods = _filter_pods(namespace, context, tags,
+                                        ['Terminating'])
 
     if len(terminating_pods) > 0:
         # If there are still terminating pods, we force delete them.
@@ -496,13 +495,14 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
         for pod_name in terminating_pods.keys():
             # grace_period_seconds=0 means force delete the pod.
             # https://github.com/kubernetes-client/python/issues/508#issuecomment-1695759777
-            kubernetes.core_api().delete_namespaced_pod(
+            kubernetes.core_api(context).delete_namespaced_pod(
                 pod_name,
                 namespace,
                 _request_timeout=config_lib.DELETION_TIMEOUT,
                 grace_period_seconds=0)
 
-    running_pods = _filter_pods(namespace, tags, ['Pending', 'Running'])
+    running_pods = _filter_pods(namespace, context, tags,
+                                ['Pending', 'Running'])
     head_pod_name = _get_head_pod_name(running_pods)
     logger.debug(f'Found {len(running_pods)} existing pods: '
                  f'{list(running_pods.keys())}')
@@ -520,7 +520,8 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
     # Add nvidia runtime class if it exists
     nvidia_runtime_exists = False
     try:
-        nvidia_runtime_exists = kubernetes_utils.check_nvidia_runtime_class()
+        nvidia_runtime_exists = kubernetes_utils.check_nvidia_runtime_class(
+            context)
     except kubernetes.kubernetes.client.ApiException as e:
         logger.warning('run_instances: Error occurred while checking for '
                        f'nvidia RuntimeClass - '
@@ -530,7 +531,9 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
                        'override runtimeClassName in ~/.sky/config.yaml. '
                        'For more details, refer to https://skypilot.readthedocs.io/en/latest/reference/config.html')  # pylint: disable=line-too-long
 
-    if nvidia_runtime_exists:
+    needs_gpus = (pod_spec['spec']['containers'][0].get('resources', {}).get(
+        'limits', {}).get('nvidia.com/gpu', 0) > 0)
+    if nvidia_runtime_exists and needs_gpus:
         pod_spec['spec']['runtimeClassName'] = 'nvidia'
 
     created_pods = {}
@@ -574,12 +577,13 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
                 }
             }
 
-        pod = kubernetes.core_api().create_namespaced_pod(namespace, pod_spec)
+        pod = kubernetes.core_api(context).create_namespaced_pod(
+            namespace, pod_spec)
         created_pods[pod.metadata.name] = pod
         if head_pod_name is None:
             head_pod_name = pod.metadata.name
 
-    wait_pods_dict = _filter_pods(namespace, tags, ['Pending'])
+    wait_pods_dict = _filter_pods(namespace, context, tags, ['Pending'])
     wait_pods = list(wait_pods_dict.values())
 
     networking_mode = network_utils.get_networking_mode(
@@ -588,7 +592,7 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
         # Adding the jump pod to the new_nodes list as well so it can be
         # checked if it's scheduled and running along with other pods.
         ssh_jump_pod_name = pod_spec['metadata']['labels']['skypilot-ssh-jump']
-        jump_pod = kubernetes.core_api().read_namespaced_pod(
+        jump_pod = kubernetes.core_api(context).read_namespaced_pod(
             ssh_jump_pod_name, namespace)
         wait_pods.append(jump_pod)
     provision_timeout = provider_config['timeout']
@@ -600,17 +604,17 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
 
     # Wait until the pods are scheduled and surface cause for error
     # if there is one
-    _wait_for_pods_to_schedule(namespace, wait_pods, provision_timeout)
+    _wait_for_pods_to_schedule(namespace, context, wait_pods, provision_timeout)
     # Wait until the pods and their containers are up and running, and
     # fail early if there is an error
     logger.debug(f'run_instances: waiting for pods to be running (pulling '
                  f'images): {list(wait_pods_dict.keys())}')
-    _wait_for_pods_to_run(namespace, wait_pods)
+    _wait_for_pods_to_run(namespace, context, wait_pods)
     logger.debug(f'run_instances: all pods are scheduled and running: '
                  f'{list(wait_pods_dict.keys())}')
 
-    running_pods = _filter_pods(namespace, tags, ['Running'])
-    initialized_pods = _filter_pods(namespace, {
+    running_pods = _filter_pods(namespace, context, tags, ['Running'])
+    initialized_pods = _filter_pods(namespace, context, {
         TAG_POD_INITIALIZED: 'true',
         **tags
     }, ['Running'])
@@ -628,12 +632,13 @@ def _create_pods(region: str, cluster_name_on_cloud: str,
         # Make sure commands used in these methods are generic and work
         # on most base images. E.g., do not use Python, since that may not
         # be installed by default.
-        _check_user_privilege(namespace, uninitialized_pods_list)
-        _setup_ssh_in_pods(namespace, uninitialized_pods_list)
-        _set_env_vars_in_pods(namespace, uninitialized_pods_list)
+        _check_user_privilege(namespace, context, uninitialized_pods_list)
+        _setup_ssh_in_pods(namespace, context, uninitialized_pods_list)
+        _set_env_vars_in_pods(namespace, context, uninitialized_pods_list)
 
         for pod in uninitialized_pods.values():
             _label_pod(namespace,
+                       context,
                        pod.metadata.name,
                        label={
                            TAG_POD_INITIALIZED: 'true',
@@ -675,18 +680,18 @@ def stop_instances(
     raise NotImplementedError()
 
 
-def _terminate_node(namespace: str, pod_name: str) -> None:
+def _terminate_node(namespace: str, context: str, pod_name: str) -> None:
     """Terminate a pod."""
     logger.debug('terminate_instances: calling delete_namespaced_pod')
     try:
-        kubernetes_utils.clean_zombie_ssh_jump_pod(namespace, pod_name)
+        kubernetes_utils.clean_zombie_ssh_jump_pod(namespace, context, pod_name)
     except Exception as e:  # pylint: disable=broad-except
         logger.warning('terminate_instances: Error occurred when analyzing '
                        f'SSH Jump pod: {e}')
     try:
-        kubernetes.core_api().delete_namespaced_service(
+        kubernetes.core_api(context).delete_namespaced_service(
             pod_name, namespace, _request_timeout=config_lib.DELETION_TIMEOUT)
-        kubernetes.core_api().delete_namespaced_service(
+        kubernetes.core_api(context).delete_namespaced_service(
             f'{pod_name}-ssh',
             namespace,
             _request_timeout=config_lib.DELETION_TIMEOUT)
@@ -696,7 +701,7 @@ def _terminate_node(namespace: str, pod_name: str) -> None:
     # This is to ensure there are no leftover resources if this down is run
     # from within the pod, e.g., for autodown.
     try:
-        kubernetes.core_api().delete_namespaced_pod(
+        kubernetes.core_api(context).delete_namespaced_pod(
             pod_name, namespace, _request_timeout=config_lib.DELETION_TIMEOUT)
     except kubernetes.api_exception() as e:
         if e.status == 404:
@@ -712,11 +717,12 @@ def terminate_instances(
     worker_only: bool = False,
 ) -> None:
     """See sky/provision/__init__.py"""
-    namespace = _get_namespace(provider_config)
+    namespace = kubernetes_utils.get_namespace_from_config(provider_config)
+    context = kubernetes_utils.get_context_from_config(provider_config)
     tag_filters = {
         TAG_RAY_CLUSTER_NAME: cluster_name_on_cloud,
     }
-    pods = _filter_pods(namespace, tag_filters, None)
+    pods = _filter_pods(namespace, context, tag_filters, None)
 
     def _is_head(pod) -> bool:
         return pod.metadata.labels[constants.TAG_RAY_NODE_KIND] == 'head'
@@ -725,7 +731,7 @@ def terminate_instances(
         logger.debug(f'Terminating instance {pod_name}: {pod}')
         if _is_head(pod) and worker_only:
             continue
-        _terminate_node(namespace, pod_name)
+        _terminate_node(namespace, context, pod_name)
 
 
 def get_cluster_info(
@@ -734,12 +740,13 @@ def get_cluster_info(
         provider_config: Optional[Dict[str, Any]] = None) -> common.ClusterInfo:
     del region  # unused
     assert provider_config is not None
-    namespace = _get_namespace(provider_config)
+    namespace = kubernetes_utils.get_namespace_from_config(provider_config)
+    context = kubernetes_utils.get_context_from_config(provider_config)
     tag_filters = {
         TAG_RAY_CLUSTER_NAME: cluster_name_on_cloud,
     }
 
-    running_pods = _filter_pods(namespace, tag_filters, ['Running'])
+    running_pods = _filter_pods(namespace, context, tag_filters, ['Running'])
     pods: Dict[str, List[common.InstanceInfo]] = {}
     head_pod_name = None
 
@@ -748,11 +755,11 @@ def get_cluster_info(
                                                   port_forward_mode.value)
     network_mode = kubernetes_enums.KubernetesNetworkingMode.from_str(
         network_mode_str)
-    external_ip = kubernetes_utils.get_external_ip(network_mode)
+    external_ip = kubernetes_utils.get_external_ip(network_mode, context)
     port = 22
     if not provider_config.get('use_internal_ips', False):
         port = kubernetes_utils.get_head_ssh_port(cluster_name_on_cloud,
-                                                  namespace)
+                                                  namespace, context)
 
     head_pod_name = None
     cpu_request = None
@@ -779,7 +786,8 @@ def get_cluster_info(
     ssh_user = 'sky'
     get_k8s_ssh_user_cmd = 'echo $(whoami)'
     assert head_pod_name is not None
-    runner = command_runner.KubernetesCommandRunner((namespace, head_pod_name))
+    runner = command_runner.KubernetesCommandRunner(
+        ((namespace, context), head_pod_name))
     rc, stdout, stderr = runner.run(get_k8s_ssh_user_cmd,
                                     require_outputs=True,
                                     separate_stderr=True,
@@ -810,7 +818,6 @@ def query_instances(
     provider_config: Optional[Dict[str, Any]] = None,
     non_terminated_only: bool = True
 ) -> Dict[str, Optional[status_lib.ClusterStatus]]:
-    del provider_config  # unused
     status_map = {
         'Pending': status_lib.ClusterStatus.INIT,
         'Running': status_lib.ClusterStatus.UP,
@@ -820,11 +827,13 @@ def query_instances(
         'Terminating': None,
     }
 
-    namespace = kubernetes_utils.get_current_kube_config_context_namespace()
+    assert provider_config is not None
+    namespace = kubernetes_utils.get_namespace_from_config(provider_config)
+    context = kubernetes_utils.get_context_from_config(provider_config)
 
     # Get all the pods with the label skypilot-cluster: <cluster_name>
     try:
-        pods = kubernetes.core_api().list_namespaced_pod(
+        pods = kubernetes.core_api(context).list_namespaced_pod(
             namespace,
             label_selector=f'skypilot-cluster={cluster_name_on_cloud}',
             _request_timeout=kubernetes.API_TIMEOUT).items
@@ -858,11 +867,14 @@ def get_command_runners(
     """Get a command runner for the given cluster."""
     assert cluster_info.provider_config is not None, cluster_info
     instances = cluster_info.instances
-    namespace = _get_namespace(cluster_info.provider_config)
+    namespace = kubernetes_utils.get_namespace_from_config(
+        cluster_info.provider_config)
+    context = kubernetes_utils.get_context_from_config(
+        cluster_info.provider_config)
     node_list = []
     if cluster_info.head_instance_id is not None:
-        node_list = [(namespace, cluster_info.head_instance_id)]
-    node_list.extend((namespace, pod_name)
+        node_list = [((namespace, context), cluster_info.head_instance_id)]
+    node_list.extend(((namespace, context), pod_name)
                      for pod_name in instances.keys()
                      if pod_name != cluster_info.head_instance_id)
     return command_runner.KubernetesCommandRunner.make_runner_list(

sky/provision/kubernetes/network.py

@@ -58,7 +58,8 @@ def _open_ports_using_loadbalancer(
     kubernetes_utils.merge_custom_metadata(content['service_spec']['metadata'])
 
     network_utils.create_or_replace_namespaced_service(
-        namespace=provider_config.get('namespace', 'default'),
+        namespace=kubernetes_utils.get_namespace_from_config(provider_config),
+        context=kubernetes_utils.get_context_from_config(provider_config),
         service_name=service_name,
         service_spec=content['service_spec'])
 
@@ -68,8 +69,9 @@ def _open_ports_using_ingress(
     ports: List[int],
     provider_config: Dict[str, Any],
 ) -> None:
+    context = kubernetes_utils.get_context_from_config(provider_config)
     # Check if an ingress controller exists
-    if not network_utils.ingress_controller_exists():
+    if not network_utils.ingress_controller_exists(context):
         raise Exception(
             'Ingress controller not found. '
             'Install Nginx ingress controller first: '
@@ -108,7 +110,9 @@ 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=provider_config.get('namespace', 'default'),
+            namespace=kubernetes_utils.get_namespace_from_config(
+                provider_config),
+            context=kubernetes_utils.get_context_from_config(provider_config),
             service_name=service_name,
             service_spec=service_spec,
         )
@@ -116,7 +120,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=provider_config.get('namespace', 'default'),
+        namespace=kubernetes_utils.get_namespace_from_config(provider_config),
+        context=kubernetes_utils.get_context_from_config(provider_config),
         ingress_name=f'{cluster_name_on_cloud}-skypilot-ingress',
         ingress_spec=content['ingress_spec'],
     )
@@ -173,7 +178,8 @@ def _cleanup_ports_for_ingress(
     # Delete the single ingress used for all ports
     ingress_name = f'{cluster_name_on_cloud}-skypilot-ingress'
     network_utils.delete_namespaced_ingress(
-        namespace=provider_config.get('namespace', 'default'),
+        namespace=kubernetes_utils.get_namespace_from_config(provider_config),
+        context=kubernetes_utils.get_context_from_config(provider_config),
         ingress_name=ingress_name,
     )
 

sky/provision/kubernetes/network_utils.py

@@ -132,10 +132,10 @@ def fill_ingress_template(namespace: str, service_details: List[Tuple[str, int,
 
 
 def create_or_replace_namespaced_ingress(
-        namespace: str, ingress_name: str,
+        namespace: str, context: str, ingress_name: str,
         ingress_spec: Dict[str, Union[str, int]]) -> None:
     """Creates an ingress resource for the specified service."""
-    networking_api = kubernetes.networking_api()
+    networking_api = kubernetes.networking_api(context)
 
     try:
         networking_api.read_namespaced_ingress(
@@ -156,9 +156,10 @@ def create_or_replace_namespaced_ingress(
         _request_timeout=kubernetes.API_TIMEOUT)
 
 
-def delete_namespaced_ingress(namespace: str, ingress_name: str) -> None:
+def delete_namespaced_ingress(namespace: str, context: str,
+                              ingress_name: str) -> None:
     """Deletes an ingress resource."""
-    networking_api = kubernetes.networking_api()
+    networking_api = kubernetes.networking_api(context)
     try:
         networking_api.delete_namespaced_ingress(
             ingress_name, namespace, _request_timeout=kubernetes.API_TIMEOUT)
@@ -170,10 +171,10 @@ def delete_namespaced_ingress(namespace: str, ingress_name: str) -> None:
 
 
 def create_or_replace_namespaced_service(
-        namespace: str, service_name: str,
+        namespace: str, context: str, service_name: str,
         service_spec: Dict[str, Union[str, int]]) -> None:
     """Creates a service resource for the specified service."""
-    core_api = kubernetes.core_api()
+    core_api = kubernetes.core_api(context)
 
     try:
         core_api.read_namespaced_service(
@@ -207,9 +208,10 @@ def delete_namespaced_service(namespace: str, service_name: str) -> None:
         raise e
 
 
-def ingress_controller_exists(ingress_class_name: str = 'nginx') -> bool:
+def ingress_controller_exists(context: str,
+                              ingress_class_name: str = 'nginx') -> bool:
     """Checks if an ingress controller exists in the cluster."""
-    networking_api = kubernetes.networking_api()
+    networking_api = kubernetes.networking_api(context)
     ingress_classes = networking_api.list_ingress_class(
         _request_timeout=kubernetes.API_TIMEOUT).items
     return any(