@spinnaker/amazon 0.11.1 → 0.12.3

package/src/serverGroup/configure/{serverGroupCommandBuilder.service.js → serverGroupCommandBuilder.service.ts}

@@ -1,6 +1,8 @@
+import type { IQService } from 'angular';
 import * as angular from 'angular';
 import _ from 'lodash';
 
+import type { Application, InstanceTypeService } from '@spinnaker/core';
 import {
   AccountService,
   DeploymentStrategyRegistry,
@@ -8,13 +10,45 @@ import {
   NameUtils,
   SubnetReader,
 } from '@spinnaker/core';
-import { AWSProviderSettings } from '../../aws.settings';
 
+import { AWSProviderSettings } from '../../aws.settings';
+import type { IAmazonLaunchTemplateOverrides, ILaunchTemplateData } from '../../domain';
+import type { IAmazonServerGroup, IAmazonServerGroupView, INetworkInterface } from '../../domain';
+import type {
+  AwsServerGroupConfigurationService,
+  IAmazonInstanceTypeOverride,
+  IAmazonServerGroupCommand,
+  IAmazonServerGroupCommandViewState,
+  IAmazonServerGroupDeployConfiguration,
+} from './serverGroupConfiguration.service';
 import { AWS_SERVER_GROUP_CONFIGURATION_SERVICE } from './serverGroupConfiguration.service';
 
 export const AMAZON_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE =
   'spinnaker.amazon.serverGroupCommandBuilder.service';
 export const name = AMAZON_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE; // for backwards compatibility
+
+export interface AwsServerGroupCommandBuilder {
+  buildNewServerGroupCommand(
+    application: Application,
+    defaults?: { account?: string; region?: string; subnet?: string; mode?: string },
+  ): PromiseLike<Partial<IAmazonServerGroupCommand>>;
+
+  buildServerGroupCommandFromExisting(
+    application: Application,
+    serverGroup: IAmazonServerGroupView,
+    mode?: string,
+  ): PromiseLike<Partial<IAmazonServerGroupCommand>>;
+
+  buildNewServerGroupCommandForPipeline(): PromiseLike<Partial<IAmazonServerGroupCommand>>;
+
+  buildServerGroupCommandFromPipeline(
+    application: Application,
+    originalCluster: IAmazonServerGroupDeployConfiguration,
+  ): PromiseLike<Partial<IAmazonServerGroupCommand>>;
+
+  buildUpdateServerGroupCommand(serverGroup: IAmazonServerGroup): Partial<IAmazonServerGroupCommand>;
+}
+
 angular
   .module(AMAZON_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE, [
     INSTANCE_TYPE_SERVICE,
@@ -24,9 +58,15 @@ angular
     '$q',
     'instanceTypeService',
     'awsServerGroupConfigurationService',
-    function ($q, instanceTypeService, awsServerGroupConfigurationService) {
-      function buildNewServerGroupCommand(application, defaults) {
-        defaults = defaults || {};
+    function (
+      $q: IQService,
+      instanceTypeService: InstanceTypeService,
+      awsServerGroupConfigurationService: AwsServerGroupConfigurationService,
+    ) {
+      function buildNewServerGroupCommand(
+        application: Application,
+        defaults: { account?: string; region?: string; subnet?: string; mode?: string } = {},
+      ) {
         const credentialsLoader = AccountService.getCredentialsKeyedByAccount('aws');
 
         const defaultCredentials =
@@ -45,14 +85,14 @@ angular
           .then(function ([preferredZones, credentialsKeyedByAccount]) {
             const credentials = credentialsKeyedByAccount[defaultCredentials];
             const keyPair = credentials ? credentials.defaultKeyPair : null;
-            const applicationAwsSettings = _.get(application, 'attributes.providerSettings.aws', {});
+            const applicationAwsSettings = application.attributes?.providerSettings?.aws ?? {};
 
             let defaultIamRole = AWSProviderSettings.defaults.iamRole || 'BaseIAMRole';
             defaultIamRole = defaultIamRole.replace('{{application}}', application.name);
 
             const useAmiBlockDeviceMappings = applicationAwsSettings.useAmiBlockDeviceMappings || false;
 
-            const command = {
+            const command: Partial<IAmazonServerGroupCommand> = {
               application: application.name,
               credentials: defaultCredentials,
               region: defaultRegion,
@@ -86,6 +126,7 @@ angular
               copySourceCustomBlockDeviceMappings: false, // default to using block device mappings from current instance type
               viewState: {
                 instanceProfile: 'custom',
+                useSimpleInstanceTypeSelector: true,
                 useAllImageSelection: false,
                 useSimpleCapacity: true,
                 usePreferredZones: true,
@@ -93,47 +134,46 @@ angular
                 disableStrategySelection: true,
                 dirty: {},
                 submitButtonLabel: getSubmitButtonLabel(defaults.mode || 'create'),
-              },
+              } as IAmazonServerGroupCommandViewState,
             };
 
-            if (
-              application.attributes &&
-              application.attributes.platformHealthOnlyShowOverride &&
-              application.attributes.platformHealthOnly
-            ) {
+            if (application.attributes?.platformHealthOnlyShowOverride && application.attributes?.platformHealthOnly) {
               command.interestingHealthProviderNames = ['Amazon'];
             }
 
-            if (
-              defaultCredentials === 'test' &&
-              AWSProviderSettings.serverGroups &&
-              AWSProviderSettings.serverGroups.enableIPv6
-            ) {
+            if (defaultCredentials === 'test' && AWSProviderSettings.serverGroups?.enableIPv6) {
               command.associateIPv6Address = true;
             }
 
-            if (AWSProviderSettings.serverGroups && AWSProviderSettings.serverGroups.enableIMDSv2) {
+            if (AWSProviderSettings.serverGroups?.enableIMDSv2) {
               /**
                * Older SDKs do not support IMDSv2. A timestamp can be optionally configured at which any apps created after can safely default to using IMDSv2.
                */
               const appAgeRequirement = AWSProviderSettings.serverGroups.defaultIMDSv2AppAgeLimit;
-              const creationDate = application.attributes && application.attributes.createTs;
+              const creationDate = application.attributes?.createTs;
 
-              command.requireIMDSv2 =
-                appAgeRequirement && creationDate && Number(creationDate) > appAgeRequirement ? true : false;
+              command.requireIMDSv2 = appAgeRequirement && creationDate && Number(creationDate) > appAgeRequirement;
             }
 
             return command;
           });
       }
 
-      function buildServerGroupCommandFromPipeline(application, originalCluster) {
+      function buildServerGroupCommandFromPipeline(
+        application: Application,
+        originalCluster: IAmazonServerGroupDeployConfiguration,
+      ) {
         const pipelineCluster = _.cloneDeep(originalCluster);
         const region = Object.keys(pipelineCluster.availabilityZones)[0];
-        const instanceTypeCategoryLoader = instanceTypeService.getCategoryForInstanceType(
+
+        const instanceTypes = pipelineCluster.launchTemplateOverridesForInstanceType
+          ? pipelineCluster.launchTemplateOverridesForInstanceType.map((o) => o.instanceType)
+          : [pipelineCluster.instanceType];
+        const instanceTypeCategoryLoader = instanceTypeService.getCategoryForMultipleInstanceTypes(
           'aws',
-          pipelineCluster.instanceType,
+          instanceTypes,
         );
+
         const commandOptions = { account: pipelineCluster.account, region: region };
         const asyncLoader = $q.all([
           buildNewServerGroupCommand(application, commandOptions),
@@ -156,6 +196,7 @@ angular
             templatingEnabled: true,
             existingPipelineCluster: true,
             dirty: {},
+            useSimpleInstanceTypeSelector: isSimpleModeEnabled(pipelineCluster),
           };
 
           const viewOverrides = {
@@ -177,11 +218,11 @@ angular
         return $q.when({
           viewState: {
             requiresTemplateSelection: true,
-          },
+          } as IAmazonServerGroupCommandViewState,
         });
       }
 
-      function getSubmitButtonLabel(mode) {
+      function getSubmitButtonLabel(mode: string) {
         switch (mode) {
           case 'createPipeline':
             return 'Add';
@@ -194,38 +235,52 @@ angular
         }
       }
 
-      function buildUpdateServerGroupCommand(serverGroup) {
-        const command = {
+      function buildUpdateServerGroupCommand(serverGroup: IAmazonServerGroup) {
+        const command = ({
           type: 'modifyAsg',
           asgs: [{ asgName: serverGroup.name, region: serverGroup.region }],
           cooldown: serverGroup.asg.defaultCooldown,
-          enabledMetrics: _.get(serverGroup, 'asg.enabledMetrics', []).map((m) => m.metric),
+          enabledMetrics: (serverGroup.asg?.enabledMetrics ?? []).map((m) => m.metric),
           healthCheckGracePeriod: serverGroup.asg.healthCheckGracePeriod,
           healthCheckType: serverGroup.asg.healthCheckType,
           terminationPolicies: angular.copy(serverGroup.asg.terminationPolicies),
           credentials: serverGroup.account,
           capacityRebalance: serverGroup.asg.capacityRebalance,
-        };
+        } as Partial<IAmazonServerGroupCommand>) as IAmazonServerGroupCommand;
         awsServerGroupConfigurationService.configureUpdateCommand(command);
         return command;
       }
 
-      function buildServerGroupCommandFromExisting(application, serverGroup, mode = 'clone') {
+      function buildServerGroupCommandFromExisting(
+        application: Application,
+        serverGroup: IAmazonServerGroupView,
+        mode = 'clone',
+      ) {
         const preferredZonesLoader = AccountService.getPreferredZonesByAccount('aws');
         const subnetsLoader = SubnetReader.listSubnets();
 
         const serverGroupName = NameUtils.parseServerGroupName(serverGroup.asg.autoScalingGroupName);
 
-        const instanceType = serverGroup.launchConfig
-          ? serverGroup.launchConfig.instanceType
-          : serverGroup.launchTemplate
-          ? serverGroup.launchTemplate.launchTemplateData.instanceType
-          : null;
-        const instanceTypeCategoryLoader = instanceTypeService.getCategoryForInstanceType('aws', instanceType);
+        let instanceTypes;
+        if (serverGroup.mixedInstancesPolicy) {
+          const ltOverrides = serverGroup.mixedInstancesPolicy?.launchTemplateOverridesForInstanceType;
+          // note: single launch template case is currently the only supported case for mixed instances policy
+          instanceTypes = ltOverrides
+            ? ltOverrides.map((o) => o.instanceType)
+            : [serverGroup.mixedInstancesPolicy?.launchTemplates[0]?.launchTemplateData?.instanceType];
+        } else if (serverGroup.launchTemplate) {
+          instanceTypes = [_.get(serverGroup, 'launchTemplate.launchTemplateData.instanceType')];
+        } else if (serverGroup.launchConfig) {
+          instanceTypes = [_.get(serverGroup, 'launchConfig.instanceType')];
+        }
+        const instanceTypeCategoryLoader = instanceTypeService.getCategoryForMultipleInstanceTypes(
+          'aws',
+          instanceTypes,
+        );
 
         return $q
           .all([preferredZonesLoader, subnetsLoader, instanceTypeCategoryLoader])
-          .then(function ([preferredZones, subnets, instanceProfile]) {
+          .then(([preferredZones, subnets, instanceProfile]) => {
             const zones = serverGroup.asg.availabilityZones.sort();
             let usePreferredZones = false;
             const preferredZonesForAccount = preferredZones[serverGroup.account];
@@ -237,10 +292,10 @@ angular
             // These processes should never be copied over, as the affect launching instances and enabling traffic
             const enabledProcesses = ['Launch', 'Terminate', 'AddToLoadBalancer'];
 
-            const applicationAwsSettings = _.get(application, 'attributes.providerSettings.aws', {});
+            const applicationAwsSettings = application.attributes?.providerSettings?.aws ?? {};
             const useAmiBlockDeviceMappings = applicationAwsSettings.useAmiBlockDeviceMappings || false;
 
-            const existingTags = {};
+            const existingTags: { [key: string]: string } = {};
             // These tags are applied by Clouddriver (if configured to do so), regardless of what the user might enter
             // Might be worth feature flagging this if it turns out other folks are hard-coding these values
             const reservedTags = ['spinnaker:application', 'spinnaker:stack', 'spinnaker:details'];
@@ -252,7 +307,7 @@ angular
                 });
             }
 
-            const command = {
+            const command: Partial<IAmazonServerGroupCommand> = {
               application: application.name,
               strategy: '',
               stack: serverGroupName.stack,
@@ -295,14 +350,10 @@ angular
                 submitButtonLabel: getSubmitButtonLabel(mode),
                 isNew: false,
                 dirty: {},
-              },
+              } as IAmazonServerGroupCommandViewState,
             };
 
-            if (
-              application.attributes &&
-              application.attributes.platformHealthOnlyShowOverride &&
-              application.attributes.platformHealthOnly
-            ) {
+            if (application.attributes?.platformHealthOnlyShowOverride && application.attributes?.platformHealthOnly) {
               command.interestingHealthProviderNames = ['Amazon'];
             }
 
@@ -318,7 +369,7 @@ angular
             const vpcZoneIdentifier = serverGroup.asg.vpczoneIdentifier;
             if (vpcZoneIdentifier !== '') {
               const subnetId = vpcZoneIdentifier.split(',')[0];
-              const subnet = _.chain(subnets).find({ id: subnetId }).value();
+              const subnet = subnets.find((x) => x.id === subnetId);
               command.subnetType = subnet.purpose;
               command.vpcId = subnet.vpcId;
             } else {
@@ -333,7 +384,8 @@ angular
                 keyPair: serverGroup.launchConfig.keyName,
                 associatePublicIpAddress: serverGroup.launchConfig.associatePublicIpAddress,
                 ramdiskId: serverGroup.launchConfig.ramdiskId,
-                instanceMonitoring: serverGroup.launchConfig.instanceMonitoring.enabled,
+                instanceMonitoring:
+                  serverGroup.launchConfig.instanceMonitoring && serverGroup.launchConfig.instanceMonitoring.enabled,
                 ebsOptimized: serverGroup.launchConfig.ebsOptimized,
                 spotPrice: serverGroup.launchConfig.spotPrice,
               });
@@ -341,18 +393,46 @@ angular
                 command.base64UserData = serverGroup.launchConfig.userData;
               }
               command.viewState.imageId = serverGroup.launchConfig.imageId;
+              command.viewState.useSimpleInstanceTypeSelector = true;
             }
 
-            if (serverGroup.launchTemplate) {
-              const { launchTemplateData } = serverGroup.launchTemplate;
-              const maxPrice =
-                launchTemplateData.instanceMarketOptions &&
-                launchTemplateData.instanceMarketOptions.spotOptions &&
-                launchTemplateData.instanceMarketOptions.spotOptions.maxPrice;
-              const { ipv6AddressCount } =
-                launchTemplateData.networkInterfaces &&
-                launchTemplateData.networkInterfaces.length &&
-                launchTemplateData.networkInterfaces[0];
+            if (serverGroup.launchTemplate || serverGroup.mixedInstancesPolicy) {
+              let launchTemplateData: ILaunchTemplateData, spotMaxPrice: string;
+              if (serverGroup.launchTemplate) {
+                launchTemplateData = serverGroup.launchTemplate.launchTemplateData;
+                spotMaxPrice = launchTemplateData.instanceMarketOptions?.spotOptions?.maxPrice;
+                command.instanceType = launchTemplateData.instanceType;
+                command.viewState.useSimpleInstanceTypeSelector = true;
+              }
+
+              if (serverGroup.mixedInstancesPolicy) {
+                const mip = serverGroup.mixedInstancesPolicy;
+                // note: single launch template case is currently the only supported case for mixed instances policy
+                launchTemplateData = mip?.launchTemplates?.[0]?.launchTemplateData;
+                spotMaxPrice = mip?.instancesDistribution?.spotMaxPrice;
+                command.securityGroups = launchTemplateData.networkInterfaces
+                  ? (launchTemplateData.networkInterfaces.find((ni) => ni.deviceIndex === 0) ?? {}).groups
+                  : launchTemplateData.securityGroups;
+                command.onDemandAllocationStrategy = mip.instancesDistribution.onDemandAllocationStrategy;
+                command.onDemandBaseCapacity = mip.instancesDistribution.onDemandBaseCapacity;
+                command.onDemandPercentageAboveBaseCapacity =
+                  mip.instancesDistribution.onDemandPercentageAboveBaseCapacity;
+                command.spotAllocationStrategy = mip.instancesDistribution.spotAllocationStrategy;
+                command.spotInstancePools = mip.instancesDistribution.spotInstancePools;
+
+                // 'launchTemplateOverridesForInstanceType' is used for multiple instance types case, 'instanceType' is used for all other cases.
+                if (mip.launchTemplateOverridesForInstanceType) {
+                  command.launchTemplateOverridesForInstanceType = getInstanceTypesWithPriority(
+                    mip.launchTemplateOverridesForInstanceType,
+                  );
+                } else {
+                  command.instanceType = launchTemplateData.instanceType;
+                }
+
+                command.viewState.useSimpleInstanceTypeSelector = isSimpleModeEnabled(command);
+              }
+
+              const ipv6AddressCount = _.get(launchTemplateData, 'networkInterfaces[0]');
 
               const asgSettings = AWSProviderSettings.serverGroups;
               const isTestEnv = serverGroup.accountDetails && serverGroup.accountDetails.environment === 'test';
@@ -360,17 +440,14 @@ angular
                 asgSettings && asgSettings.enableIPv6 && asgSettings.setIPv6InTest && isTestEnv;
 
               angular.extend(command, {
-                instanceType: launchTemplateData.instanceType,
                 iamRole: launchTemplateData.iamInstanceProfile.name,
                 keyPair: launchTemplateData.keyName,
                 associateIPv6Address: shouldAutoEnableIPv6 || Boolean(ipv6AddressCount),
                 ramdiskId: launchTemplateData.ramdiskId,
-                instanceMonitoring: launchTemplateData.monitoring.enabled,
+                instanceMonitoring: launchTemplateData.monitoring && launchTemplateData.monitoring.enabled,
                 ebsOptimized: launchTemplateData.ebsOptimized,
-                spotPrice: maxPrice || undefined,
-                requireIMDSv2: Boolean(
-                  launchTemplateData.metadataOptions && launchTemplateData.metadataOptions.httpTokens === 'required',
-                ),
+                spotPrice: spotMaxPrice || undefined,
+                requireIMDSv2: Boolean(launchTemplateData.metadataOptions?.httpTokens === 'required'),
                 unlimitedCpuCredits: launchTemplateData.creditSpecification
                   ? launchTemplateData.creditSpecification.cpuCredits === 'unlimited'
                   : undefined,
@@ -393,8 +470,8 @@ angular
 
             if (serverGroup.launchTemplate && serverGroup.launchTemplate.launchTemplateData.networkInterfaces) {
               const networkInterface =
-                serverGroup.launchTemplate.launchTemplateData.networkInterfaces.find((ni) => ni.deviceIndex === 0) ||
-                {};
+                serverGroup.launchTemplate.launchTemplateData.networkInterfaces.find((ni) => ni.deviceIndex === 0) ??
+                ({} as INetworkInterface);
               command.securityGroups = networkInterface.groups;
             }
 
@@ -402,12 +479,44 @@ angular
           });
       }
 
+      // Since Deck allows changing priority of instance types via drag handle, fill priority field explicitly if empty
+      function getInstanceTypesWithPriority(
+        instanceTypeOverrides: IAmazonLaunchTemplateOverrides[],
+      ): IAmazonInstanceTypeOverride[] {
+        let explicitPriority = 1;
+        return _.sortBy(instanceTypeOverrides, ['priority']).map((override) => {
+          const { instanceType, weightedCapacity } = override;
+          let priority;
+          if (override.priority) {
+            priority = override.priority;
+            explicitPriority = override.priority + 1;
+          } else {
+            priority = explicitPriority++;
+          }
+          return { instanceType, weightedCapacity, priority };
+        });
+      }
+
+      function isSimpleModeEnabled(
+        command: IAmazonServerGroupDeployConfiguration | Partial<IAmazonServerGroupCommand>,
+      ) {
+        const isAdvancedModeEnabledInCommand =
+          command.onDemandAllocationStrategy ||
+          command.onDemandBaseCapacity ||
+          command.onDemandPercentageAboveBaseCapacity ||
+          command.spotAllocationStrategy ||
+          command.spotInstancePools ||
+          (command.launchTemplateOverridesForInstanceType && command.launchTemplateOverridesForInstanceType.length > 0);
+
+        return !isAdvancedModeEnabledInCommand;
+      }
+
       return {
-        buildNewServerGroupCommand: buildNewServerGroupCommand,
-        buildServerGroupCommandFromExisting: buildServerGroupCommandFromExisting,
-        buildNewServerGroupCommandForPipeline: buildNewServerGroupCommandForPipeline,
-        buildServerGroupCommandFromPipeline: buildServerGroupCommandFromPipeline,
-        buildUpdateServerGroupCommand: buildUpdateServerGroupCommand,
-      };
+        buildNewServerGroupCommand,
+        buildServerGroupCommandFromExisting,
+        buildNewServerGroupCommandForPipeline,
+        buildServerGroupCommandFromPipeline,
+        buildUpdateServerGroupCommand,
+      } as AwsServerGroupCommandBuilder;
     },
   ]);

package/src/serverGroup/configure/serverGroupCommandBuilder.spec.js

@@ -4,7 +4,11 @@ import { AccountService, SubnetReader } from '@spinnaker/core';
 
 import { AWSProviderSettings } from '../../aws.settings';
 
-import { createMockAmazonServerGroupWithLt, createCustomMockLaunchTemplate } from '@spinnaker/mocks';
+import {
+  createMockAmazonServerGroupWithLt,
+  createCustomMockLaunchTemplate,
+  mockLaunchTemplate,
+} from '@spinnaker/mocks';
 
 describe('awsServerGroupCommandBuilder', function () {
   const AccountServiceFixture = require('./AccountServiceFixtures');
@@ -64,7 +68,7 @@ describe('awsServerGroupCommandBuilder', function () {
 
   describe('buildServerGroupCommandFromExisting', function () {
     it('sets usePreferredZones flag based on initial value', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForInstanceType').and.returnValue(this.$q.when('custom'));
+      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(this.$q.when('custom'));
       const baseServerGroup = {
         account: 'prod',
         region: 'us-west-1',
@@ -72,6 +76,7 @@ describe('awsServerGroupCommandBuilder', function () {
           availabilityZones: ['g', 'h', 'i'],
           vpczoneIdentifier: '',
         },
+        launchTemplate: mockLaunchTemplate,
       };
       let command = null;
 
@@ -101,7 +106,9 @@ describe('awsServerGroupCommandBuilder', function () {
     });
 
     it('sets profile and instance type if available', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForInstanceType').and.returnValue(this.$q.when('selectedProfile'));
+      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
+        this.$q.when('selectedProfile'),
+      );
 
       const baseServerGroup = {
         account: 'prod',
@@ -131,7 +138,9 @@ describe('awsServerGroupCommandBuilder', function () {
     });
 
     it('copies suspended processes unless the mode is "editPipeline"', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForInstanceType').and.returnValue(this.$q.when('selectedProfile'));
+      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
+        this.$q.when('selectedProfile'),
+      );
 
       const baseServerGroup = {
         account: 'prod',
@@ -167,7 +176,9 @@ describe('awsServerGroupCommandBuilder', function () {
     });
 
     it('copies tags not in the reserved list:', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForInstanceType').and.returnValue(this.$q.when('selectedProfile'));
+      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
+        this.$q.when('selectedProfile'),
+      );
 
       const baseServerGroup = {
         account: 'prod',
@@ -208,7 +219,9 @@ describe('awsServerGroupCommandBuilder', function () {
     });
 
     it('sets unlimitedCpuCredits to false when building from source server group with standard credits', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForInstanceType').and.returnValue(this.$q.when('selectedProfile'));
+      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
+        this.$q.when('selectedProfile'),
+      );
 
       const baseServerGroup = createMockAmazonServerGroupWithLt(
         createCustomMockLaunchTemplate('testLtCpuCredits', {
@@ -229,7 +242,9 @@ describe('awsServerGroupCommandBuilder', function () {
     });
 
     it('sets unlimitedCpuCredits to true when building from source server group with unlimited credits', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForInstanceType').and.returnValue(this.$q.when('selectedProfile'));
+      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
+        this.$q.when('selectedProfile'),
+      );
 
       const baseServerGroup = createMockAmazonServerGroupWithLt(
         createCustomMockLaunchTemplate('testLtCpuCredits', {
@@ -250,7 +265,9 @@ describe('awsServerGroupCommandBuilder', function () {
     });
 
     it('sets unlimitedCpuCredits to undefined when building from source server group with cpu credits unset', function () {
-      spyOn(this.instanceTypeService, 'getCategoryForInstanceType').and.returnValue(this.$q.when('selectedProfile'));
+      spyOn(this.instanceTypeService, 'getCategoryForMultipleInstanceTypes').and.returnValue(
+        this.$q.when('selectedProfile'),
+      );
 
       const baseServerGroup = createMockAmazonServerGroupWithLt();
 

package/src/serverGroup/configure/serverGroupConfiguration.service.spec.ts

@@ -1,19 +1,12 @@
-import { mock, IQService, IScope, IRootScopeService } from 'angular';
+import type { IQService, IRootScopeService, IScope } from 'angular';
+import { mock } from 'angular';
 
-import {
-  AccountService,
-  ApplicationModelBuilder,
-  CacheInitializerService,
-  LoadBalancerReader,
-  SecurityGroupReader,
-  SubnetReader,
-} from '@spinnaker/core';
+import type { CacheInitializerService, LoadBalancerReader, SecurityGroupReader } from '@spinnaker/core';
+import { AccountService, ApplicationModelBuilder, SubnetReader } from '@spinnaker/core';
 
 import { KeyPairsReader } from '../../keyPairs';
-import {
-  AWS_SERVER_GROUP_CONFIGURATION_SERVICE,
-  AwsServerGroupConfigurationService,
-} from './serverGroupConfiguration.service';
+import type { AwsServerGroupConfigurationService } from './serverGroupConfiguration.service';
+import { AWS_SERVER_GROUP_CONFIGURATION_SERVICE } from './serverGroupConfiguration.service';
 
 describe('Service: awsServerGroupConfiguration', function () {
   let service: AwsServerGroupConfigurationService,

package/src/serverGroup/configure/serverGroupConfiguration.service.ts

@@ -80,15 +80,44 @@ export interface IAmazonServerGroupCommandBackingData extends IServerGroupComman
 }
 
 export interface IAmazonServerGroupCommandViewState extends IServerGroupCommandViewState {
+  isNew: boolean;
   dirty: IAmazonServerGroupCommandDirty;
   spelTargetGroups: string[];
   spelLoadBalancers: string[];
+  useSimpleInstanceTypeSelector: boolean;
+}
+
+export interface IAmazonInstanceTypeOverride {
+  instanceType: string;
+  weightedCapacity?: string;
+  priority?: number;
+}
+
+/**
+ * We model server group commands in two subtly different ways.
+ * It's unclear what the intention is, but we should converge on a single model eventually.
+ *
+ * This model is stored in a Aws Deploy Stage under `clusters[]`.
+ * It is also sent across the wire during a deploy task from infrastructure view
+ * (i.e., "clone server group", "create server group")
+ */
+export interface IAmazonServerGroupDeployConfiguration extends IAmazonServerGroupCommand_Internal {
+  account: string;
+  availabilityZones: {
+    [region: string]: string[];
+  };
+}
+
+interface IAmazonServerGroupCommand_Internal extends IAmazonServerGroupCommand {
+  // widen 'string[]' to 'any' so we can narrow it to an incompatible type in IAmazonServerGroupDeployConfiguration
+  availabilityZones: any;
 }
 
 export interface IAmazonServerGroupCommand extends IServerGroupCommand {
   associateIPv6Address?: boolean;
   associatePublicIpAddress: boolean;
   backingData: IAmazonServerGroupCommandBackingData;
+  base64UserData: string;
   copySourceCustomBlockDeviceMappings: boolean;
   ebsOptimized: boolean;
   healthCheckGracePeriod: number;
@@ -103,12 +132,25 @@ export interface IAmazonServerGroupCommand extends IServerGroupCommand {
   setLaunchTemplate?: boolean;
   unlimitedCpuCredits?: boolean;
   capacityRebalance?: boolean;
+  ramdiskId?: string;
   viewState: IAmazonServerGroupCommandViewState;
+  source: {
+    account: string;
+    region: string;
+    asgName: string;
+  };
+  onDemandAllocationStrategy?: string;
+  onDemandBaseCapacity?: number;
+  onDemandPercentageAboveBaseCapacity?: number;
+  spotAllocationStrategy?: string;
+  spotInstancePools?: number;
+  launchTemplateOverridesForInstanceType?: IAmazonInstanceTypeOverride[];
 
   getBlockDeviceMappingsSource: (command: IServerGroupCommand) => IBlockDeviceMappingSource;
   selectBlockDeviceMappingsSource: (command: IServerGroupCommand, selection: string) => void;
   usePreferredZonesChanged: (command: IServerGroupCommand) => IAmazonServerGroupCommandResult;
   regionIsDeprecated: (command: IServerGroupCommand) => boolean;
+  launchTemplateOverridesChanged: (command: IServerGroupCommand) => void;
 }
 
 export class AwsServerGroupConfigurationService {
@@ -643,10 +685,21 @@ export class AwsServerGroupConfigurationService {
     cmd.imageChanged = (command: IAmazonServerGroupCommand): IServerGroupCommandResult =>
       this.configureInstanceTypes(command);
 
+    // Handles derived values for single instance type case
     cmd.instanceTypeChanged = (command: IAmazonServerGroupCommand): void => {
       command.ebsOptimized = this.awsInstanceTypeService.isEbsOptimized(command.instanceType);
     };
 
+    // Handles derived values for multiple instance types case
+    cmd.launchTemplateOverridesChanged = (command: IAmazonServerGroupCommand): void => {
+      // set ebsOptimized to true if all instance types in overrides are included in the hard-coded array in awsInstanceTypeService.
+      // this function exists for backwards compatibility with single instance type case, matching behavior in `cmd.instanceTypeChanged`
+      // note: this parameter has no effect on instance types with EBS optimization enabled by default.
+      command.ebsOptimized = command.launchTemplateOverridesForInstanceType?.every((o) =>
+        this.awsInstanceTypeService.isEbsOptimized(o.instanceType),
+      );
+    };
+
     this.applyOverrides('attachEventHandlers', cmd);
   }
 }

package/src/serverGroup/configure/wizard/AmazonCloneServerGroupModal.tsx

@@ -207,7 +207,7 @@ export class AmazonCloneServerGroupModal extends React.Component<
             />
 
             <WizardPage
-              label="Instance Type"
+              label={command.viewState.useSimpleInstanceTypeSelector ? 'Instance Type' : 'Instance Types'}
               wizard={wizard}
               order={nextIdx()}
               render={({ innerRef }) => <ServerGroupInstanceType ref={innerRef} formik={formik} />}