Add deployment strategy to wizard'

ashley-o0o · ashley-o0o · commit 1f787598480f · 2025-11-06T09:07:16.000-05:00
diff --git a/frontend/src/__tests__/cypress/cypress/pages/modelServing.ts b/frontend/src/__tests__/cypress/cypress/pages/modelServing.ts
@@ -1190,6 +1190,18 @@ class ModelServingWizard extends Wizard {
   findDiscardButton() {
     return cy.findByRole('button', { name: 'Discard' });
   }
+
+  findDeploymentStrategySection() {
+    return cy.findByTestId('deployment-strategy-section');
+  }
+
+  findDeploymentStrategyRollingOption() {
+    return this.findDeploymentStrategySection().findByTestId('deployment-strategy-rolling');
+  }
+
+  findDeploymentStrategyRecreateOption() {
+    return this.findDeploymentStrategySection().findByTestId('deployment-strategy-recreate');
+  }
 }
 
 export const modelServingGlobal = new ModelServingGlobal();
diff --git a/frontend/src/__tests__/cypress/cypress/tests/mocked/modelServing/modelServingDeploy.cy.ts b/frontend/src/__tests__/cypress/cypress/tests/mocked/modelServing/modelServingDeploy.cy.ts
@@ -416,6 +416,9 @@ describe('Model Serving Deploy Wizard', () => {
     modelServingWizard.findServiceAccountByIndex(0).clear();
     modelServingWizard.findNextButton().should('be.disabled');
     modelServingWizard.findServiceAccountByIndex(0).clear().type('new name');
+
+    modelServingWizard.findDeploymentStrategySection().should('exist');
+    modelServingWizard.findDeploymentStrategyRollingOption().should('be.checked');
     modelServingWizard.findNextButton().should('be.enabled').click();
 
     // Step 4: Summary
@@ -445,6 +448,9 @@ describe('Model Serving Deploy Wizard', () => {
         predictor: {
           minReplicas: 99,
           maxReplicas: 99,
+          deploymentStrategy: {
+            type: 'RollingUpdate',
+          },
           model: {
             modelFormat: {
               name: 'vLLM',
@@ -475,6 +481,9 @@ describe('Model Serving Deploy Wizard', () => {
       // Check spec structure without the model details
       expect(interception.request.body.spec.predictor.minReplicas).to.equal(99);
       expect(interception.request.body.spec.predictor.maxReplicas).to.equal(99);
+      expect(interception.request.body.spec.predictor.deploymentStrategy.type).to.equal(
+        'RollingUpdate',
+      );
 
       // Check model format exists
       expect(interception.request.body.spec.predictor.model.modelFormat.name).to.equal('vLLM');
@@ -691,6 +700,8 @@ describe('Model Serving Deploy Wizard', () => {
     modelServingWizard.findEnvVariableName('0').clear().type('valid_name');
     modelServingWizard.findEnvVariableValue('0').type('test-value');
 
+    modelServingWizard.findDeploymentStrategySection().should('exist');
+    modelServingWizard.findDeploymentStrategyRecreateOption().click();
     modelServingWizard.findNextButton().should('be.enabled').click();
 
     // Step 4: Summary
@@ -715,6 +726,9 @@ describe('Model Serving Deploy Wizard', () => {
       },
       spec: {
         predictor: {
+          deploymentStrategy: {
+            type: 'Recreate',
+          },
           model: {
             modelFormat: {
               name: 'openvino_ir',
@@ -750,6 +764,7 @@ describe('Model Serving Deploy Wizard', () => {
         'openvino_ir',
       );
       expect(interception.request.body.spec.predictor.model.modelFormat.version).to.equal('opset1');
+      expect(interception.request.body.spec.predictor.deploymentStrategy.type).to.equal('Recreate');
     });
 
     // Actual request
diff --git a/frontend/src/k8sTypes.ts b/frontend/src/k8sTypes.ts
@@ -536,6 +536,9 @@ export type InferenceServiceKind = K8sResourceCommon & {
       annotations?: Record<string, string>;
       tolerations?: Toleration[];
       nodeSelector?: NodeSelector;
+      deploymentStrategy?: {
+        type: 'RollingUpdate' | 'Recreate';
+      };
       model?: {
         modelFormat?: {
           name: string;
diff --git a/packages/kserve/src/deploy.ts b/packages/kserve/src/deploy.ts
@@ -35,6 +35,7 @@ export const deployKServeDeployment = async (
     runtimeArgs: wizardData.runtimeArgs.data,
     environmentVariables: wizardData.environmentVariables.data,
     modelAvailability: wizardData.modelAvailability.data,
+    deploymentStrategy: wizardData.deploymentStrategy.data,
   };
 
   const servingRuntime =
diff --git a/packages/kserve/src/deployModel.ts b/packages/kserve/src/deployModel.ts
@@ -6,6 +6,7 @@ import {
 import { ServingRuntimeModelType } from '@odh-dashboard/internal/types';
 
 import {
+  DeploymentStrategyFieldData,
   type ModelLocationData,
   ModelLocationType,
 } from '@odh-dashboard/model-serving/types/form-data';
@@ -26,6 +27,7 @@ import {
   applyDashboardResourceLabel,
   applyDisplayNameDesc,
   applyModelType,
+  applyDeploymentStrategy,
 } from './deployUtils';
 import { applyHardwareProfileToDeployment, applyReplicas } from './hardware';
 import {
@@ -50,6 +52,7 @@ export type CreatingInferenceServiceObject = {
   environmentVariables?: EnvironmentVariablesFieldData;
   modelAvailability?: ModelAvailabilityFieldsData;
   createConnectionData?: CreateConnectionData;
+  deploymentStrategy?: DeploymentStrategyFieldData;
 };
 
 const assembleInferenceService = (
@@ -74,6 +77,7 @@ const assembleInferenceService = (
     tokenAuth,
     runtimeArgs,
     environmentVariables,
+    deploymentStrategy,
   } = data;
   let inferenceService: InferenceServiceKind = existingInferenceService
     ? { ...existingInferenceService }
@@ -142,6 +146,10 @@ const assembleInferenceService = (
     environmentVariables ?? { variables: [], enabled: false },
   );
 
+  if (deploymentStrategy) {
+    inferenceService = applyDeploymentStrategy(inferenceService, deploymentStrategy);
+  }
+
   return inferenceService;
 };
 
diff --git a/packages/kserve/src/deployUtils.ts b/packages/kserve/src/deployUtils.ts
@@ -369,3 +369,14 @@ export const applyModelType = (
   };
   return result;
 };
+
+export const applyDeploymentStrategy = (
+  inferenceService: InferenceServiceKind,
+  deploymentStrategy: 'rolling' | 'recreate',
+): InferenceServiceKind => {
+  const result = structuredClone(inferenceService);
+  result.spec.predictor.deploymentStrategy = {
+    type: deploymentStrategy === 'rolling' ? 'RollingUpdate' : 'Recreate',
+  };
+  return result;
+};
diff --git a/packages/model-serving/src/components/deploymentWizard/fields/DeploymentStrategyField.tsx b/packages/model-serving/src/components/deploymentWizard/fields/DeploymentStrategyField.tsx
@@ -0,0 +1,102 @@
+import React from 'react';
+import { Radio, Stack, StackItem } from '@patternfly/react-core';
+import { z } from 'zod';
+import { useAppContext } from '@odh-dashboard/internal/app/AppContext';
+
+// Schema
+export const deploymentStrategyFieldSchema = z.enum(['rolling', 'recreate']);
+
+export type DeploymentStrategyFieldData = z.infer<typeof deploymentStrategyFieldSchema>;
+
+export const isValidDeploymentStrategy = (value: unknown): value is DeploymentStrategyFieldData => {
+  return deploymentStrategyFieldSchema.safeParse(value).success;
+};
+
+// Hook
+export type DeploymentStrategyFieldHook = {
+  data: DeploymentStrategyFieldData;
+  setData: (data: DeploymentStrategyFieldData) => void;
+};
+
+export const useDeploymentStrategyField = (
+  existingData?: DeploymentStrategyFieldData,
+): DeploymentStrategyFieldHook => {
+  const { dashboardConfig } = useAppContext();
+  const hasInitializedRef = React.useRef(false);
+
+  const clusterDefault = React.useMemo(() => {
+    const strategy = dashboardConfig.spec.modelServing?.deploymentStrategy;
+    if (strategy === 'rolling' || strategy === 'recreate') {
+      return strategy;
+    }
+    return 'rolling';
+  }, [dashboardConfig.spec.modelServing?.deploymentStrategy]);
+
+  const [deploymentStrategy, setDeploymentStrategy] = React.useState<DeploymentStrategyFieldData>(
+    () => existingData || clusterDefault,
+  );
+
+  React.useEffect(() => {
+    if (!existingData && !hasInitializedRef.current) {
+      hasInitializedRef.current = true;
+      setDeploymentStrategy(clusterDefault);
+    }
+  }, [clusterDefault, existingData]);
+
+  return {
+    data: deploymentStrategy,
+    setData: setDeploymentStrategy,
+  };
+};
+
+// Component
+type DeploymentStrategyFieldProps = {
+  value: DeploymentStrategyFieldData;
+  onChange: (value: DeploymentStrategyFieldData) => void;
+  isDisabled?: boolean;
+};
+
+export const DeploymentStrategyField: React.FC<DeploymentStrategyFieldProps> = ({
+  value,
+  onChange,
+  isDisabled = false,
+}) => {
+  return (
+    <Stack hasGutter>
+      <StackItem>
+        <Radio
+          id="deployment-strategy-rolling"
+          name="deployment-strategy"
+          label={<span className="pf-v6-u-font-weight-bold">Rolling update</span>}
+          description={
+            <>
+              Existing inference service pods are terminated <u>after</u> new ones are started. This
+              ensures zero downtime and continuous availability.
+            </>
+          }
+          isChecked={value === 'rolling'}
+          onChange={() => onChange('rolling')}
+          isDisabled={isDisabled}
+          data-testid="deployment-strategy-rolling"
+        />
+      </StackItem>
+      <StackItem>
+        <Radio
+          id="deployment-strategy-recreate"
+          name="deployment-strategy"
+          label={<span className="pf-v6-u-font-weight-bold">Recreate</span>}
+          description={
+            <>
+              All existing inference service pods are terminated <u>before</u> any new ones are
+              started. This saves resources but guarantees a period of downtime.
+            </>
+          }
+          isChecked={value === 'recreate'}
+          onChange={() => onChange('recreate')}
+          isDisabled={isDisabled}
+          data-testid="deployment-strategy-recreate"
+        />
+      </StackItem>
+    </Stack>
+  );
+};
diff --git a/packages/model-serving/src/components/deploymentWizard/steps/AdvancedOptionsStep.tsx b/packages/model-serving/src/components/deploymentWizard/steps/AdvancedOptionsStep.tsx
@@ -13,6 +13,7 @@ import { ExternalRouteField } from '../fields/ExternalRouteField';
 import { TokenAuthenticationField } from '../fields/TokenAuthenticationField';
 import { RuntimeArgsField } from '../fields/RuntimeArgsField';
 import { EnvironmentVariablesField } from '../fields/EnvironmentVariablesField';
+import { DeploymentStrategyField } from '../fields/DeploymentStrategyField';
 import { UseModelDeploymentWizardState } from '../useDeploymentWizard';
 import { AvailableAiAssetsFieldsComponent } from '../fields/ModelAvailabilityFields';
 import { showAuthWarning } from '../hooks/useAuthWarning';
@@ -51,6 +52,11 @@ export const AdvancedSettingsStepContent: React.FC<AdvancedSettingsStepContentPr
     wizardState.state.modelServer.data,
   ]);
 
+  const isLlmdSelected = React.useMemo(() => {
+    const modelServerData = wizardState.state.modelServer.data;
+    return modelServerData?.name === 'llmd-serving';
+  }, [wizardState.state.modelServer.data]);
+
   const getKServeContainer = (
     servingRuntime?: ServingRuntimeKind,
   ): ServingContainer | undefined => {
@@ -192,6 +198,21 @@ export const AdvancedSettingsStepContent: React.FC<AdvancedSettingsStepContentPr
                 </Stack>
               </FormGroup>
             </StackItem>
+            {!isLlmdSelected && (
+              <StackItem>
+                <FormGroup
+                  label="Deployment strategy"
+                  data-testid="deployment-strategy-section"
+                  fieldId="deployment-strategy"
+                >
+                  <DeploymentStrategyField
+                    value={wizardState.state.deploymentStrategy.data}
+                    onChange={wizardState.state.deploymentStrategy.setData}
+                    isDisabled={!allowCreate}
+                  />
+                </FormGroup>
+              </StackItem>
+            )}
           </Stack>
         </FormSection>
       </Form>
diff --git a/packages/model-serving/src/components/deploymentWizard/steps/ReviewStep.tsx b/packages/model-serving/src/components/deploymentWizard/steps/ReviewStep.tsx
@@ -307,6 +307,18 @@ const getStatusSections = (projectName: string): StatusSection[] => [
         },
         optional: true,
       },
+      {
+        key: 'deploymentStrategy',
+        label: 'Deployment strategy',
+        comp: (state) => {
+          const strategy = state.deploymentStrategy.data;
+          return strategy === 'recreate' ? 'Recreate' : 'Rolling update';
+        },
+        isVisible: (wizardState) => {
+          const modelServerData = wizardState.state.modelServer.data;
+          return modelServerData?.name !== 'llmd-serving';
+        },
+      },
     ],
   },
 ];
diff --git a/packages/model-serving/src/components/deploymentWizard/types.ts b/packages/model-serving/src/components/deploymentWizard/types.ts
@@ -19,6 +19,7 @@ import type { useModelLocationData } from './fields/ModelLocationInputFields';
 import type { useNumReplicasField } from './fields/NumReplicasField';
 import type { useRuntimeArgsField } from './fields/RuntimeArgsField';
 import type { useTokenAuthenticationField } from './fields/TokenAuthenticationField';
+import type { useDeploymentStrategyField } from './fields/DeploymentStrategyField';
 import {
   useCreateConnectionData,
   type CreateConnectionData,
@@ -67,6 +68,7 @@ export type InitialWizardFormData = {
   initSelectedConnection?: LabeledConnection | undefined;
   modelAvailability?: ModelAvailabilityFieldsData;
   createConnectionData?: CreateConnectionData;
+  deploymentStrategy?: DeploymentStrategyFieldData;
   // Add more field handlers as needed
 };
 
@@ -86,6 +88,7 @@ export type WizardFormData = {
     modelAvailability: ReturnType<typeof useModelAvailabilityFields>;
     modelServer: ReturnType<typeof useModelServerSelectField>;
     createConnectionData: ReturnType<typeof useCreateConnectionData>;
+    deploymentStrategy: ReturnType<typeof useDeploymentStrategyField>;
   };
 };
 // wizard form data
@@ -104,6 +107,7 @@ export type HardwareProfileConfigFieldData =
   WizardFormData['state']['hardwareProfileConfig']['formData'];
 export type ModelFormatFieldData = WizardFormData['state']['modelFormatState']['modelFormat'];
 export type ModelAvailabilityFieldsData = WizardFormData['state']['modelAvailability']['data'];
+export type DeploymentStrategyFieldData = WizardFormData['state']['deploymentStrategy']['data'];
 
 // extensible fields
 
diff --git a/packages/model-serving/src/components/deploymentWizard/useDeploymentWizard.ts b/packages/model-serving/src/components/deploymentWizard/useDeploymentWizard.ts
@@ -16,6 +16,7 @@ import { useRuntimeArgsField } from './fields/RuntimeArgsField';
 import { useEnvironmentVariablesField } from './fields/EnvironmentVariablesField';
 import { useModelAvailabilityFields } from './fields/ModelAvailabilityFields';
 import { useModelServerSelectField } from './fields/ModelServerTemplateSelectField';
+import { useDeploymentStrategyField } from './fields/DeploymentStrategyField';
 import {
   isExternalRouteField,
   isTokenAuthField,
@@ -170,6 +171,9 @@ export const useModelDeploymentWizard = (
   const environmentVariables = useEnvironmentVariablesField(
     initialData?.environmentVariables ?? undefined,
   );
+  const deploymentStrategy = useDeploymentStrategyField(
+    initialData?.deploymentStrategy ?? undefined,
+  );
 
   // Step 4: Summary
 
@@ -192,6 +196,7 @@ export const useModelDeploymentWizard = (
       environmentVariables,
       modelAvailability,
       modelServer,
+      deploymentStrategy,
     },
     loaded: {
       modelSourceLoaded,
diff --git a/packages/model-serving/src/components/deploymentWizard/useExtractFormDataFromDeployment.ts b/packages/model-serving/src/components/deploymentWizard/useExtractFormDataFromDeployment.ts
@@ -6,6 +6,7 @@ import {
   getModelTypeFromDeployment,
   getExternalRouteFromDeployment,
   getTokenAuthenticationFromDeployment,
+  getDeploymentStrategyFromDeployment,
 } from './utils';
 import {
   type Deployment,
@@ -138,6 +139,9 @@ export const useExtractFormDataFromDeployment = (
       // Include existing authentication tokens
       existingAuthTokens: deploymentSecrets,
 
+      // Extract deployment strategy configuration
+      deploymentStrategy: getDeploymentStrategyFromDeployment(deployment),
+
       // Extract runtime arguments if available
       runtimeArgs:
         typeof formDataExtension?.properties.extractRuntimeArgs === 'function'
diff --git a/packages/model-serving/src/components/deploymentWizard/utils.ts b/packages/model-serving/src/components/deploymentWizard/utils.ts
