@spinnaker/amazon 0.12.2 → 0.12.6

package/dist/reactShims/aws.react.injector.d.ts

@@ -3,11 +3,12 @@ import IInjectorService = angular.auto.IInjectorService;
 import type { FunctionReader } from '@spinnaker/core';
 import { ReactInject } from '@spinnaker/core';
 import type { EvaluateCloudFormationChangeSetExecutionService } from '../pipeline/stages/deployCloudFormation/evaluateCloudFormationChangeSetExecution.service';
+import type { AwsServerGroupCommandBuilder } from '../serverGroup/configure/serverGroupCommandBuilder.service';
 import type { AwsServerGroupConfigurationService } from '../serverGroup/configure/serverGroupConfiguration.service';
 import type { AwsServerGroupTransformer } from '../serverGroup/serverGroup.transformer';
 export declare class AwsReactInject extends ReactInject {
     get awsInstanceTypeService(): any;
-    get awsServerGroupCommandBuilder(): any;
+    get awsServerGroupCommandBuilder(): AwsServerGroupCommandBuilder;
     get awsServerGroupConfigurationService(): AwsServerGroupConfigurationService;
     get awsServerGroupTransformer(): AwsServerGroupTransformer;
     get functionReader(): FunctionReader;

package/dist/serverGroup/configure/serverGroupCommandBuilder.service.d.ts

@@ -1,2 +1,17 @@
-export const AMAZON_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE: "spinnaker.amazon.serverGroupCommandBuilder.service";
-export const name: "spinnaker.amazon.serverGroupCommandBuilder.service";
+import type { Application } from '@spinnaker/core';
+import type { IAmazonServerGroup, IAmazonServerGroupView } from '../../domain';
+import type { IAmazonServerGroupCommand, IAmazonServerGroupDeployConfiguration } from './serverGroupConfiguration.service';
+export declare const AMAZON_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE = "spinnaker.amazon.serverGroupCommandBuilder.service";
+export declare const name = "spinnaker.amazon.serverGroupCommandBuilder.service";
+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>;
+}

package/dist/serverGroup/configure/serverGroupConfiguration.service.d.ts

@@ -19,6 +19,7 @@ export interface IAmazonServerGroupCommandBackingData extends IServerGroupComman
     scalingProcesses: IScalingProcess[];
 }
 export interface IAmazonServerGroupCommandViewState extends IServerGroupCommandViewState {
+    isNew: boolean;
     dirty: IAmazonServerGroupCommandDirty;
     spelTargetGroups: string[];
     spelLoadBalancers: string[];
@@ -26,14 +27,31 @@ export interface IAmazonServerGroupCommandViewState extends IServerGroupCommandV
 }
 export interface IAmazonInstanceTypeOverride {
     instanceType: string;
-    weightedCapacity?: number;
+    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 {
+    availabilityZones: any;
+}
 export interface IAmazonServerGroupCommand extends IServerGroupCommand {
-    viewState: IAmazonServerGroupCommandViewState;
     associateIPv6Address?: boolean;
     associatePublicIpAddress: boolean;
     backingData: IAmazonServerGroupCommandBackingData;
+    base64UserData: string;
     copySourceCustomBlockDeviceMappings: boolean;
     ebsOptimized: boolean;
     healthCheckGracePeriod: number;
@@ -48,6 +66,13 @@ 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;
@@ -93,3 +118,4 @@ export declare class AwsServerGroupConfigurationService {
     attachEventHandlers(cmd: IAmazonServerGroupCommand): void;
 }
 export declare const AWS_SERVER_GROUP_CONFIGURATION_SERVICE = "spinnaker.amazon.serverGroup.configure.service";
+export {};

package/dist/serverGroup/serverGroup.transformer.d.ts

@@ -1,3 +1,4 @@
+import type { IAmazonServerGroupCommand, IAmazonServerGroupDeployConfiguration } from './configure';
 import type { IAmazonServerGroup, IAmazonServerGroupView, IScalingPolicy, IScalingPolicyView, ITargetTrackingPolicy } from '../domain';
 export declare class AwsServerGroupTransformer {
     private addComparator;
@@ -6,7 +7,7 @@ export declare class AwsServerGroupTransformer {
     normalizeServerGroupDetails(serverGroup: IAmazonServerGroup): IAmazonServerGroupView;
     normalizeServerGroup(serverGroup: IAmazonServerGroup): PromiseLike<IAmazonServerGroup>;
     private addVpcNameToServerGroup;
-    convertServerGroupCommandToDeployConfiguration(base: any): any;
+    convertServerGroupCommandToDeployConfiguration(base: IAmazonServerGroupCommand): IAmazonServerGroupDeployConfiguration;
     constructNewStepScalingPolicyTemplate(serverGroup: IAmazonServerGroup): IScalingPolicy;
     constructNewTargetTrackingPolicyTemplate(): ITargetTrackingPolicy;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@spinnaker/amazon",
   "license": "Apache-2.0",
-  "version": "0.12.2",
+  "version": "0.12.6",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
@@ -13,7 +13,7 @@
     "lib": "npm run build"
   },
   "dependencies": {
-    "@spinnaker/core": "^0.16.0",
+    "@spinnaker/core": "^0.19.0",
     "@uirouter/angularjs": "1.0.26",
     "@uirouter/core": "6.0.8",
     "@uirouter/react": "1.0.7",
@@ -55,5 +55,5 @@
     "shx": "0.3.3",
     "typescript": "4.3.5"
   },
-  "gitHead": "59026ea6af7b81ffb8e8c59e18f43396906ddafb"
+  "gitHead": "9f35728cf0ae71f5b28422920e4f802d92193845"
 }

package/src/domain/IAmazonLaunchTemplate.ts

@@ -39,7 +39,7 @@ export interface ILicenseConfig {
 export interface IMetadataOptions {
   httpEndpoint?: 'disabled' | 'enabled';
   httpPutResponseHopLimit?: number;
-  httpsTokens?: 'required' | 'optional';
+  httpTokens?: 'required' | 'optional';
   state?: 'pending' | 'applied';
 }
 

package/src/domain/IAmazonServerGroup.ts

@@ -5,16 +5,27 @@ import type { IScalingPolicyView } from './IAmazonScalingPolicy';
 import type { IScalingPolicy } from './IScalingPolicy';
 import type { ISuspendedProcess } from './IScalingProcess';
 
+export interface IAmazonAsgTag {
+  key: string;
+  value: string;
+  propagateAtLaunch: boolean;
+  resourceId: string;
+  resourceType: string;
+}
+
 export interface IAmazonAsg extends IAsg {
   availabilityZones: string[];
+  autoScalingGroupName: string;
   defaultCooldown: number;
   healthCheckType: string;
   healthCheckGracePeriod: number;
+  loadBalancerNames: string[];
   terminationPolicies: string[];
   enabledMetrics: Array<{ metric: string }>;
   vpczoneIdentifier?: string;
   suspendedProcesses?: ISuspendedProcess[];
   capacityRebalance?: boolean;
+  tags: IAmazonAsgTag[];
 }
 
 export interface IAmazonServerGroup extends IServerGroup {

package/src/reactShims/aws.react.injector.ts

@@ -3,6 +3,7 @@ import IInjectorService = angular.auto.IInjectorService;
 import type { FunctionReader } from '@spinnaker/core';
 import { ReactInject } from '@spinnaker/core';
 import type { EvaluateCloudFormationChangeSetExecutionService } from '../pipeline/stages/deployCloudFormation/evaluateCloudFormationChangeSetExecution.service';
+import type { AwsServerGroupCommandBuilder } from '../serverGroup/configure/serverGroupCommandBuilder.service';
 
 import type { AwsServerGroupConfigurationService } from '../serverGroup/configure/serverGroupConfiguration.service';
 import type { AwsServerGroupTransformer } from '../serverGroup/serverGroup.transformer';
@@ -10,7 +11,7 @@ import type { AwsServerGroupTransformer } from '../serverGroup/serverGroup.trans
 // prettier-ignore
 export class AwsReactInject extends ReactInject {
   public get awsInstanceTypeService() { return this.$injector.get('awsInstanceTypeService') as any; }
-  public get awsServerGroupCommandBuilder() { return this.$injector.get('awsServerGroupCommandBuilder') as any; }
+  public get awsServerGroupCommandBuilder() { return this.$injector.get('awsServerGroupCommandBuilder') as AwsServerGroupCommandBuilder; }
   public get awsServerGroupConfigurationService() { return this.$injector.get('awsServerGroupConfigurationService') as AwsServerGroupConfigurationService; }
   public get awsServerGroupTransformer() { return this.$injector.get('awsServerGroupTransformer') as AwsServerGroupTransformer; }
 

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,
@@ -94,45 +134,39 @@ 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];
 
-        let instanceTypes = pipelineCluster.launchTemplateOverridesForInstanceType
+        const instanceTypes = pipelineCluster.launchTemplateOverridesForInstanceType
           ? pipelineCluster.launchTemplateOverridesForInstanceType.map((o) => o.instanceType)
           : [pipelineCluster.instanceType];
         const instanceTypeCategoryLoader = instanceTypeService.getCategoryForMultipleInstanceTypes(
@@ -184,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';
@@ -201,33 +235,39 @@ 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);
 
         let instanceTypes;
         if (serverGroup.mixedInstancesPolicy) {
-          const ltOverrides = _.get(serverGroup, 'mixedInstancesPolicy.launchTemplateOverridesForInstanceType');
+          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)
-            : [_.get(serverGroup, 'mixedInstancesPolicy.launchTemplates[0].launchTemplateData.instanceType')]; // note: single launch template case is currently the only supported case for mixed instances policy
+            : [serverGroup.mixedInstancesPolicy?.launchTemplates[0]?.launchTemplateData?.instanceType];
         } else if (serverGroup.launchTemplate) {
           instanceTypes = [_.get(serverGroup, 'launchTemplate.launchTemplateData.instanceType')];
         } else if (serverGroup.launchConfig) {
@@ -240,7 +280,7 @@ angular
 
         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];
@@ -252,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'];
@@ -267,7 +307,7 @@ angular
                 });
             }
 
-            const command = {
+            const command: Partial<IAmazonServerGroupCommand> = {
               application: application.name,
               strategy: '',
               stack: serverGroupName.stack,
@@ -310,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'];
             }
 
@@ -333,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 {
@@ -361,23 +397,22 @@ angular
             }
 
             if (serverGroup.launchTemplate || serverGroup.mixedInstancesPolicy) {
-              let launchTemplateData, spotMaxPrice;
+              let launchTemplateData: ILaunchTemplateData, spotMaxPrice: string;
               if (serverGroup.launchTemplate) {
                 launchTemplateData = serverGroup.launchTemplate.launchTemplateData;
-                spotMaxPrice = _.get(launchTemplateData, 'instanceMarketOptions.spotOptions.maxPrice');
-
+                spotMaxPrice = launchTemplateData.instanceMarketOptions?.spotOptions?.maxPrice;
                 command.instanceType = launchTemplateData.instanceType;
                 command.viewState.useSimpleInstanceTypeSelector = true;
               }
 
               if (serverGroup.mixedInstancesPolicy) {
                 const mip = serverGroup.mixedInstancesPolicy;
-                launchTemplateData = _.get(mip, 'launchTemplates[0].launchTemplateData'); // note: single launch template case is currently the only supported case for mixed instances policy
-                spotMaxPrice = _.get(mip, 'instancesDistribution.spotMaxPrice');
-
+                // 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
-                  : _.get(launchTemplateData, 'securityGroups');
+                  ? (launchTemplateData.networkInterfaces.find((ni) => ni.deviceIndex === 0) ?? {}).groups
+                  : launchTemplateData.securityGroups;
                 command.onDemandAllocationStrategy = mip.instancesDistribution.onDemandAllocationStrategy;
                 command.onDemandBaseCapacity = mip.instancesDistribution.onDemandBaseCapacity;
                 command.onDemandPercentageAboveBaseCapacity =
@@ -412,9 +447,7 @@ angular
                 instanceMonitoring: launchTemplateData.monitoring && launchTemplateData.monitoring.enabled,
                 ebsOptimized: launchTemplateData.ebsOptimized,
                 spotPrice: spotMaxPrice || undefined,
-                requireIMDSv2: Boolean(
-                  launchTemplateData.metadataOptions && launchTemplateData.metadataOptions.httpsTokens === 'required',
-                ),
+                requireIMDSv2: Boolean(launchTemplateData.metadataOptions?.httpTokens === 'required'),
                 unlimitedCpuCredits: launchTemplateData.creditSpecification
                   ? launchTemplateData.creditSpecification.cpuCredits === 'unlimited'
                   : undefined,
@@ -437,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;
             }
 
@@ -447,7 +480,9 @@ angular
       }
 
       // Since Deck allows changing priority of instance types via drag handle, fill priority field explicitly if empty
-      function getInstanceTypesWithPriority(instanceTypeOverrides) {
+      function getInstanceTypesWithPriority(
+        instanceTypeOverrides: IAmazonLaunchTemplateOverrides[],
+      ): IAmazonInstanceTypeOverride[] {
         let explicitPriority = 1;
         return _.sortBy(instanceTypeOverrides, ['priority']).map((override) => {
           const { instanceType, weightedCapacity } = override;
@@ -462,7 +497,9 @@ angular
         });
       }
 
-      function isSimpleModeEnabled(command) {
+      function isSimpleModeEnabled(
+        command: IAmazonServerGroupDeployConfiguration | Partial<IAmazonServerGroupCommand>,
+      ) {
         const isAdvancedModeEnabledInCommand =
           command.onDemandAllocationStrategy ||
           command.onDemandBaseCapacity ||
@@ -475,11 +512,11 @@ angular
       }
 
       return {
-        buildNewServerGroupCommand: buildNewServerGroupCommand,
-        buildServerGroupCommandFromExisting: buildServerGroupCommandFromExisting,
-        buildNewServerGroupCommandForPipeline: buildNewServerGroupCommandForPipeline,
-        buildServerGroupCommandFromPipeline: buildServerGroupCommandFromPipeline,
-        buildUpdateServerGroupCommand: buildUpdateServerGroupCommand,
-      };
+        buildNewServerGroupCommand,
+        buildServerGroupCommandFromExisting,
+        buildNewServerGroupCommandForPipeline,
+        buildServerGroupCommandFromPipeline,
+        buildUpdateServerGroupCommand,
+      } as AwsServerGroupCommandBuilder;
     },
   ]);

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

@@ -80,6 +80,7 @@ export interface IAmazonServerGroupCommandBackingData extends IServerGroupComman
 }
 
 export interface IAmazonServerGroupCommandViewState extends IServerGroupCommandViewState {
+  isNew: boolean;
   dirty: IAmazonServerGroupCommandDirty;
   spelTargetGroups: string[];
   spelLoadBalancers: string[];
@@ -88,15 +89,35 @@ export interface IAmazonServerGroupCommandViewState extends IServerGroupCommandV
 
 export interface IAmazonInstanceTypeOverride {
   instanceType: string;
-  weightedCapacity?: number;
+  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 {
-  viewState: IAmazonServerGroupCommandViewState;
   associateIPv6Address?: boolean;
   associatePublicIpAddress: boolean;
   backingData: IAmazonServerGroupCommandBackingData;
+  base64UserData: string;
   copySourceCustomBlockDeviceMappings: boolean;
   ebsOptimized: boolean;
   healthCheckGracePeriod: number;
@@ -111,6 +132,13 @@ 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;

package/src/serverGroup/configure/wizard/instanceType/advancedMode/InstanceTypeTable.tsx

@@ -52,14 +52,15 @@ export function InstanceTypeTable(props: IInstanceTypeTableProps) {
 
   const addOrUpdateInstanceType = (type: string, weight: string) => {
     const weightNum = Number(weight);
+    const weightedCapacity = isNaN(weightNum) || weightNum === 0 ? undefined : weightNum.toString();
     const itemToUpdate = selectedInstanceTypesMap.has(type)
       ? {
           ...selectedInstanceTypesMap.get(type), // update existing item
-          weightedCapacity: !isNaN(weightNum) && weightNum !== 0 ? weightNum : undefined,
+          weightedCapacity,
         }
       : {
           instanceType: type, // new item
-          weightedCapacity: !isNaN(weightNum) && weightNum !== 0 ? weightNum : undefined,
+          weightedCapacity,
           priority:
             1 +
             Array.from(selectedInstanceTypesMap.values()).reduce(

package/src/serverGroup/configure/wizard/pages/ServerGroupInstanceType.tsx

@@ -65,7 +65,8 @@ export class ServerGroupInstanceType
     }
     if (
       some(weightsSpecified, function (instanceType) {
-        return instanceType.weightedCapacity < 1 || instanceType.weightedCapacity > 999;
+        const weightedCapacity = Number(instanceType.weightedCapacity);
+        return weightedCapacity < 1 || weightedCapacity > 999;
       })
     ) {
       errors.instanceType = 'Weighted capacity must be a number between 1 and 999.';