mlrun 1.10.0rc18__py3-none-any.whl → 1.11.0rc16__py3-none-any.whl

mlrun/runtimes/nuclio/application/application.py

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import copy
 import pathlib
 import typing
 
@@ -20,21 +21,20 @@ import nuclio.auth
 import mlrun.common.schemas as schemas
 import mlrun.errors
 import mlrun.run
-from mlrun.common.runtimes.constants import NuclioIngressAddTemplatedIngressModes
-from mlrun.runtimes import RemoteRuntime
-from mlrun.runtimes.nuclio import min_nuclio_versions
-from mlrun.runtimes.nuclio.api_gateway import (
-    APIGateway,
-    APIGatewayMetadata,
-    APIGatewaySpec,
+import mlrun.runtimes.nuclio.api_gateway as nuclio_api_gateway
+import mlrun.runtimes.nuclio.function as nuclio_function
+from mlrun.common.runtimes.constants import (
+    NuclioIngressAddTemplatedIngressModes,
+    ProbeTimeConfig,
+    ProbeType,
 )
-from mlrun.runtimes.nuclio.function import NuclioSpec, NuclioStatus
-from mlrun.utils import logger, update_in
+from mlrun.utils import is_valid_port, logger, update_in
 
 
-class ApplicationSpec(NuclioSpec):
-    _dict_fields = NuclioSpec._dict_fields + [
+class ApplicationSpec(nuclio_function.NuclioSpec):
+    _dict_fields = nuclio_function.NuclioSpec._dict_fields + [
         "internal_application_port",
+        "application_ports",
     ]
 
     def __init__(
@@ -78,7 +78,13 @@ class ApplicationSpec(NuclioSpec):
         add_templated_ingress_host_mode=None,
         state_thresholds=None,
         disable_default_http_trigger=None,
+        serving_spec=None,
+        graph=None,
+        parameters=None,
+        track_models=None,
         internal_application_port=None,
+        application_ports=None,
+        auth=None,
     ):
         super().__init__(
             command=command,
@@ -118,19 +124,73 @@ class ApplicationSpec(NuclioSpec):
             security_context=security_context,
             service_type=service_type,
             add_templated_ingress_host_mode=add_templated_ingress_host_mode,
+            serving_spec=serving_spec,
+            graph=graph,
+            parameters=parameters,
+            track_models=track_models,
             state_thresholds=state_thresholds,
             disable_default_http_trigger=disable_default_http_trigger,
+            auth=auth,
         )
 
         # Override default min/max replicas (don't assume application is stateless)
         self.min_replicas = min_replicas or 1
         self.max_replicas = max_replicas or 1
 
+        # initializing internal application port and application ports
+        self._internal_application_port = None
+        self._application_ports = []
+
+        application_ports = application_ports or []
+
+        # if internal_application_port is not provided, use the first application port
+        if not internal_application_port and len(application_ports) > 0:
+            internal_application_port = application_ports[0]
+
+        # the port of application sidecar to which traffic will be routed from a nuclio function
         self.internal_application_port = (
             internal_application_port
             or mlrun.mlconf.function.application.default_sidecar_internal_port
         )
 
+        # all exposed ports by the application sidecar
+        self.application_ports = application_ports
+
+    @property
+    def application_ports(self):
+        return self._application_ports
+
+    @application_ports.setter
+    def application_ports(self, ports):
+        """
+        Set the application ports for the application sidecar.
+        The internal application port is always included and always first.
+        """
+        # Handle None / single int
+        if ports is None:
+            ports = []
+        elif isinstance(ports, int):
+            ports = [ports]
+        elif not isinstance(ports, list):
+            raise mlrun.errors.MLRunInvalidArgumentError(
+                "Application ports must be a list of integers"
+            )
+
+        # Validate and normalize
+        cleaned_ports = []
+        for port in ports:
+            is_valid_port(port, raise_on_error=True)
+            if port != self.internal_application_port:
+                cleaned_ports.append(port)
+
+        application_ports = [self.internal_application_port] + cleaned_ports
+
+        # ensure multiple ports are supported in Nuclio
+        if len(application_ports) > 1:
+            nuclio_function.multiple_port_sidecar_is_supported()
+
+        self._application_ports = application_ports
+
     @property
     def internal_application_port(self):
         return self._internal_application_port
@@ -138,12 +198,22 @@ class ApplicationSpec(NuclioSpec):
     @internal_application_port.setter
     def internal_application_port(self, port):
         port = int(port)
-        if port < 0 or port > 65535:
-            raise ValueError("Port must be in the range 0-65535")
+        is_valid_port(port, raise_on_error=True)
         self._internal_application_port = port
 
+        # If when internal application port is being set, length of self._application_ports is 1,
+        # it means that it consist of [old_port] only
+        # so in this case, we rewrite the list completely, by setting value to [new_value]
+        if len(self.application_ports) == 1:
+            self._application_ports = [port]
+            return
+
+        # when setting new internal application port, ensure that it is included in the application ports
+        # it just triggers setter logic, so setting to the same value is a no-op
+        self.application_ports = self._application_ports
 
-class ApplicationStatus(NuclioStatus):
+
+class ApplicationStatus(nuclio_function.NuclioStatus):
     def __init__(
         self,
         state=None,
@@ -173,15 +243,17 @@ class ApplicationStatus(NuclioStatus):
         self.application_source = application_source or None
         self.sidecar_name = sidecar_name or None
         self.api_gateway_name = api_gateway_name or None
-        self.api_gateway: typing.Optional[APIGateway] = api_gateway or None
+        self.api_gateway: typing.Optional[nuclio_api_gateway.APIGateway] = (
+            api_gateway or None
+        )
         self.url = url or None
 
 
-class ApplicationRuntime(RemoteRuntime):
+class ApplicationRuntime(nuclio_function.RemoteRuntime):
     kind = "application"
     reverse_proxy_image = None
 
-    @min_nuclio_versions("1.13.1")
+    @nuclio_function.min_nuclio_versions("1.13.1")
     def __init__(self, spec=None, metadata=None):
         super().__init__(spec=spec, metadata=metadata)
 
@@ -206,7 +278,7 @@ class ApplicationRuntime(RemoteRuntime):
         return self.status.api_gateway
 
     @api_gateway.setter
-    def api_gateway(self, api_gateway: APIGateway):
+    def api_gateway(self, api_gateway: nuclio_api_gateway.APIGateway):
         self.status.api_gateway = api_gateway
 
     @property
@@ -222,6 +294,122 @@ class ApplicationRuntime(RemoteRuntime):
     def set_internal_application_port(self, port: int):
         self.spec.internal_application_port = port
 
+    def set_probe(
+        self,
+        type: str,
+        initial_delay_seconds: int | None = None,
+        period_seconds: int | None = None,
+        failure_threshold: int | None = None,
+        timeout_seconds: int | None = None,
+        http_path: str | None = None,
+        http_port: int | None = None,
+        http_scheme: str | None = None,
+        config: dict | None = None,
+    ):
+        """Set a Kubernetes probe configuration for the sidecar container
+
+        The config parameter serves as the base configuration, and individual parameters
+        override values in config. If http_path is provided without http_port and config
+        is not provided, the port will be enriched from the internal application port
+        just before deployment.
+
+        :param type:                 Probe type - one of "readiness", "liveness", "startup"
+        :param initial_delay_seconds: Number of seconds after the container has started before probes are initiated
+        :param period_seconds:         How often (in seconds) to perform the probe
+        :param failure_threshold:     Minimum consecutive failures for the probe to be considered failed
+        :param timeout_seconds:       Number of seconds after which the probe times out
+        :param http_path:            If provided, use an HTTP probe with this path
+        :param http_port:            If HTTP probe is used and no port provided,
+                                     the internal application port will be used
+        :param http_scheme:           "http" or "https" for HTTP probe. Defaults to "http"
+        :param config:                A full dict with the probe configuration
+                                     (used as base, overridden by individual parameters)
+
+        :return: function object (self)
+        """
+        self._validate_set_probes_input(locals())
+        type = ProbeType(type)
+
+        # Start with config as base
+        probe_config = copy.deepcopy(config) if config else {}
+
+        # Build HTTP probe configuration if http_path is provided
+        # Note: If http_path is None, all HTTP-related parameters (http_port, http_scheme) are ignored
+        if http_path:
+            http_probe = probe_config.get("httpGet", {})
+            http_probe["path"] = http_path
+            if http_port is not None:
+                http_probe["port"] = http_port
+            http_probe["scheme"] = http_scheme or http_probe.get("scheme", "HTTP")
+            probe_config["httpGet"] = http_probe
+
+        # Override timing parameters from explicit arguments
+        probe_config.update(
+            {
+                config.value: value
+                for config, value in {
+                    ProbeTimeConfig.INITIAL_DELAY_SECONDS: initial_delay_seconds,
+                    ProbeTimeConfig.PERIOD_SECONDS: period_seconds,
+                    ProbeTimeConfig.FAILURE_THRESHOLD: failure_threshold,
+                    ProbeTimeConfig.TIMEOUT_SECONDS: timeout_seconds,
+                }.items()
+                if value is not None
+            }
+        )
+
+        # Store probe configuration in the sidecar
+        sidecar = self._set_sidecar(self._get_sidecar_name())
+        sidecar[type.key] = probe_config
+
+        return self
+
+    def delete_probe(
+        self,
+        type: str,
+    ):
+        """Delete a Kubernetes probe configuration from the sidecar container
+
+        :param type: Probe type - one of "readiness", "liveness", "startup"
+
+        :return: function object (self)
+        """
+        # Validate probe type
+        ProbeType.is_valid(type, raise_on_error=True)
+        type = ProbeType(type)
+
+        sidecar = self._get_sidecar()
+        if sidecar:
+            if type.key in sidecar:
+                del sidecar[type.key]
+
+        return self
+
+    def with_sidecar(
+        self,
+        name: typing.Optional[str] = None,
+        image: typing.Optional[str] = None,
+        ports: typing.Optional[typing.Union[int, list[int]]] = None,
+        command: typing.Optional[str] = None,
+        args: typing.Optional[list[str]] = None,
+    ):
+        # wraps with_sidecar just to set the application ports
+        super().with_sidecar(
+            name=name,
+            image=image,
+            ports=ports,
+            command=command,
+            args=args,
+        )
+
+        if ports:
+            if self.spec.internal_application_port != ports[0]:
+                logger.info(
+                    f"Setting internal application port to the first port from the sidecar: {ports[0]}. "
+                    f"If this is not intended, please set the internal_application_port explicitly."
+                )
+                self.spec.internal_application_port = ports[0]
+            self.spec.application_ports = ports
+
     def pre_deploy_validation(self):
         super().pre_deploy_validation()
         if not self.spec.config.get("spec.sidecars"):
@@ -302,6 +490,7 @@ class ApplicationRuntime(RemoteRuntime):
 
         :return: The default API gateway URL if created or True if the function is ready (deployed)
         """
+
         if (self.requires_build() and not self.spec.image) or force_build:
             self._fill_credentials()
             self._build_application_image(
@@ -315,14 +504,14 @@ class ApplicationRuntime(RemoteRuntime):
                 show_on_failure=show_on_failure,
             )
 
-        # This is a class method that accepts a function instance, so we pass self as the function instance
-        self._ensure_reverse_proxy_configurations(self)
+        self._ensure_reverse_proxy_configurations()
         self._configure_application_sidecar()
 
         # We only allow accessing the application via the API Gateway
         self.spec.add_templated_ingress_host_mode = (
             NuclioIngressAddTemplatedIngressModes.never
         )
+        self._enrich_sidecar_probe_ports()
 
         super().deploy(
             project=project,
@@ -431,6 +620,7 @@ class ApplicationRuntime(RemoteRuntime):
         ssl_redirect: typing.Optional[bool] = None,
         set_as_default: bool = False,
         gateway_timeout: typing.Optional[int] = None,
+        port: typing.Optional[int] = None,
     ):
         """
         Create the application API gateway. Once the application is deployed, the API gateway can be created.
@@ -447,6 +637,8 @@ class ApplicationRuntime(RemoteRuntime):
         :param set_as_default:          Set the API gateway as the default for the application (`status.api_gateway`)
         :param gateway_timeout:         nginx ingress timeout in sec (request timeout, when will the gateway return an
                                         error)
+        :param port:                    The API gateway port, used only when direct_port_access=True
+
         :return:                        The API gateway URL
         """
         if not name:
@@ -467,15 +659,23 @@ class ApplicationRuntime(RemoteRuntime):
                 "Authentication credentials not provided"
             )
 
-        ports = self.spec.internal_application_port if direct_port_access else []
+        if not direct_port_access and port:
+            logger.warning(
+                "Ignoring 'port' because 'direct_port_access' is not enabled. "
+                "The 'port' setting is only applicable when 'direct_port_access' is enabled."
+            )
 
-        api_gateway = APIGateway(
-            APIGatewayMetadata(
+        ports = (
+            port or self.spec.internal_application_port if direct_port_access else []
+        )
+
+        api_gateway = nuclio_api_gateway.APIGateway(
+            nuclio_api_gateway.APIGatewayMetadata(
                 name=name,
                 namespace=self.metadata.namespace,
                 labels=self.metadata.labels.copy(),
             ),
-            APIGatewaySpec(
+            nuclio_api_gateway.APIGatewaySpec(
                 functions=[self],
                 project=self.metadata.project,
                 path=path,
@@ -499,6 +699,8 @@ class ApplicationRuntime(RemoteRuntime):
             api_gateway.with_access_key_auth()
         elif authentication_mode == schemas.APIGatewayAuthenticationMode.basic:
             api_gateway.with_basic_auth(*authentication_creds)
+        elif authentication_mode == schemas.APIGatewayAuthenticationMode.iguazio:
+            api_gateway.with_iguazio_auth()
 
         db = self._get_db()
         api_gateway_scheme = db.store_api_gateway(
@@ -507,12 +709,14 @@ class ApplicationRuntime(RemoteRuntime):
 
         if set_as_default:
             self.status.api_gateway_name = api_gateway_scheme.metadata.name
-            self.status.api_gateway = APIGateway.from_scheme(api_gateway_scheme)
+            self.status.api_gateway = nuclio_api_gateway.APIGateway.from_scheme(
+                api_gateway_scheme
+            )
             self.status.api_gateway.wait_for_readiness()
             self.url = self.status.api_gateway.invoke_url
             url = self.url
         else:
-            api_gateway = APIGateway.from_scheme(api_gateway_scheme)
+            api_gateway = nuclio_api_gateway.APIGateway.from_scheme(api_gateway_scheme)
             api_gateway.wait_for_readiness()
             url = api_gateway.invoke_url
             # Update application status (enriches invocation url)
@@ -536,7 +740,7 @@ class ApplicationRuntime(RemoteRuntime):
     def invoke(
         self,
         path: str = "",
-        body: typing.Optional[typing.Union[str, bytes, dict]] = None,
+        body: typing.Optional[typing.Union[str, bytes, dict, list]] = None,
         method: typing.Optional[str] = None,
         headers: typing.Optional[dict] = None,
         force_external_address: bool = False,
@@ -595,6 +799,12 @@ class ApplicationRuntime(RemoteRuntime):
         """
         # create a function that includes only the reverse proxy, without the application
 
+        if not mlrun.get_current_project(silent=True):
+            raise mlrun.errors.MLRunMissingProjectError(
+                "An active project is required to run deploy_reverse_proxy_image(). "
+                "Use `mlrun.get_or_create_project()` or set an active project first."
+            )
+
         reverse_proxy_func = mlrun.run.new_function(
             name="reverse-proxy-temp", kind="remote"
         )
@@ -624,7 +834,7 @@ class ApplicationRuntime(RemoteRuntime):
             else self.metadata.name
         )
 
-    @min_nuclio_versions("1.13.1")
+    @nuclio_function.min_nuclio_versions("1.13.1")
     def disable_default_http_trigger(
         self,
     ):
@@ -632,7 +842,7 @@ class ApplicationRuntime(RemoteRuntime):
             "Application runtime does not support disabling the default HTTP trigger"
         )
 
-    @min_nuclio_versions("1.13.1")
+    @nuclio_function.min_nuclio_versions("1.13.1")
     def enable_default_http_trigger(
         self,
     ):
@@ -684,27 +894,42 @@ class ApplicationRuntime(RemoteRuntime):
             with_mlrun=with_mlrun,
         )
 
-    @staticmethod
-    def _ensure_reverse_proxy_configurations(function: RemoteRuntime):
-        if function.spec.build.functionSourceCode or function.status.container_image:
+    def _ensure_reverse_proxy_configurations(self):
+        # If an HTTP trigger already exists in the spec,
+        # it means the user explicitly defined a custom configuration,
+        # so, skip automatic creation.
+        skip_http_trigger_creation = False
+        for key, value in self.spec.config.items():
+            if key.startswith("spec.triggers"):
+                if isinstance(value, dict):
+                    if value.get("kind") == "http":
+                        skip_http_trigger_creation = True
+                        break
+        if not skip_http_trigger_creation:
+            self.with_http(
+                workers=mlrun.mlconf.function.application.default_worker_number,
+                trigger_name="application-http",
+            )
+
+        if self.spec.build.functionSourceCode or self.status.container_image:
             return
 
         filename, handler = ApplicationRuntime.get_filename_and_handler()
         name, spec, code = nuclio.build_file(
             filename,
-            name=function.metadata.name,
+            name=self.metadata.name,
             handler=handler,
         )
-        function.spec.function_handler = mlrun.utils.get_in(spec, "spec.handler")
-        function.spec.build.functionSourceCode = mlrun.utils.get_in(
+        self.spec.function_handler = mlrun.utils.get_in(spec, "spec.handler")
+        self.spec.build.functionSourceCode = mlrun.utils.get_in(
             spec, "spec.build.functionSourceCode"
         )
-        function.spec.nuclio_runtime = mlrun.utils.get_in(spec, "spec.runtime")
+        self.spec.nuclio_runtime = mlrun.utils.get_in(spec, "spec.runtime")
 
         # default the reverse proxy logger level to info
         logger_sinks_key = "spec.loggerSinks"
-        if not function.spec.config.get(logger_sinks_key):
-            function.set_config(
+        if not self.spec.config.get(logger_sinks_key):
+            self.set_config(
                 logger_sinks_key, [{"level": "info", "sink": "myStdoutLoggerSink"}]
             )
 
@@ -728,7 +953,7 @@ class ApplicationRuntime(RemoteRuntime):
         self.with_sidecar(
             name=self.status.sidecar_name,
             image=self.status.application_image,
-            ports=self.spec.internal_application_port,
+            ports=self.spec.application_ports,
             command=self.spec.command,
             args=self.spec.args,
         )
@@ -748,6 +973,80 @@ class ApplicationRuntime(RemoteRuntime):
         api_gateway_scheme = db.get_api_gateway(
             name=self.status.api_gateway_name, project=self.metadata.project
         )
-        self.status.api_gateway = APIGateway.from_scheme(api_gateway_scheme)
+        self.status.api_gateway = nuclio_api_gateway.APIGateway.from_scheme(
+            api_gateway_scheme
+        )
         self.status.api_gateway.wait_for_readiness()
         self.url = self.status.api_gateway.invoke_url
+
+    def _enrich_sidecar_probe_ports(self):
+        """Enrich sidecar probe configurations with internal application port if needed
+
+        This method is called just before deployment to automatically enrich HTTP probes
+        in the sidecar container that were configured without an explicit port.
+
+        Enrichment logic:
+        - Only enriches HTTP probes (httpGet) that don't already have a port specified
+        - If the user explicitly provided http_port in set_probe(), enrichment is skipped
+        - If the user provided a port in the config dict, enrichment is skipped
+        - Enrichment happens just before deployment to ensure the latest internal_application_port
+          value is used, even if it was modified after set_probe() was called
+        """
+        # Check each probe type and enrich missing HTTP ports
+        sidecar = self._get_sidecar()
+        if not sidecar:
+            return
+
+        for probe_type in ProbeType:
+            probe_config = sidecar.get(probe_type.key)
+
+            if probe_config and isinstance(probe_config, dict):
+                http_get = probe_config.get("httpGet")
+                if http_get and isinstance(http_get, dict) and "port" not in http_get:
+                    if self.spec.internal_application_port is None:
+                        raise ValueError(
+                            f"Cannot enrich {probe_type.value} probe: HTTP probe requires a port, "
+                            "but internal_application_port is not set. "
+                            "Please set the internal_application_port or provide http_port in set_probe()."
+                        )
+                    http_get["port"] = self.spec.internal_application_port
+                    logger.debug(
+                        "Enriched sidecar probe port",
+                        probe_type=probe_type.value,
+                        port=http_get["port"],
+                        application_name=self.metadata.name,
+                    )
+                    sidecar[probe_type.key] = probe_config
+
+    def _get_sidecar(self) -> dict | None:
+        """Get the sidecar container for ApplicationRuntime
+
+        Returns the sidecar dict if found, None otherwise.
+        """
+        sidecar_name = self._get_sidecar_name()
+        if not hasattr(self.spec, "config") or "spec.sidecars" not in self.spec.config:
+            return None
+
+        sidecars = self.spec.config["spec.sidecars"]
+        for sidecar in sidecars:
+            if sidecar.get("name") == sidecar_name:
+                return sidecar
+
+        return None
+
+    def _get_sidecar_name(self) -> str:
+        return f"{self.metadata.name}-sidecar"
+
+    @staticmethod
+    def _validate_set_probes_input(params: dict):
+        # Validate probe type
+        ProbeType.is_valid(params.get("type"), raise_on_error=True)
+
+        # At least one optional parameter must be provided
+        optional_params = {
+            k: v for k, v in params.items() if (k != "type" and k != "self")
+        }
+        if all(v is None for v in optional_params.values()):
+            raise ValueError(
+                "Empty probe configuration: at least one parameter must be set"
+            )