Skip to content

armgit / floci

Public Imported from GitHub
0

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.java
new file mode 100644
index 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.md
index 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.md
index 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 Mapping
Floci resolves AMI IDs to Docker images from the EC2 image catalog at
diff --git a/docs/services/servicequotas.md b/docs/services/servicequotas.md
index 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` and
change 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 |
## Example
diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java
index 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 Docker
diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceTypeCatalog.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2InstanceTypeCatalog.java
index 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)
@RegisterForReflection
public 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.java
index 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.java
index 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, Resettab
String 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, Resettab
throw 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, Resettab
inst.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, Resettab
public 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, Resettab
return 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, Resettab
securityGroupIds, 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.java
index 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.yml
index 296c8addee..ed371c2e81 100644
--- a/src/main/resources/application.yml
+++ b/src/main/resources/application.yml
@@ -651,6 +651,8 @@ floci:
proxy-max-port: 9499
keep-running-on-shutdown: false
ec2:
+ # 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
diff --git a/src/main/resources/ec2/instance-type-vcpus.yaml b/src/main/resources/ec2/instance-type-vcpus.yaml
new file mode 100644
index 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: 4
diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateFleetRollbackTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2CreateFleetRollbackTest.java
index 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.java
index 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);
+ }
+
@Test
void 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.java
new file mode 100644
index 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.java
index 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.java
new file mode 100644
index 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.java
new file mode 100644
index 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.java
new file mode 100644
index 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.yml
index d471094706..245f424632 100644
--- a/src/test/resources/application.yml
+++ b/src/test/resources/application.yml
@@ -308,6 +308,8 @@ floci:
proxy-base-port: 9400
proxy-max-port: 9499
ec2:
+ # 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