Deploy a Model from a PVC

frontend/src/__mocks__/mockPVCK8sResource.ts

@@ -11,6 +11,8 @@ type MockResourceConfigType = {
   uid?: string;
   status?: PersistentVolumeClaimKind['status'];
   accessModes?: AccessMode[];
+  annotations?: Record<string, string>;
+  labels?: Record<string, string>;
 };
 
 export const mockPVCK8sResource = ({
@@ -28,18 +30,22 @@ export const mockPVCK8sResource = ({
     },
   },
   accessModes = [AccessMode.RWO],
+  annotations = {},
+  labels = {},
 }: MockResourceConfigType): PersistentVolumeClaimKind => ({
   kind: 'PersistentVolumeClaim',
   apiVersion: 'v1',
   metadata: {
     annotations: {
       'openshift.io/description': '',
       'openshift.io/display-name': displayName,
+      ...annotations,
     },
     name,
     namespace,
     labels: {
       [KnownLabels.DASHBOARD_RESOURCE]: 'true',
+      ...labels,
     },
     uid,
   },

frontend/src/__tests__/cypress/cypress/pages/modelServing.ts

@@ -249,6 +249,10 @@ class InferenceServiceModal extends ServingModal {
     });
   }
 
+  findPVCSelect() {
+    return this.find().findByTestId('pvc-connection-selector');
+  }
+
   findHardProfileSelection(): Cypress.Chainable<JQuery<HTMLElement>> {
     return cy.findByTestId('hardware-profile-select');
   }
@@ -552,6 +556,10 @@ class KServeModal extends InferenceServiceModal {
   findMemoryLimitButton(type: 'Plus' | 'Minus') {
     return this.find().findByTestId('memory-limit-input').findByRole('button', { name: type });
   }
+
+  findPVCConnectionOption() {
+    return this.find().findByTestId('pvc-serving-radio');
+  }
 }
 mixin(KServeModal, [ServingRuntimeModal, InferenceServiceModal]);
 

frontend/src/__tests__/cypress/cypress/tests/mocked/modelServing/runtime/servingRuntimeList.cy.ts

@@ -97,6 +97,7 @@ type HandlersProps = {
   DscComponents?: DataScienceClusterKindStatus['components'];
   disableProjectScoped?: boolean;
   disableHardwareProfiles?: boolean;
+  disablePVCServing?: boolean;
 };
 import { STOP_MODAL_PREFERENCE_KEY } from '#~/pages/modelServing/useStopModalPreference';
 
@@ -110,6 +111,7 @@ const initIntercepts = ({
   projectEnableModelMesh,
   disableProjectScoped = true,
   disableHardwareProfiles = true,
+  disablePVCServing = true,
   servingRuntimes = [
     mockServingRuntimeK8sResourceLegacy({ tolerations: [], nodeSelector: {} }),
     mockServingRuntimeK8sResource({
@@ -169,6 +171,7 @@ const initIntercepts = ({
       disableKServeRaw,
       disableProjectScoped,
       disableHardwareProfiles,
+      disablePVCServing,
     }),
   );
   cy.interceptK8sList(PodModel, mockK8sResourceList([mockPodK8sResource({})]));
@@ -2356,6 +2359,122 @@ describe('Serving Runtime List', () => {
         });
       });
     });
+
+    it('Deploy model with PVC', () => {
+      initIntercepts({
+        disableModelMeshConfig: false,
+        disableKServeConfig: false,
+        disableServingRuntimeParams: false,
+        disablePVCServing: false,
+        requiredCapabilities: [StackCapability.SERVICE_MESH, StackCapability.SERVICE_MESH_AUTHZ],
+        projectEnableModelMesh: false,
+      });
+      cy.intercept(
+        'GET',
+        '**/namespaces/test-project/persistentvolumeclaims?labelSelector=opendatahub.io%2Fdashboard%3Dtrue',
+        mockK8sResourceList([
+          mockPVCK8sResource({
+            name: 'test-pvc',
+            namespace: 'test-project',
+            displayName: 'Test PVC',
+            storageClassName: 'openshift-default-sc',
+            annotations: {
+              'dashboard.opendatahub.io/model-name': 'test-model',
+              'dashboard.opendatahub.io/model-path': 'test-path',
+            },
+            labels: {
+              'opendatahub.io/dashboard': 'true',
+            },
+          }),
+        ]),
+      );
+
+      projectDetails.visitSection('test-project', 'model-server');
+      modelServingSection.findDeployModelButton().click();
+
+      kserveModal.shouldBeOpen();
+
+      kserveModal.findModelNameInput().type('Test Name');
+      kserveModal.findServingRuntimeTemplateSearchSelector().click();
+      kserveModal.findGlobalScopedTemplateOption('Caikit').click();
+      kserveModal.findModelFrameworkSelect().findSelectOption('onnx - 1').click();
+      // Auto-selects the only pvc
+      kserveModal.findPVCConnectionOption().should('be.visible').click();
+      kserveModal.findLocationPathInput().should('have.value', 'test-path');
+      kserveModal.findSubmitButton().should('be.enabled');
+      kserveModal.findSubmitButton().click();
+      kserveModal.shouldBeOpen(false);
+
+      // dry run request
+      cy.wait('@createServingRuntime').then((interception) => {
+        expect(interception.request.url).to.include('?dryRun=All');
+        expect(interception.request.body).to.containSubset({
+          metadata: {
+            name: 'test-name',
+            annotations: {
+              'openshift.io/display-name': 'test-name',
+              'opendatahub.io/apiProtocol': 'REST',
+              'opendatahub.io/template-display-name': 'Caikit',
+              'opendatahub.io/template-name': 'template-2',
+            },
+            namespace: 'test-project',
+          },
+          spec: {
+            protocolVersions: ['grpc-v1'],
+            supportedModelFormats: [
+              { autoSelect: true, name: 'openvino_ir', version: 'opset1' },
+              { autoSelect: true, name: 'onnx', version: '1' },
+            ],
+          },
+        });
+      });
+      // Actual request
+      cy.wait('@createServingRuntime').then((interception) => {
+        expect(interception.request.url).not.to.include('?dryRun=All');
+      });
+
+      // the serving runtime should have been created
+      cy.get('@createServingRuntime.all').then((interceptions) => {
+        expect(interceptions).to.have.length(2); // 1 dry-run request and 1 actual request
+      });
+      cy.wait('@createInferenceService').then((interception) => {
+        expect(interception.request.url).to.include('?dryRun=All');
+        expect(interception.request.body).to.containSubset({
+          apiVersion: 'serving.kserve.io/v1beta1',
+          kind: 'InferenceService',
+          metadata: {
+            annotations: {
+              'openshift.io/display-name': 'Test Name',
+              'serving.knative.openshift.io/enablePassthrough': 'true',
+              'serving.kserve.io/deploymentMode': DeploymentMode.Serverless,
+              'sidecar.istio.io/inject': 'true',
+              'sidecar.istio.io/rewriteAppHTTPProbers': 'true',
+            },
+            labels: {
+              'opendatahub.io/dashboard': 'true',
+              'networking.knative.dev/visibility': 'cluster-local',
+            },
+            name: 'test-name',
+            namespace: 'test-project',
+          },
+          spec: {
+            predictor: {
+              minReplicas: 1,
+              maxReplicas: 1,
+              model: {
+                modelFormat: { name: 'onnx', version: '1' },
+                resources: {
+                  requests: { cpu: '1', memory: '4Gi' },
+                  limits: { cpu: '2', memory: '8Gi' },
+                },
+                runtime: 'test-name',
+                storageUri: 'pvc://test-pvc/test-path',
+              },
+            },
+          },
+        });
+      });
+    });
   });
 
   describe('ModelMesh model server', () => {

frontend/src/pages/modelServing/__tests__/utils.spec.ts

@@ -6,8 +6,10 @@ import {
   isOciModelUri,
   getInferenceServiceStoppedStatus,
   getServingRuntimeVersionStatus,
+  getModelServingPVCAnnotations,
 } from '#~/pages/modelServing/utils';
 import { mockServingRuntimeK8sResource } from '#~/__mocks__/mockServingRuntimeK8sResource';
+import { mockPVCK8sResource } from '#~/__mocks__/mockPVCK8sResource';
 import { ContainerResources } from '#~/types';
 import { mockServiceAccountK8sResource } from '#~/__mocks__/mockServiceAccountK8sResource';
 import { mockRoleBindingK8sResource } from '#~/__mocks__/mockRoleBindingK8sResource';
@@ -353,3 +355,26 @@ describe('getServingRuntimeVersionStatus', () => {
     );
   });
 });
+
+describe('getModelServingPVCAnnotations', () => {
+  it('should return the right annotations', () => {
+    const pvc = mockPVCK8sResource({
+      annotations: {
+        'dashboard.opendatahub.io/model-name': 'test-model',
+        'dashboard.opendatahub.io/model-path': 'test-path',
+      },
+    });
+    expect(getModelServingPVCAnnotations(pvc)).toEqual({
+      modelName: 'test-model',
+      modelPath: 'test-path',
+    });
+  });
+
+  it('should return null if annotations are not present', () => {
+    const pvc = mockPVCK8sResource({});
+    expect(getModelServingPVCAnnotations(pvc)).toEqual({
+      modelName: null,
+      modelPath: null,
+    });
+  });
+});