mlrun 1.4.0rc25__py3-none-any.whl → 1.5.0rc2__py3-none-any.whl

mlrun/api/api/endpoints/pipelines.py

@@ -129,11 +129,9 @@ async def get_pipeline(
     auth_info: mlrun.common.schemas.AuthInfo = Depends(
         mlrun.api.api.deps.authenticate_request
     ),
-    db_session: Session = Depends(deps.get_db_session),
 ):
     pipeline = await run_in_threadpool(
         mlrun.api.crud.Pipelines().get_pipeline,
-        db_session,
         run_id,
         project,
         namespace,
@@ -145,7 +143,7 @@ async def get_pipeline(
         # legacy flow in which we first get the pipeline, resolve the project out of it, and only then query permissions
         # we don't use the return value from this function since the user may have asked for a different format than
         # summary which is the one used inside
-        await _get_pipeline_without_project(db_session, auth_info, run_id, namespace)
+        await _get_pipeline_without_project(auth_info, run_id, namespace)
     else:
         await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
             mlrun.common.schemas.AuthorizationResourceTypes.pipeline,
@@ -158,7 +156,6 @@ async def get_pipeline(
 
 
 async def _get_pipeline_without_project(
-    db_session: Session,
     auth_info: mlrun.common.schemas.AuthInfo,
     run_id: str,
     namespace: str,
@@ -170,7 +167,6 @@ async def _get_pipeline_without_project(
     """
     run = await run_in_threadpool(
         mlrun.api.crud.Pipelines().get_pipeline,
-        db_session,
         run_id,
         namespace=namespace,
         # minimal format that includes the project

mlrun/api/api/endpoints/projects.py

@@ -20,6 +20,7 @@ import sqlalchemy.orm
 from fastapi.concurrency import run_in_threadpool
 
 import mlrun.api.api.deps
+import mlrun.api.crud
 import mlrun.api.utils.auth.verifier
 import mlrun.api.utils.clients.chief
 import mlrun.common.schemas
@@ -323,6 +324,93 @@ async def get_project_summary(
     return project_summary
 
 
+@router.post("/projects/{name}/load")
+async def load_project(
+    name: str,
+    url: str,
+    secrets: mlrun.common.schemas.SecretsData = None,
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
+        mlrun.api.api.deps.authenticate_request
+    ),
+    db_session: sqlalchemy.orm.Session = fastapi.Depends(
+        mlrun.api.api.deps.get_db_session
+    ),
+):
+    """
+    Loading a project remotely from a given source.
+
+    :param name:                project name
+    :param url:                 git or tar.gz or .zip sources archive path e.g.:
+                                git://github.com/mlrun/demo-xgb-project.git
+                                http://mysite/archived-project.zip
+                                The git project should include the project yaml file.
+    :param secrets:             Secrets to store in project in order to load it from the provided url.
+                                For more information see :py:func:`mlrun.load_project` function.
+    :param auth_info:           auth info of the request
+    :param db_session:          session that manages the current dialog with the database
+
+    :returns: a Run object of the load project function
+    """
+
+    project = mlrun.common.schemas.Project(
+        metadata=mlrun.common.schemas.ProjectMetadata(name=name),
+        spec=mlrun.common.schemas.ProjectSpec(source=url),
+    )
+
+    # We must create the project before we run the remote load_project function because
+    # we want this function will be running under the project itself instead of the default project.
+    project, _ = await fastapi.concurrency.run_in_threadpool(
+        get_project_member().create_project,
+        db_session=db_session,
+        project=project,
+        projects_role=auth_info.projects_role,
+        leader_session=auth_info.session,
+    )
+
+    # Storing secrets in project
+    if secrets is not None:
+        await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
+            mlrun.common.schemas.AuthorizationResourceTypes.secret,
+            project.metadata.name,
+            secrets.provider,
+            mlrun.common.schemas.AuthorizationAction.create,
+            auth_info,
+        )
+
+        await run_in_threadpool(
+            mlrun.api.crud.Secrets().store_project_secrets,
+            project.metadata.name,
+            secrets,
+        )
+
+    # Creating the auxiliary function for loading the project:
+    load_project_runner = await fastapi.concurrency.run_in_threadpool(
+        mlrun.api.crud.WorkflowRunners().create_runner,
+        run_name=f"load-{name}",
+        project=name,
+        db_session=db_session,
+        auth_info=auth_info,
+        image=mlrun.mlconf.default_base_image,
+    )
+
+    logger.debug(
+        "Saved function for loading project",
+        project_name=name,
+        function_name=load_project_runner.metadata.name,
+        kind=load_project_runner.kind,
+        source=project.spec.source,
+    )
+
+    run = await fastapi.concurrency.run_in_threadpool(
+        mlrun.api.crud.WorkflowRunners().run,
+        runner=load_project_runner,
+        project=project,
+        workflow_request=None,
+        load_only=True,
+    )
+    return {"data": run.to_dict()}
+
+
 def _is_request_from_leader(
     projects_role: typing.Optional[mlrun.common.schemas.ProjectsRole],
 ) -> bool:

mlrun/api/api/endpoints/runs.py

@@ -31,7 +31,14 @@ from mlrun.utils.helpers import datetime_from_iso
 router = APIRouter()
 
 
-@router.post("/run/{project}/{uid}")
+# TODO: remove /run/{project}/{uid} in 1.7.0
+@router.post(
+    "/run/{project}/{uid}",
+    deprecated=True,
+    description="/run/{project}/{uid} is deprecated in 1.5.0 and will be removed in 1.7.0, "
+    "use /projects/{project}/runs/{uid} instead",
+)
+@router.post("/projects/{project}/runs/{uid}")
 async def store_run(
     request: Request,
     project: str,
@@ -70,7 +77,14 @@ async def store_run(
     return {}
 
 
-@router.patch("/run/{project}/{uid}")
+# TODO: remove /run/{project}/{uid} in 1.7.0
+@router.patch(
+    "/run/{project}/{uid}",
+    deprecated=True,
+    description="/run/{project}/{uid} is deprecated in 1.5.0 and will be removed in 1.7.0, "
+    "use /projects/{project}/runs/{uid} instead",
+)
+@router.patch("/projects/{project}/runs/{uid}")
 async def update_run(
     request: Request,
     project: str,
@@ -103,7 +117,14 @@ async def update_run(
     return {}
 
 
-@router.get("/run/{project}/{uid}")
+# TODO: remove /run/{project}/{uid} in 1.7.0
+@router.get(
+    "/run/{project}/{uid}",
+    deprecated=True,
+    description="/run/{project}/{uid} is deprecated in 1.5.0 and will be removed in 1.7.0, "
+    "use /projects/{project}/runs/{uid} instead",
+)
+@router.get("/projects/{project}/runs/{uid}")
 async def get_run(
     project: str,
     uid: str,
@@ -126,7 +147,14 @@ async def get_run(
     }
 
 
-@router.delete("/run/{project}/{uid}")
+# TODO: remove /run/{project}/{uid} in 1.7.0
+@router.delete(
+    "/run/{project}/{uid}",
+    deprecated=True,
+    description="/run/{project}/{uid} is deprecated in 1.5.0 and will be removed in 1.7.0, "
+    "use /projects/{project}/runs/{uid} instead",
+)
+@router.delete("/projects/{project}/runs/{uid}")
 async def delete_run(
     project: str,
     uid: str,
@@ -151,7 +179,14 @@ async def delete_run(
     return {}
 
 
-@router.get("/runs")
+# TODO: remove /runs in 1.7.0
+@router.get(
+    "/runs",
+    deprecated=True,
+    description="/runs is deprecated in 1.5.0 and will be removed in 1.7.0, "
+    "use /projects/{project}/runs/{uid} instead",
+)
+@router.get("/projects/{project}/runs")
 async def list_runs(
     project: str = None,
     name: str = None,
@@ -222,7 +257,14 @@ async def list_runs(
     }
 
 
-@router.delete("/runs")
+# TODO: remove /runs in 1.7.0
+@router.delete(
+    "/runs",
+    deprecated=True,
+    description="/runs is deprecated in 1.5.0 and will be removed in 1.7.0, "
+    "use /projects/{project}/runs/{uid} instead",
+)
+@router.delete("/projects/{project}/runs")
 async def delete_runs(
     project: str = None,
     name: str = None,

mlrun/api/api/endpoints/submit.py

@@ -23,6 +23,7 @@ import mlrun.api.api.utils
 import mlrun.api.utils.auth.verifier
 import mlrun.api.utils.clients.chief
 import mlrun.api.utils.singletons.project_member
+import mlrun.common.helpers
 import mlrun.common.schemas
 import mlrun.utils.helpers
 from mlrun.api.api import deps
@@ -68,7 +69,7 @@ async def submit_job(
             function_name,
             _,
             _,
-        ) = mlrun.utils.helpers.parse_versioned_object_uri(function_url)
+        ) = mlrun.common.helpers.parse_versioned_object_uri(function_url)
         await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
             mlrun.common.schemas.AuthorizationResourceTypes.function,
             function_project,

mlrun/api/api/endpoints/workflows.py

@@ -0,0 +1,355 @@
+# Copyright 2018 Iguazio
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 collections.abc
+import copy
+import traceback
+import typing
+from http import HTTPStatus
+from typing import Dict
+
+import fastapi
+from fastapi.concurrency import run_in_threadpool
+from sqlalchemy.orm import Session
+
+import mlrun
+import mlrun.api.api.deps
+import mlrun.api.api.utils
+import mlrun.api.crud
+import mlrun.api.utils.auth.verifier
+import mlrun.api.utils.clients.chief
+import mlrun.api.utils.singletons.db
+import mlrun.api.utils.singletons.project_member
+import mlrun.common.schemas
+import mlrun.projects.pipelines
+from mlrun.api.api.utils import log_and_raise
+from mlrun.utils.helpers import logger
+
+router = fastapi.APIRouter()
+
+
+@router.post(
+    "/projects/{project}/workflows/{name}/submit",
+    status_code=HTTPStatus.ACCEPTED.value,
+    response_model=mlrun.common.schemas.WorkflowResponse,
+)
+async def submit_workflow(
+    project: str,
+    name: str,
+    request: fastapi.Request,
+    workflow_request: mlrun.common.schemas.WorkflowRequest = mlrun.common.schemas.WorkflowRequest(),
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
+        mlrun.api.api.deps.authenticate_request
+    ),
+    db_session: Session = fastapi.Depends(mlrun.api.api.deps.get_db_session),
+):
+    """
+    Submitting a workflow of existing project.
+    To support workflow scheduling, we use here an auxiliary function called 'load_and_run'.
+    This function runs remotely (in a distinct pod), loads a project and then runs the workflow.
+    In this way we can run the workflow remotely with the workflow's engine or
+    schedule this function which in every time loads the project and runs the workflow.
+    Notice:
+    in case of simply running a workflow, the returned run_id value is the id of the run of the auxiliary function.
+    For getting the id and status of the workflow, use the `get_workflow_id` endpoint with the returned run id.
+
+    :param project:             name of the project
+    :param name:                name of the workflow
+    :param request:             fastapi request for supporting rerouting to chief if needed
+    :param workflow_request:    the request includes: workflow spec, arguments for the workflow, artifact path
+                                as the artifact target path of the workflow, source url of the project for overriding
+                                the existing one, run name to override the default: 'workflow-runner-<workflow name>'
+                                and kubernetes namespace if other than default
+    :param auth_info:           auth info of the request
+    :param db_session:          session that manages the current dialog with the database
+
+    :returns: response that contains the project name, workflow name, name of the workflow,
+             status, run id (in case of a single run) and schedule (in case of scheduling)
+    """
+    project = await run_in_threadpool(
+        mlrun.api.utils.singletons.project_member.get_project_member().get_project,
+        db_session=db_session,
+        name=project,
+        leader_session=auth_info.session,
+    )
+
+    # check permission CREATE run
+    await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
+        resource_type=mlrun.common.schemas.AuthorizationResourceTypes.run,
+        project_name=project.metadata.name,
+        resource_name=workflow_request.run_name or "",
+        action=mlrun.common.schemas.AuthorizationAction.create,
+        auth_info=auth_info,
+    )
+    # check permission READ workflow on project's workflow
+    await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
+        resource_type=mlrun.common.schemas.AuthorizationResourceTypes.workflow,
+        project_name=project.metadata.name,
+        resource_name=name,
+        action=mlrun.common.schemas.AuthorizationAction.read,
+        auth_info=auth_info,
+    )
+    # Check permission CREATE workflow on new workflow's name
+    await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
+        resource_type=mlrun.common.schemas.AuthorizationResourceTypes.workflow,
+        project_name=project.metadata.name,
+        # If workflow spec has not passed need to create on same name:
+        resource_name=getattr(workflow_request.spec, "name", name),
+        action=mlrun.common.schemas.AuthorizationAction.create,
+        auth_info=auth_info,
+    )
+    # Re-route to chief in case of schedule
+    if (
+        _is_requested_schedule(name, workflow_request.spec, project)
+        and mlrun.mlconf.httpdb.clusterization.role
+        != mlrun.common.schemas.ClusterizationRole.chief
+    ):
+        chief_client = mlrun.api.utils.clients.chief.Client()
+        return await chief_client.submit_workflow(
+            project=project.metadata.name,
+            name=name,
+            request=request,
+            json=workflow_request.dict(),
+        )
+
+    workflow_spec = _fill_workflow_missing_fields_from_project(
+        project=project,
+        workflow_name=name,
+        spec=workflow_request.spec,
+        arguments=workflow_request.arguments,
+    )
+    updated_request = workflow_request.copy()
+    updated_request.spec = workflow_spec
+
+    # This function is for loading the project and running workflow remotely.
+    # In this way we can schedule workflows (by scheduling a job that runs the workflow)
+    workflow_runner = await run_in_threadpool(
+        mlrun.api.crud.WorkflowRunners().create_runner,
+        run_name=updated_request.run_name
+        or mlrun.mlconf.workflows.default_workflow_runner_name.format(
+            workflow_spec.name
+        ),
+        project=project.metadata.name,
+        db_session=db_session,
+        auth_info=auth_info,
+        image=workflow_spec.image
+        or project.spec.default_image
+        or mlrun.mlconf.default_base_image,
+    )
+
+    logger.debug(
+        "Saved function for running workflow",
+        project_name=workflow_runner.metadata.project,
+        function_name=workflow_runner.metadata.name,
+        workflow_name=workflow_spec.name,
+        arguments=workflow_spec.args,
+        source=updated_request.source or project.spec.source,
+        kind=workflow_runner.kind,
+        image=workflow_runner.spec.image,
+    )
+
+    run_uid = None
+    status = None
+    workflow_action = "schedule" if workflow_spec.schedule else "run"
+    try:
+        if workflow_spec.schedule:
+            await run_in_threadpool(
+                mlrun.api.crud.WorkflowRunners().schedule,
+                runner=workflow_runner,
+                project=project,
+                workflow_request=updated_request,
+                db_session=db_session,
+                auth_info=auth_info,
+            )
+            status = "scheduled"
+
+        else:
+            run = await run_in_threadpool(
+                mlrun.api.crud.WorkflowRunners().run,
+                runner=workflow_runner,
+                project=project,
+                workflow_request=updated_request,
+            )
+            status = mlrun.run.RunStatuses.running
+            run_uid = run.uid()
+    except Exception as error:
+        logger.error(traceback.format_exc())
+        log_and_raise(
+            reason="Workflow failed",
+            workflow_name=workflow_spec.name,
+            workflow_action=workflow_action,
+            error=mlrun.errors.err_to_str(error),
+        )
+
+    return mlrun.common.schemas.WorkflowResponse(
+        project=project.metadata.name,
+        name=workflow_spec.name,
+        status=status,
+        run_id=run_uid,
+        schedule=workflow_spec.schedule,
+    )
+
+
+def _is_requested_schedule(
+    name: str,
+    workflow_spec: mlrun.common.schemas.WorkflowSpec,
+    project: mlrun.common.schemas.Project,
+) -> bool:
+    """
+    Checks if the workflow needs to be scheduled, which can be decided either the request itself
+    contains schedule information or the workflow which was predefined in the project contains schedule.
+
+    :param name:            workflow name
+    :param workflow_spec:   workflow spec input
+    :param project:         MLRun project that contains the workflow
+
+    :return: True if the workflow need to be scheduled and False if not.
+    """
+    if workflow_spec:
+        return workflow_spec.schedule is not None
+
+    project_workflow = _get_workflow_by_name(project, name)
+    return bool(project_workflow.get("schedule"))
+
+
+def _get_workflow_by_name(
+    project: mlrun.common.schemas.Project, name: str
+) -> typing.Optional[Dict]:
+    """
+    Getting workflow from project
+
+    :param project:     MLRun project
+    :param name:        workflow name
+
+    :return: workflow as a dict if project has the workflow, otherwise raises a bad request exception
+    """
+    for workflow in project.spec.workflows:
+        if workflow["name"] == name:
+            return workflow
+    log_and_raise(
+        reason=f"workflow {name} not found in project",
+    )
+
+
+def _fill_workflow_missing_fields_from_project(
+    project: mlrun.common.schemas.Project,
+    workflow_name: str,
+    spec: mlrun.common.schemas.WorkflowSpec,
+    arguments: typing.Dict,
+) -> mlrun.common.schemas.WorkflowSpec:
+    """
+    Fill the workflow spec details from the project object, with favour to spec
+
+    :param project:         MLRun project that contains the workflow.
+    :param workflow_name:   workflow name
+    :param spec:            workflow spec input
+    :param arguments:       arguments to workflow
+
+    :return: completed workflow spec
+    """
+    # Verifying workflow exists in project:
+    workflow = _get_workflow_by_name(project, workflow_name)
+
+    if spec:
+        # Merge between the workflow spec provided in the request with existing
+        # workflow while the provided workflow takes precedence over the existing workflow params
+        workflow = copy.deepcopy(workflow)
+        workflow = _update_dict(workflow, spec.dict())
+
+    workflow_spec = mlrun.common.schemas.WorkflowSpec(**workflow)
+    # Overriding arguments of the existing workflow:
+    if arguments:
+        workflow_spec.args = workflow_spec.args or {}
+        workflow_spec.args.update(arguments)
+
+    return workflow_spec
+
+
+def _update_dict(dict_1: dict, dict_2: dict):
+    """
+    Update two dictionaries included nested dictionaries (recursively).
+    :param dict_1: The dict to update
+    :param dict_2: The values of this dict take precedence over dict_1.
+    :return:
+    """
+    for key, val in dict_2.items():
+        if isinstance(val, collections.abc.Mapping):
+            dict_1[key] = _update_dict(dict_1.get(key, {}), val)
+        # It is necessary to update only if value is exist because
+        # on initialization of the WorkflowSpec object all unfilled values gets None values,
+        # and when converting to dict the keys gets those None values.
+        elif val:
+            dict_1[key] = val
+    return dict_1
+
+
+@router.get(
+    "/projects/{project}/workflows/{name}/runs/{uid}",
+    response_model=mlrun.common.schemas.GetWorkflowResponse,
+)
+async def get_workflow_id(
+    project: str,
+    name: str,
+    uid: str,
+    auth_info: mlrun.common.schemas.AuthInfo = fastapi.Depends(
+        mlrun.api.api.deps.authenticate_request
+    ),
+    db_session: Session = fastapi.Depends(mlrun.api.api.deps.get_db_session),
+    engine: str = "kfp",
+) -> mlrun.common.schemas.GetWorkflowResponse:
+    """
+    Retrieve workflow id from the uid of the workflow runner.
+    When creating a remote workflow we are creating an auxiliary function
+    which is responsible for actually running the workflow,
+    as we don't know beforehand the workflow uid but only the run uid of the auxiliary function we ran,
+    we have to wait until the running function will log the workflow id it created.
+    Because we don't know how long it will take for the run to create the workflow
+    we decided to implement that in an asynchronous mechanism which at first,
+    client will get the run uid and then will pull the workflow id from the run id
+    kinda as you would use a background task to query if it finished.
+    Supporting workflows that executed by the remote engine **only**.
+
+    :param project:     name of the project
+    :param name:        name of the workflow
+    :param uid:         the id of the running job that runs the workflow
+    :param auth_info:   auth info of the request
+    :param db_session:  session that manages the current dialog with the database
+    :param engine:      pipeline runner, for example: "kfp"
+
+    :returns: workflow id
+    """
+    # Check permission READ run:
+    await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
+        mlrun.common.schemas.AuthorizationResourceTypes.run,
+        project,
+        uid,
+        mlrun.common.schemas.AuthorizationAction.read,
+        auth_info,
+    )
+    # Check permission READ workflow:
+    await mlrun.api.utils.auth.verifier.AuthVerifier().query_project_resource_permissions(
+        mlrun.common.schemas.AuthorizationResourceTypes.workflow,
+        project,
+        name,
+        mlrun.common.schemas.AuthorizationAction.read,
+        auth_info,
+    )
+
+    return await run_in_threadpool(
+        mlrun.api.crud.WorkflowRunners().get_workflow_id,
+        uid=uid,
+        project=project,
+        engine=engine,
+        db_session=db_session,
+    )

mlrun/api/api/utils.py

@@ -37,15 +37,16 @@ import mlrun.errors
 import mlrun.runtimes.pod
 import mlrun.utils.helpers
 from mlrun.api.db.sqldb.db import SQLDB
+from mlrun.api.rundb.sqldb import SQLRunDB
 from mlrun.api.utils.singletons.db import get_db
 from mlrun.api.utils.singletons.logs_dir import get_logs_dir
 from mlrun.api.utils.singletons.scheduler import get_scheduler
+from mlrun.common.helpers import parse_versioned_object_uri
 from mlrun.config import config
-from mlrun.db.sqldb import SQLDB as SQLRunDB
 from mlrun.errors import err_to_str
 from mlrun.run import import_function, new_function
 from mlrun.runtimes.utils import enrich_function_from_dict
-from mlrun.utils import get_in, logger, parse_versioned_object_uri
+from mlrun.utils import get_in, logger
 
 
 def log_and_raise(status=HTTPStatus.BAD_REQUEST.value, **kw):
@@ -203,7 +204,6 @@ async def submit_run(
 
 
 def apply_enrichment_and_validation_on_task(task):
-
     # Masking notification config params from the task object
     mask_notification_params_on_task(task)
 
@@ -817,7 +817,6 @@ def ensure_function_security_context(
         mlrun.common.schemas.SecurityContextEnrichmentModes.override.value,
         mlrun.common.schemas.SecurityContextEnrichmentModes.retain.value,
     ]:
-
         # before iguazio 3.6 the user unix id is not passed in the session verification response headers
         # so we need to request it explicitly
         if auth_info.user_unix_id is None:

mlrun/api/crud/__init__.py

@@ -29,3 +29,4 @@ from .runs import Runs
 from .runtime_resources import RuntimeResources
 from .secrets import Secrets, SecretsClientType
 from .tags import Tags
+from .workflows import WorkflowRunners

mlrun/api/crud/client_spec.py

@@ -12,10 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+import mlrun.api.utils.runtimes.nuclio
 import mlrun.common.schemas
 import mlrun.utils.singleton
 from mlrun.config import Config, config, default_config
-from mlrun.runtimes.utils import resolve_mpijob_crd_version, resolve_nuclio_version
+from mlrun.runtimes.utils import resolve_mpijob_crd_version
 
 
 class ClientSpec(
@@ -44,7 +45,7 @@ class ClientSpec(
                 config.dask_kfp_image, client_version, client_python_version
             ),
             api_url=config.httpdb.api_url,
-            nuclio_version=resolve_nuclio_version(),
+            nuclio_version=mlrun.api.utils.runtimes.nuclio.resolve_nuclio_version(),
             spark_operator_version=config.spark_operator_version,
             calculate_artifact_hash=config.artifacts.calculate_hash,
             generate_artifact_target_path_from_artifact_hash=config.artifacts.generate_target_path_from_artifact_hash,
@@ -101,6 +102,9 @@ class ClientSpec(
             feature_store_data_prefixes=self._get_config_value_if_not_default(
                 "feature_store.data_prefixes"
             ),
+            model_endpoint_monitoring_store_type=self._get_config_value_if_not_default(
+                "model_endpoint_monitoring.store_type"
+            ),
         )
 
     @staticmethod

mlrun/api/crud/feature_store.py

@@ -58,6 +58,11 @@ class FeatureStore(
         if not feature_set.spec.engine:
             feature_set.spec.engine = "storey"
 
+        if not feature_set.status.state:
+            feature_set.status.state = (
+                mlrun.common.schemas.object.ObjectStatusState.CREATED
+            )
+
         return self._store_object(
             db_session,
             project,