Use data connection secret to store s3 info, use storage-initializer mage from the cluster

tests/model_registry/conftest.py

@@ -12,7 +12,7 @@
 
 from tests.model_registry.utils import get_endpoint_from_mr_service, get_mr_service_by_label
 from utilities.infra import create_ns
-from utilities.constants import Protocols, KubernetesAnnotations
+from utilities.constants import Annotations, Protocols
 
 
 LOGGER = get_logger(name=__name__)
@@ -22,9 +22,9 @@
 MR_OPERATOR_NAME: str = "model-registry-operator"
 MR_NAMESPACE: str = "rhoai-model-registries"
 DEFAULT_LABEL_DICT_DB: dict[str, str] = {
-    KubernetesAnnotations.NAME: DB_RESOURCES_NAME,
-    KubernetesAnnotations.INSTANCE: DB_RESOURCES_NAME,
-    KubernetesAnnotations.PART_OF: DB_RESOURCES_NAME,
+    Annotations.KubernetesIo.NAME: DB_RESOURCES_NAME,
+    Annotations.KubernetesIo.INSTANCE: DB_RESOURCES_NAME,
+    Annotations.KubernetesIo.PART_OF: DB_RESOURCES_NAME,
 }
 
 
@@ -251,10 +251,10 @@ def model_registry_instance(
         name=MR_INSTANCE_NAME,
         namespace=model_registry_namespace.name,
         label={
-            KubernetesAnnotations.NAME: MR_INSTANCE_NAME,
-            KubernetesAnnotations.INSTANCE: MR_INSTANCE_NAME,
-            KubernetesAnnotations.PART_OF: MR_OPERATOR_NAME,
-            KubernetesAnnotations.CREATED_BY: MR_OPERATOR_NAME,
+            Annotations.KubernetesIo.NAME: MR_INSTANCE_NAME,
+            Annotations.KubernetesIo.INSTANCE: MR_INSTANCE_NAME,
+            Annotations.KubernetesIo.PART_OF: MR_OPERATOR_NAME,
+            Annotations.KubernetesIo.CREATED_BY: MR_OPERATOR_NAME,
         },
         grpc={},
         rest={},

tests/model_serving/model_server/authentication/conftest.py

@@ -1,5 +1,6 @@
 import shlex
 from typing import Any, Generator
+from urllib.parse import urlparse
 
 import pytest
 from _pytest.fixtures import FixtureRequest
@@ -74,17 +75,17 @@ def grpc_s3_inference_service(
     model_namespace: Namespace,
     grpc_s3_caikit_serving_runtime: ServingRuntime,
     s3_models_storage_uri: str,
-    grpc_model_service_account: ServiceAccount,
+    models_endpoint_s3_secret: Secret,
 ) -> InferenceService:
     with create_isvc(
         client=admin_client,
         name=f"{Protocols.GRPC}-{ModelFormat.CAIKIT}",
         namespace=model_namespace.name,
         runtime=grpc_s3_caikit_serving_runtime.name,
-        storage_uri=s3_models_storage_uri,
         model_format=grpc_s3_caikit_serving_runtime.instance.spec.supportedModelFormats[0].name,
+        storage_key=models_endpoint_s3_secret.name,
+        storage_path=urlparse(s3_models_storage_uri).path,
         deployment_mode=KServeDeploymentType.SERVERLESS,
-        model_service_account=grpc_model_service_account.name,
         enable_auth=True,
     ) as isvc:
         yield isvc
@@ -199,18 +200,18 @@ def http_s3_caikit_serverless_inference_service(
     model_namespace: Namespace,
     http_s3_caikit_tgis_serving_runtime: ServingRuntime,
     s3_models_storage_uri: str,
-    model_service_account: ServiceAccount,
+    models_endpoint_s3_secret: Secret,
 ) -> InferenceService:
     with create_isvc(
         client=admin_client,
         name=f"{Protocols.HTTP}-{ModelFormat.CAIKIT}",
         namespace=model_namespace.name,
         runtime=http_s3_caikit_tgis_serving_runtime.name,
-        storage_uri=s3_models_storage_uri,
         model_format=http_s3_caikit_tgis_serving_runtime.instance.spec.supportedModelFormats[0].name,
         deployment_mode=KServeDeploymentType.SERVERLESS,
-        model_service_account=model_service_account.name,
         enable_auth=True,
+        storage_key=models_endpoint_s3_secret.name,
+        storage_path=urlparse(s3_models_storage_uri).path,
     ) as isvc:
         yield isvc
 
@@ -266,37 +267,23 @@ def unprivileged_models_endpoint_s3_secret(
         yield secret
 
 
-@pytest.fixture(scope="class")
-def unprivileged_model_service_account(
-    unprivileged_client: DynamicClient, unprivileged_models_endpoint_s3_secret: Secret
-) -> ServiceAccount:
-    with ServiceAccount(
-        client=unprivileged_client,
-        namespace=unprivileged_models_endpoint_s3_secret.namespace,
-        name=f"{Protocols.HTTP}-models-bucket-sa",
-        secrets=[{"name": unprivileged_models_endpoint_s3_secret.name}],
-    ) as sa:
-        yield sa
-
-
 @pytest.fixture(scope="class")
 def unprivileged_s3_caikit_serverless_inference_service(
     request: FixtureRequest,
     unprivileged_client: DynamicClient,
     unprivileged_model_namespace: Namespace,
     unprivileged_s3_caikit_serving_runtime: ServingRuntime,
-    s3_models_storage_uri: str,
-    unprivileged_model_service_account: ServiceAccount,
+    unprivileged_models_endpoint_s3_secret: Secret,
 ) -> InferenceService:
     with create_isvc(
         client=unprivileged_client,
         name=f"{Protocols.HTTP}-{ModelFormat.CAIKIT}",
         namespace=unprivileged_model_namespace.name,
         runtime=unprivileged_s3_caikit_serving_runtime.name,
-        storage_uri=s3_models_storage_uri,
         model_format=unprivileged_s3_caikit_serving_runtime.instance.spec.supportedModelFormats[0].name,
         deployment_mode=KServeDeploymentType.SERVERLESS,
-        model_service_account=unprivileged_model_service_account.name,
+        storage_key=unprivileged_models_endpoint_s3_secret.name,
+        storage_path=request.param["model-dir"],
     ) as isvc:
         yield isvc
 

tests/model_serving/model_server/authentication/test_non_admin_users.py

@@ -6,12 +6,11 @@
 
 
 @pytest.mark.parametrize(
-    "unprivileged_model_namespace, s3_models_storage_uri, unprivileged_s3_caikit_serverless_inference_service",
+    "unprivileged_model_namespace, unprivileged_s3_caikit_serverless_inference_service",
     [
         pytest.param(
             {"name": "non-admin-test"},
             {"model-dir": ModelStoragePath.FLAN_T5_SMALL},
-            {"enable-auth": False},
         )
     ],
     indirect=True,

tests/model_serving/model_server/conftest.py

@@ -95,29 +95,23 @@ def serving_runtime_from_template(
         yield model_runtime
 
 
-@pytest.fixture(scope="class")
-def ci_s3_storage_uri(request: FixtureRequest, ci_s3_bucket_name: str) -> str:
-    return f"s3://{ci_s3_bucket_name}/{request.param['model-dir']}/"
-
-
 @pytest.fixture(scope="class")
 def s3_models_inference_service(
     request: FixtureRequest,
     admin_client: DynamicClient,
     model_namespace: Namespace,
     serving_runtime_from_template: ServingRuntime,
-    s3_models_storage_uri: str,
-    model_service_account: ServiceAccount,
+    models_endpoint_s3_secret: Secret,
 ) -> InferenceService:
     isvc_kwargs = {
         "client": admin_client,
         "name": request.param["name"],
         "namespace": model_namespace.name,
         "runtime": serving_runtime_from_template.name,
-        "storage_uri": s3_models_storage_uri,
         "model_format": serving_runtime_from_template.instance.spec.supportedModelFormats[0].name,
-        "model_service_account": model_service_account.name,
         "deployment_mode": request.param["deployment-mode"],
+        "storage_key": models_endpoint_s3_secret.name,
+        "storage_path": request.param["model-dir"],
     }
 
     if (external_route := request.param.get("external-route")) is not None:

tests/model_serving/model_server/metrics/test_model_metrics.py

@@ -19,18 +19,21 @@
 @pytest.mark.serverless
 @pytest.mark.jira("RHOAIENG-3236", run=False)
 @pytest.mark.parametrize(
-    "model_namespace, s3_models_storage_uri, serving_runtime_from_template, s3_models_inference_service",
+    "model_namespace, serving_runtime_from_template, s3_models_inference_service",
     [
         pytest.param(
             {"name": "kserve-tgis-metrics"},
-            {"model-dir": ModelStoragePath.FLAN_T5_SMALL},
             {
                 "name": f"{Protocols.HTTP}-{ModelInferenceRuntime.CAIKIT_TGIS_RUNTIME}",
                 "template-name": RuntimeTemplates.CAIKIT_TGIS_SERVING,
                 "multi-model": False,
                 "enable-http": True,
             },
-            {"name": f"{Protocols.HTTP}-{ModelFormat.CAIKIT}", "deployment-mode": KServeDeploymentType.SERVERLESS},
+            {
+                "name": f"{Protocols.HTTP}-{ModelFormat.CAIKIT}",
+                "deployment-mode": KServeDeploymentType.SERVERLESS,
+                "model-dir": ModelStoragePath.FLAN_T5_SMALL,
+            },
         )
     ],
     indirect=True,

tests/model_serving/model_server/ovms/kserve/conftest.py

@@ -4,14 +4,12 @@
 from ocp_resources.inference_service import InferenceService
 from ocp_resources.namespace import Namespace
 from ocp_resources.secret import Secret
-from ocp_resources.service_account import ServiceAccount
 from ocp_resources.serving_runtime import ServingRuntime
 
 from tests.model_serving.model_server.utils import create_isvc
 from utilities.constants import (
     KServeDeploymentType,
     ModelAndFormat,
-    Protocols,
     RuntimeTemplates,
 )
 from utilities.infra import s3_endpoint_secret
@@ -64,35 +62,23 @@ def ci_endpoint_s3_secret(
         yield secret
 
 
-@pytest.fixture(scope="class")
-def openvino_model_service_account(admin_client: DynamicClient, ci_endpoint_s3_secret: Secret) -> ServiceAccount:
-    with ServiceAccount(
-        client=admin_client,
-        namespace=ci_endpoint_s3_secret.namespace,
-        name=f"{Protocols.GRPC}-models-bucket-sa",
-        secrets=[{"name": ci_endpoint_s3_secret.name}],
-    ) as sa:
-        yield sa
-
-
 @pytest.fixture(scope="class")
 def ovms_serverless_inference_service(
     request: FixtureRequest,
     admin_client: DynamicClient,
     model_namespace: Namespace,
     openvino_kserve_serving_runtime: ServingRuntime,
-    ci_s3_storage_uri: str,
-    openvino_model_service_account: ServiceAccount,
+    ci_endpoint_s3_secret: Secret,
 ) -> InferenceService:
     with create_isvc(
         client=admin_client,
         name=f"{request.param['name']}-serverless",
         namespace=model_namespace.name,
         runtime=openvino_kserve_serving_runtime.name,
-        storage_uri=ci_s3_storage_uri,
+        storage_path=request.param["model-dir"],
+        storage_key=ci_endpoint_s3_secret.name,
         model_format=ModelAndFormat.OPENVINO_IR,
         deployment_mode=KServeDeploymentType.SERVERLESS,
-        model_service_account=openvino_model_service_account.name,
         model_version=request.param["model-version"],
     ) as isvc:
         yield isvc

tests/model_serving/model_server/ovms/kserve/test_onnx_serverless.py

@@ -15,16 +15,15 @@
 
 @pytest.mark.serverless
 @pytest.mark.parametrize(
-    "model_namespace, ci_s3_storage_uri, openvino_kserve_serving_runtime, ovms_serverless_inference_service",
+    "model_namespace, openvino_kserve_serving_runtime, ovms_serverless_inference_service",
     [
         pytest.param(
             {"name": "kserve-serverless-onnx"},
-            {"model-dir": "test-dir"},
             {
                 "runtime-name": ModelInferenceRuntime.ONNX_RUNTIME,
                 "model-format": {ModelFormat.ONNX: ModelVersion.OPSET13},
             },
-            {"name": ModelFormat.ONNX, "model-version": ModelVersion.OPSET13},
+            {"name": ModelFormat.ONNX, "model-version": ModelVersion.OPSET13, "model-dir": "test-dir"},
         )
     ],
     indirect=True,

tests/model_serving/model_server/ovms/kserve/test_openvino_serverless.py

@@ -17,16 +17,19 @@
 
 @pytest.mark.serverless
 @pytest.mark.parametrize(
-    "model_namespace, ci_s3_storage_uri, openvino_kserve_serving_runtime, ovms_serverless_inference_service",
+    "model_namespace, openvino_kserve_serving_runtime, ovms_serverless_inference_service",
     [
         pytest.param(
             {"name": "kserve-serverless-openvino"},
-            {"model-dir": ModelStoragePath.KSERVE_OPENVINO_EXAMPLE_MODEL},
             {
                 "runtime-name": ModelInferenceRuntime.OPENVINO_KSERVE_RUNTIME,
                 "model-format": {ModelAndFormat.OPENVINO_IR: ModelVersion.OPSET1},
             },
-            {"name": ModelFormat.OPENVINO, "model-version": ModelVersion.OPSET1},
+            {
+                "name": ModelFormat.OPENVINO,
+                "model-version": ModelVersion.OPSET1,
+                "model-dir": ModelStoragePath.KSERVE_OPENVINO_EXAMPLE_MODEL,
+            },
         )
     ],
     indirect=True,

tests/model_serving/model_server/ovms/model_mesh/conftest.py

@@ -1,5 +1,4 @@
 import shlex
-from typing import Generator
 
 import pytest
 from _pytest.fixtures import FixtureRequest
@@ -24,7 +23,7 @@
     ModelInferenceRuntime,
     RuntimeTemplates,
 )
-from utilities.infra import create_isvc_view_role, create_storage_config_secret, s3_endpoint_secret
+from utilities.infra import create_isvc_view_role, s3_endpoint_secret
 from utilities.serving_runtime import ServingRuntimeFromTemplate
 
 
@@ -72,29 +71,6 @@ def ci_model_mesh_endpoint_s3_secret(
         yield secret
 
 
-@pytest.fixture(scope="class")
-def model_mesh_storage_config_secret(
-    admin_client: DynamicClient,
-    ci_model_mesh_endpoint_s3_secret: Secret,
-    aws_access_key_id: str,
-    aws_secret_access_key: str,
-    ci_s3_bucket_name: str,
-    ci_s3_bucket_region: str,
-    ci_s3_bucket_endpoint: str,
-) -> Generator[Secret, None, None]:
-    with create_storage_config_secret(
-        admin_client=admin_client,
-        endpoint_secret_name=ci_model_mesh_endpoint_s3_secret.name,
-        namespace=ci_model_mesh_endpoint_s3_secret.namespace,
-        aws_access_key=aws_access_key_id,
-        aws_secret_access_key=aws_secret_access_key,
-        aws_s3_bucket=ci_s3_bucket_name,
-        aws_s3_region=ci_s3_bucket_region,
-        aws_s3_endpoint=ci_s3_bucket_endpoint,
-    ) as storage_config:
-        yield storage_config
-
-
 @pytest.fixture(scope="class")
 def model_mesh_model_service_account(
     admin_client: DynamicClient, ci_model_mesh_endpoint_s3_secret: Secret
@@ -115,7 +91,6 @@ def http_s3_openvino_model_mesh_inference_service(
     ns_with_modelmesh_enabled: Namespace,
     http_s3_openvino_model_mesh_serving_runtime: ServingRuntime,
     ci_model_mesh_endpoint_s3_secret: Secret,
-    model_mesh_storage_config_secret: Secret,
     model_mesh_model_service_account: ServiceAccount,
 ) -> InferenceService:
     isvc_kwargs = {

tests/model_serving/model_server/private_endpoint/conftest.py

@@ -12,7 +12,7 @@
 from tests.model_serving.model_server.private_endpoint.utils import create_sidecar_pod
 from tests.model_serving.model_server.utils import create_isvc
 from utilities.constants import KServeDeploymentType, ModelFormat, ModelStoragePath
-from utilities.infra import create_ns, create_storage_config_secret
+from utilities.infra import create_ns
 
 LOGGER = get_logger(name=__name__)
 
@@ -28,7 +28,6 @@ def endpoint_isvc(
     admin_client: DynamicClient,
     serving_runtime_from_template: ServingRuntime,
     models_endpoint_s3_secret: Secret,
-    storage_config_secret: Secret,
 ) -> Generator[InferenceService, None, None]:
     with create_isvc(
         client=admin_client,
@@ -44,29 +43,6 @@ def endpoint_isvc(
         yield isvc
 
 
-@pytest.fixture(scope="class")
-def storage_config_secret(
-    admin_client: DynamicClient,
-    models_endpoint_s3_secret: Secret,
-    aws_access_key_id: str,
-    aws_secret_access_key: str,
-    models_s3_bucket_name: str,
-    models_s3_bucket_region: str,
-    models_s3_bucket_endpoint: str,
-) -> Generator[Secret, None, None]:
-    with create_storage_config_secret(
-        admin_client=admin_client,
-        endpoint_secret_name=models_endpoint_s3_secret.name,
-        namespace=models_endpoint_s3_secret.namespace,
-        aws_access_key=aws_access_key_id,
-        aws_secret_access_key=aws_secret_access_key,
-        aws_s3_bucket=models_s3_bucket_name,
-        aws_s3_region=models_s3_bucket_region,
-        aws_s3_endpoint=models_s3_bucket_endpoint,
-    ) as storage_config:
-        yield storage_config
-
-
 @pytest.fixture()
 def endpoint_pod_with_istio_sidecar(
     admin_client: DynamicClient, model_namespace: Namespace