Light, fluffy, and always free - The AWS Local Emulator alternative
fix(ec2): add opt-in Standard On-Demand vCPU admission (#6058)
David Phillips689201122fcc
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2VcpuAdmissionTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2VcpuAdmissionTest.javanew file mode 100644index 0000000000..935e5759d7--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/Ec2VcpuAdmissionTest.java@@ -0,0 +1,204 @@+package com.floci.test;++import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.function.Executable;+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;+import software.amazon.awssdk.regions.Region;+import software.amazon.awssdk.services.ec2.Ec2Client;+import software.amazon.awssdk.services.ec2.model.CreateFleetResponse;+import software.amazon.awssdk.services.ec2.model.Ec2Exception;+import software.amazon.awssdk.services.ec2.model.InstanceType;+import software.amazon.awssdk.services.ec2.model.RequestSpotLaunchSpecification;+import software.amazon.awssdk.services.ec2.model.RunInstancesResponse;+import software.amazon.awssdk.services.ec2.model.SpotInstanceRequest;+import software.amazon.awssdk.services.servicequotas.ServiceQuotasClient;++import java.util.ArrayList;+import java.util.List;+import java.util.UUID;++import static org.assertj.core.api.Assertions.assertThat;+import static org.junit.jupiter.api.Assertions.assertAll;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assumptions.assumeFalse;++class Ec2VcpuAdmissionTest {+ @Test+ void quotaAdmissionFollowsOptInWhileSpotAndOtherAccountsRemainIndependent() {+ assumeFalse(TestFixtures.isRealAws(), "Local opt-in admission and mock guest lifecycle only");+ Region region = TestFixtures.region();+ String owner = "765432101234";+ StaticCredentialsProvider credentials = StaticCredentialsProvider.create(AwsBasicCredentials.create(owner, "test"));+ List<String> ids = new ArrayList<>();+ List<String> otherIds = new ArrayList<>();+ List<String> regionIds = new ArrayList<>();+ String templateId = null;+ String spotRequestId = null;+ try (Ec2Client ec2 = client(region, owner);+ Ec2Client other = client(region, "765432101235");+ Ec2Client otherRegion = client(Region.of(region.id().startsWith("cn-")+ ? "cn-northwest-1" : "eu-west-1"), owner);+ ServiceQuotasClient quotas = ServiceQuotasClient.builder().endpointOverride(TestFixtures.endpoint())+ .region(region).credentialsProvider(credentials).build()) {+ int limit = quotas.getServiceQuota(r -> r.serviceCode("ec2").quotaCode("L-1216C47A"))+ .quota().value().intValue();+ int expectedLimit = Integer.parseInt(System.getenv().getOrDefault(+ "FLOCI_TEST_EXPECTED_STANDARD_ON_DEMAND_VCPUS", "5"));+ assertThat(limit).as("applied quota retains the ordinary default or explicit fixture value")+ .isEqualTo(expectedLimit);+ if (!enforcementExpected()) {+ try {+ ec2.runInstances(r -> r.imageId("ami-0abcdef1234567890").instanceType(InstanceType.T2_MICRO)+ .minCount(6).maxCount(6)).instances().forEach(i -> ids.add(i.instanceId()));+ ids.add(ec2.runInstances(r -> r.imageId("ami-0abcdef1234567890")+ .instanceType(InstanceType.M5_2_XLARGE).minCount(1).maxCount(1))+ .instances().get(0).instanceId());+ assertThat(ids).hasSize(7);+ ec2.stopInstances(r -> r.instanceIds(ids));+ ec2.startInstances(r -> r.instanceIds(ids));+ assertThat(ec2.describeInstances(r -> r.instanceIds(ids)).reservations())+ .flatExtracting(reservation -> reservation.instances())+ .allSatisfy(instance -> assertThat(instance.state().nameAsString()).isEqualTo("running"));+ } finally {+ if (!ids.isEmpty()) {+ ec2.terminateInstances(r -> r.instanceIds(ids));+ }+ }+ return;+ }+ assertThat(limit).as("compatibility fixture uses a small positive applied quota")+ .isBetween(2, 32);+ int guests = limit / 2;+ try {+ RunInstancesResponse batch = ec2.runInstances(r -> r.imageId("ami-0abcdef1234567890")+ .instanceType(InstanceType.T3_MICRO).minCount(1).maxCount(guests + 2));+ batch.instances().forEach(i -> ids.add(i.instanceId()));+ assertThat(ids).hasSize(guests);+ ec2.waiter().waitUntilInstanceRunning(r -> r.instanceIds(ids));+ Ec2Exception full = assertThrows(Ec2Exception.class, () -> launch(ec2));+ assertThat(full.statusCode()).isEqualTo(400);+ assertThat(full.awsErrorDetails().errorCode()).isEqualTo("VcpuLimitExceeded");+ otherIds.add(launch(other));+ regionIds.add(launch(otherRegion));++ SpotInstanceRequest spot = ec2.requestSpotInstances(r -> r.instanceCount(1).type("one-time")+ .launchSpecification(RequestSpotLaunchSpecification.builder()+ .imageId("ami-0abcdef1234567890").instanceType(InstanceType.T3_MICRO).build()))+ .spotInstanceRequests().get(0);+ spotRequestId = spot.spotInstanceRequestId();+ ids.add(spot.instanceId());+ String spotId = spot.instanceId();+ ec2.stopInstances(r -> r.instanceIds(spotId));+ ec2.startInstances(r -> r.instanceIds(spotId));++ templateId = ec2.createLaunchTemplate(r -> r.launchTemplateName("quota-" + UUID.randomUUID())+ .launchTemplateData(d -> d.imageId("ami-0abcdef1234567890")+ .instanceType(InstanceType.T3_MICRO))).launchTemplate().launchTemplateId();+ String directSpot = ec2.runInstances(r -> r.imageId("ami-0abcdef1234567890")+ .instanceType(InstanceType.T3_MICRO).minCount(1).maxCount(1)+ .instanceMarketOptions(m -> m.marketType("spot"))).instances().get(0).instanceId();+ ids.add(directSpot);+ assertThat(ec2.describeInstances(r -> r.instanceIds(directSpot)).reservations().get(0)+ .instances().get(0).instanceLifecycleAsString()).isEqualTo("spot");+ ec2.stopInstances(r -> r.instanceIds(directSpot));+ ec2.startInstances(r -> r.instanceIds(directSpot));+ assertThat(ec2.describeInstances(r -> r.instanceIds(directSpot)).reservations().get(0)+ .instances().get(0).instanceLifecycleAsString()).isEqualTo("spot");+ String template = templateId;+ ec2.createLaunchTemplateVersion(r -> r.launchTemplateId(template)+ .launchTemplateData(d -> d.imageId("ami-0abcdef1234567890")+ .instanceType(InstanceType.T3_MICRO).instanceMarketOptions(m -> m.marketType("spot"))));+ RunInstancesResponse templateSpot = ec2.runInstances(r -> r.minCount(1).maxCount(1)+ .launchTemplate(t -> t.launchTemplateId(template).version("$Latest")));+ ids.add(templateSpot.instances().get(0).instanceId());+ assertThat(templateSpot.instances().get(0).instanceLifecycleAsString()).isEqualTo("spot");+ assertThat(assertThrows(Ec2Exception.class, () -> ec2.runInstances(r -> r.minCount(1).maxCount(1)+ .launchTemplate(t -> t.launchTemplateId(template).version("$Latest"))+ .instanceMarketOptions(m -> m.marketType("on-demand"))))+ .awsErrorDetails().errorCode()).isEqualTo("VcpuLimitExceeded");+ CreateFleetResponse fleet = ec2.createFleet(r -> r.type("instant").launchTemplateConfigs(c ->+ c.launchTemplateSpecification(t -> t.launchTemplateId(template).version("$Latest")))+ .targetCapacitySpecification(t -> t.totalTargetCapacity(1).defaultTargetCapacityType("spot")));+ fleet.instances().forEach(group -> ids.addAll(group.instanceIds()));+ assertThat(fleet.instances()).hasSize(1);+ assertThat(assertThrows(Ec2Exception.class, () -> launch(ec2)).awsErrorDetails().errorCode())+ .isEqualTo("VcpuLimitExceeded");++ String stopped = ids.get(0);+ ec2.stopInstances(r -> r.instanceIds(stopped));+ String replacement = launch(ec2);+ ids.add(replacement);+ ec2.waiter().waitUntilInstanceRunning(r -> r.instanceIds(replacement));+ assertThat(assertThrows(Ec2Exception.class, () -> ec2.startInstances(r -> r.instanceIds(stopped)))+ .awsErrorDetails().errorCode()).isEqualTo("VcpuLimitExceeded");+ assertThat(ec2.describeInstances(r -> r.instanceIds(stopped)).reservations().get(0)+ .instances().get(0).state().nameAsString()).isEqualTo("stopped");+ ec2.terminateInstances(r -> r.instanceIds(replacement));+ ec2.startInstances(r -> r.instanceIds(stopped));+ assertThat(ec2.describeInstances(r -> r.instanceIds(stopped)).reservations().get(0)+ .instances().get(0).state().nameAsString()).isEqualTo("running");+ } finally {+ List<Executable> cleanup = new ArrayList<>();+ if (!ids.isEmpty()) {+ cleanup.add(() -> ec2.terminateInstances(r -> r.instanceIds(ids)));+ }+ if (!otherIds.isEmpty()) {+ cleanup.add(() -> other.terminateInstances(r -> r.instanceIds(otherIds)));+ }+ if (!regionIds.isEmpty()) {+ cleanup.add(() -> otherRegion.terminateInstances(r -> r.instanceIds(regionIds)));+ }+ if (spotRequestId != null) {+ String requestId = spotRequestId;+ cleanup.add(() -> ec2.cancelSpotInstanceRequests(r -> r.spotInstanceRequestIds(requestId)));+ }+ if (templateId != null) {+ String template = templateId;+ cleanup.add(() -> ec2.deleteLaunchTemplate(r -> r.launchTemplateId(template)));+ }+ assertAll(cleanup);+ }+ }+ }++ @Test+ void unknownTypesFollowTheEnforcementOptIn() {+ assumeFalse(TestFixtures.isRealAws(), "Local unsupported-type mapping is not an AWS response claim");+ try (Ec2Client ec2 = client(TestFixtures.region(), "765432101236")) {+ if (!enforcementExpected()) {+ String id = ec2.runInstances(r -> r.imageId("ami-0abcdef1234567890")+ .instanceType("m999.unmeasured").minCount(1).maxCount(1)).instances().get(0).instanceId();+ try {+ ec2.stopInstances(r -> r.instanceIds(id));+ ec2.startInstances(r -> r.instanceIds(id));+ assertThat(ec2.describeInstances(r -> r.instanceIds(id)).reservations().get(0)+ .instances().get(0).state().nameAsString()).isEqualTo("running");+ } finally {+ ec2.terminateInstances(r -> r.instanceIds(id));+ }+ return;+ }+ Ec2Exception unsupported = assertThrows(Ec2Exception.class, () -> ec2.runInstances(r ->+ r.imageId("ami-0abcdef1234567890").instanceType("m999.unmeasured").minCount(1).maxCount(1)));+ assertThat(unsupported.statusCode()).isEqualTo(400);+ assertThat(unsupported.awsErrorDetails().errorCode()).isEqualTo("InvalidParameterValue");+ assertThat(ec2.describeInstances().reservations()).isEmpty();+ }+ }++ private static boolean enforcementExpected() {+ return Boolean.parseBoolean(System.getenv().getOrDefault("FLOCI_TEST_EC2_ENFORCE_VCPU_QUOTAS", "false"));+ }++ private static String launch(Ec2Client ec2) {+ return ec2.runInstances(r -> r.imageId("ami-0abcdef1234567890").instanceType(InstanceType.T3_MICRO)+ .minCount(1).maxCount(1)).instances().get(0).instanceId();+ }++ private static Ec2Client client(Region region, String account) {+ return Ec2Client.builder().endpointOverride(TestFixtures.endpoint()).region(region)+ .credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create(account, "test")))+ .build();+ }+}diff --git a/docs/configuration/environment-variables.md b/docs/configuration/environment-variables.mdindex 6621184e94..ee47b7e700 100644--- a/docs/configuration/environment-variables.md+++ b/docs/configuration/environment-variables.md@@ -536,6 +536,7 @@ These services spawn Docker containers. They require access to the Docker socket| Variable | Default | Description ||---|---|---|+| `FLOCI_SERVICES_EC2_ENFORCE_VCPU_QUOTAS` | `false` | Opt in to EC2 Run/Start admission against current running Standard On-Demand vCPU usage || `FLOCI_SERVICES_EC2_ENABLED` | `true` | Enable the EC2 service || `FLOCI_SERVICES_EC2_MOCK` | `false` | When `true`, instances are registered in state but no containers are spawned || `FLOCI_SERVICES_EC2_MOCK_PUBLIC_ADDRESSES` | `none` | Automatic public IPv4 address of a mock instance: `none`, `documentation` (from `203.0.113.0/24`) or `fixed` (`FLOCI_SERVICES_EC2_MOCK_PUBLIC_ADDRESS`) |@@ -610,6 +611,7 @@ See [Web Console](../ui/index.md) for running the console and swapping in a thir| `FLOCI_SERVICES_CODEPIPELINE_SOURCE_POLL_INTERVAL_MS` | `500` | How often (ms) the CodePipeline S3 source poller checks a configured `S3Bucket`/`S3ObjectKey` for a new object revision || `FLOCI_SERVICES_NETWORKFIREWALL_ENABLED` | `true` | Enable the AWS Network Firewall service || `FLOCI_SERVICES_SERVICEQUOTAS_ENABLED` | `true` | Enable the Service Quotas service |+| `FLOCI_SERVICES_SERVICEQUOTAS_STANDARD_ON_DEMAND_VCPUS` | `5` | Non-negative Standard On-Demand vCPU limit per account and region; EC2 launches and starts reserve capacity against this applied limit || `FLOCI_SERVICES_RAM_ENABLED` | `true` | Enable the AWS RAM service || `FLOCI_SERVICES_BACKUP_ENABLED` | `true` | Enable the AWS Backup service || `FLOCI_SERVICES_BACKUP_JOB_COMPLETION_DELAY_SECONDS` | `3` | Simulated delay before backup jobs transition to `COMPLETED` |diff --git a/docs/services/ec2.md b/docs/services/ec2.mdindex 29c862db69..ceb6ee3aff 100644--- a/docs/services/ec2.md+++ b/docs/services/ec2.md@@ -22,9 +22,38 @@ By default, Docker containers launched for EC2 instances are bounded to the CPU- **CPU limit**: Each vCPU corresponds to 1024 CPU units (Docker nanoCPUs = `vcpu * 1_000_000_000`). If the host machine has fewer physical cores than requested, Floci clamps execution to available host CPUs and warns (since Docker refuses a nanoCPUs value exceeding the host CPU count).- **Memory limit**: Container memory is bounded to the exact MiB value specified for the instance type in the catalog.-- **Unknown instance types**: If an instance type is not present in the catalog, the container launches unbounded without CPU or memory restrictions, avoiding launch failures for custom or unmodeled instance types.+- **Types outside the full catalog**: Docker CPU and memory limits are not applied when the full catalog lacks a type. When opted in, Standard On-Demand admission requires a known default vCPU count, as described below.- **Configuration knob**: To disable container resource limits (for example, running a large instance type on a developer machine with limited resources), set `floci.services.ec2.instance-resource-limits: false` (or environment variable `FLOCI_SERVICES_EC2_INSTANCE_RESOURCE_LIMITS=false`).+## Standard On-Demand admission++Quota admission is opt-in. Set `FLOCI_SERVICES_EC2_ENFORCE_VCPU_QUOTAS=true` to+check `RunInstances` and `StartInstances` against the applied Standard On-Demand+quota (`L-1216C47A`) for the caller's account and region. The flag defaults to+`false`, including mock mode. Disabled admission does not refuse a type merely+because its default vCPU count is absent from the snapshot.++`FLOCI_SERVICES_SERVICEQUOTAS_STANDARD_ON_DEMAND_VCPUS` supplies the applied value+(default `5`). Service Quotas reports this value independently of admission.+With admission enabled, a launch batch can return fewer than `MaxCount` when at+least `MinCount` fits, otherwise it returns `VcpuLimitExceeded`. A refused start+leaves stopped instances unchanged. Types in the Standard bucket require a+known default vCPU count; the separate CPU-only snapshot supplements the full+instance metadata catalog without inventing memory sizes or regional availability.++Only current `running` Standard On-Demand instances count. Pending, stopping,+stopped, shutting-down and terminated instances do not reserve capacity. Spot+and dedicated-host instances do not consume this bucket. RunInstances retains+direct or inherited launch-template Spot selection; explicit request market+options override the template. Requests for Spot through the other supported+launch APIs retain that provenance too.++These are checks of running usage at request admission, not a reservation ledger+or an eventual running ceiling. Accepted pending operations can complete after+other work consumes capacity, and changing a running instance's type is not+covered by the Run/Start checks. Admission does not change guest cleanup,+restart, user-data, public-address or CloudFormation lifecycle behavior.+## AMI to Docker Image MappingFloci resolves AMI IDs to Docker images from the EC2 image catalog atdiff --git a/docs/services/servicequotas.md b/docs/services/servicequotas.mdindex a2598254df..a979320ff3 100644--- a/docs/services/servicequotas.md+++ b/docs/services/servicequotas.md@@ -20,8 +20,8 @@ instances") reports a configurable applied value through `GetServiceQuota` andchange that value for all local accounts and regions. Use a nonnegative integer;negative values prevent Floci from starting, even when Service Quotas is disabled.It defaults to 5. The AWS-default read actions always return 5. This setting does not enforce a vCPU-admission limit on EC2.+default read actions always return 5. EC2 can use this applied value for opt-in+Standard On-Demand launch/start admission for each account and region; see [EC2 admission](ec2.md#standard-on-demand-admission).All other applied quotas and AWS default quotas return the same catalog data.`RequestServiceQuotaIncrease` is accepted and validated, records the request, and lets you read@@ -74,7 +74,7 @@ Limitations.| Environment variable | Default | Description || --- | --- | --- || `FLOCI_SERVICES_SERVICEQUOTAS_ENABLED` | `true` | Enables the service |-| `FLOCI_SERVICES_SERVICEQUOTAS_STANDARD_ON_DEMAND_VCPUS` | `5` | Applied EC2 Standard On-Demand vCPU quota reported for every local account and region; does not enforce EC2 admission |+| `FLOCI_SERVICES_SERVICEQUOTAS_STANDARD_ON_DEMAND_VCPUS` | `5` | Applied EC2 Standard On-Demand vCPU quota reported per local account and region; used by opt-in EC2 admission |## Examplediff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 0c8d5932dd..07035b12a6 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -3141,6 +3141,10 @@ public interface EmulatorConfig {@WithDefault("true")boolean enabled();+ /** Enables RunInstances and StartInstances checks against current running vCPU usage. */+ @WithDefault("false")+ boolean enforceVcpuQuotas();+/*** When true, DescribeInstances and IMDS report each instance's CFN- and* subnet-allocated private IP (AWS-faithful) instead of the Dockerdiff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceTypeCatalog.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceTypeCatalog.javaindex 67809ed06e..a77c09bfe9 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceTypeCatalog.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceTypeCatalog.java@@ -37,6 +37,7 @@ public class Ec2InstanceTypeCatalog {"t4g", "unlimited");private volatile Loaded loaded;+ private volatile Map<String, Integer> defaultVcpus;public Ec2InstanceTypeCatalog() {// Load lazily so tests and mock-mode paths that do not need instance type@@ -58,6 +59,32 @@ public class Ec2InstanceTypeCatalog {return Optional.ofNullable(loaded().instanceTypesByName.get(instanceType));}+ /** Default hardware vCPUs for quota accounting, independently of the full network catalog. */+ public Optional<Integer> defaultVcpus(String instanceType) {+ Optional<CatalogInstanceType> full = find(instanceType);+ if (full.isPresent()) {+ return Optional.of(full.get().vcpu);+ }+ Map<String, Integer> values = defaultVcpus;+ if (values == null) {+ synchronized (this) {+ values = defaultVcpus;+ if (values == null) {+ VcpuCatalog catalog = readResource("ec2/instance-type-vcpus.yaml", VcpuCatalog.class);+ if (catalog.defaultVcpus == null || catalog.defaultVcpus.isEmpty()+ || catalog.defaultVcpus.entrySet().stream().anyMatch(entry ->+ entry.getKey() == null || entry.getKey().isBlank()+ || entry.getValue() == null || entry.getValue() <= 0)) {+ throw new IllegalStateException("EC2 vCPU catalog must contain positive default vCPU counts");+ }+ values = Map.copyOf(catalog.defaultVcpus);+ defaultVcpus = values;+ }+ }+ }+ return instanceType == null ? Optional.empty() : Optional.ofNullable(values.get(instanceType));+ }+/*** The credit option a launch of this instance type gets when it names no CreditSpecification,* or empty when the type has no burstable credit model.@@ -180,6 +207,12 @@ public class Ec2InstanceTypeCatalog {return value;}+ @JsonIgnoreProperties(ignoreUnknown = true)+ @RegisterForReflection+ public static final class VcpuCatalog {+ public Map<String, Integer> defaultVcpus = Map.of();+ }+@JsonIgnoreProperties(ignoreUnknown = true)@RegisterForReflectionpublic static final class Catalog {diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.javaindex 6100762998..6d038862f3 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2QueryHandler.java@@ -795,6 +795,7 @@ public class Ec2QueryHandler {// Absent fields stay null so the launch default, or the launch template's value, applies.LaunchTemplateData.MetadataOptions metadataOptions = parseMetadataOptions(p, "MetadataOptions.");String creditSpecificationCpuCredits = p.getFirst("CreditSpecification.CpuCredits");+ String marketType = p.getFirst("InstanceMarketOptions.MarketType");List<LaunchTemplateData.BlockDeviceMapping> blockDeviceMappings =parseLaunchTemplateBlockDeviceMappings(p, "");@@ -808,6 +809,9 @@ public class Ec2QueryHandler {"Network interfaces and an instance-level subnet ID may not be specified on the same request", 400);}if (launchTemplateData != null) {+ if (marketType == null && launchTemplateData.getInstanceMarketOptions() != null) {+ marketType = launchTemplateData.getInstanceMarketOptions().getMarketType();+ }blockDeviceMappings = LaunchTemplateData.BlockDeviceMapping.merge(launchTemplateData.getBlockDeviceMappings(), blockDeviceMappings);if (!suppliedInterfaces) {@@ -860,7 +864,8 @@ public class Ec2QueryHandler {keyName, sgIds, subnetId, clientToken, instanceTags, userData, iamInstanceProfileArn,associatePublicIp, networkInterfaceId, networkInterfaceDeviceIndex, null, metadataOptions,creditSpecificationCpuCredits, userDataEncoded, Boolean.parseBoolean(p.getFirst("DryRun")),- p.getFirst("Placement.HostId"), p.getFirst("Placement.Tenancy"), blockDeviceMappings);+ p.getFirst("Placement.HostId"), p.getFirst("Placement.Tenancy"), blockDeviceMappings,+ "spot".equals(marketType));if (!networkInterfaceTags.isEmpty()) {List<String> eniIds = new ArrayList<>();@@ -987,7 +992,7 @@ public class Ec2QueryHandler {null,0,launch.availabilityZone(), launch.metadataOptions(), null, launch.encodedUserData(), false,- null, null, launch.blockDeviceMappings());+ null, null, launch.blockDeviceMappings(), "spot".equals(capacityType));Instance instance = reservation.getInstances().get(0);launchedInstanceIds.add(instance.getInstanceId());results.add(new FleetLaunchResult(instance, launch));@@ -4845,6 +4850,10 @@ public class Ec2QueryHandler {.elem("instanceType", inst.getInstanceType()).elem("launchTime", inst.getLaunchTime() != null ? ISO_FMT.format(inst.getLaunchTime()) : "");+ if (inst.isSpot()) {+ xml.elem("instanceLifecycle", "spot");+ }+if (inst.getPlacement() != null) {xml.start("placement").elem("availabilityZone", inst.getPlacement().getAvailabilityZone())diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.javaindex 049cf973dc..a0cf331126 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2Service.java@@ -3535,6 +3535,24 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, ResettabString creditSpecificationCpuCredits, String encodedUserData, boolean dryRun,String hostId, String tenancy,List<LaunchTemplateData.BlockDeviceMapping> blockDeviceMappings) {+ return runInstances(region, imageId, instanceType, minCount, maxCount, keyName,+ securityGroupIds, subnetId, clientToken, instanceTags, userData, iamInstanceProfileArn,+ associatePublicIp, networkInterfaceId, networkInterfaceDeviceIndex, availabilityZone,+ metadataOptions, creditSpecificationCpuCredits, encodedUserData, dryRun, hostId, tenancy,+ blockDeviceMappings, false);+ }++ Reservation runInstances(String region, String imageId, String instanceType,+ int minCount, int maxCount, String keyName,+ List<String> securityGroupIds, String subnetId,+ String clientToken, List<Tag> instanceTags,+ String userData, String iamInstanceProfileArn,+ Boolean associatePublicIp, String networkInterfaceId,+ int networkInterfaceDeviceIndex, String availabilityZone,+ LaunchTemplateData.MetadataOptions metadataOptions,+ String creditSpecificationCpuCredits, String encodedUserData, boolean dryRun,+ String hostId, String tenancy,+ List<LaunchTemplateData.BlockDeviceMapping> blockDeviceMappings, boolean spot) {if (hostId != null && !hostId.isBlank()) {Host host = getRequiredAvailableHost(region, hostId);if ((availabilityZone == null || availabilityZone.isBlank())@@ -3673,14 +3691,16 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabthrow new AwsException("DryRunOperation", "Request would have succeeded, but DryRun flag is set.", 412);}synchronized (privateIpAllocationLock) {+ int admitted = !config.services().ec2().enforceVcpuQuotas() || spot || "host".equals(tenancy)+ ? count : admittedInstanceCount(region, effectiveInstanceType, minCount, maxCount);synchronized (hostLock) {if (hostId != null) {// Re-checked under hostLock: a ReleaseHosts or ModifyHosts may have landed// since the unlocked check above.validateHostPlacement(getRequiredAvailableHost(region, hostId), az, effectiveInstanceType, tenancy);}- List<String> privateIps = allocateLaunchAddresses(region, finalSubnetId, suppliedEni, count);- for (int i = 0; i < count; i++) {+ List<String> privateIps = allocateLaunchAddresses(region, finalSubnetId, suppliedEni, admitted);+ for (int i = 0; i < admitted; i++) {String instanceId = "i-" + randomHex(17);String privateIp = privateIps.get(i);@@ -3690,6 +3710,7 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabinst.setImageId(imageId);inst.setState(InstanceState.pending());inst.setInstanceType(effectiveInstanceType);+ inst.setSpot(spot);Placement placement = new Placement(az);placement.setHostId(hostId);if (tenancy != null && !tenancy.isBlank()) {@@ -4590,6 +4611,33 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabpublic List<Map<String, String>> startInstances(String region, List<String> instanceIds) {ensureDefaultResources(region);+ if (config.services().ec2().enforceVcpuQuotas()) {+ synchronized (privateIpAllocationLock) {+ long additional = 0;+ Set<String> legacySpot = spotInstanceIds(region);+ List<Instance> targets = new ArrayList<>();+ for (String id : new LinkedHashSet<>(instanceIds)) {+ Instance instance = getRequiredInstance(region, id);+ if (isExternalInstance(region, id)) {+ throw new AwsException("OperationNotPermitted",+ "The instance '" + id + "' is a cluster node and cannot be started through EC2", 400);+ }+ if ("terminated".equals(instance.getState().getName())) {+ throw new AwsException("IncorrectInstanceState",+ "The instance '" + id + "' is not in a state from which it can be started.", 400);+ }+ targets.add(instance);+ }+ for (Instance instance : targets) {+ String state = instance.getState().getName();+ if (("stopped".equals(state) || "stopping".equals(state))+ && !isSpot(instance, legacySpot) && !onDedicatedHost(instance)) {+ additional += standardOnDemandVcpus(instance.getInstanceType());+ }+ }+ enforceStandardOnDemandQuota(region, additional);+ }+ }List<Map<String, String>> result = new ArrayList<>();for (String id : instanceIds) {Instance inst = getRequiredInstance(region, id);@@ -4631,6 +4679,71 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, Resettabreturn result;}+ private int appliedStandardOnDemandLimit() {+ return config.services().servicequotas() == null ? 5+ : config.services().servicequotas().standardOnDemandVcpus();+ }++ private int admittedInstanceCount(String region, String instanceType, int minimum, int maximum) {+ int vcpus = standardOnDemandVcpus(instanceType);+ int requested = Math.max(maximum, Math.max(minimum, 1));+ if (vcpus == 0) {+ return requested;+ }+ long available = Math.max(0L, (long) appliedStandardOnDemandLimit() - runningStandardOnDemandVcpus(region));+ int admitted = (int) Math.min(requested, available / vcpus);+ if (admitted < Math.max(minimum, 1)) {+ throw vcpuLimitExceeded();+ }+ return admitted;+ }++ private void enforceStandardOnDemandQuota(String region, long additional) {+ if (additional > 0 && runningStandardOnDemandVcpus(region) + additional > appliedStandardOnDemandLimit()) {+ throw vcpuLimitExceeded();+ }+ }++ private AwsException vcpuLimitExceeded() {+ return new AwsException("VcpuLimitExceeded", "You have requested more vCPU capacity than your current vCPU limit of "+ + appliedStandardOnDemandLimit() + " allows for the instance bucket that the specified instance type belongs to.", 400);+ }++ private Set<String> spotInstanceIds(String region) {+ return spotInstanceRequests.scan(k -> k.startsWith(region + "::")).stream()+ .map(SpotInstanceRequest::getInstanceId).filter(Objects::nonNull).collect(Collectors.toSet());+ }++ private static boolean isSpot(Instance instance, Set<String> legacySpot) {+ return instance.isSpot() || legacySpot.contains(instance.getInstanceId());+ }++ private static boolean onDedicatedHost(Instance instance) {+ return instance.getPlacement() != null && "host".equals(instance.getPlacement().getTenancy());+ }++ /** Current running usage only: pending operations do not reserve admission capacity. */+ private long runningStandardOnDemandVcpus(String region) {+ Set<String> legacySpot = spotInstanceIds(region);+ return instances.scan(k -> k.startsWith(region + "::")).stream()+ .filter(i -> !isSpot(i, legacySpot) && !onDedicatedHost(i))+ .filter(i -> i.getState() != null && "running".equals(i.getState().getName()))+ .mapToLong(i -> standardOnDemandVcpus(i.getInstanceType())).sum();+ }++ private int standardOnDemandVcpus(String type) {+ if (type == null || type.isBlank() || type.startsWith("mac") || type.startsWith("dl")+ || type.startsWith("hpc") || type.startsWith("inf") || type.startsWith("trn")) {+ return 0;+ }+ return switch (Character.toLowerCase(type.charAt(0))) {+ case 'a', 'c', 'd', 'h', 'i', 'm', 'r', 't', 'z' -> instanceTypeCatalog.defaultVcpus(type)+ .orElseThrow(() -> new AwsException("InvalidParameterValue",+ "Instance type '" + type + "' is not supported for quota-enforced launches.", 400));+ default -> 0;+ };+ }+public void rebootInstances(String region, List<String> instanceIds) {ensureDefaultResources(region);for (String id : instanceIds) {@@ -12727,7 +12840,8 @@ public class Ec2Service implements ContainerTeardown, ResourceProvider, ResettabsecurityGroupIds, subnetId, null, instanceTags, userData, iamInstanceProfileArn,/* associatePublicIp */ null, /* networkInterfaceId */ null,/* networkInterfaceDeviceIndex */ 0, /* availabilityZone */ null,- /* metadataOptions */ null, /* creditSpecificationCpuCredits */ null, encodedUserData);+ /* metadataOptions */ null, /* creditSpecificationCpuCredits */ null, encodedUserData,+ false, null, null, null, true);Instance launchedInstance = reservation.getInstances().get(0);diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/Instance.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/Instance.javaindex 23444ccfd8..ef7c28848f 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/model/Instance.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/Instance.java@@ -18,6 +18,7 @@ public class Instance {private volatile InstanceState state;private String stateTransitionReason;private String instanceType;+ private boolean spot;private Placement placement;private String subnetId;private String vpcId;@@ -110,6 +111,9 @@ public class Instance {public String getStateTransitionReason() { return stateTransitionReason; }public void setStateTransitionReason(String stateTransitionReason) { this.stateTransitionReason = stateTransitionReason; }+ public boolean isSpot() { return spot; }+ public void setSpot(boolean spot) { this.spot = spot; }+public String getInstanceType() { return instanceType; }public void setInstanceType(String instanceType) { this.instanceType = instanceType; }diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 296c8addee..ed371c2e81 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -651,6 +651,8 @@ floci:proxy-max-port: 9499keep-running-on-shutdown: falseec2:+ # Opt-in Standard On-Demand vCPU admission. FLOCI_SERVICES_EC2_ENFORCE_VCPU_QUOTAS+ enforce-vcpu-quotas: false# Optional complete catalog override for locally built guest images.image-catalog-path: ${FLOCI_SERVICES_EC2_IMAGE_CATALOG_PATH:}enabled: truediff --git a/src/main/resources/ec2/instance-type-vcpus.yaml b/src/main/resources/ec2/instance-type-vcpus.yamlnew file mode 100644index 0000000000..3e0d01ab4f--- /dev/null+++ b/src/main/resources/ec2/instance-type-vcpus.yaml@@ -0,0 +1,1443 @@+# DefaultVCpus captured 2026-10-20 with EC2 DescribeInstanceTypes in us-east-1,+# IncludeUnsupportedInRegion=true. Presence is not a regional launchability guarantee.+# https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstanceTypes.html+# The sole documentation-only row is p6e-gb200.36xlarge (144 vCPUs):+# https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html+# No size formula or inferred CPU count is used. This supplements CPU accounting only;+# the separate full catalog still defines DescribeInstanceTypes/network metadata.+defaultVcpus:+ a1.2xlarge: 8+ a1.4xlarge: 16+ a1.large: 2+ a1.medium: 1+ a1.metal: 16+ a1.xlarge: 4+ c1.medium: 2+ c1.xlarge: 8+ c3.2xlarge: 8+ c3.4xlarge: 16+ c3.8xlarge: 32+ c3.large: 2+ c3.xlarge: 4+ c4.2xlarge: 8+ c4.4xlarge: 16+ c4.8xlarge: 36+ c4.large: 2+ c4.xlarge: 4+ c5.12xlarge: 48+ c5.18xlarge: 72+ c5.24xlarge: 96+ c5.2xlarge: 8+ c5.4xlarge: 16+ c5.9xlarge: 36+ c5.large: 2+ c5.metal: 96+ c5.xlarge: 4+ c5a.12xlarge: 48+ c5a.16xlarge: 64+ c5a.24xlarge: 96+ c5a.2xlarge: 8+ c5a.4xlarge: 16+ c5a.8xlarge: 32+ c5a.large: 2+ c5a.xlarge: 4+ c5ad.12xlarge: 48+ c5ad.16xlarge: 64+ c5ad.24xlarge: 96+ c5ad.2xlarge: 8+ c5ad.4xlarge: 16+ c5ad.8xlarge: 32+ c5ad.large: 2+ c5ad.xlarge: 4+ c5d.12xlarge: 48+ c5d.18xlarge: 72+ c5d.24xlarge: 96+ c5d.2xlarge: 8+ c5d.4xlarge: 16+ c5d.9xlarge: 36+ c5d.large: 2+ c5d.metal: 96+ c5d.xlarge: 4+ c5n.18xlarge: 72+ c5n.2xlarge: 8+ c5n.4xlarge: 16+ c5n.9xlarge: 36+ c5n.large: 2+ c5n.metal: 72+ c5n.xlarge: 4+ c6a.12xlarge: 48+ c6a.16xlarge: 64+ c6a.24xlarge: 96+ c6a.2xlarge: 8+ c6a.32xlarge: 128+ c6a.48xlarge: 192+ c6a.4xlarge: 16+ c6a.8xlarge: 32+ c6a.large: 2+ c6a.metal: 192+ c6a.xlarge: 4+ c6g.12xlarge: 48+ c6g.16xlarge: 64+ c6g.2xlarge: 8+ c6g.4xlarge: 16+ c6g.8xlarge: 32+ c6g.large: 2+ c6g.medium: 1+ c6g.metal: 64+ c6g.xlarge: 4+ c6gd.12xlarge: 48+ c6gd.16xlarge: 64+ c6gd.2xlarge: 8+ c6gd.4xlarge: 16+ c6gd.8xlarge: 32+ c6gd.large: 2+ c6gd.medium: 1+ c6gd.metal: 64+ c6gd.xlarge: 4+ c6gn.12xlarge: 48+ c6gn.16xlarge: 64+ c6gn.2xlarge: 8+ c6gn.4xlarge: 16+ c6gn.8xlarge: 32+ c6gn.large: 2+ c6gn.medium: 1+ c6gn.xlarge: 4+ c6i.12xlarge: 48+ c6i.16xlarge: 64+ c6i.24xlarge: 96+ c6i.2xlarge: 8+ c6i.32xlarge: 128+ c6i.4xlarge: 16+ c6i.8xlarge: 32+ c6i.large: 2+ c6i.metal: 128+ c6i.xlarge: 4+ c6id.12xlarge: 48+ c6id.16xlarge: 64+ c6id.24xlarge: 96+ c6id.2xlarge: 8+ c6id.32xlarge: 128+ c6id.4xlarge: 16+ c6id.8xlarge: 32+ c6id.large: 2+ c6id.metal: 128+ c6id.xlarge: 4+ c6in.12xlarge: 48+ c6in.16xlarge: 64+ c6in.24xlarge: 96+ c6in.2xlarge: 8+ c6in.32xlarge: 128+ c6in.4xlarge: 16+ c6in.8xlarge: 32+ c6in.large: 2+ c6in.metal: 128+ c6in.xlarge: 4+ c7a.12xlarge: 48+ c7a.16xlarge: 64+ c7a.24xlarge: 96+ c7a.2xlarge: 8+ c7a.32xlarge: 128+ c7a.48xlarge: 192+ c7a.4xlarge: 16+ c7a.8xlarge: 32+ c7a.large: 2+ c7a.medium: 1+ c7a.metal-48xl: 192+ c7a.xlarge: 4+ c7g.12xlarge: 48+ c7g.16xlarge: 64+ c7g.2xlarge: 8+ c7g.4xlarge: 16+ c7g.8xlarge: 32+ c7g.large: 2+ c7g.medium: 1+ c7g.metal: 64+ c7g.xlarge: 4+ c7gd.12xlarge: 48+ c7gd.16xlarge: 64+ c7gd.2xlarge: 8+ c7gd.4xlarge: 16+ c7gd.8xlarge: 32+ c7gd.large: 2+ c7gd.medium: 1+ c7gd.metal: 64+ c7gd.xlarge: 4+ c7gn.12xlarge: 48+ c7gn.16xlarge: 64+ c7gn.2xlarge: 8+ c7gn.4xlarge: 16+ c7gn.8xlarge: 32+ c7gn.large: 2+ c7gn.medium: 1+ c7gn.metal: 64+ c7gn.xlarge: 4+ c7i-flex.12xlarge: 48+ c7i-flex.16xlarge: 64+ c7i-flex.2xlarge: 8+ c7i-flex.4xlarge: 16+ c7i-flex.8xlarge: 32+ c7i-flex.large: 2+ c7i-flex.xlarge: 4+ c7i.12xlarge: 48+ c7i.16xlarge: 64+ c7i.24xlarge: 96+ c7i.2xlarge: 8+ c7i.48xlarge: 192+ c7i.4xlarge: 16+ c7i.8xlarge: 32+ c7i.large: 2+ c7i.metal-24xl: 96+ c7i.metal-48xl: 192+ c7i.xlarge: 4+ c8a.12xlarge: 48+ c8a.16xlarge: 64+ c8a.24xlarge: 96+ c8a.2xlarge: 8+ c8a.48xlarge: 192+ c8a.4xlarge: 16+ c8a.8xlarge: 32+ c8a.large: 2+ c8a.medium: 1+ c8a.metal-24xl: 96+ c8a.metal-48xl: 192+ c8a.xlarge: 4+ c8g.12xlarge: 48+ c8g.16xlarge: 64+ c8g.24xlarge: 96+ c8g.2xlarge: 8+ c8g.48xlarge: 192+ c8g.4xlarge: 16+ c8g.8xlarge: 32+ c8g.large: 2+ c8g.medium: 1+ c8g.metal-24xl: 96+ c8g.metal-48xl: 192+ c8g.xlarge: 4+ c8gb.12xlarge: 48+ c8gb.16xlarge: 64+ c8gb.24xlarge: 96+ c8gb.2xlarge: 8+ c8gb.48xlarge: 192+ c8gb.4xlarge: 16+ c8gb.8xlarge: 32+ c8gb.large: 2+ c8gb.medium: 1+ c8gb.metal-24xl: 96+ c8gb.metal-48xl: 192+ c8gb.xlarge: 4+ c8gd.12xlarge: 48+ c8gd.16xlarge: 64+ c8gd.24xlarge: 96+ c8gd.2xlarge: 8+ c8gd.48xlarge: 192+ c8gd.4xlarge: 16+ c8gd.8xlarge: 32+ c8gd.large: 2+ c8gd.medium: 1+ c8gd.metal-24xl: 96+ c8gd.metal-48xl: 192+ c8gd.xlarge: 4+ c8gn.12xlarge: 48+ c8gn.16xlarge: 64+ c8gn.24xlarge: 96+ c8gn.2xlarge: 8+ c8gn.48xlarge: 192+ c8gn.4xlarge: 16+ c8gn.8xlarge: 32+ c8gn.large: 2+ c8gn.medium: 1+ c8gn.metal-24xl: 96+ c8gn.metal-48xl: 192+ c8gn.xlarge: 4+ c8i-flex.12xlarge: 48+ c8i-flex.16xlarge: 64+ c8i-flex.2xlarge: 8+ c8i-flex.4xlarge: 16+ c8i-flex.8xlarge: 32+ c8i-flex.large: 2+ c8i-flex.xlarge: 4+ c8i.12xlarge: 48+ c8i.16xlarge: 64+ c8i.24xlarge: 96+ c8i.2xlarge: 8+ c8i.32xlarge: 128+ c8i.48xlarge: 192+ c8i.4xlarge: 16+ c8i.8xlarge: 32+ c8i.96xlarge: 384+ c8i.large: 2+ c8i.metal-48xl: 192+ c8i.metal-96xl: 384+ c8i.xlarge: 4+ c8ib.12xlarge: 48+ c8ib.16xlarge: 64+ c8ib.24xlarge: 96+ c8ib.2xlarge: 8+ c8ib.32xlarge: 128+ c8ib.48xlarge: 192+ c8ib.4xlarge: 16+ c8ib.8xlarge: 32+ c8ib.96xlarge: 384+ c8ib.large: 2+ c8ib.metal-48xl: 192+ c8ib.metal-96xl: 384+ c8ib.xlarge: 4+ c8id.12xlarge: 48+ c8id.16xlarge: 64+ c8id.24xlarge: 96+ c8id.2xlarge: 8+ c8id.32xlarge: 128+ c8id.48xlarge: 192+ c8id.4xlarge: 16+ c8id.8xlarge: 32+ c8id.96xlarge: 384+ c8id.large: 2+ c8id.metal-48xl: 192+ c8id.metal-96xl: 384+ c8id.xlarge: 4+ c8in.12xlarge: 48+ c8in.16xlarge: 64+ c8in.24xlarge: 96+ c8in.2xlarge: 8+ c8in.32xlarge: 128+ c8in.48xlarge: 192+ c8in.4xlarge: 16+ c8in.8xlarge: 32+ c8in.96xlarge: 384+ c8in.large: 2+ c8in.metal-48xl: 192+ c8in.metal-96xl: 384+ c8in.xlarge: 4+ c8ine.12xlarge: 48+ c8ine.2xlarge: 8+ c8ine.4xlarge: 16+ c8ine.8xlarge: 32+ c8ine.large: 2+ c8ine.xlarge: 4+ c9g.12xlarge: 48+ c9g.16xlarge: 64+ c9g.24xlarge: 96+ c9g.2xlarge: 8+ c9g.48xlarge: 192+ c9g.4xlarge: 16+ c9g.8xlarge: 32+ c9g.large: 2+ c9g.medium: 1+ c9g.metal-48xl: 192+ c9g.xlarge: 4+ c9gd.12xlarge: 48+ c9gd.16xlarge: 64+ c9gd.24xlarge: 96+ c9gd.2xlarge: 8+ c9gd.48xlarge: 192+ c9gd.4xlarge: 16+ c9gd.8xlarge: 32+ c9gd.large: 2+ c9gd.medium: 1+ c9gd.metal-48xl: 192+ c9gd.xlarge: 4+ cc1.4xlarge: 2+ cc2.8xlarge: 32+ cg1.4xlarge: 16+ cr1.8xlarge: 32+ d2.2xlarge: 8+ d2.4xlarge: 16+ d2.8xlarge: 36+ d2.xlarge: 4+ d3.2xlarge: 8+ d3.4xlarge: 16+ d3.8xlarge: 32+ d3.xlarge: 4+ d3en.12xlarge: 48+ d3en.2xlarge: 8+ d3en.4xlarge: 16+ d3en.6xlarge: 24+ d3en.8xlarge: 32+ d3en.xlarge: 4+ dl1.24xlarge: 96+ dl2q.24xlarge: 96+ f1.16xlarge: 64+ f1.2xlarge: 8+ f1.4xlarge: 16+ f2.12xlarge: 48+ f2.48xlarge: 192+ f2.6xlarge: 24+ g2.2xlarge: 8+ g2.8xlarge: 32+ g3.16xlarge: 64+ g3.4xlarge: 16+ g3.8xlarge: 32+ g3s.xlarge: 4+ g4ad.16xlarge: 64+ g4ad.2xlarge: 8+ g4ad.4xlarge: 16+ g4ad.8xlarge: 32+ g4ad.xlarge: 4+ g4dn.12xlarge: 48+ g4dn.16xlarge: 64+ g4dn.2xlarge: 8+ g4dn.4xlarge: 16+ g4dn.8xlarge: 32+ g4dn.metal: 96+ g4dn.xlarge: 4+ g5.12xlarge: 48+ g5.16xlarge: 64+ g5.24xlarge: 96+ g5.2xlarge: 8+ g5.48xlarge: 192+ g5.4xlarge: 16+ g5.8xlarge: 32+ g5.xlarge: 4+ g5g.16xlarge: 64+ g5g.2xlarge: 8+ g5g.4xlarge: 16+ g5g.8xlarge: 32+ g5g.metal: 64+ g5g.xlarge: 4+ g6.12xlarge: 48+ g6.16xlarge: 64+ g6.24xlarge: 96+ g6.2xlarge: 8+ g6.48xlarge: 192+ g6.4xlarge: 16+ g6.8xlarge: 32+ g6.xlarge: 4+ g6e.12xlarge: 48+ g6e.16xlarge: 64+ g6e.24xlarge: 96+ g6e.2xlarge: 8+ g6e.48xlarge: 192+ g6e.4xlarge: 16+ g6e.8xlarge: 32+ g6e.xlarge: 4+ g6f.2xlarge: 8+ g6f.4xlarge: 16+ g6f.large: 2+ g6f.xlarge: 4+ g7.12xlarge: 48+ g7.24xlarge: 96+ g7.2xlarge: 8+ g7.48xlarge: 192+ g7.4xlarge: 16+ g7.8xlarge: 32+ g7e.12xlarge: 48+ g7e.24xlarge: 96+ g7e.2xlarge: 8+ g7e.48xlarge: 192+ g7e.4xlarge: 16+ g7e.8xlarge: 32+ gr6.4xlarge: 16+ gr6.8xlarge: 32+ gr6f.4xlarge: 16+ h1.16xlarge: 64+ h1.2xlarge: 8+ h1.4xlarge: 16+ h1.8xlarge: 32+ hi1.4xlarge: 16+ hpc6a.48xlarge: 96+ hpc6id.32xlarge: 64+ hpc7a.12xlarge: 24+ hpc7a.24xlarge: 48+ hpc7a.48xlarge: 96+ hpc7a.96xlarge: 192+ hpc7g.16xlarge: 64+ hpc7g.4xlarge: 16+ hpc7g.8xlarge: 32+ hpc8a.96xlarge: 192+ hs1.8xlarge: 16+ i2.2xlarge: 8+ i2.4xlarge: 16+ i2.8xlarge: 32+ i2.xlarge: 4+ i3.16xlarge: 64+ i3.2xlarge: 8+ i3.4xlarge: 16+ i3.8xlarge: 32+ i3.large: 2+ i3.metal: 72+ i3.xlarge: 4+ i3en.12xlarge: 48+ i3en.24xlarge: 96+ i3en.2xlarge: 8+ i3en.3xlarge: 12+ i3en.6xlarge: 24+ i3en.large: 2+ i3en.metal: 96+ i3en.xlarge: 4+ i4g.16xlarge: 64+ i4g.2xlarge: 8+ i4g.4xlarge: 16+ i4g.8xlarge: 32+ i4g.large: 2+ i4g.xlarge: 4+ i4i.12xlarge: 48+ i4i.16xlarge: 64+ i4i.24xlarge: 96+ i4i.2xlarge: 8+ i4i.32xlarge: 128+ i4i.4xlarge: 16+ i4i.8xlarge: 32+ i4i.large: 2+ i4i.metal: 128+ i4i.xlarge: 4+ i7i.12xlarge: 48+ i7i.16xlarge: 64+ i7i.24xlarge: 96+ i7i.2xlarge: 8+ i7i.48xlarge: 192+ i7i.4xlarge: 16+ i7i.8xlarge: 32+ i7i.large: 2+ i7i.metal-24xl: 96+ i7i.metal-48xl: 192+ i7i.xlarge: 4+ i7ie.12xlarge: 48+ i7ie.18xlarge: 72+ i7ie.24xlarge: 96+ i7ie.2xlarge: 8+ i7ie.3xlarge: 12+ i7ie.48xlarge: 192+ i7ie.6xlarge: 24+ i7ie.large: 2+ i7ie.metal-24xl: 96+ i7ie.metal-48xl: 192+ i7ie.xlarge: 4+ i8g.12xlarge: 48+ i8g.16xlarge: 64+ i8g.24xlarge: 96+ i8g.2xlarge: 8+ i8g.48xlarge: 192+ i8g.4xlarge: 16+ i8g.8xlarge: 32+ i8g.large: 2+ i8g.metal-24xl: 96+ i8g.metal-48xl: 192+ i8g.xlarge: 4+ i8ge.12xlarge: 48+ i8ge.18xlarge: 72+ i8ge.24xlarge: 96+ i8ge.2xlarge: 8+ i8ge.3xlarge: 12+ i8ge.48xlarge: 192+ i8ge.6xlarge: 24+ i8ge.large: 2+ i8ge.metal-24xl: 96+ i8ge.metal-48xl: 192+ i8ge.xlarge: 4+ im4gn.16xlarge: 64+ im4gn.2xlarge: 8+ im4gn.4xlarge: 16+ im4gn.8xlarge: 32+ im4gn.large: 2+ im4gn.xlarge: 4+ inf1.24xlarge: 96+ inf1.2xlarge: 8+ inf1.6xlarge: 24+ inf1.xlarge: 4+ inf2.24xlarge: 96+ inf2.48xlarge: 192+ inf2.8xlarge: 32+ inf2.xlarge: 4+ is4gen.2xlarge: 8+ is4gen.4xlarge: 16+ is4gen.8xlarge: 32+ is4gen.large: 2+ is4gen.medium: 1+ is4gen.xlarge: 4+ m1.large: 2+ m1.medium: 1+ m1.small: 1+ m1.xlarge: 4+ m2.2xlarge: 4+ m2.4xlarge: 8+ m2.xlarge: 2+ m3.2xlarge: 8+ m3.large: 2+ m3.medium: 1+ m3.xlarge: 4+ m4.10xlarge: 40+ m4.16xlarge: 64+ m4.2xlarge: 8+ m4.4xlarge: 16+ m4.large: 2+ m4.xlarge: 4+ m5.12xlarge: 48+ m5.16xlarge: 64+ m5.24xlarge: 96+ m5.2xlarge: 8+ m5.4xlarge: 16+ m5.8xlarge: 32+ m5.large: 2+ m5.metal: 96+ m5.xlarge: 4+ m5a.12xlarge: 48+ m5a.16xlarge: 64+ m5a.24xlarge: 96+ m5a.2xlarge: 8+ m5a.4xlarge: 16+ m5a.8xlarge: 32+ m5a.large: 2+ m5a.xlarge: 4+ m5ad.12xlarge: 48+ m5ad.16xlarge: 64+ m5ad.24xlarge: 96+ m5ad.2xlarge: 8+ m5ad.4xlarge: 16+ m5ad.8xlarge: 32+ m5ad.large: 2+ m5ad.xlarge: 4+ m5d.12xlarge: 48+ m5d.16xlarge: 64+ m5d.24xlarge: 96+ m5d.2xlarge: 8+ m5d.4xlarge: 16+ m5d.8xlarge: 32+ m5d.large: 2+ m5d.metal: 96+ m5d.xlarge: 4+ m5dn.12xlarge: 48+ m5dn.16xlarge: 64+ m5dn.24xlarge: 96+ m5dn.2xlarge: 8+ m5dn.4xlarge: 16+ m5dn.8xlarge: 32+ m5dn.large: 2+ m5dn.metal: 96+ m5dn.xlarge: 4+ m5n.12xlarge: 48+ m5n.16xlarge: 64+ m5n.24xlarge: 96+ m5n.2xlarge: 8+ m5n.4xlarge: 16+ m5n.8xlarge: 32+ m5n.large: 2+ m5n.metal: 96+ m5n.xlarge: 4+ m5zn.12xlarge: 48+ m5zn.2xlarge: 8+ m5zn.3xlarge: 12+ m5zn.6xlarge: 24+ m5zn.large: 2+ m5zn.metal: 48+ m5zn.xlarge: 4+ m6a.12xlarge: 48+ m6a.16xlarge: 64+ m6a.24xlarge: 96+ m6a.2xlarge: 8+ m6a.32xlarge: 128+ m6a.48xlarge: 192+ m6a.4xlarge: 16+ m6a.8xlarge: 32+ m6a.large: 2+ m6a.metal: 192+ m6a.xlarge: 4+ m6g.12xlarge: 48+ m6g.16xlarge: 64+ m6g.2xlarge: 8+ m6g.4xlarge: 16+ m6g.8xlarge: 32+ m6g.large: 2+ m6g.medium: 1+ m6g.metal: 64+ m6g.xlarge: 4+ m6gd.12xlarge: 48+ m6gd.16xlarge: 64+ m6gd.2xlarge: 8+ m6gd.4xlarge: 16+ m6gd.8xlarge: 32+ m6gd.large: 2+ m6gd.medium: 1+ m6gd.metal: 64+ m6gd.xlarge: 4+ m6i.12xlarge: 48+ m6i.16xlarge: 64+ m6i.24xlarge: 96+ m6i.2xlarge: 8+ m6i.32xlarge: 128+ m6i.4xlarge: 16+ m6i.8xlarge: 32+ m6i.large: 2+ m6i.metal: 128+ m6i.xlarge: 4+ m6id.12xlarge: 48+ m6id.16xlarge: 64+ m6id.24xlarge: 96+ m6id.2xlarge: 8+ m6id.32xlarge: 128+ m6id.4xlarge: 16+ m6id.8xlarge: 32+ m6id.large: 2+ m6id.metal: 128+ m6id.xlarge: 4+ m6idn.12xlarge: 48+ m6idn.16xlarge: 64+ m6idn.24xlarge: 96+ m6idn.2xlarge: 8+ m6idn.32xlarge: 128+ m6idn.4xlarge: 16+ m6idn.8xlarge: 32+ m6idn.large: 2+ m6idn.metal: 128+ m6idn.xlarge: 4+ m6in.12xlarge: 48+ m6in.16xlarge: 64+ m6in.24xlarge: 96+ m6in.2xlarge: 8+ m6in.32xlarge: 128+ m6in.4xlarge: 16+ m6in.8xlarge: 32+ m6in.large: 2+ m6in.metal: 128+ m6in.xlarge: 4+ m7a.12xlarge: 48+ m7a.16xlarge: 64+ m7a.24xlarge: 96+ m7a.2xlarge: 8+ m7a.32xlarge: 128+ m7a.48xlarge: 192+ m7a.4xlarge: 16+ m7a.8xlarge: 32+ m7a.large: 2+ m7a.medium: 1+ m7a.metal-48xl: 192+ m7a.xlarge: 4+ m7g.12xlarge: 48+ m7g.16xlarge: 64+ m7g.2xlarge: 8+ m7g.4xlarge: 16+ m7g.8xlarge: 32+ m7g.large: 2+ m7g.medium: 1+ m7g.metal: 64+ m7g.xlarge: 4+ m7gd.12xlarge: 48+ m7gd.16xlarge: 64+ m7gd.2xlarge: 8+ m7gd.4xlarge: 16+ m7gd.8xlarge: 32+ m7gd.large: 2+ m7gd.medium: 1+ m7gd.metal: 64+ m7gd.xlarge: 4+ m7i-flex.12xlarge: 48+ m7i-flex.16xlarge: 64+ m7i-flex.2xlarge: 8+ m7i-flex.4xlarge: 16+ m7i-flex.8xlarge: 32+ m7i-flex.large: 2+ m7i-flex.xlarge: 4+ m7i.12xlarge: 48+ m7i.16xlarge: 64+ m7i.24xlarge: 96+ m7i.2xlarge: 8+ m7i.48xlarge: 192+ m7i.4xlarge: 16+ m7i.8xlarge: 32+ m7i.large: 2+ m7i.metal-24xl: 96+ m7i.metal-48xl: 192+ m7i.xlarge: 4+ m8a.12xlarge: 48+ m8a.16xlarge: 64+ m8a.24xlarge: 96+ m8a.2xlarge: 8+ m8a.48xlarge: 192+ m8a.4xlarge: 16+ m8a.8xlarge: 32+ m8a.large: 2+ m8a.medium: 1+ m8a.metal-24xl: 96+ m8a.metal-48xl: 192+ m8a.xlarge: 4+ m8azn.12xlarge: 48+ m8azn.24xlarge: 96+ m8azn.3xlarge: 12+ m8azn.6xlarge: 24+ m8azn.large: 2+ m8azn.medium: 1+ m8azn.metal-12xl: 48+ m8azn.metal-24xl: 96+ m8azn.xlarge: 4+ m8g.12xlarge: 48+ m8g.16xlarge: 64+ m8g.24xlarge: 96+ m8g.2xlarge: 8+ m8g.48xlarge: 192+ m8g.4xlarge: 16+ m8g.8xlarge: 32+ m8g.large: 2+ m8g.medium: 1+ m8g.metal-24xl: 96+ m8g.metal-48xl: 192+ m8g.xlarge: 4+ m8gb.12xlarge: 48+ m8gb.16xlarge: 64+ m8gb.24xlarge: 96+ m8gb.2xlarge: 8+ m8gb.48xlarge: 192+ m8gb.4xlarge: 16+ m8gb.8xlarge: 32+ m8gb.large: 2+ m8gb.medium: 1+ m8gb.metal-24xl: 96+ m8gb.metal-48xl: 192+ m8gb.xlarge: 4+ m8gd.12xlarge: 48+ m8gd.16xlarge: 64+ m8gd.24xlarge: 96+ m8gd.2xlarge: 8+ m8gd.48xlarge: 192+ m8gd.4xlarge: 16+ m8gd.8xlarge: 32+ m8gd.large: 2+ m8gd.medium: 1+ m8gd.metal-24xl: 96+ m8gd.metal-48xl: 192+ m8gd.xlarge: 4+ m8gn.12xlarge: 48+ m8gn.16xlarge: 64+ m8gn.24xlarge: 96+ m8gn.2xlarge: 8+ m8gn.48xlarge: 192+ m8gn.4xlarge: 16+ m8gn.8xlarge: 32+ m8gn.large: 2+ m8gn.medium: 1+ m8gn.metal-24xl: 96+ m8gn.metal-48xl: 192+ m8gn.xlarge: 4+ m8i-flex.12xlarge: 48+ m8i-flex.16xlarge: 64+ m8i-flex.2xlarge: 8+ m8i-flex.4xlarge: 16+ m8i-flex.8xlarge: 32+ m8i-flex.large: 2+ m8i-flex.xlarge: 4+ m8i.12xlarge: 48+ m8i.16xlarge: 64+ m8i.24xlarge: 96+ m8i.2xlarge: 8+ m8i.32xlarge: 128+ m8i.48xlarge: 192+ m8i.4xlarge: 16+ m8i.8xlarge: 32+ m8i.96xlarge: 384+ m8i.large: 2+ m8i.metal-48xl: 192+ m8i.metal-96xl: 384+ m8i.xlarge: 4+ m8ib.12xlarge: 48+ m8ib.16xlarge: 64+ m8ib.24xlarge: 96+ m8ib.2xlarge: 8+ m8ib.32xlarge: 128+ m8ib.48xlarge: 192+ m8ib.4xlarge: 16+ m8ib.8xlarge: 32+ m8ib.96xlarge: 384+ m8ib.large: 2+ m8ib.metal-48xl: 192+ m8ib.metal-96xl: 384+ m8ib.xlarge: 4+ m8id.12xlarge: 48+ m8id.16xlarge: 64+ m8id.24xlarge: 96+ m8id.2xlarge: 8+ m8id.32xlarge: 128+ m8id.48xlarge: 192+ m8id.4xlarge: 16+ m8id.8xlarge: 32+ m8id.96xlarge: 384+ m8id.large: 2+ m8id.metal-48xl: 192+ m8id.metal-96xl: 384+ m8id.xlarge: 4+ m8idb.12xlarge: 48+ m8idb.16xlarge: 64+ m8idb.24xlarge: 96+ m8idb.2xlarge: 8+ m8idb.32xlarge: 128+ m8idb.48xlarge: 192+ m8idb.4xlarge: 16+ m8idb.8xlarge: 32+ m8idb.96xlarge: 384+ m8idb.large: 2+ m8idb.metal-48xl: 192+ m8idb.metal-96xl: 384+ m8idb.xlarge: 4+ m8idn.12xlarge: 48+ m8idn.16xlarge: 64+ m8idn.24xlarge: 96+ m8idn.2xlarge: 8+ m8idn.32xlarge: 128+ m8idn.48xlarge: 192+ m8idn.4xlarge: 16+ m8idn.8xlarge: 32+ m8idn.96xlarge: 384+ m8idn.large: 2+ m8idn.metal-48xl: 192+ m8idn.metal-96xl: 384+ m8idn.xlarge: 4+ m8in.12xlarge: 48+ m8in.16xlarge: 64+ m8in.24xlarge: 96+ m8in.2xlarge: 8+ m8in.32xlarge: 128+ m8in.48xlarge: 192+ m8in.4xlarge: 16+ m8in.8xlarge: 32+ m8in.96xlarge: 384+ m8in.large: 2+ m8in.metal-48xl: 192+ m8in.metal-96xl: 384+ m8in.xlarge: 4+ m8ine.12xlarge: 48+ m8ine.2xlarge: 8+ m8ine.4xlarge: 16+ m8ine.8xlarge: 32+ m8ine.large: 2+ m8ine.xlarge: 4+ m9g.12xlarge: 48+ m9g.16xlarge: 64+ m9g.24xlarge: 96+ m9g.2xlarge: 8+ m9g.48xlarge: 192+ m9g.4xlarge: 16+ m9g.8xlarge: 32+ m9g.large: 2+ m9g.medium: 1+ m9g.metal-48xl: 192+ m9g.xlarge: 4+ m9gd.12xlarge: 48+ m9gd.16xlarge: 64+ m9gd.24xlarge: 96+ m9gd.2xlarge: 8+ m9gd.48xlarge: 192+ m9gd.4xlarge: 16+ m9gd.8xlarge: 32+ m9gd.large: 2+ m9gd.medium: 1+ m9gd.metal-48xl: 192+ m9gd.xlarge: 4+ mac-m3ultra.metal: 28+ mac-m4.metal: 10+ mac-m4max.metal: 16+ mac-m4pro.metal: 14+ mac1.metal: 12+ mac2-m1ultra.metal: 20+ mac2-m2.metal: 8+ mac2-m2pro.metal: 12+ mac2.metal: 8+ p2.16xlarge: 64+ p2.8xlarge: 32+ p2.xlarge: 4+ p3.16xlarge: 64+ p3.2xlarge: 8+ p3.8xlarge: 32+ p3dn.24xlarge: 96+ p4d.24xlarge: 96+ p4de.24xlarge: 96+ p5.48xlarge: 192+ p5.4xlarge: 16+ p5e.48xlarge: 192+ p5en.48xlarge: 192+ p6-b200.48xlarge: 192+ p6-b300.48xlarge: 192+ p6e-gb200.36xlarge: 144+ r3.2xlarge: 8+ r3.4xlarge: 16+ r3.8xlarge: 32+ r3.large: 2+ r3.xlarge: 4+ r4.16xlarge: 64+ r4.2xlarge: 8+ r4.4xlarge: 16+ r4.8xlarge: 32+ r4.large: 2+ r4.xlarge: 4+ r5.12xlarge: 48+ r5.16xlarge: 64+ r5.24xlarge: 96+ r5.2xlarge: 8+ r5.4xlarge: 16+ r5.8xlarge: 32+ r5.large: 2+ r5.metal: 96+ r5.xlarge: 4+ r5a.12xlarge: 48+ r5a.16xlarge: 64+ r5a.24xlarge: 96+ r5a.2xlarge: 8+ r5a.4xlarge: 16+ r5a.8xlarge: 32+ r5a.large: 2+ r5a.xlarge: 4+ r5ad.12xlarge: 48+ r5ad.16xlarge: 64+ r5ad.24xlarge: 96+ r5ad.2xlarge: 8+ r5ad.4xlarge: 16+ r5ad.8xlarge: 32+ r5ad.large: 2+ r5ad.xlarge: 4+ r5b.12xlarge: 48+ r5b.16xlarge: 64+ r5b.24xlarge: 96+ r5b.2xlarge: 8+ r5b.4xlarge: 16+ r5b.8xlarge: 32+ r5b.large: 2+ r5b.metal: 96+ r5b.xlarge: 4+ r5d.12xlarge: 48+ r5d.16xlarge: 64+ r5d.24xlarge: 96+ r5d.2xlarge: 8+ r5d.4xlarge: 16+ r5d.8xlarge: 32+ r5d.large: 2+ r5d.metal: 96+ r5d.xlarge: 4+ r5dn.12xlarge: 48+ r5dn.16xlarge: 64+ r5dn.24xlarge: 96+ r5dn.2xlarge: 8+ r5dn.4xlarge: 16+ r5dn.8xlarge: 32+ r5dn.large: 2+ r5dn.metal: 96+ r5dn.xlarge: 4+ r5n.12xlarge: 48+ r5n.16xlarge: 64+ r5n.24xlarge: 96+ r5n.2xlarge: 8+ r5n.4xlarge: 16+ r5n.8xlarge: 32+ r5n.large: 2+ r5n.metal: 96+ r5n.xlarge: 4+ r6a.12xlarge: 48+ r6a.16xlarge: 64+ r6a.24xlarge: 96+ r6a.2xlarge: 8+ r6a.32xlarge: 128+ r6a.48xlarge: 192+ r6a.4xlarge: 16+ r6a.8xlarge: 32+ r6a.large: 2+ r6a.metal: 192+ r6a.xlarge: 4+ r6g.12xlarge: 48+ r6g.16xlarge: 64+ r6g.2xlarge: 8+ r6g.4xlarge: 16+ r6g.8xlarge: 32+ r6g.large: 2+ r6g.medium: 1+ r6g.metal: 64+ r6g.xlarge: 4+ r6gd.12xlarge: 48+ r6gd.16xlarge: 64+ r6gd.2xlarge: 8+ r6gd.4xlarge: 16+ r6gd.8xlarge: 32+ r6gd.large: 2+ r6gd.medium: 1+ r6gd.metal: 64+ r6gd.xlarge: 4+ r6i.12xlarge: 48+ r6i.16xlarge: 64+ r6i.24xlarge: 96+ r6i.2xlarge: 8+ r6i.32xlarge: 128+ r6i.4xlarge: 16+ r6i.8xlarge: 32+ r6i.large: 2+ r6i.metal: 128+ r6i.xlarge: 4+ r6id.12xlarge: 48+ r6id.16xlarge: 64+ r6id.24xlarge: 96+ r6id.2xlarge: 8+ r6id.32xlarge: 128+ r6id.4xlarge: 16+ r6id.8xlarge: 32+ r6id.large: 2+ r6id.metal: 128+ r6id.xlarge: 4+ r6idn.12xlarge: 48+ r6idn.16xlarge: 64+ r6idn.24xlarge: 96+ r6idn.2xlarge: 8+ r6idn.32xlarge: 128+ r6idn.4xlarge: 16+ r6idn.8xlarge: 32+ r6idn.large: 2+ r6idn.metal: 128+ r6idn.xlarge: 4+ r6in.12xlarge: 48+ r6in.16xlarge: 64+ r6in.24xlarge: 96+ r6in.2xlarge: 8+ r6in.32xlarge: 128+ r6in.4xlarge: 16+ r6in.8xlarge: 32+ r6in.large: 2+ r6in.metal: 128+ r6in.xlarge: 4+ r7a.12xlarge: 48+ r7a.16xlarge: 64+ r7a.24xlarge: 96+ r7a.2xlarge: 8+ r7a.32xlarge: 128+ r7a.48xlarge: 192+ r7a.4xlarge: 16+ r7a.8xlarge: 32+ r7a.large: 2+ r7a.medium: 1+ r7a.metal-48xl: 192+ r7a.xlarge: 4+ r7g.12xlarge: 48+ r7g.16xlarge: 64+ r7g.2xlarge: 8+ r7g.4xlarge: 16+ r7g.8xlarge: 32+ r7g.large: 2+ r7g.medium: 1+ r7g.metal: 64+ r7g.xlarge: 4+ r7gd.12xlarge: 48+ r7gd.16xlarge: 64+ r7gd.2xlarge: 8+ r7gd.4xlarge: 16+ r7gd.8xlarge: 32+ r7gd.large: 2+ r7gd.medium: 1+ r7gd.metal: 64+ r7gd.xlarge: 4+ r7i.12xlarge: 48+ r7i.16xlarge: 64+ r7i.24xlarge: 96+ r7i.2xlarge: 8+ r7i.48xlarge: 192+ r7i.4xlarge: 16+ r7i.8xlarge: 32+ r7i.large: 2+ r7i.metal-24xl: 96+ r7i.metal-48xl: 192+ r7i.xlarge: 4+ r7iz.12xlarge: 48+ r7iz.16xlarge: 64+ r7iz.2xlarge: 8+ r7iz.32xlarge: 128+ r7iz.4xlarge: 16+ r7iz.8xlarge: 32+ r7iz.large: 2+ r7iz.metal-16xl: 64+ r7iz.metal-32xl: 128+ r7iz.xlarge: 4+ r8a.12xlarge: 48+ r8a.16xlarge: 64+ r8a.24xlarge: 96+ r8a.2xlarge: 8+ r8a.48xlarge: 192+ r8a.4xlarge: 16+ r8a.8xlarge: 32+ r8a.large: 2+ r8a.medium: 1+ r8a.metal-24xl: 96+ r8a.metal-48xl: 192+ r8a.xlarge: 4+ r8g.12xlarge: 48+ r8g.16xlarge: 64+ r8g.24xlarge: 96+ r8g.2xlarge: 8+ r8g.48xlarge: 192+ r8g.4xlarge: 16+ r8g.8xlarge: 32+ r8g.large: 2+ r8g.medium: 1+ r8g.metal-24xl: 96+ r8g.metal-48xl: 192+ r8g.xlarge: 4+ r8gb.12xlarge: 48+ r8gb.16xlarge: 64+ r8gb.24xlarge: 96+ r8gb.2xlarge: 8+ r8gb.48xlarge: 192+ r8gb.4xlarge: 16+ r8gb.8xlarge: 32+ r8gb.large: 2+ r8gb.medium: 1+ r8gb.metal-24xl: 96+ r8gb.metal-48xl: 192+ r8gb.xlarge: 4+ r8gd.12xlarge: 48+ r8gd.16xlarge: 64+ r8gd.24xlarge: 96+ r8gd.2xlarge: 8+ r8gd.48xlarge: 192+ r8gd.4xlarge: 16+ r8gd.8xlarge: 32+ r8gd.large: 2+ r8gd.medium: 1+ r8gd.metal-24xl: 96+ r8gd.metal-48xl: 192+ r8gd.xlarge: 4+ r8gn.12xlarge: 48+ r8gn.16xlarge: 64+ r8gn.24xlarge: 96+ r8gn.2xlarge: 8+ r8gn.48xlarge: 192+ r8gn.4xlarge: 16+ r8gn.8xlarge: 32+ r8gn.large: 2+ r8gn.medium: 1+ r8gn.metal-24xl: 96+ r8gn.metal-48xl: 192+ r8gn.xlarge: 4+ r8i-flex.12xlarge: 48+ r8i-flex.16xlarge: 64+ r8i-flex.2xlarge: 8+ r8i-flex.4xlarge: 16+ r8i-flex.8xlarge: 32+ r8i-flex.large: 2+ r8i-flex.xlarge: 4+ r8i.12xlarge: 48+ r8i.16xlarge: 64+ r8i.24xlarge: 96+ r8i.2xlarge: 8+ r8i.32xlarge: 128+ r8i.48xlarge: 192+ r8i.4xlarge: 16+ r8i.8xlarge: 32+ r8i.96xlarge: 384+ r8i.large: 2+ r8i.metal-48xl: 192+ r8i.metal-96xl: 384+ r8i.xlarge: 4+ r8ib.12xlarge: 48+ r8ib.16xlarge: 64+ r8ib.24xlarge: 96+ r8ib.2xlarge: 8+ r8ib.32xlarge: 128+ r8ib.48xlarge: 192+ r8ib.4xlarge: 16+ r8ib.8xlarge: 32+ r8ib.96xlarge: 384+ r8ib.large: 2+ r8ib.metal-48xl: 192+ r8ib.metal-96xl: 384+ r8ib.xlarge: 4+ r8id.12xlarge: 48+ r8id.16xlarge: 64+ r8id.24xlarge: 96+ r8id.2xlarge: 8+ r8id.32xlarge: 128+ r8id.48xlarge: 192+ r8id.4xlarge: 16+ r8id.8xlarge: 32+ r8id.96xlarge: 384+ r8id.large: 2+ r8id.metal-48xl: 192+ r8id.metal-96xl: 384+ r8id.xlarge: 4+ r8idb.12xlarge: 48+ r8idb.16xlarge: 64+ r8idb.24xlarge: 96+ r8idb.2xlarge: 8+ r8idb.32xlarge: 128+ r8idb.48xlarge: 192+ r8idb.4xlarge: 16+ r8idb.8xlarge: 32+ r8idb.96xlarge: 384+ r8idb.large: 2+ r8idb.metal-48xl: 192+ r8idb.metal-96xl: 384+ r8idb.xlarge: 4+ r8idn.12xlarge: 48+ r8idn.16xlarge: 64+ r8idn.24xlarge: 96+ r8idn.2xlarge: 8+ r8idn.32xlarge: 128+ r8idn.48xlarge: 192+ r8idn.4xlarge: 16+ r8idn.8xlarge: 32+ r8idn.96xlarge: 384+ r8idn.large: 2+ r8idn.metal-48xl: 192+ r8idn.metal-96xl: 384+ r8idn.xlarge: 4+ r8in.12xlarge: 48+ r8in.16xlarge: 64+ r8in.24xlarge: 96+ r8in.2xlarge: 8+ r8in.32xlarge: 128+ r8in.48xlarge: 192+ r8in.4xlarge: 16+ r8in.8xlarge: 32+ r8in.96xlarge: 384+ r8in.large: 2+ r8in.metal-48xl: 192+ r8in.metal-96xl: 384+ r8in.xlarge: 4+ r9g.12xlarge: 48+ r9g.16xlarge: 64+ r9g.24xlarge: 96+ r9g.2xlarge: 8+ r9g.48xlarge: 192+ r9g.4xlarge: 16+ r9g.8xlarge: 32+ r9g.large: 2+ r9g.medium: 1+ r9g.metal-48xl: 192+ r9g.xlarge: 4+ r9gd.12xlarge: 48+ r9gd.16xlarge: 64+ r9gd.24xlarge: 96+ r9gd.2xlarge: 8+ r9gd.48xlarge: 192+ r9gd.4xlarge: 16+ r9gd.8xlarge: 32+ r9gd.large: 2+ r9gd.medium: 1+ r9gd.metal-48xl: 192+ r9gd.xlarge: 4+ t1.micro: 1+ t2.2xlarge: 8+ t2.large: 2+ t2.medium: 2+ t2.micro: 1+ t2.nano: 1+ t2.small: 1+ t2.xlarge: 4+ t3.2xlarge: 8+ t3.large: 2+ t3.medium: 2+ t3.micro: 2+ t3.nano: 2+ t3.small: 2+ t3.xlarge: 4+ t3a.2xlarge: 8+ t3a.large: 2+ t3a.medium: 2+ t3a.micro: 2+ t3a.nano: 2+ t3a.small: 2+ t3a.xlarge: 4+ t4g.2xlarge: 8+ t4g.large: 2+ t4g.medium: 2+ t4g.micro: 2+ t4g.nano: 2+ t4g.small: 2+ t4g.xlarge: 4+ t8i.medium: 2+ t8i.micro: 2+ t8i.nano: 2+ t8i.small: 2+ trn1.2xlarge: 8+ trn1.32xlarge: 128+ trn1n.32xlarge: 128+ trn2.3xlarge: 12+ trn2.48xlarge: 192+ trn2u.48xlarge: 192+ u-12tb1.112xlarge: 448+ u-12tb1.metal: 448+ u-18tb1.112xlarge: 448+ u-18tb1.metal: 448+ u-24tb1.112xlarge: 448+ u-24tb1.metal: 448+ u-3tb1.56xlarge: 224+ u-6tb1.112xlarge: 448+ u-6tb1.56xlarge: 224+ u-6tb1.metal: 448+ u-9tb1.112xlarge: 448+ u-9tb1.metal: 448+ u7i-12tb.224xlarge: 896+ u7i-6tb.112xlarge: 448+ u7i-8tb.112xlarge: 448+ u7ib-12tb.224xlarge: 896+ u7in-16tb.224xlarge: 896+ u7in-24tb.224xlarge: 896+ u7in-32tb.224xlarge: 896+ u7inh-32tb.480xlarge: 1920+ vt1.24xlarge: 96+ vt1.3xlarge: 12+ vt1.6xlarge: 24+ x1.16xlarge: 64+ x1.32xlarge: 128+ x1e.16xlarge: 64+ x1e.2xlarge: 8+ x1e.32xlarge: 128+ x1e.4xlarge: 16+ x1e.8xlarge: 32+ x1e.xlarge: 4+ x2gd.12xlarge: 48+ x2gd.16xlarge: 64+ x2gd.2xlarge: 8+ x2gd.4xlarge: 16+ x2gd.8xlarge: 32+ x2gd.large: 2+ x2gd.medium: 1+ x2gd.metal: 64+ x2gd.xlarge: 4+ x2idn.16xlarge: 64+ x2idn.24xlarge: 96+ x2idn.32xlarge: 128+ x2idn.metal: 128+ x2iedn.16xlarge: 64+ x2iedn.24xlarge: 96+ x2iedn.2xlarge: 8+ x2iedn.32xlarge: 128+ x2iedn.4xlarge: 16+ x2iedn.8xlarge: 32+ x2iedn.metal: 128+ x2iedn.xlarge: 4+ x2iezn.12xlarge: 48+ x2iezn.2xlarge: 8+ x2iezn.4xlarge: 16+ x2iezn.6xlarge: 24+ x2iezn.8xlarge: 32+ x2iezn.metal: 48+ x8aedz.12xlarge: 48+ x8aedz.24xlarge: 96+ x8aedz.3xlarge: 12+ x8aedz.6xlarge: 24+ x8aedz.large: 2+ x8aedz.metal-12xl: 48+ x8aedz.metal-24xl: 96+ x8aedz.xlarge: 4+ x8g.12xlarge: 48+ x8g.16xlarge: 64+ x8g.24xlarge: 96+ x8g.2xlarge: 8+ x8g.48xlarge: 192+ x8g.4xlarge: 16+ x8g.8xlarge: 32+ x8g.large: 2+ x8g.medium: 1+ x8g.metal-24xl: 96+ x8g.metal-48xl: 192+ x8g.xlarge: 4+ x8i.12xlarge: 48+ x8i.16xlarge: 64+ x8i.24xlarge: 96+ x8i.2xlarge: 8+ x8i.32xlarge: 128+ x8i.48xlarge: 192+ x8i.4xlarge: 16+ x8i.64xlarge: 256+ x8i.8xlarge: 32+ x8i.96xlarge: 384+ x8i.large: 2+ x8i.metal-48xl: 192+ x8i.metal-96xl: 384+ x8i.xlarge: 4+ z1d.12xlarge: 48+ z1d.2xlarge: 8+ z1d.3xlarge: 12+ z1d.6xlarge: 24+ z1d.large: 2+ z1d.metal: 48+ z1d.xlarge: 4diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateFleetRollbackTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateFleetRollbackTest.javaindex 9ec960dac3..bf82b20d57 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateFleetRollbackTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateFleetRollbackTest.java@@ -44,7 +44,7 @@ class Ec2CreateFleetRollbackTest {nullable(String.class), nullable(Boolean.class), nullable(String.class), anyInt(),nullable(String.class), nullable(LaunchTemplateData.MetadataOptions.class),nullable(String.class), nullable(String.class), eq(false), nullable(String.class),- nullable(String.class), anyList()))+ nullable(String.class), anyList(), eq(false))).thenReturn(reservation("i-first")).thenReturn(reservation("i-second")).thenThrow(new AwsException("InvalidSubnetID.NotFound", "launch failed", 400));diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceTypeCatalogTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceTypeCatalogTest.javaindex babad3528f..0aa6339f41 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceTypeCatalogTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceTypeCatalogTest.java@@ -74,6 +74,39 @@ class Ec2InstanceTypeCatalogTest {assertFalse(instanceTypeCatalog.find("m8gd.xlarge").isPresent());}+ @Test+ void defaultCpuSnapshotDoesNotInventOtherDescribeMetadata() {+ assertEquals(Optional.of(2), instanceTypeCatalog.defaultVcpus("t3.large"));+ assertEquals(Optional.of(144), instanceTypeCatalog.defaultVcpus("p6e-gb200.36xlarge"));+ assertEquals(Optional.of(2), instanceTypeCatalog.defaultVcpus("cc1.4xlarge"));+ assertTrue(instanceTypeCatalog.find("t3.large").isEmpty());+ assertTrue(instanceTypeCatalog.find("p6e-gb200.36xlarge").isEmpty());+ assertTrue(instanceTypeCatalog.defaultVcpus("m9g.metal-24xl").isEmpty());+ assertTrue(instanceTypeCatalog.defaultVcpus("m9gd.metal-24xl").isEmpty());+ assertTrue(instanceTypeCatalog.defaultVcpus(null).isEmpty());+ assertTrue(instanceTypeCatalog.defaultVcpus("").isEmpty());+ }++ @Test+ void anExplicitFullCatalogEntryTakesPrecedenceOverTheCpuOnlySnapshot() {+ Ec2InstanceTypeCatalog.CatalogInstanceType configured =+ instanceTypeCatalog.find("t3.micro").orElseThrow();+ Ec2InstanceTypeCatalog.Catalog catalog = new Ec2InstanceTypeCatalog.Catalog();+ // Make a detached entry so this test cannot alter the injected application catalog.+ Ec2InstanceTypeCatalog.CatalogInstanceType override = new Ec2InstanceTypeCatalog.CatalogInstanceType();+ override.instanceType = configured.instanceType;+ override.vcpu = 3;+ override.memoryMib = configured.memoryMib;+ override.supportedArchitectures = configured.supportedArchitectures;+ override.encryptionInTransitSupported = configured.encryptionInTransitSupported;+ override.defaultNetworkCardIndex = configured.defaultNetworkCardIndex;+ override.ipv4AddressesPerInterface = configured.ipv4AddressesPerInterface;+ override.networkCards = configured.networkCards;+ catalog.instanceTypes = List.of(override);+ assertEquals(Optional.of(3), new Ec2InstanceTypeCatalog(catalog).defaultVcpus("t3.micro"));+ assertEquals(2, configured.vcpu);+ }+@Testvoid catalogEntriesIncludeNetworkCompatibilityMetadata() {instanceTypeCatalog.instanceTypes().forEach(instanceType ->diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2QuotaDefaultOffIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2QuotaDefaultOffIntegrationTest.javanew file mode 100644index 0000000000..7bea840364--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2QuotaDefaultOffIntegrationTest.java@@ -0,0 +1,47 @@+package io.github.hectorvent.floci.services.ec2;++import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.QuarkusTestProfile;+import io.quarkus.test.junit.TestProfile;+import org.junit.jupiter.api.Test;++import java.util.Map;++import static io.restassured.RestAssured.given;++@QuarkusTest+@TestProfile(Ec2QuotaDefaultOffIntegrationTest.Disabled.class)+class Ec2QuotaDefaultOffIntegrationTest {+ public static class Disabled implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of("floci.services.servicequotas.standard-on-demand-vcpus", "5");+ }+ }++ @Test+ void defaultOffKeepsSixMicroInstancesAcceptable() {+ try {+ given().header("Authorization", auth("687432101241")).formParams("Action", "RunInstances",+ "ImageId", "ami-0abcdef1234567890", "InstanceType", "t2.micro", "MinCount", "6", "MaxCount", "6")+ .post("/").then().statusCode(200);+ } finally {+ given().post("/_floci/state/reset").then().statusCode(200);+ }+ }++ @Test+ void defaultOffDoesNotRequireAVcpuSnapshotEntry() {+ try {+ given().header("Authorization", auth("687432101242")).formParams("Action", "RunInstances",+ "ImageId", "ami-0abcdef1234567890", "InstanceType", "m999.unmeasured",+ "MinCount", "1", "MaxCount", "1").post("/").then().statusCode(200);+ } finally {+ given().post("/_floci/state/reset").then().statusCode(200);+ }+ }++ private static String auth(String account) {+ return "AWS4-HMAC-SHA256 Credential=" + account + "/20261020/us-east-1/ec2/aws4_request";+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2RunInstancesPublicIpParamTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2RunInstancesPublicIpParamTest.javaindex 974dcbe6bc..9fbdd1fb92 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2RunInstancesPublicIpParamTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2RunInstancesPublicIpParamTest.java@@ -64,7 +64,7 @@ class Ec2RunInstancesPublicIpParamTest {nullable(String.class), anyList(), nullable(String.class), nullable(String.class),nullable(Boolean.class), nullable(String.class), anyInt(), nullable(String.class),nullable(LaunchTemplateData.MetadataOptions.class), nullable(String.class), nullable(String.class), eq(false),- nullable(String.class), nullable(String.class), nullable(List.class)))+ nullable(String.class), nullable(String.class), nullable(List.class), eq(false))).thenReturn(new Reservation());Ec2QueryHandler handler = new Ec2QueryHandler(service, mock(EmulatorConfig.class),@@ -79,7 +79,7 @@ class Ec2RunInstancesPublicIpParamTest {nullable(String.class), anyList(), nullable(String.class), nullable(String.class),associatePublicIp.capture(), nullable(String.class), anyInt(), nullable(String.class),nullable(LaunchTemplateData.MetadataOptions.class), nullable(String.class), nullable(String.class), eq(false),- nullable(String.class), nullable(String.class), nullable(List.class));+ nullable(String.class), nullable(String.class), nullable(List.class), eq(false));if (expected == null) {assertNull(associatePublicIp.getValue(),"an absent override must stay null so the subnet default decides");diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VcpuAdmissionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VcpuAdmissionIntegrationTest.javanew file mode 100644index 0000000000..fde9601ff3--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VcpuAdmissionIntegrationTest.java@@ -0,0 +1,70 @@+package io.github.hectorvent.floci.services.ec2;++import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.QuarkusTestProfile;+import io.quarkus.test.junit.TestProfile;+import org.junit.jupiter.api.Test;++import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;++@QuarkusTest+@TestProfile(Ec2VcpuAdmissionIntegrationTest.TwoVcpus.class)+class Ec2VcpuAdmissionIntegrationTest {+ public static class TwoVcpus implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of("floci.services.servicequotas.standard-on-demand-vcpus", "2",+ "floci.services.ec2.enforce-vcpu-quotas", "true");+ }+ }++ private static String auth(String account, String service) {+ return "AWS4-HMAC-SHA256 Credential=" + account + "/20260205/us-east-1/" + service + "/aws4_request";+ }++ @Test+ void directAndTemplateSpotDoNotConsumeOnDemandCapacityAndRequestOverridesTemplate() {+ String account = "687432101234";+ String header = auth(account, "ec2");+ given().header("Authorization", header).formParams("Action", "RunInstances",+ "ImageId", "ami-0abcdef1234567890", "InstanceType", "t3.micro", "MinCount", "1", "MaxCount", "1")+ .post("/").then().statusCode(200);+ given().header("Authorization", header).formParam("Action", "DescribeInstances")+ .post("/").then().statusCode(200).body(containsString("<name>running</name>"));+ try {+ given().header("Authorization", header).formParams("Action", "RunInstances",+ "ImageId", "ami-0abcdef1234567890", "InstanceType", "t3.micro", "MinCount", "1", "MaxCount", "1",+ "InstanceMarketOptions.MarketType", "spot")+ .post("/").then().statusCode(200).body(containsString("<instanceLifecycle>spot</instanceLifecycle>"));+ String template = given().header("Authorization", header).formParams("Action", "CreateLaunchTemplate",+ "LaunchTemplateName", "quota-market-" + UUID.randomUUID(),+ "LaunchTemplateData.ImageId", "ami-0abcdef1234567890", "LaunchTemplateData.InstanceType", "t3.micro",+ "LaunchTemplateData.InstanceMarketOptions.MarketType", "spot")+ .post("/").then().statusCode(200)+ .extract().path("CreateLaunchTemplateResponse.launchTemplate.launchTemplateId");+ try {+ given().header("Authorization", header).formParams("Action", "RunInstances",+ "LaunchTemplate.LaunchTemplateId", template, "MinCount", "1", "MaxCount", "1")+ .post("/").then().statusCode(200)+ .body(containsString("<instanceLifecycle>spot</instanceLifecycle>"));+ given().header("Authorization", header).formParams("Action", "RunInstances",+ "LaunchTemplate.LaunchTemplateId", template, "MinCount", "1", "MaxCount", "1",+ "InstanceMarketOptions.MarketType", "on-demand")+ .post("/").then().statusCode(400).body(containsString("VcpuLimitExceeded"));+ given().header("Authorization", header).formParam("Action", "DescribeInstances")+ .post("/").then().statusCode(200)+ .body(containsString("<instanceLifecycle>spot</instanceLifecycle>"));+ } finally {+ given().header("Authorization", header).formParams("Action", "DeleteLaunchTemplate",+ "LaunchTemplateId", template).post("/").then().statusCode(200);+ }+ } finally {+ given().post("/_floci/state/reset").then().statusCode(200);+ }+ }++}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VcpuPersistenceTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VcpuPersistenceTest.javanew file mode 100644index 0000000000..ad16c6a760--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VcpuPersistenceTest.java@@ -0,0 +1,76 @@+package io.github.hectorvent.floci.services.ec2;++import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.ServiceConfigAccess;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.ec2.model.Instance;+import io.github.hectorvent.floci.services.ec2.model.InstanceState;+import io.github.hectorvent.floci.services.ec2.portforward.Ec2PortForwardManager;+import org.junit.jupiter.api.io.TempDir;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import java.nio.file.Path;+import java.util.List;+import java.util.Map;+import java.util.Optional;+import java.util.stream.Collectors;++import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.Mockito.*;++class Ec2VcpuPersistenceTest {+ @ParameterizedTest+ @ValueSource(strings = {"persistent", "hybrid", "wal"})+ void reloadedInstancesRetainSpotProvenance(String mode, @TempDir Path dir) {+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(config.defaultAccountId()).thenReturn("000000000000");+ when(config.storage().persistentPath()).thenReturn(dir.toString());+ when(config.storage().wal().compactionIntervalMs()).thenReturn(60000L);+ when(config.services().ec2().mock()).thenReturn(true);+ when(config.services().ec2().mockPublicAddresses())+ .thenReturn(EmulatorConfig.Ec2ServiceConfig.MockPublicAddresses.NONE);+ when(config.services().ec2().mockPublicAddress()).thenReturn(Optional.empty());+ when(config.services().servicequotas().standardOnDemandVcpus()).thenReturn(5);+ ServiceConfigAccess access = mock(ServiceConfigAccess.class);+ when(access.storageMode("ec2")).thenReturn(mode);+ when(access.storageFlushInterval("ec2")).thenReturn(60000L);+ StorageFactory first = new StorageFactory(config, access);+ try {+ Ec2Service service = service(config, first);+ Instance spot = guest("i-persisted-spot", InstanceState.running());+ spot.setSpot(true);+ Instance ordinary = guest("i-persisted-ordinary", InstanceState.running());+ service.putInstanceForTest(spot);+ service.putInstanceForTest(ordinary);+ } finally {+ first.shutdownAll();+ }+ StorageFactory reloaded = new StorageFactory(config, access);+ try {+ Ec2Service service = service(config, reloaded);+ Map<String, Instance> instances = service.describeInstances("us-east-1", List.of(), Map.of()).stream()+ .flatMap(reservation -> reservation.getInstances().stream())+ .collect(Collectors.toMap(Instance::getInstanceId, i -> i));+ assertTrue(instances.get("i-persisted-spot").isSpot());+ assertFalse(instances.get("i-persisted-ordinary").isSpot());+ } finally {+ reloaded.shutdownAll();+ }+ }++ private static Instance guest(String id, InstanceState state) {+ Instance instance = new Instance();+ instance.setInstanceId(id);+ instance.setInstanceType("t3.large");+ instance.setOwnerId("000000000000");+ instance.setRegion("us-east-1");+ instance.setState(state);+ return instance;+ }++ private static Ec2Service service(EmulatorConfig config, StorageFactory storage) {+ return new Ec2Service(config, mock(Ec2ContainerManager.class), mock(Ec2PortForwardManager.class),+ mock(AmiImageResolver.class), new Ec2ImageCatalog(), new Ec2InstanceTypeCatalog(), storage);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VcpuQuotaTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VcpuQuotaTest.javanew file mode 100644index 0000000000..c42328dddf--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2VcpuQuotaTest.java@@ -0,0 +1,203 @@+package io.github.hectorvent.floci.services.ec2;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.ec2.model.Instance;+import io.github.hectorvent.floci.services.ec2.model.InstanceState;+import io.github.hectorvent.floci.services.ec2.model.Placement;+import io.github.hectorvent.floci.services.ec2.portforward.Ec2PortForwardManager;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import java.util.List;+import java.util.Map;+import java.util.Optional;++import static org.junit.jupiter.api.Assertions.*;+import static org.mockito.Mockito.*;++class Ec2VcpuQuotaTest {+ @Test+ void defaultOffPreservesLargeBatchesAndUnsizedTypes() {+ Ec2Service service = service(5, false);+ assertEquals(6, service.runInstances("us-east-1", "ami-test", "t2.micro", 6, 6, null,+ List.of(), null, null, List.of(), null, null).getInstances().size());+ assertNotNull(launch(service, "m5.2xlarge"));+ assertNotNull(launch(service, "m999.unmeasured"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"pending", "running", "stopping", "stopped", "shutting-down", "terminated"})+ void enabledAdmissionCountsOnlyRunningInstances(String state) {+ Ec2Service service = service(2, true);+ Instance existing = instance("i-existing", state);+ service.putInstanceForTest(existing);+ if ("running".equals(state)) {+ AwsException failure = assertThrows(AwsException.class, () -> launch(service, "t3.micro"));+ assertEquals("VcpuLimitExceeded", failure.getErrorCode());+ assertEquals(400, failure.getHttpStatus());+ existing.setState(InstanceState.stopping());+ assertNotNull(launch(service, "t3.micro"));+ } else {+ assertNotNull(launch(service, "t3.micro"));+ }+ }++ @Test+ void partialBatchesFitCurrentRunningUsageAndRefusedMinimumPublishesNothing() {+ Ec2Service service = service(5, true);+ Instance running = instance("i-running", "running");+ running.setInstanceType("t3.large");+ service.putInstanceForTest(running);+ assertEquals(1, service.runInstances("us-east-1", "ami-test", "t3.micro", 1, 4, null,+ List.of(), null, null, List.of(), null, null).getInstances().size());+ AwsException refused = assertThrows(AwsException.class, () -> service.runInstances("us-east-1", "ami-test",+ "t3.micro", 2, 4, null, List.of(), null, null, List.of(), null, null));+ assertEquals("VcpuLimitExceeded", refused.getErrorCode());+ assertEquals(2, service.describeInstances("us-east-1", List.of(), Map.of()).stream()+ .mapToInt(reservation -> reservation.getInstances().size()).sum());+ }++ @Test+ void pendingLaunchesDoNotReserveFutureRunningCapacity() {+ Ec2Service service = service(2, true);+ Instance first = launch(service, "t3.micro");+ assertEquals("pending", first.getState().getName());+ Instance second = launch(service, "t3.micro");+ assertEquals("pending", second.getState().getName());+ }++ @Test+ void startsUseCurrentRunningUsageDeduplicateIdsAndRetryAfterStop() {+ Ec2Service service = service(2, true);+ Instance running = instance("i-running", "running");+ Instance stopped = instance("i-stopped", "stopped");+ service.putInstanceForTest(running);+ service.putInstanceForTest(stopped);+ AwsException refused = assertThrows(AwsException.class, () -> service.startInstances("us-east-1",+ List.of(stopped.getInstanceId(), stopped.getInstanceId())));+ assertEquals("VcpuLimitExceeded", refused.getErrorCode());+ assertEquals("stopped", stopped.getState().getName());+ service.stopInstances("us-east-1", List.of(running.getInstanceId()));+ service.startInstances("us-east-1", List.of(stopped.getInstanceId(), stopped.getInstanceId()));+ assertEquals("running", stopped.getState().getName());+ }++ @Test+ void startingAStoppingTargetChecksItsNewRunningCostAndCanRetry() {+ Ec2Service service = service(2, true);+ Instance running = instance("i-running", "running");+ Instance stopping = instance("i-stopping", "stopping");+ service.putInstanceForTest(running);+ service.putInstanceForTest(stopping);+ AwsException refused = assertThrows(AwsException.class,+ () -> service.startInstances("us-east-1", List.of(stopping.getInstanceId())));+ assertEquals("VcpuLimitExceeded", refused.getErrorCode());+ assertEquals("stopping", stopping.getState().getName());+ service.stopInstances("us-east-1", List.of(running.getInstanceId()));+ service.startInstances("us-east-1", List.of(stopping.getInstanceId()));+ assertEquals("running", stopping.getState().getName());+ }++ @Test+ void terminatedTargetIsRejectedBeforeQuotaAndNoEarlierTargetStarts() {+ Ec2Service service = service(2, true);+ Instance running = instance("i-running", "running");+ Instance stopped = instance("i-stopped", "stopped");+ Instance terminated = instance("i-terminated", "terminated");+ service.putInstanceForTest(running);+ service.putInstanceForTest(stopped);+ service.putInstanceForTest(terminated);+ AwsException refused = assertThrows(AwsException.class, () -> service.startInstances("us-east-1",+ List.of(stopped.getInstanceId(), terminated.getInstanceId())));+ assertEquals("IncorrectInstanceState", refused.getErrorCode());+ assertEquals("stopped", stopped.getState().getName());+ assertEquals("terminated", terminated.getState().getName());+ service.stopInstances("us-east-1", List.of(running.getInstanceId()));+ service.startInstances("us-east-1", List.of(stopped.getInstanceId()));+ assertEquals("running", stopped.getState().getName());+ }++ @Test+ void defaultOffStartsLargeAndUnsizedStoppedTargets() {+ Ec2Service service = service(0, false);+ Instance large = instance("i-large", "stopped");+ large.setInstanceType("m5.2xlarge");+ Instance unsized = instance("i-unsized", "stopped");+ unsized.setInstanceType("m999.unmeasured");+ service.putInstanceForTest(large);+ service.putInstanceForTest(unsized);+ service.startInstances("us-east-1", List.of(large.getInstanceId(), unsized.getInstanceId()));+ assertEquals("running", large.getState().getName());+ assertEquals("running", unsized.getState().getName());+ }++ @Test+ void enabledUnknownTypesAreRefusedBeforePublicationAndKnownTypesCanRetry() {+ Ec2Service service = service(4, true);+ AwsException failure = assertThrows(AwsException.class, () -> launch(service, "m999.unmeasured"));+ assertEquals("InvalidParameterValue", failure.getErrorCode());+ assertTrue(service.describeInstances("us-east-1", List.of(), Map.of()).isEmpty());+ assertNotNull(launch(service, "t3.large"));+ }++ @Test+ void spotHostsAndOtherRegionsDoNotConsumeThisRegionalBucket() {+ Ec2Service service = service(2, true);+ Instance spot = instance("i-spot", "running");+ spot.setSpot(true);+ Instance host = instance("i-host", "running");+ Placement placement = new Placement("us-east-1a");+ placement.setTenancy("host");+ host.setPlacement(placement);+ Instance other = instance("i-other-region", "running");+ other.setRegion("eu-west-1");+ service.putInstanceForTest(spot);+ service.putInstanceForTest(host);+ service.putInstanceForTest(other);+ assertNotNull(launch(service, "t3.micro"));+ }++ private static Instance instance(String id, String state) {+ Instance instance = new Instance();+ instance.setInstanceId(id);+ instance.setRegion("us-east-1");+ instance.setOwnerId("000000000000");+ instance.setInstanceType("t3.micro");+ instance.setState(new InstanceState(0, state));+ return instance;+ }++ private static Instance launch(Ec2Service service, String type) {+ return service.runInstances("us-east-1", "ami-test", type, 1, 1, null,+ List.of(), null, null, List.of(), null, null).getInstances().getFirst();+ }++ private static Ec2Service service(int limit, boolean enabled) {+ EmulatorConfig config = mock(EmulatorConfig.class, RETURNS_DEEP_STUBS);+ when(config.defaultAccountId()).thenReturn("000000000000");+ when(config.services().ec2().mock()).thenReturn(true);+ when(config.services().ec2().enforceVcpuQuotas()).thenReturn(enabled);+ when(config.services().ec2().mockPublicAddresses())+ .thenReturn(EmulatorConfig.Ec2ServiceConfig.MockPublicAddresses.NONE);+ when(config.services().ec2().mockPublicAddress()).thenReturn(Optional.empty());+ when(config.services().servicequotas().standardOnDemandVcpus()).thenReturn(limit);+ return new Ec2Service(config, mock(Ec2ContainerManager.class), mock(Ec2PortForwardManager.class),+ mock(AmiImageResolver.class), mock(Ec2ImageCatalog.class), new Ec2InstanceTypeCatalog(),+ new MemoryFactory());+ }++ private static final class MemoryFactory extends StorageFactory {+ private MemoryFactory() { super(null, null); }++ @Override+ public <V> AccountAwareStorageBackend<V> create(String service, String file,+ TypeReference<Map<String, V>> type) {+ return AccountAwareStorageBackend.inMemory("000000000000");+ }+ }+}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex d471094706..245f424632 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -308,6 +308,8 @@ floci:proxy-base-port: 9400proxy-max-port: 9499ec2:+ # Opt-in Standard On-Demand vCPU admission. FLOCI_SERVICES_EC2_ENFORCE_VCPU_QUOTAS+ enforce-vcpu-quotas: false# Optional complete catalog override for locally built guest images.image-catalog-path: ${FLOCI_SERVICES_EC2_IMAGE_CATALOG_PATH:}enabled: true