@spinnaker/amazon 0.13.0 → 0.13.1

package/dist/instance/awsInstanceType.service.d.ts

@@ -1,4 +1,4 @@
-import type { IInstanceTypeCategory, IPreferredInstanceType } from '@spinnaker/core';
+import type { IInstanceType, IInstanceTypeCategory, IInstanceTypesByRegion, IPreferredInstanceType } from '@spinnaker/core';
 export interface IAmazonPreferredInstanceType extends IPreferredInstanceType {
     cpuCreditsPerHour?: number;
 }
@@ -6,5 +6,45 @@ export interface IAmazonInstanceTypeCategory extends IInstanceTypeCategory {
     showCpuCredits?: boolean;
     descriptionListOverride?: string[];
 }
+export interface IAmazonInstanceType extends IInstanceType {
+    defaultVCpus: number;
+    memoryInGiB: number;
+    hypervisor: string;
+    instanceStorageInfo?: IAmazonInstanceTypeStorageInfo;
+    ebsInfo?: IAmazonInstanceTypeEbsInfo;
+    gpuInfo?: IAmazonInstanceGpuInfo;
+    instanceStorageSupported: boolean;
+    currentGeneration: boolean;
+    bareMetal: boolean;
+    ipv6Supported?: boolean;
+    burstablePerformanceSupported: boolean;
+    supportedArchitectures: string[];
+    supportedUsageClasses: string[];
+    supportedRootDeviceTypes: string[];
+    supportedVirtualizationTypes: string[];
+}
+export interface IAmazonInstanceTypeStorageInfo {
+    storageTypes: string;
+    totalSizeInGB?: number;
+    nvmeSupport?: string;
+}
+export interface IAmazonInstanceTypeEbsInfo {
+    ebsOptimizedSupport: string;
+    nvmeSupport?: string;
+    encryptionSupport: string;
+}
+export interface IAmazonInstanceGpuInfo {
+    totalGpuMemoryInMiB: number;
+    gpus: IAmazonInstanceGpuDeviceInfo[];
+}
+export interface IAmazonInstanceGpuDeviceInfo {
+    name: string;
+    manufacturer: string;
+    count: number;
+    gpuSizeInMiB: number;
+}
+export interface IAmazonInstanceTypesByRegion extends IInstanceTypesByRegion {
+    [region: string]: IAmazonInstanceType[];
+}
 export declare const AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE = "spinnaker.amazon.instanceType.service";
 export declare const name = "spinnaker.amazon.instanceType.service";

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

@@ -1,5 +1,6 @@
 import type { Application, CacheInitializerService, ISecurityGroup, IServerGroupCommand, IServerGroupCommandBackingData, IServerGroupCommandBackingDataFiltered, IServerGroupCommandDirty, IServerGroupCommandResult, IServerGroupCommandViewState, LoadBalancerReader, SecurityGroupReader, ServerGroupCommandRegistry } from '@spinnaker/core';
 import type { IAmazonLoadBalancerSourceData, IKeyPair, IScalingProcess } from '../../domain';
+import type { IAmazonInstanceType } from '../../instance/awsInstanceType.service';
 export declare type IBlockDeviceMappingSource = 'source' | 'ami' | 'default';
 export interface IAmazonServerGroupCommandDirty extends IServerGroupCommandDirty {
     targetGroups?: string[];
@@ -10,6 +11,7 @@ export interface IAmazonServerGroupCommandResult extends IServerGroupCommandResu
 export interface IAmazonServerGroupCommandBackingDataFiltered extends IServerGroupCommandBackingDataFiltered {
     keyPairs: string[];
     targetGroups: string[];
+    instanceTypesInfo: IAmazonInstanceType[];
 }
 export interface IAmazonServerGroupCommandBackingData extends IServerGroupCommandBackingData {
     appLoadBalancers: IAmazonLoadBalancerSourceData[];
@@ -17,6 +19,7 @@ export interface IAmazonServerGroupCommandBackingData extends IServerGroupComman
     keyPairs: IKeyPair[];
     targetGroups: string[];
     scalingProcesses: IScalingProcess[];
+    instanceTypesInfo: IAmazonInstanceType[];
 }
 export interface IAmazonServerGroupCommandViewState extends IServerGroupCommandViewState {
     isNew: boolean;
@@ -79,6 +82,7 @@ export interface IAmazonServerGroupCommand extends IServerGroupCommand {
     spotAllocationStrategy?: string;
     spotInstancePools?: number;
     launchTemplateOverridesForInstanceType?: IAmazonInstanceTypeOverride[];
+    amiArchitecture: string;
     getBlockDeviceMappingsSource: (command: IServerGroupCommand) => IBlockDeviceMappingSource;
     selectBlockDeviceMappingsSource: (command: IServerGroupCommand, selection: string) => void;
     usePreferredZonesChanged: (command: IServerGroupCommand) => IAmazonServerGroupCommandResult;

package/dist/serverGroup/configure/wizard/instanceType/advancedMode/AmazonInstanceTypeInfoRenderer.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import type { IAmazonInstanceType } from '../../../../../instance/awsInstanceType.service';
+export declare function AmazonInstanceTypeInfoRenderer(props: {
+    instanceType: IAmazonInstanceType;
+}): JSX.Element;

package/dist/serverGroup/configure/wizard/instanceType/advancedMode/InstanceTypeRow.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="react" />
 import type { IAmazonPreferredInstanceType } from '../../../../../instance/awsInstanceType.service';
+import type { IAmazonInstanceType } from '../../../../../instance/awsInstanceType.service';
 import type { IAmazonInstanceTypeOverride } from '../../../serverGroupConfiguration.service';
 export interface IRowProps {
     isCustom: boolean;
     selectedType?: IAmazonInstanceTypeOverride;
+    selectedTypeInfo?: IAmazonInstanceType;
     instanceTypeDetails?: IAmazonPreferredInstanceType;
     removeInstanceType?: (typeToRemove: string) => void;
     addOrUpdateInstanceType: (instanceType: string, weight: string) => void;

package/dist/serverGroup/configure/wizard/instanceType/advancedMode/InstanceTypeSelect.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import type { IAmazonInstanceType } from '../../../../../instance/awsInstanceType.service';
+export interface InstanceTypeSelectProps {
+    availableInstanceTypesList: IAmazonInstanceType[];
+    addOrUpdateInstanceType: (type: string, weight: string) => void;
+}
+export declare function InstanceTypeSelect(props: InstanceTypeSelectProps): JSX.Element;

package/dist/serverGroup/configure/wizard/instanceType/advancedMode/InstanceTypeTable.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="react" />
 import type { IAmazonInstanceTypeCategory } from '../../../../../instance/awsInstanceType.service';
+import type { IAmazonInstanceType } from '../../../../../instance/awsInstanceType.service';
 import type { IAmazonInstanceTypeOverride } from '../../../serverGroupConfiguration.service';
 import './advancedMode.less';
 export interface IInstanceTypeTableProps {
@@ -7,7 +8,7 @@ export interface IInstanceTypeTableProps {
     selectedInstanceTypesMap: Map<string, IAmazonInstanceTypeOverride>;
     unlimitedCpuCreditsInCmd: boolean;
     profileDetails: IAmazonInstanceTypeCategory;
-    availableInstanceTypesList: string[];
+    availableInstanceTypesList: IAmazonInstanceType[];
     handleInstanceTypesChange: (instanceTypes: IAmazonInstanceTypeOverride[]) => void;
     setUnlimitedCpuCredits: (unlimitedCpuCredits: boolean | undefined) => void;
 }

package/dist/serverGroup/configure/wizard/instanceType/advancedMode/InstanceTypeTableBody.d.ts

@@ -1,11 +1,13 @@
 /// <reference types="react" />
 import type { SortEnd } from 'react-sortable-hoc';
 import type { IInstanceTypeFamily } from '@spinnaker/core';
+import type { IAmazonInstanceType } from '../../../../../instance/awsInstanceType.service';
 import type { IAmazonInstanceTypeOverride } from '../../../serverGroupConfiguration.service';
 export declare function InstanceTypeTableBody(props: {
     isCustom: boolean;
     profileFamiliesDetails?: IInstanceTypeFamily[];
     selectedInstanceTypesMap: Map<string, IAmazonInstanceTypeOverride>;
+    selectedInstanceTypesInfo?: IAmazonInstanceType[];
     addOrUpdateInstanceType: (instanceType: string, weight: string) => void;
     removeInstanceType: (instanceType: string) => void;
     handleSortEnd: (sortEnd: SortEnd) => void;

package/dist/serverGroup/configure/wizard/instanceType/advancedMode/InstanceTypeTableParts.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="react" />
+import type { IAmazonInstanceType } from '../../../../../instance/awsInstanceType.service';
+import './advancedMode.less';
 export declare function Heading(props: {
     isCustom: boolean;
     profileLabel?: string;
@@ -10,6 +12,6 @@ export declare function Header(props: {
 }): JSX.Element;
 export declare function Footer(props: {
     isCustom: boolean;
-    availableInstanceTypesList: string[];
+    availableInstanceTypesList: IAmazonInstanceType[];
     addOrUpdateInstanceType: (type: string, weight: string) => void;
 }): JSX.Element;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@spinnaker/amazon",
   "license": "Apache-2.0",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
@@ -55,5 +55,5 @@
     "shx": "0.3.3",
     "typescript": "4.3.5"
   },
-  "gitHead": "3efb67c7d040c3b549e9d3f589663f4e70c74390"
+  "gitHead": "12dc0b2f8cb61cc6ee529fa1a017890390e69d54"
 }

package/src/help/amazon.help.ts

@@ -73,8 +73,26 @@ const helpContents: { [key: string]: string } = {
   'aws.serverGroup.odAllocationStrategy': `The only strategy / <b>default is 'prioritized'</b>. The order specified in the list of selected instance types is used to determine which instance type to use first when fulfilling On-Demand capacity.`,
   'aws.serverGroup.odBase': `Minimum amount of the Auto Scaling Group's capacity that must be fulfilled by On-Demand Instances. This base portion is provisioned first as the group scales. <b>Default: 0.</b>`,
   'aws.serverGroup.odPercentAboveBase': `Percentages of On-Demand and Spot instances for additional capacity beyond OnDemandBaseCapacity.<b>Default: 100.</b>`,
-  'aws.serverGroup.instanceTypeWeight': `The number of capacity units gives the instance type a proportional weight to other instance types. When specified, weights count towards desired capacity.`,
+  'aws.serverGroup.instanceTypeWeight': `The number of capacity units gives the instance type a proportional weight to other instance types. When specified, weights count towards desired capacity.
+Learn more in <a target="_blank" href="https://spinnaker.io/docs/setup/other_config/server-group-launch-settings/aws-ec2/launch-templates/#convert-a-server-group-with-launch-template-to-use-mixed-instances-policy-with-multiple-instance-types-and-capacity-weighting">examples and docs</a>.`,
   'aws.serverGroup.instanceTypes': `Specify up to 20 instance types.`,
+  'aws.serverGroup.instanceTypesSelect': `<p>Filter instance types on one or more criteria, comma separated:
+      <ul>
+        <li>Minimum vCPU e.g. 16vcpu</li>
+        <li>Minimum memory e.g. 32gib</li>
+        <li>Spot support</li>
+        <li>EBS support</li>
+        <li>GPU support</li>
+        <li>Instance storage type e.g. ssd</li>
+        <li>Generation with 'currentGen' / 'oldGen'</li>
+        <li>Instance family / size / type e.g. c3 / large / c3.large</li>
+      </ul>
+      Examples:
+      <ul>
+        <li>16vcpu, 32gib, spot, oldGen</li>
+        <li>medium, ebs</li>
+        <li>ssd,ebs,gpu,currentgen</li>
+      </ul>`,
   'aws.serverGroup.multipleInstanceTypes': `Instance types a server group can launch, first (highest priority) to last (lowest priority).`,
   'aws.serverGroup.unlimitedCpuCredits': `<p>CPU credits can be configured with 2 modes:</p><br/>
       <ul>

package/src/image/image.reader.ts

@@ -8,6 +8,7 @@ export interface IAmazonImage {
     [region: string]: string[];
   };
   attributes: {
+    architecture: string;
     creationDate: string;
     virtualizationType: string;
   };

package/src/instance/awsInstanceType.service.spec.js

@@ -12,20 +12,132 @@ describe('Service: InstanceType', function () {
       this.awsInstanceTypeService = _awsInstanceTypeService_;
 
       this.allTypes = [
-        { account: 'test', region: 'us-west-2', name: 'm1.small', availabilityZone: 'us-west-2a' },
-        { account: 'test', region: 'us-west-2', name: 'm2.xlarge', availabilityZone: 'us-west-2b' },
-        { account: 'test', region: 'eu-west-1', name: 'hs1.8xlarge', availabilityZone: 'eu-west-1c' },
-        { account: 'test', region: 'eu-west-1', name: 'm2.xlarge', availabilityZone: 'eu-west-1c' },
-        { account: 'test', region: 'us-east-1', name: 'm4.2xlarge', availabilityZone: 'us-east-1c' },
-        { account: 'test', region: 'us-east-1', name: 't2.nano', availabilityZone: 'us-east-1c' },
-        { account: 'test', region: 'us-east-1', name: 't2.micro', availabilityZone: 'us-east-1c' },
-        { account: 'test', region: 'us-east-1', name: 'm4.xlarge', availabilityZone: 'us-east-1c' },
-        { account: 'test', region: 'us-east-1', name: 'm4.4xlarge', availabilityZone: 'us-east-1c' },
-        { account: 'test', region: 'us-east-1', name: 't2.medium', availabilityZone: 'us-east-1c' },
-        { account: 'test', region: 'us-east-1', name: 'm4.large', availabilityZone: 'us-east-1c' },
-        { account: 'test', region: 'us-east-1', name: 'm4.16xlarge', availabilityZone: 'us-east-1c' },
-        { account: 'test', region: 'us-east-1', name: 'm4.10xlarge', availabilityZone: 'us-east-1c' },
-        { account: 'test', region: 'us-east-1', name: 't2.loltiny', availabilityZone: 'us-east-1c' },
+        {
+          account: 'test',
+          region: 'us-west-2',
+          name: 'm1.small',
+          defaultVCpus: 1,
+          memoryInGiB: 1,
+          supportedArchitectures: ['i386', 'x86_64'],
+          supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+        },
+        {
+          account: 'test',
+          region: 'us-west-2',
+          name: 'm2.xlarge',
+          defaultVCpus: 2,
+          memoryInGiB: 17,
+          supportedArchitectures: ['x86_64'],
+          supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+        },
+        {
+          account: 'test',
+          region: 'eu-west-1',
+          name: 'hs1.8xlarge',
+          defaultVCpus: 32,
+          memoryInGiB: 256,
+          supportedArchitectures: ['i386', 'x86_64'],
+          supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+        },
+        {
+          account: 'test',
+          region: 'eu-west-1',
+          name: 'm2.xlarge',
+          defaultVCpus: 2,
+          memoryInGiB: 17,
+          supportedArchitectures: ['x86_64'],
+          supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+        },
+        {
+          account: 'test',
+          region: 'us-east-1',
+          name: 'm4.2xlarge',
+          defaultVCpus: 8,
+          memoryInGiB: 32,
+          supportedArchitectures: ['x86_64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
+        {
+          account: 'test',
+          region: 'us-east-1',
+          name: 't2.nano',
+          defaultVCpus: 1,
+          memoryInGiB: 0,
+          supportedArchitectures: ['i386', 'x86_64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
+        {
+          account: 'test',
+          region: 'us-east-1',
+          name: 't2.micro',
+          defaultVCpus: 1,
+          memoryInGiB: 1,
+          supportedArchitectures: ['i386', 'x86_64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
+        {
+          account: 'test',
+          region: 'us-east-1',
+          name: 'm4.xlarge',
+          defaultVCpus: 4,
+          memoryInGiB: 16,
+          supportedArchitectures: ['x86_64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
+        {
+          account: 'test',
+          region: 'us-east-1',
+          name: 'm4.4xlarge',
+          defaultVCpus: 16,
+          memoryInGiB: 64,
+          supportedArchitectures: ['x86_64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
+        {
+          account: 'test',
+          region: 'us-east-1',
+          name: 't2.medium',
+          defaultVCpus: 2,
+          memoryInGiB: 4,
+          supportedArchitectures: ['i386', 'x86_64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
+        {
+          account: 'test',
+          region: 'us-east-1',
+          name: 'm4.large',
+          defaultVCpus: 2,
+          memoryInGiB: 8,
+          supportedArchitectures: ['x86_64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
+        {
+          account: 'test',
+          region: 'us-east-1',
+          name: 'm4.16xlarge',
+          defaultVCpus: 64,
+          memoryInGiB: 256,
+          supportedArchitectures: ['x86_64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
+        {
+          account: 'test',
+          region: 'us-east-1',
+          name: 'm4.10xlarge',
+          defaultVCpus: 40,
+          memoryInGiB: 160,
+          supportedArchitectures: ['x86_64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
+        {
+          account: 'test',
+          region: 'us-east-1',
+          name: 't2.loltiny',
+          defaultVCpus: 1,
+          memoryInGiB: 0,
+          supportedArchitectures: ['i386', 'x86_64'],
+          supportedVirtualizationTypes: ['hvm'],
+        },
       ];
     }),
   );
@@ -59,7 +171,28 @@ describe('Service: InstanceType', function () {
       });
 
       await http.flush();
-      expect(results).toEqual(['m1.small', 'm2.xlarge']);
+      expect(results).toEqual([
+        {
+          account: 'test',
+          region: 'us-west-2',
+          name: 'm1.small',
+          defaultVCpus: 1,
+          memoryInGiB: 1,
+          supportedArchitectures: ['i386', 'x86_64'],
+          supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+          key: 'us-west-2:test:m1.small',
+        },
+        {
+          account: 'test',
+          region: 'us-west-2',
+          name: 'm2.xlarge',
+          defaultVCpus: 2,
+          memoryInGiB: 17,
+          supportedArchitectures: ['x86_64'],
+          supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+          key: 'us-west-2:test:m2.xlarge',
+        },
+      ]);
     });
 
     it('returns empty list for region with no instance types', async function () {
@@ -89,22 +222,7 @@ describe('Service: InstanceType', function () {
       });
 
       await http.flush();
-      expect(results).toEqual(['m2.xlarge']);
-    });
-
-    it('filters instance types by VPC and virtualization type', function () {
-      const types = ['c4.a', 'c3.a', 'c4.a', 'c1.a'];
-      const service = this.awsInstanceTypeService;
-      expect(service.filterInstanceTypes(types, 'hvm', true)).toEqual(['c4.a', 'c3.a', 'c4.a']);
-      expect(service.filterInstanceTypes(types, 'hvm', false)).toEqual(['c3.a']);
-      expect(service.filterInstanceTypes(types, 'paravirtual', true)).toEqual(['c3.a', 'c1.a']);
-      expect(service.filterInstanceTypes(types, 'paravirtual', false)).toEqual(['c3.a', 'c1.a']);
-    });
-
-    it('assumes HVM is supported for unknown families', function () {
-      const types = ['c400.a', 'c300.a', 'c3.a', 'c1.a'];
-      const service = this.awsInstanceTypeService;
-      expect(service.filterInstanceTypes(types, 'hvm', true)).toEqual(['c400.a', 'c300.a', 'c3.a']);
+      expect(map(results, 'name')).toEqual(['m2.xlarge']);
     });
 
     it('sorts instance types by family then class size', async function () {
@@ -119,7 +237,7 @@ describe('Service: InstanceType', function () {
       });
 
       await http.flush();
-      expect(results).toEqual([
+      expect(map(results, 'name')).toEqual([
         'm4.large',
         'm4.xlarge',
         'm4.2xlarge',
@@ -134,6 +252,81 @@ describe('Service: InstanceType', function () {
     });
   });
 
+  describe('filterInstanceTypes', function () {
+    const instanceTypes = [
+      {
+        account: 'test',
+        region: 'us-west-2',
+        name: 'm1.small',
+        defaultVCpus: 1,
+        memoryInGiB: 1,
+        supportedArchitectures: ['i386', 'x86_64'],
+        supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+      },
+      {
+        account: 'test',
+        region: 'eu-west-1',
+        name: 'hs1.8xlarge',
+        defaultVCpus: 32,
+        memoryInGiB: 256,
+        supportedArchitectures: ['i386', 'x86_64'],
+        supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+      },
+      {
+        account: 'test',
+        region: 'eu-west-1',
+        name: 'm2.xlarge',
+        defaultVCpus: 2,
+        memoryInGiB: 17,
+        supportedArchitectures: ['x86_64'],
+        supportedVirtualizationTypes: ['hvm', 'paravirtual'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 'm4.2xlarge',
+        defaultVCpus: 8,
+        memoryInGiB: 32,
+        supportedArchitectures: ['x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+      {
+        account: 'test',
+        region: 'us-east-1',
+        name: 't2.nano',
+        defaultVCpus: 1,
+        memoryInGiB: 0,
+        supportedArchitectures: ['i386', 'x86_64'],
+        supportedVirtualizationTypes: ['hvm'],
+      },
+    ];
+
+    it('filters instance types by VPC, virtualization type and architecture', function () {
+      const service = this.awsInstanceTypeService;
+      expect(map(service.filterInstanceTypes(instanceTypes, 'hvm', true, 'x86_64'), 'name')).toEqual([
+        'm1.small',
+        'hs1.8xlarge',
+        'm2.xlarge',
+        'm4.2xlarge',
+        't2.nano',
+      ]);
+      expect(map(service.filterInstanceTypes(instanceTypes, 'hvm', false, 'x86_64'), 'name')).toEqual([
+        'm1.small',
+        'hs1.8xlarge',
+        'm2.xlarge',
+      ]);
+      expect(map(service.filterInstanceTypes(instanceTypes, 'hvm', true, 'i386'), 'name')).toEqual([
+        'm1.small',
+        'hs1.8xlarge',
+        't2.nano',
+      ]);
+      expect(map(service.filterInstanceTypes(instanceTypes, 'paravirtual', true, 'i386'), 'name')).toEqual([
+        'm1.small',
+        'hs1.8xlarge',
+      ]);
+    });
+  });
+
   describe('isBurstingSupportedForAllTypes', function () {
     const testInputs = [
       { types: ['t2.small', 't3.nano', 't3a.medium', 't4g.large'], result: true },

package/src/instance/awsInstanceType.service.ts

@@ -21,6 +21,54 @@ export interface IAmazonInstanceTypeCategory extends IInstanceTypeCategory {
   descriptionListOverride?: string[];
 }
 
+export interface IAmazonInstanceType extends IInstanceType {
+  defaultVCpus: number;
+  memoryInGiB: number;
+  hypervisor: string;
+  instanceStorageInfo?: IAmazonInstanceTypeStorageInfo;
+  ebsInfo?: IAmazonInstanceTypeEbsInfo;
+  gpuInfo?: IAmazonInstanceGpuInfo;
+
+  instanceStorageSupported: boolean;
+  currentGeneration: boolean;
+  bareMetal: boolean;
+  ipv6Supported?: boolean;
+  burstablePerformanceSupported: boolean;
+
+  supportedArchitectures: string[];
+  supportedUsageClasses: string[];
+  supportedRootDeviceTypes: string[];
+  supportedVirtualizationTypes: string[];
+}
+
+export interface IAmazonInstanceTypeStorageInfo {
+  storageTypes: string;
+  totalSizeInGB?: number;
+  nvmeSupport?: string;
+}
+
+export interface IAmazonInstanceTypeEbsInfo {
+  ebsOptimizedSupport: string;
+  nvmeSupport?: string;
+  encryptionSupport: string;
+}
+
+export interface IAmazonInstanceGpuInfo {
+  totalGpuMemoryInMiB: number;
+  gpus: IAmazonInstanceGpuDeviceInfo[];
+}
+
+export interface IAmazonInstanceGpuDeviceInfo {
+  name: string;
+  manufacturer: string;
+  count: number;
+  gpuSizeInMiB: number;
+}
+
+export interface IAmazonInstanceTypesByRegion extends IInstanceTypesByRegion {
+  [region: string]: IAmazonInstanceType[];
+}
+
 export const AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE = 'spinnaker.amazon.instanceType.service';
 export const name = AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE; // for backwards compatibility
 
@@ -31,16 +79,14 @@ module(AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE, []).factory('awsInstanceTypeServ
       return $q.when(categories);
     }
 
-    const getAllTypesByRegion = function getAllTypesByRegion(): PromiseLike<IInstanceTypesByRegion> {
+    const getAllTypesByRegion = function getAllTypesByRegion(): PromiseLike<IAmazonInstanceTypesByRegion> {
       return REST('/instanceTypes')
         .get()
         .then(function (types) {
           return _.chain(types)
-            .map(function (type: IInstanceType) {
+            .map(function (type: IAmazonInstanceType) {
               return {
-                region: type.region,
-                account: type.account,
-                name: type.name,
+                ...type,
                 key: [type.region, type.account, type.name].join(':'),
               };
             })
@@ -95,47 +141,57 @@ module(AMAZON_INSTANCE_AWSINSTANCETYPE_SERVICE, []).factory('awsInstanceTypeServ
       return 0;
     }
 
-    function getAvailableTypesForRegions(availableInstanceTypes: IInstanceTypesByRegion, selectedRegions: string[]) {
+    function getAvailableTypesForRegions(
+      availableInstanceTypes: IAmazonInstanceTypesByRegion,
+      selectedRegions: string[],
+    ): IAmazonInstanceType[] {
       selectedRegions = selectedRegions || [];
-      let availableTypes: string[] = [];
+      let availableTypes: IAmazonInstanceType[] = [];
 
       // prime the list of available types
       if (selectedRegions && selectedRegions.length) {
-        availableTypes = _.map(availableInstanceTypes[selectedRegions[0]], 'name');
+        availableTypes = availableInstanceTypes[selectedRegions[0]] || [];
       }
 
       // this will perform an unnecessary intersection with the first region, which is fine
       selectedRegions.forEach(function (selectedRegion) {
         if (availableInstanceTypes[selectedRegion]) {
-          availableTypes = _.intersection(availableTypes, _.map(availableInstanceTypes[selectedRegion], 'name'));
+          availableTypes = _.intersectionBy(availableTypes, availableInstanceTypes[selectedRegion], 'name');
         }
       });
 
-      return availableTypes.sort(sortTypesByFamilyAndSize);
+      return availableTypes?.sort((a, b) => sortTypesByFamilyAndSize(a.name, b.name));
     }
 
     const families: { [key: string]: string[] } = {
-      paravirtual: ['c1', 'c3', 'hi1', 'hs1', 'm1', 'm2', 'm3', 't1'],
-      hvm: ['c3', 'c4', 'd2', 'i2', 'g2', 'm3', 'm4', 'm5', 'p2', 'r3', 'r4', 'r5', 't2', 'x1'],
-      vpcOnly: ['c4', 'm4', 'm5', 'r4', 'r5', 't2', 'x1'],
+      ec2ClassicSupported: ['m1', 'm3', 't1', 'c1', 'c3', 'cc2', 'cr1', 'm2', 'r3', 'd2', 'hs1', 'i2', 'g2'], // https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-classic-platform.html#ec2-classic-instance-types
       ebsOptimized: ['c4', 'd2', 'f1', 'g3', 'i3', 'm4', 'm5', 'p2', 'r4', 'r5', 'x1'],
       burstablePerf: ['t2', 't3', 't3a', 't4g'],
     };
 
-    function filterInstanceTypes(instanceTypes: string[], virtualizationType: string, vpcOnly: boolean): string[] {
-      return instanceTypes.filter((instanceType: string) => {
-        if (virtualizationType === '*') {
+    function filterInstanceTypes(
+      instanceTypes: IAmazonInstanceType[],
+      virtualizationType: string,
+      vpcConfigured: boolean,
+      architecture: string,
+    ): IAmazonInstanceType[] {
+      return _.filter(instanceTypes, function (i) {
+        if (virtualizationType === '*' && architecture === '*') {
           // show all instance types
           return true;
         }
-        const [family] = instanceType.split('.');
-        if (!vpcOnly && families.vpcOnly.includes(family)) {
+
+        if (!vpcConfigured && !families.ec2ClassicSupported.includes(i.name.split('.')[0])) {
           return false;
         }
-        if (!families.paravirtual.includes(family) && virtualizationType === 'hvm') {
-          return true;
+        if (virtualizationType && !i.supportedVirtualizationTypes.includes(virtualizationType)) {
+          return false;
+        }
+        if (architecture && !i.supportedArchitectures.includes(architecture)) {
+          return false;
         }
-        return families[virtualizationType].includes(family);
+
+        return true;
       });
     }
 

package/src/serverGroup/configure/AmazonImageSelectInput.tsx

@@ -59,7 +59,7 @@ export class AmazonImageSelectInput extends React.Component<IAmazonImageSelector
 
     // assume that the specific image exists in the selected region
     const amis = { [region]: [imageId] };
-    const attributes = { virtualizationType: '*', creationDate: new Date().toISOString() };
+    const attributes = { virtualizationType: '*', architecture: '*', creationDate: new Date().toISOString() };
 
     return { imageName, amis, attributes } as IAmazonImage;
   }