zenml-nightly 0.70.0.dev20241120__py3-none-any.whl → 0.70.0.dev20241125__py3-none-any.whl

zenml/models/v2/core/artifact_version.py

@@ -37,7 +37,7 @@ from zenml.constants import STR_FIELD_MAX_LENGTH, TEXT_FIELD_MAX_LENGTH
 from zenml.enums import ArtifactSaveType, ArtifactType, GenericFilterOps
 from zenml.logger import get_logger
 from zenml.metadata.metadata_types import MetadataType
-from zenml.models.v2.base.filter import StrFilter
+from zenml.models.v2.base.filter import FilterGenerator, StrFilter
 from zenml.models.v2.base.scoped import (
     WorkspaceScopedRequest,
     WorkspaceScopedResponse,
@@ -474,6 +474,7 @@ class ArtifactVersionFilter(WorkspaceScopedTaggableFilter):
         "user",
         "model",
         "pipeline_run",
+        "model_version_id",
         "run_metadata",
     ]
     artifact_id: Optional[Union[UUID, str]] = Field(
@@ -525,6 +526,11 @@ class ArtifactVersionFilter(WorkspaceScopedTaggableFilter):
         description="User that produced this artifact",
         union_mode="left_to_right",
     )
+    model_version_id: Optional[Union[UUID, str]] = Field(
+        default=None,
+        description="ID of the model version that is associated with this artifact version.",
+        union_mode="left_to_right",
+    )
     only_unused: Optional[bool] = Field(
         default=False, description="Filter only for unused artifacts"
     )
@@ -568,6 +574,7 @@ class ArtifactVersionFilter(WorkspaceScopedTaggableFilter):
             ArtifactVersionSchema,
             ModelSchema,
             ModelVersionArtifactSchema,
+            ModelVersionSchema,
             PipelineRunSchema,
             RunMetadataSchema,
             StepRunInputArtifactSchema,
@@ -600,6 +607,20 @@ class ArtifactVersionFilter(WorkspaceScopedTaggableFilter):
             )
             custom_filters.append(unused_filter)
 
+        if self.model_version_id:
+            value, operator = self._resolve_operator(self.model_version_id)
+
+            model_version_filter = and_(
+                ArtifactVersionSchema.id
+                == ModelVersionArtifactSchema.artifact_version_id,
+                ModelVersionArtifactSchema.model_version_id
+                == ModelVersionSchema.id,
+                FilterGenerator(ModelVersionSchema)
+                .define_filter(column="id", value=value, operator=operator)
+                .generate_query_conditions(ModelVersionSchema),
+            )
+            custom_filters.append(model_version_filter)
+
         if self.has_custom_name is not None:
             custom_name_filter = and_(
                 ArtifactVersionSchema.artifact_id == ArtifactSchema.id,
@@ -622,7 +643,9 @@ class ArtifactVersionFilter(WorkspaceScopedTaggableFilter):
             model_filter = and_(
                 ArtifactVersionSchema.id
                 == ModelVersionArtifactSchema.artifact_version_id,
-                ModelVersionArtifactSchema.model_id == ModelSchema.id,
+                ModelVersionArtifactSchema.model_version_id
+                == ModelVersionSchema.id,
+                ModelVersionSchema.model_id == ModelSchema.id,
                 self.generate_name_or_id_query_conditions(
                     value=self.model, table=ModelSchema
                 ),

zenml/models/v2/core/model_version.py

@@ -576,10 +576,6 @@ class ModelVersionResponse(
             force=force,
         )
 
-    # TODO in https://zenml.atlassian.net/browse/OSS-2433
-    # def generate_model_card(self, template_name: str) -> str:
-    #     """Return HTML/PDF based on input template"""
-
 
 # ------------------ Filter Model ------------------
 

zenml/models/v2/core/model_version_artifact.py

@@ -16,20 +16,17 @@
 from typing import TYPE_CHECKING, List, Optional, Union
 from uuid import UUID
 
-from pydantic import ConfigDict, Field, model_validator
+from pydantic import ConfigDict, Field
 
 from zenml.enums import GenericFilterOps
 from zenml.models.v2.base.base import (
     BaseDatedResponseBody,
     BaseIdentifiedResponse,
+    BaseRequest,
     BaseResponseMetadata,
     BaseResponseResources,
 )
-from zenml.models.v2.base.filter import StrFilter
-from zenml.models.v2.base.scoped import (
-    WorkspaceScopedFilter,
-    WorkspaceScopedRequest,
-)
+from zenml.models.v2.base.filter import BaseFilter, StrFilter
 
 if TYPE_CHECKING:
     from sqlalchemy.sql.elements import ColumnElement
@@ -40,14 +37,11 @@ if TYPE_CHECKING:
 # ------------------ Request Model ------------------
 
 
-class ModelVersionArtifactRequest(WorkspaceScopedRequest):
+class ModelVersionArtifactRequest(BaseRequest):
     """Request model for links between model versions and artifacts."""
 
-    model: UUID
     model_version: UUID
     artifact_version: UUID
-    is_model_artifact: bool = False
-    is_deployment_artifact: bool = False
 
     # TODO: In Pydantic v2, the `model_` is a protected namespaces for all
     #  fields defined under base models. If not handled, this raises a warning.
@@ -57,15 +51,6 @@ class ModelVersionArtifactRequest(WorkspaceScopedRequest):
     #  careful we might overwrite some fields protected by pydantic.
     model_config = ConfigDict(protected_namespaces=())
 
-    @model_validator(mode="after")
-    def _validate_is_endpoint_artifact(self) -> "ModelVersionArtifactRequest":
-        if self.is_model_artifact and self.is_deployment_artifact:
-            raise ValueError(
-                "Artifact cannot be a model artifact and deployment artifact "
-                "at the same time."
-            )
-        return self
-
 
 # ------------------ Update Model ------------------
 
@@ -77,11 +62,8 @@ class ModelVersionArtifactRequest(WorkspaceScopedRequest):
 class ModelVersionArtifactResponseBody(BaseDatedResponseBody):
     """Response body for links between model versions and artifacts."""
 
-    model: UUID
     model_version: UUID
     artifact_version: "ArtifactVersionResponse"
-    is_model_artifact: bool = False
-    is_deployment_artifact: bool = False
 
     # TODO: In Pydantic v2, the `model_` is a protected namespaces for all
     #  fields defined under base models. If not handled, this raises a warning.
@@ -105,16 +87,6 @@ class ModelVersionArtifactResponse(
 ):
     """Response model for links between model versions and artifacts."""
 
-    # Body and metadata properties
-    @property
-    def model(self) -> UUID:
-        """The `model` property.
-
-        Returns:
-            the value of the property.
-        """
-        return self.get_body().model
-
     @property
     def model_version(self) -> UUID:
         """The `model_version` property.
@@ -133,34 +105,16 @@ class ModelVersionArtifactResponse(
         """
         return self.get_body().artifact_version
 
-    @property
-    def is_model_artifact(self) -> bool:
-        """The `is_model_artifact` property.
-
-        Returns:
-            the value of the property.
-        """
-        return self.get_body().is_model_artifact
-
-    @property
-    def is_deployment_artifact(self) -> bool:
-        """The `is_deployment_artifact` property.
-
-        Returns:
-            the value of the property.
-        """
-        return self.get_body().is_deployment_artifact
-
 
 # ------------------ Filter Model ------------------
 
 
-class ModelVersionArtifactFilter(WorkspaceScopedFilter):
+class ModelVersionArtifactFilter(BaseFilter):
     """Model version pipeline run links filter model."""
 
     # Artifact name and type are not DB fields and need to be handled separately
     FILTER_EXCLUDE_FIELDS = [
-        *WorkspaceScopedFilter.FILTER_EXCLUDE_FIELDS,
+        *BaseFilter.FILTER_EXCLUDE_FIELDS,
         "artifact_name",
         "only_data_artifacts",
         "only_model_artifacts",
@@ -169,34 +123,16 @@ class ModelVersionArtifactFilter(WorkspaceScopedFilter):
         "user",
     ]
     CLI_EXCLUDE_FIELDS = [
-        *WorkspaceScopedFilter.CLI_EXCLUDE_FIELDS,
+        *BaseFilter.CLI_EXCLUDE_FIELDS,
         "only_data_artifacts",
         "only_model_artifacts",
         "only_deployment_artifacts",
         "has_custom_name",
-        "model_id",
         "model_version_id",
-        "user_id",
-        "workspace_id",
         "updated",
         "id",
     ]
 
-    workspace_id: Optional[Union[UUID, str]] = Field(
-        default=None,
-        description="The workspace of the Model Version",
-        union_mode="left_to_right",
-    )
-    user_id: Optional[Union[UUID, str]] = Field(
-        default=None,
-        description="The user of the Model Version",
-        union_mode="left_to_right",
-    )
-    model_id: Optional[Union[UUID, str]] = Field(
-        default=None,
-        description="Filter by model ID",
-        union_mode="left_to_right",
-    )
     model_version_id: Optional[Union[UUID, str]] = Field(
         default=None,
         description="Filter by model version ID",
@@ -236,7 +172,7 @@ class ModelVersionArtifactFilter(WorkspaceScopedFilter):
         """
         custom_filters = super().get_custom_filters()
 
-        from sqlmodel import and_
+        from sqlmodel import and_, col
 
         from zenml.zen_stores.schemas import (
             ArtifactSchema,
@@ -262,20 +198,27 @@ class ModelVersionArtifactFilter(WorkspaceScopedFilter):
 
         if self.only_data_artifacts:
             data_artifact_filter = and_(
-                ModelVersionArtifactSchema.is_model_artifact.is_(False),  # type: ignore[attr-defined]
-                ModelVersionArtifactSchema.is_deployment_artifact.is_(False),  # type: ignore[attr-defined]
+                ModelVersionArtifactSchema.artifact_version_id
+                == ArtifactVersionSchema.id,
+                col(ArtifactVersionSchema.type).not_in(
+                    ["ServiceArtifact", "ModelArtifact"]
+                ),
             )
             custom_filters.append(data_artifact_filter)
 
         if self.only_model_artifacts:
             model_artifact_filter = and_(
-                ModelVersionArtifactSchema.is_model_artifact.is_(True),  # type: ignore[attr-defined]
+                ModelVersionArtifactSchema.artifact_version_id
+                == ArtifactVersionSchema.id,
+                ArtifactVersionSchema.type == "ModelArtifact",
             )
             custom_filters.append(model_artifact_filter)
 
         if self.only_deployment_artifacts:
             deployment_artifact_filter = and_(
-                ModelVersionArtifactSchema.is_deployment_artifact.is_(True),  # type: ignore[attr-defined]
+                ModelVersionArtifactSchema.artifact_version_id
+                == ArtifactVersionSchema.id,
+                ArtifactVersionSchema.type == "ServiceArtifact",
             )
             custom_filters.append(deployment_artifact_filter)
 

zenml/models/v2/core/model_version_pipeline_run.py

@@ -23,23 +23,19 @@ from zenml.enums import GenericFilterOps
 from zenml.models.v2.base.base import (
     BaseDatedResponseBody,
     BaseIdentifiedResponse,
+    BaseRequest,
     BaseResponseMetadata,
     BaseResponseResources,
 )
-from zenml.models.v2.base.filter import StrFilter
-from zenml.models.v2.base.scoped import (
-    WorkspaceScopedFilter,
-    WorkspaceScopedRequest,
-)
+from zenml.models.v2.base.filter import BaseFilter, StrFilter
 from zenml.models.v2.core.pipeline_run import PipelineRunResponse
 
 # ------------------ Request Model ------------------
 
 
-class ModelVersionPipelineRunRequest(WorkspaceScopedRequest):
+class ModelVersionPipelineRunRequest(BaseRequest):
     """Request model for links between model versions and pipeline runs."""
 
-    model: UUID
     model_version: UUID
     pipeline_run: UUID
 
@@ -62,7 +58,6 @@ class ModelVersionPipelineRunRequest(WorkspaceScopedRequest):
 class ModelVersionPipelineRunResponseBody(BaseDatedResponseBody):
     """Response body for links between model versions and pipeline runs."""
 
-    model: UUID
     model_version: UUID
     pipeline_run: PipelineRunResponse
 
@@ -88,16 +83,6 @@ class ModelVersionPipelineRunResponse(
 ):
     """Response model for links between model versions and pipeline runs."""
 
-    # Body and metadata properties
-    @property
-    def model(self) -> UUID:
-        """The `model` property.
-
-        Returns:
-            the value of the property.
-        """
-        return self.get_body().model
-
     @property
     def model_version(self) -> UUID:
         """The `model_version` property.
@@ -120,39 +105,21 @@ class ModelVersionPipelineRunResponse(
 # ------------------ Filter Model ------------------
 
 
-class ModelVersionPipelineRunFilter(WorkspaceScopedFilter):
+class ModelVersionPipelineRunFilter(BaseFilter):
     """Model version pipeline run links filter model."""
 
     FILTER_EXCLUDE_FIELDS = [
-        *WorkspaceScopedFilter.FILTER_EXCLUDE_FIELDS,
+        *BaseFilter.FILTER_EXCLUDE_FIELDS,
         "pipeline_run_name",
         "user",
     ]
     CLI_EXCLUDE_FIELDS = [
-        *WorkspaceScopedFilter.CLI_EXCLUDE_FIELDS,
-        "model_id",
+        *BaseFilter.CLI_EXCLUDE_FIELDS,
         "model_version_id",
-        "user_id",
-        "workspace_id",
         "updated",
         "id",
     ]
 
-    workspace_id: Optional[Union[UUID, str]] = Field(
-        default=None,
-        description="The workspace of the Model Version",
-        union_mode="left_to_right",
-    )
-    user_id: Optional[Union[UUID, str]] = Field(
-        default=None,
-        description="The user of the Model Version",
-        union_mode="left_to_right",
-    )
-    model_id: Optional[Union[UUID, str]] = Field(
-        default=None,
-        description="Filter by model ID",
-        union_mode="left_to_right",
-    )
     model_version_id: Optional[Union[UUID, str]] = Field(
         default=None,
         description="Filter by model version ID",

zenml/models/v2/core/service_connector.py

@@ -488,6 +488,10 @@ class ServiceConnectorResponse(
 ):
     """Response model for service connectors."""
 
+    # Disable the warning for updating responses, because we update the
+    # service connector type in place
+    _warn_on_response_updates: bool = False
+
     name: str = Field(
         title="The service connector name.",
         max_length=STR_FIELD_MAX_LENGTH,

zenml/models/v2/misc/server_models.py

@@ -118,3 +118,26 @@ class ServerModel(BaseModel):
         # Local ZenML servers are identifiable by the fact that their
         # server ID is the same as the local client (user) ID.
         return self.id == GlobalConfiguration().user_id
+
+
+class ServerLoadInfo(BaseModel):
+    """Domain model for ZenML server load information."""
+
+    threads: int = Field(
+        title="Number of threads that the server is currently using."
+    )
+
+    db_connections_total: int = Field(
+        title="Total number of database connections (active and idle) that the "
+        "server currently has established."
+    )
+
+    db_connections_active: int = Field(
+        title="Number of database connections that the server is currently "
+        "actively using to make queries or transactions."
+    )
+
+    db_connections_overflow: int = Field(
+        title="Number of overflow database connections that the server is "
+        "currently actively using to make queries or transactions."
+    )

zenml/orchestrators/step_launcher.py

@@ -294,7 +294,6 @@ class StepLauncher:
                     ):
                         step_run_utils.link_output_artifacts_to_model_version(
                             artifacts=step_run.outputs,
-                            output_configurations=step_run.config.outputs,
                             model_version=model_version,
                         )
 

zenml/orchestrators/step_run_utils.py

@@ -14,12 +14,12 @@
 """Utilities for creating step runs."""
 
 from datetime import datetime
-from typing import TYPE_CHECKING, Dict, List, Mapping, Optional, Set, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
 
 from zenml.client import Client
-from zenml.config.step_configurations import ArtifactConfiguration, Step
+from zenml.config.step_configurations import Step
 from zenml.constants import CODE_HASH_PARAMETER_NAME, TEXT_FIELD_MAX_LENGTH
-from zenml.enums import ArtifactSaveType, ExecutionStatus
+from zenml.enums import ExecutionStatus
 from zenml.logger import get_logger
 from zenml.model.utils import link_artifact_version_to_model_version
 from zenml.models import (
@@ -344,7 +344,6 @@ def create_cached_step_runs(
             if model_version := step_model_version or pipeline_model_version:
                 link_output_artifacts_to_model_version(
                     artifacts=step_run.outputs,
-                    output_configurations=step_run.config.outputs,
                     model_version=model_version,
                 )
 
@@ -542,10 +541,7 @@ def link_pipeline_run_to_model_version(
     client = Client()
     client.zen_store.create_model_version_pipeline_run_link(
         ModelVersionPipelineRunRequest(
-            user=client.active_user.id,
-            workspace=client.active_workspace.id,
             pipeline_run=pipeline_run.id,
-            model=model_version.model.id,
             model_version=model_version.id,
         )
     )
@@ -553,26 +549,17 @@ def link_pipeline_run_to_model_version(
 
 def link_output_artifacts_to_model_version(
     artifacts: Dict[str, List[ArtifactVersionResponse]],
-    output_configurations: Mapping[str, ArtifactConfiguration],
     model_version: ModelVersionResponse,
 ) -> None:
     """Link the outputs of a step run to a model version.
 
     Args:
         artifacts: The step output artifacts.
-        output_configurations: The output configurations for the step.
         model_version: The model version to link.
     """
-    for output_name, output_artifacts in artifacts.items():
+    for output_artifacts in artifacts.values():
         for output_artifact in output_artifacts:
-            artifact_config = None
-            if output_artifact.save_type == ArtifactSaveType.STEP_OUTPUT and (
-                output_config := output_configurations.get(output_name, None)
-            ):
-                artifact_config = output_config.artifact_config
-
             link_artifact_version_to_model_version(
                 artifact_version=output_artifact,
                 model_version=model_version,
-                artifact_config=artifact_config,
             )

zenml/orchestrators/step_runner.py

@@ -247,7 +247,6 @@ class StepRunner:
                                 artifacts={
                                     k: [v] for k, v in output_artifacts.items()
                                 },
-                                output_configurations=step_run.config.outputs,
                                 model_version=model_version,
                             )
                 finally:
@@ -577,9 +576,11 @@ class StepRunner:
             uri = output_artifact_uris[output_name]
             artifact_config = output_annotations[output_name].artifact_config
 
+            artifact_type = None
             if artifact_config is not None:
                 has_custom_name = bool(artifact_config.name)
                 version = artifact_config.version
+                artifact_type = artifact_config.artifact_type
             else:
                 has_custom_name, version = False, None
 
@@ -605,6 +606,7 @@ class StepRunner:
                 data=return_value,
                 materializer_class=materializer_class,
                 uri=uri,
+                artifact_type=artifact_type,
                 store_metadata=artifact_metadata_enabled,
                 store_visualizations=artifact_visualization_enabled,
                 has_custom_name=has_custom_name,

zenml/zen_server/deploy/helm/templates/_environment.tpl

@@ -3,6 +3,123 @@ Helpers for environment variables configured in ZenML deployments and secrets st
 */}}
 
 
+{{/*
+ZenML store configuration options (non-secret values).
+
+This template constructs a dictionary that is similar to the python values that
+can be configured in the zenml.zen_store.sql_zen_store.SqlZenStoreConfiguration
+class. Only non-secret values are included in this dictionary.
+
+The dictionary is then converted into deployment environment variables by other
+templates and inserted where it is needed.
+
+The input is taken from a .ZenML dict that is passed to the template and
+contains the values configured in the values.yaml file for the ZenML server.
+
+Args:
+  .ZenML: A dictionary with the ZenML configuration values configured for the
+  ZenML server.
+Returns:
+  A dictionary with the non-secret values configured for the ZenML store.
+*/}}
+{{- define "zenml.storeConfigurationAttrs" -}}
+{{- if .ZenML.database.url }}
+type: sql
+ssl_verify_server_cert: {{ .ZenML.database.sslVerifyServerCert | default "false" | quote }}
+{{- if .ZenML.database.backupStrategy }}
+backup_strategy: {{ .ZenML.database.backupStrategy | quote }}
+{{- if eq .ZenML.database.backupStrategy "database" }}
+backup_database: {{ .ZenML.database.backupDatabase | quote }}
+{{- else if eq .ZenML.database.backupStrategy "dump-file" }}
+backup_directory: "/backups"
+{{- end }}
+{{- end }}
+{{- if .ZenML.database.poolSize }}
+pool_size: {{ .ZenML.database.poolSize | quote }}
+{{- end }}
+{{- if .ZenML.database.maxOverflow }}
+max_overflow: {{ .ZenML.database.maxOverflow | quote }}
+{{- end }}
+{{- end }}
+{{- end }}
+
+
+{{/*
+ZenML store configuration options (secret values).
+
+This template constructs a dictionary that is similar to the python values that
+can be configured in the zenml.zen_store.sql_zen_store.SqlZenStoreConfiguration
+class. Only secret values are included in this dictionary.
+
+The dictionary is then converted into deployment environment variables by other
+templates and inserted where it is needed.
+
+The input is taken from a .ZenML dict that is passed to the template and
+contains the values configured in the values.yaml file for the ZenML server.
+
+Args:
+  .ZenML: A dictionary with the ZenML configuration values configured for the
+  ZenML server.
+Returns:
+  A dictionary with the secret values configured for the ZenML store.
+*/}}
+{{- define "zenml.storeSecretConfigurationAttrs" -}}
+{{- if .ZenML.database.url }}
+url: {{ .ZenML.database.url | quote }}
+{{- if .ZenML.database.sslCa }}
+ssl_ca: {{ .Files.Get .ZenML.database.sslCa }}
+{{- end }}
+{{- if .ZenML.database.sslCert }}
+ssl_cert: {{ .Files.Get .ZenML.database.sslCert }}
+{{- end }}
+{{- if .ZenML.database.sslKey }}
+ssl_key: {{ .Files.Get .ZenML.database.sslKey }}
+{{- end }}
+{{- end }}
+{{- end }}
+
+
+{{/*
+Store configuration environment variables (non-secret values).
+
+Passes the .Values.zenml dict as input to the `zenml.storeConfigurationAttrs`
+template and converts the output into a dictionary of environment variables that
+need to be configured for the store.
+
+Args:
+  .Values: The values.yaml file for the ZenML deployment.
+Returns:
+  A dictionary with the non-secret environment variables that are configured for
+  the store (i.e. keys starting with `ZENML_STORE_`).
+*/}}
+{{- define "zenml.storeEnvVariables" -}}
+{{ $zenml := dict "ZenML" .Values.zenml }}
+{{- range $k, $v := include "zenml.storeConfigurationAttrs" $zenml | fromYaml }}
+ZENML_STORE_{{ $k | upper }}: {{ $v | quote }}
+{{- end }}
+{{- end }}
+
+
+{{/*
+Store configuration environment variables (secret values).
+
+Passes the .Values.zenml dict as input to the `zenml.storeSecretConfigurationAttrs`
+template and converts the output into a dictionary of environment variables that
+need to be configured for the store.
+
+Args:
+  .Values: The values.yaml file for the ZenML deployment.
+Returns:
+  A dictionary with the secret environment variables that are configured for
+  the store (i.e. keys starting with `ZENML_STORE_`).
+*/}}
+{{- define "zenml.storeSecretEnvVariables" -}}
+{{ $zenml := dict "ZenML" .Values.zenml }}
+{{- range $k, $v := include "zenml.storeSecretConfigurationAttrs" $zenml | fromYaml }}
+ZENML_STORE_{{ $k | upper }}: {{ $v | quote }}
+{{- end }}
+{{- end }}
+
 {{/*
 ZenML server configuration options (non-secret values).
 

zenml/zen_server/deploy/helm/templates/server-db-job.yaml

@@ -79,20 +79,9 @@ spec:
             {{- end }}
             - name: ZENML_DEFAULT_PROJECT_NAME
               value: {{ .Values.zenml.defaultProject | quote }}
-            - name: ZENML_STORE_TYPE
-              value: sql
-            - name: ZENML_STORE_SSL_VERIFY_SERVER_CERT
-              value: {{ .Values.zenml.database.sslVerifyServerCert | default "false" | quote }}
-            {{- if .Values.zenml.database.backupStrategy }}
-            - name: ZENML_STORE_BACKUP_STRATEGY
-              value: {{ .Values.zenml.database.backupStrategy | quote }}
-            {{- if eq .Values.zenml.database.backupStrategy "database" }}
-            - name: ZENML_STORE_BACKUP_DATABASE
-              value: {{ .Values.zenml.database.backupDatabase | quote }}
-            {{- else if eq .Values.zenml.database.backupStrategy "dump-file" }}
-            - name: ZENML_STORE_BACKUP_DIRECTORY
-              value: /backups
-            {{- end }}
+            {{- range $k, $v := include "zenml.storeEnvVariables" . | fromYaml }}
+            - name: {{ $k }}
+              value: {{ $v | quote }}
             {{- end }}
             {{- range $k, $v := include "zenml.serverEnvVariables" . | fromYaml }}
             - name: {{ $k }}