Light, fluffy, and always free - The AWS Local Emulator alternative
Add EC2 provisioning primitives (#1252)
Jason van Zylf9c305b7c65e
diff --git a/docs/services/ec2.md b/docs/services/ec2.mdindex 4d174b06ec..5562b4d09b 100644--- a/docs/services/ec2.md+++ b/docs/services/ec2.md@@ -18,18 +18,24 @@ Terminated instances remain queryable for 1 hour (matching real EC2 tombstone be## AMI to Docker Image Mapping-Floci resolves AMI IDs to Docker images. Built-in mappings:+Floci resolves AMI IDs to Docker images from the EC2 image catalog at+`src/main/resources/ec2/image-catalog.yaml`. The same catalog stores the+fallback Docker image, per-AMI Docker image mappings, and `DescribeImages`+metadata.-| AMI ID | Docker image |-|---|---|-| `ami-amazonlinux2023` | `public.ecr.aws/amazonlinux/amazonlinux:2023` |-| `ami-amazonlinux2` | `public.ecr.aws/amazonlinux/amazonlinux:2` |-| `ami-ubuntu2204` | `public.ecr.aws/docker/library/ubuntu:22.04` |-| `ami-ubuntu2004` | `public.ecr.aws/docker/library/ubuntu:20.04` |-| `ami-debian12` | `public.ecr.aws/docker/library/debian:12` |-| `ami-alpine` | `public.ecr.aws/docker/library/alpine:latest` |--Any unrecognized AMI ID (including real AWS AMI IDs like `ami-0abc12345678`) falls back to `public.ecr.aws/amazonlinux/amazonlinux:2023`.+| AMI ID | Aliases | Docker image |+|---|---|---|+| `ami-0abcdef1234567890` | `ami-amazonlinux2` | `public.ecr.aws/amazonlinux/amazonlinux:2` |+| `ami-0abcdef1234567891` | `ami-amazonlinux2023` | `public.ecr.aws/amazonlinux/amazonlinux:2023` |+| `ami-0abcdef1234567892` | `ami-ubuntu2004` | `public.ecr.aws/docker/library/ubuntu:20.04` |+| `ami-ubuntu2204` | | `public.ecr.aws/docker/library/ubuntu:22.04` |+| `ami-ubuntu2404-arm64` | `ami-ubuntu2404` | `public.ecr.aws/docker/library/ubuntu:24.04` |+| `ami-ubuntu2404-amd64` | | `public.ecr.aws/docker/library/ubuntu:24.04` |+| `ami-debian12` | | `public.ecr.aws/docker/library/debian:12` |+| `ami-alpine` | | `public.ecr.aws/docker/library/alpine:latest` |+| `ami-0abcdef1234567893` | | `public.ecr.aws/amazonlinux/amazonlinux:2023` |++Any unrecognized AMI ID (including real AWS AMI IDs like `ami-0abc12345678`) falls back to the catalog `defaultDockerImage` (`public.ecr.aws/amazonlinux/amazonlinux:2023` by default).## SSH Key Injection@@ -101,7 +107,7 @@ Floci seeds the following resources on first use in each region so Terraform, th`RunInstances` · `DescribeInstances` · `TerminateInstances` · `StartInstances` · `StopInstances` · `RebootInstances` · `DescribeInstanceStatus` · `DescribeInstanceAttribute` · `ModifyInstanceAttribute`### VPCs-`CreateVpc` · `DescribeVpcs` · `DeleteVpc` · `ModifyVpcAttribute` · `DescribeVpcAttribute` · `CreateDefaultVpc` · `AssociateVpcCidrBlock` · `DisassociateVpcCidrBlock`+`CreateVpc` · `DescribeVpcs` · `DeleteVpc` · `ModifyVpcAttribute` · `DescribeVpcAttribute` · `DescribeVpcEndpointServices` · `CreateVpcEndpoint` · `DescribeVpcEndpoints` · `DeleteVpcEndpoints` · `CreateDefaultVpc` · `AssociateVpcCidrBlock` · `DisassociateVpcCidrBlock`### Subnets`CreateSubnet` · `DescribeSubnets` · `DeleteSubnet` · `ModifySubnetAttribute`@@ -124,14 +130,26 @@ Floci seeds the following resources on first use in each region so Terraform, th### Route Tables`CreateRouteTable` · `DescribeRouteTables` · `DeleteRouteTable` · `AssociateRouteTable` · `DisassociateRouteTable` · `CreateRoute` · `DeleteRoute`+### NAT Gateways+`CreateNatGateway` · `DescribeNatGateways` · `DeleteNatGateway`+### Elastic IPs-`AllocateAddress` · `DescribeAddresses` · `AssociateAddress` · `DisassociateAddress` · `ReleaseAddress`+`AllocateAddress` · `DescribeAddresses` · `DescribeAddressesAttribute` · `AssociateAddress` · `DisassociateAddress` · `ReleaseAddress`### Availability Zones & Regions`DescribeAvailabilityZones` · `DescribeRegions` · `DescribeAccountAttributes`### Instance Types-`DescribeInstanceTypes`+`DescribeInstanceTypes` · `DescribeInstanceTypeOfferings`++### Launch Templates+`CreateLaunchTemplate` · `DescribeLaunchTemplates` · `DeleteLaunchTemplate`++### IAM Instance Profiles+`DescribeIamInstanceProfileAssociations`++### Network Interfaces+`DescribeNetworkInterfaces`### Volumes`CreateVolume` · `DescribeVolumes` · `DeleteVolume`@@ -234,7 +252,7 @@ aws ec2 associate-address \## Notes-- `DescribeImages` returns a static list of common AMIs (Amazon Linux 2, Amazon Linux 2023, Ubuntu 20.04, Windows Server 2022) plus all Floci-native AMI IDs.+- `DescribeImages` returns AMIs from the EC2 image catalog, including common AMIs and Floci-native AMI IDs.- Key material returned by `CreateKeyPair` is a dummy RSA PEM — not usable for real SSH. Use `ImportKeyPair` for working SSH access.- Security group rules are stored and returned correctly but are not enforced at the network level — Docker bridge networking handles routing.- The IMDS server identifies which instance is calling via IMDSv2 tokens (mapped at token issuance time) or by the container's bridge IP for IMDSv1.diff --git a/docs/services/index.md b/docs/services/index.mdindex 1892d4d0ae..5ce510e906 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -40,7 +40,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [Neptune](neptune.md) | `POST /` with `Action=` param + Gremlin TCP proxy | Query + WebSocket | 8 || [Data Firehose](firehose.md) | `POST /` + `X-Amz-Target: Firehose_20150804.*` | JSON 1.1 | 6 || [ECS](ecs.md) | `POST /` + `X-Amz-Target: AmazonEC2ContainerServiceV20141113.*` | JSON 1.1 | 58 |-| [EC2](ec2.md) | `POST /` with `Action=` param | EC2 Query | 61 |+| [EC2](ec2.md) | `POST /` with `Action=` param | EC2 Query | 78 || [ACM](acm.md) | `POST /` + `X-Amz-Target: CertificateManager.*` | JSON 1.1 | 12 || [ECR](ecr.md) | `POST /` + `X-Amz-Target: AmazonEC2ContainerRegistry_V20150921.*` (control plane) and `/v2/...` (data plane via `registry:2`) | JSON 1.1 + OCI Distribution | 17 || [Resource Groups Tagging API](resource-groups-tagging.md) | `POST /` + `X-Amz-Target: ResourceGroupsTaggingAPI_20170126.*` | JSON 1.1 | 5 |diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.javaindex f67fd2c8b2..f366c4d999 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java@@ -110,6 +110,7 @@ public class AwsQueryController {"CreateLaunchConfiguration", "DescribeLaunchConfigurations", "DeleteLaunchConfiguration","CreateAutoScalingGroup", "UpdateAutoScalingGroup", "DeleteAutoScalingGroup","DescribeAutoScalingGroups", "SetDesiredCapacity",+ "CreateOrUpdateTags", "DeleteTags","DescribeAutoScalingInstances", "AttachInstances", "DetachInstances","TerminateInstanceInAutoScalingGroup","AttachLoadBalancerTargetGroups", "DetachLoadBalancerTargetGroups",@@ -141,7 +142,7 @@ public class AwsQueryController {"RunInstances", "DescribeInstances", "TerminateInstances", "StartInstances", "StopInstances","RebootInstances", "DescribeInstanceStatus", "DescribeInstanceAttribute", "ModifyInstanceAttribute","CreateVpc", "DescribeVpcs", "DeleteVpc", "ModifyVpcAttribute", "DescribeVpcAttribute",- "DescribeVpcEndpointServices",+ "DescribeVpcEndpointServices", "CreateVpcEndpoint", "DescribeVpcEndpoints", "DeleteVpcEndpoints","CreateDefaultVpc", "AssociateVpcCidrBlock", "DisassociateVpcCidrBlock","CreateSubnet", "DescribeSubnets", "DeleteSubnet", "ModifySubnetAttribute","CreateSecurityGroup", "DescribeSecurityGroups", "DeleteSecurityGroup",@@ -156,11 +157,14 @@ public class AwsQueryController {"AttachInternetGateway", "DetachInternetGateway","CreateRouteTable", "DescribeRouteTables", "DeleteRouteTable","AssociateRouteTable", "DisassociateRouteTable", "CreateRoute", "DeleteRoute",+ "CreateNatGateway", "DescribeNatGateways", "DeleteNatGateway","AllocateAddress", "AssociateAddress", "DisassociateAddress", "ReleaseAddress", "DescribeAddresses","DescribeAddressesAttribute","DescribeIamInstanceProfileAssociations","DescribeAvailabilityZones", "DescribeRegions", "DescribeAccountAttributes",- "DescribeInstanceTypes",+ "DescribeInstanceTypes", "DescribeInstanceTypeOfferings",+ "CreateLaunchTemplate", "CreateLaunchTemplateVersion", "DescribeLaunchTemplates", "DescribeLaunchTemplateVersions",+ "ModifyLaunchTemplate", "DeleteLaunchTemplate","DescribeNetworkInterfaces");diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/AmiImageResolver.java b/src/main/java/io/github/hectorvent/floci/services/ec2/AmiImageResolver.javaindex c0da9b8bbe..503231f099 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/AmiImageResolver.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/AmiImageResolver.java@@ -1,55 +1,43 @@package io.github.hectorvent.floci.services.ec2;import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;import org.jboss.logging.Logger;-import java.util.Map;-/*** Resolves EC2 AMI IDs to Docker image URIs.** Floci-local AMI IDs (e.g. "ami-amazonlinux2023") map to public Docker images.- * Real AWS AMI IDs (e.g. "ami-0abc12345678") fall back to amazonlinux:2023.+ * Real AWS AMI IDs (e.g. "ami-0abc12345678") fall back to the catalog default.*/@ApplicationScopedpublic class AmiImageResolver {private static final Logger LOG = Logger.getLogger(AmiImageResolver.class);- private static final String DEFAULT_IMAGE = "public.ecr.aws/amazonlinux/amazonlinux:2023";+ private final Ec2ImageCatalog imageCatalog;- private static final Map<String, String> BUILTIN_MAPPINGS = Map.ofEntries(- Map.entry("ami-amazonlinux2023", "public.ecr.aws/amazonlinux/amazonlinux:2023"),- Map.entry("ami-amazonlinux2", "public.ecr.aws/amazonlinux/amazonlinux:2"),- Map.entry("ami-ubuntu2204", "public.ecr.aws/docker/library/ubuntu:22.04"),- Map.entry("ami-ubuntu2004", "public.ecr.aws/docker/library/ubuntu:20.04"),- Map.entry("ami-debian12", "public.ecr.aws/docker/library/debian:12"),- Map.entry("ami-alpine", "public.ecr.aws/docker/library/alpine:latest")- );+ @Inject+ public AmiImageResolver(Ec2ImageCatalog imageCatalog) {+ this.imageCatalog = imageCatalog;+ }/*** Resolves an AMI ID to a Docker image URI.- * Falls back to Amazon Linux 2023 for unrecognised IDs.+ * Falls back to the catalog default image for unrecognised IDs.*/public String resolve(String imageId) {if (imageId == null || imageId.isBlank()) {- LOG.warnv("No imageId provided; using default image {0}", DEFAULT_IMAGE);- return DEFAULT_IMAGE;- }-- String mapped = BUILTIN_MAPPINGS.get(imageId);- if (mapped != null) {- return mapped;+ LOG.warnv("No imageId provided; using default image {0}", imageCatalog.defaultDockerImage());+ return imageCatalog.defaultDockerImage();}- LOG.warnv("Unknown AMI ID {0}; falling back to default image {1}", imageId, DEFAULT_IMAGE);- return DEFAULT_IMAGE;- }-- /**- * Returns the pre-seeded AMI catalogue entries for DescribeImages.- */- public static Map<String, String> builtinMappings() {- return BUILTIN_MAPPINGS;+ return imageCatalog.findByIdOrAlias(imageId)+ .map(image -> image.dockerImage)+ .orElseGet(() -> {+ LOG.warnv("Unknown AMI ID {0}; falling back to default image {1}",+ imageId, imageCatalog.defaultDockerImage());+ return imageCatalog.defaultDockerImage();+ });}}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2ImageCatalog.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2ImageCatalog.javanew file mode 100644index 0000000000..93d6a61f6e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2ImageCatalog.java@@ -0,0 +1,198 @@+package io.github.hectorvent.floci.services.ec2;++import java.io.IOException;+import java.io.InputStream;+import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.Optional;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;++import io.github.hectorvent.floci.services.ec2.model.Image;+import io.quarkus.runtime.annotations.RegisterForReflection;+import jakarta.enterprise.context.ApplicationScoped;++@ApplicationScoped+public class Ec2ImageCatalog {++ private static final String CATALOG_RESOURCE_NAME = "ec2/image-catalog.yaml";+ private static final ObjectMapper YAML_MAPPER = new ObjectMapper(new YAMLFactory());++ private final String defaultDockerImage;+ private final List<CatalogImage> images;+ private final Map<String, CatalogImage> imagesByIdOrAlias;++ public Ec2ImageCatalog() {+ this(readResource(CATALOG_RESOURCE_NAME, Catalog.class));+ }++ Ec2ImageCatalog(Catalog catalog) {+ this.defaultDockerImage = require(catalog.defaultDockerImage, "defaultDockerImage");+ this.images = List.copyOf(catalog.images == null ? List.of() : catalog.images);+ if (this.images.isEmpty()) {+ throw new IllegalStateException("EC2 image catalog has no images: " + CATALOG_RESOURCE_NAME);+ }+ this.imagesByIdOrAlias = indexImages(this.images);+ }++ public String defaultDockerImage() {+ return defaultDockerImage;+ }++ public List<CatalogImage> images() {+ return images;+ }++ public Optional<CatalogImage> findByIdOrAlias(String imageId) {+ if (imageId == null || imageId.isBlank()) {+ return Optional.empty();+ }+ return Optional.ofNullable(imagesByIdOrAlias.get(imageId));+ }++ private static <T> T readResource(String resourceName, Class<T> type) {+ ClassLoader loader = Thread.currentThread().getContextClassLoader();+ try (InputStream input = loader.getResourceAsStream(resourceName)) {+ if (input == null) {+ throw new IllegalStateException("Missing EC2 image catalog resource: " + resourceName);+ }+ return YAML_MAPPER.readValue(input, type);+ } catch (IOException e) {+ throw new IllegalStateException("Failed to load EC2 image catalog resource: " + resourceName, e);+ }+ }++ private static Map<String, CatalogImage> indexImages(List<CatalogImage> images) {+ Map<String, CatalogImage> index = new LinkedHashMap<>();+ for (CatalogImage image : images) {+ addIndexEntry(index, require(image.imageId, "imageId"), image);+ require(image.dockerImage, "dockerImage");+ require(image.name, "name");+ require(image.description, "description");+ require(image.architecture, "architecture");+ require(image.creationDate, "creationDate");++ for (String alias : image.aliases()) {+ addIndexEntry(index, alias, image);+ }+ }+ return Map.copyOf(index);+ }++ private static void addIndexEntry(Map<String, CatalogImage> index, String imageIdOrAlias, CatalogImage image) {+ CatalogImage previous = index.putIfAbsent(imageIdOrAlias, image);+ if (previous != null) {+ throw new IllegalStateException("Duplicate EC2 image catalog id or alias: " + imageIdOrAlias);+ }+ }++ private static String require(String value, String field) {+ if (value == null || value.isBlank()) {+ throw new IllegalStateException("EC2 image catalog entry is missing required field: " + field);+ }+ return value;+ }++ @JsonIgnoreProperties(ignoreUnknown = true)+ @RegisterForReflection+ public static final class Catalog {+ public String defaultDockerImage;+ public List<CatalogImage> images = List.of();+ }++ @JsonIgnoreProperties(ignoreUnknown = true)+ @RegisterForReflection+ public static final class CatalogImage {+ public String imageId;+ public List<String> aliases = List.of();+ public String dockerImage;+ public String name;+ public String description;+ public String state;+ public String ownerId;+ public Boolean publicImage;+ public String architecture;+ public String rootDeviceType;+ public String rootDeviceName;+ public String virtualizationType;+ public String hypervisor;+ public String platform;+ public String imageOwnerAlias;+ public String creationDate;+ public Boolean advertised;++ public boolean advertised() {+ return advertised == null || advertised;+ }++ public List<String> aliases() {+ return aliases == null ? List.of() : List.copyOf(aliases);+ }++ public List<String> idsAndAliases() {+ List<String> ids = new ArrayList<>();+ ids.add(imageId);+ ids.addAll(aliases());+ return ids;+ }++ public boolean matchesIdOrAlias(List<String> candidates) {+ if (candidates == null || candidates.isEmpty()) {+ return true;+ }+ for (String id : idsAndAliases()) {+ if (candidates.contains(id)) {+ return true;+ }+ }+ return false;+ }++ public boolean matchesOwner(List<String> owners) {+ if (owners == null || owners.isEmpty()) {+ return true;+ }+ Image image = toImage();+ return owners.contains(image.getOwnerId()) || owners.contains(image.getImageOwnerAlias());+ }++ public Image toImage() {+ Image image = new Image();+ image.setImageId(imageId);+ image.setName(name);+ image.setDescription(description);+ if (state != null) {+ image.setState(state);+ }+ if (ownerId != null) {+ image.setOwnerId(ownerId);+ }+ if (publicImage != null) {+ image.setPublic(publicImage);+ }+ image.setArchitecture(architecture);+ if (rootDeviceType != null) {+ image.setRootDeviceType(rootDeviceType);+ }+ if (rootDeviceName != null) {+ image.setRootDeviceName(rootDeviceName);+ }+ if (virtualizationType != null) {+ image.setVirtualizationType(virtualizationType);+ }+ if (hypervisor != null) {+ image.setHypervisor(hypervisor);+ }+ image.setPlatform(platform);+ if (imageOwnerAlias != null) {+ image.setImageOwnerAlias(imageOwnerAlias);+ }+ image.setCreationDate(creationDate);+ return image;+ }+ }+}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 2f1c007d2a..9eb9ddf0de 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@@ -11,10 +11,13 @@ import jakarta.ws.rs.core.MultivaluedMap;import jakarta.ws.rs.core.Response;import org.jboss.logging.Logger;+import java.io.ByteArrayInputStream;+import java.io.IOException;import java.nio.charset.StandardCharsets;import java.time.ZoneOffset;import java.time.format.DateTimeFormatter;import java.util.*;+import java.util.zip.GZIPInputStream;@ApplicationScopedpublic class Ec2QueryHandler {@@ -53,6 +56,9 @@ public class Ec2QueryHandler {case "ModifyVpcAttribute" -> handleModifyVpcAttribute(params, region);case "DescribeVpcAttribute" -> handleDescribeVpcAttribute(params, region);case "DescribeVpcEndpointServices" -> handleDescribeVpcEndpointServices(params, region);+ case "CreateVpcEndpoint" -> handleCreateVpcEndpoint(params, region);+ case "DescribeVpcEndpoints" -> handleDescribeVpcEndpoints(params, region);+ case "DeleteVpcEndpoints" -> handleDeleteVpcEndpoints(params, region);case "CreateDefaultVpc" -> handleCreateDefaultVpc(params, region);case "AssociateVpcCidrBlock" -> handleAssociateVpcCidrBlock(params, region);case "DisassociateVpcCidrBlock" -> handleDisassociateVpcCidrBlock(params, region);@@ -100,6 +106,10 @@ public class Ec2QueryHandler {case "DisassociateRouteTable" -> handleDisassociateRouteTable(params, region);case "CreateRoute" -> handleCreateRoute(params, region);case "DeleteRoute" -> handleDeleteRoute(params, region);+ // NAT Gateways+ case "CreateNatGateway" -> handleCreateNatGateway(params, region);+ case "DescribeNatGateways" -> handleDescribeNatGateways(params, region);+ case "DeleteNatGateway" -> handleDeleteNatGateway(params, region);// Elastic IPscase "AllocateAddress" -> handleAllocateAddress(params, region);case "AssociateAddress" -> handleAssociateAddress(params, region);@@ -113,6 +123,14 @@ public class Ec2QueryHandler {case "DescribeAccountAttributes" -> handleDescribeAccountAttributes(params, region);// Instance Typescase "DescribeInstanceTypes" -> handleDescribeInstanceTypes(params, region);+ case "DescribeInstanceTypeOfferings" -> handleDescribeInstanceTypeOfferings(params, region);+ // Launch Templates+ case "CreateLaunchTemplate" -> handleCreateLaunchTemplate(params, region);+ case "CreateLaunchTemplateVersion" -> handleCreateLaunchTemplateVersion(params, region);+ case "DescribeLaunchTemplates" -> handleDescribeLaunchTemplates(params, region);+ case "DescribeLaunchTemplateVersions" -> handleDescribeLaunchTemplateVersions(params, region);+ case "ModifyLaunchTemplate" -> handleModifyLaunchTemplate(params, region);+ case "DeleteLaunchTemplate" -> handleDeleteLaunchTemplate(params, region);// Network Interfacescase "DescribeNetworkInterfaces" -> handleDescribeNetworkInterfaces(params, region);// Volumes@@ -209,6 +227,23 @@ public class Ec2QueryHandler {return perms;}+ private List<Tag> parseTagsForResource(MultivaluedMap<String, String> p, String resourceType) {+ List<Tag> tags = new ArrayList<>();+ for (int i = 1; ; i++) {+ String resType = p.getFirst("TagSpecification." + i + ".ResourceType");+ if (resType == null) break;+ if (resourceType.equals(resType)) {+ for (int j = 1; ; j++) {+ String key = p.getFirst("TagSpecification." + i + ".Tag." + j + ".Key");+ if (key == null) break;+ String value = p.getFirst("TagSpecification." + i + ".Tag." + j + ".Value");+ tags.add(new Tag(key, value));+ }+ }+ }+ return tags;+ }+private Response xmlResponse(String xml) {return Response.ok(xml).type(MediaType.APPLICATION_XML).build();}@@ -239,7 +274,7 @@ public class Ec2QueryHandler {String userDataEncoded = p.getFirst("UserData");String userData = null;if (userDataEncoded != null && !userDataEncoded.isBlank()) {- userData = new String(Base64.getDecoder().decode(userDataEncoded), StandardCharsets.UTF_8);+ userData = decodeUserData(userDataEncoded);}// IamInstanceProfile@@ -600,12 +635,58 @@ public class Ec2QueryHandler {XmlBuilder xml = new XmlBuilder().start("DescribeVpcEndpointServicesResponse", AwsNamespaces.EC2).elem("requestId", UUID.randomUUID().toString())- .start("serviceNameSet").end("serviceNameSet")- .start("serviceDetailSet").end("serviceDetailSet")+ .start("serviceNameSet")+ .end("serviceNameSet")+ .start("serviceDetailSet")+ .end("serviceDetailSet").end("DescribeVpcEndpointServicesResponse");return xmlResponse(xml.build());}+ private Response handleCreateVpcEndpoint(MultivaluedMap<String, String> p, String region) {+ VpcEndpoint endpoint = service.createVpcEndpoint(+ region,+ p.getFirst("VpcId"),+ p.getFirst("ServiceName"),+ p.getFirst("VpcEndpointType"),+ getList(p, "RouteTableId"),+ getList(p, "SubnetId"),+ getList(p, "SecurityGroupId"),+ parseTagsForResource(p, "vpc-endpoint"));+ XmlBuilder xml = new XmlBuilder()+ .start("CreateVpcEndpointResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("vpcEndpoint").raw(vpcEndpointXml(endpoint)).end("vpcEndpoint")+ .end("CreateVpcEndpointResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDescribeVpcEndpoints(MultivaluedMap<String, String> p, String region) {+ List<String> endpointIds = getList(p, "VpcEndpointId");+ Map<String, List<String>> filters = getFilters(p);+ List<VpcEndpoint> endpoints = service.describeVpcEndpoints(region, endpointIds, filters);+ XmlBuilder xml = new XmlBuilder()+ .start("DescribeVpcEndpointsResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("vpcEndpointSet");+ for (VpcEndpoint endpoint : endpoints) {+ xml.start("item").raw(vpcEndpointXml(endpoint)).end("item");+ }+ xml.end("vpcEndpointSet").end("DescribeVpcEndpointsResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDeleteVpcEndpoints(MultivaluedMap<String, String> p, String region) {+ List<String> endpointIds = getList(p, "VpcEndpointId");+ service.deleteVpcEndpoints(region, endpointIds);+ XmlBuilder xml = new XmlBuilder()+ .start("DeleteVpcEndpointsResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("unsuccessful").end("unsuccessful")+ .end("DeleteVpcEndpointsResponse");+ return xmlResponse(xml.build());+ }+private Response handleCreateDefaultVpc(MultivaluedMap<String, String> p, String region) {Vpc vpc = service.createDefaultVpc(region);XmlBuilder xml = new XmlBuilder()@@ -883,7 +964,8 @@ public class Ec2QueryHandler {private Response handleDescribeImages(MultivaluedMap<String, String> p, String region) {List<String> imageIds = getList(p, "ImageId");List<String> owners = getList(p, "Owner");- List<Image> images = service.describeImages(region, imageIds, owners);+ Map<String, List<String>> filters = getFilters(p);+ List<Image> images = service.describeImages(region, imageIds, owners, filters);XmlBuilder xml = new XmlBuilder().start("DescribeImagesResponse", AwsNamespaces.EC2).elem("requestId", UUID.randomUUID().toString())@@ -1068,6 +1150,48 @@ public class Ec2QueryHandler {return booleanResponse("DeleteRoute");}+ // ─── NAT Gateway handlers ─────────────────────────────────────────────────++ private Response handleCreateNatGateway(MultivaluedMap<String, String> p, String region) {+ NatGateway natGateway = service.createNatGateway(+ region,+ p.getFirst("SubnetId"),+ p.getFirst("AllocationId"),+ p.getFirst("ConnectivityType"),+ parseTagsForResource(p, "natgateway"));+ XmlBuilder xml = new XmlBuilder()+ .start("CreateNatGatewayResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("natGateway").raw(natGatewayXml(natGateway)).end("natGateway")+ .end("CreateNatGatewayResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDescribeNatGateways(MultivaluedMap<String, String> p, String region) {+ List<String> natGatewayIds = getList(p, "NatGatewayId");+ Map<String, List<String>> filters = getFilters(p);+ List<NatGateway> natGateways = service.describeNatGateways(region, natGatewayIds, filters);+ XmlBuilder xml = new XmlBuilder()+ .start("DescribeNatGatewaysResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("natGatewaySet");+ for (NatGateway natGateway : natGateways) {+ xml.start("item").raw(natGatewayXml(natGateway)).end("item");+ }+ xml.end("natGatewaySet").end("DescribeNatGatewaysResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDeleteNatGateway(MultivaluedMap<String, String> p, String region) {+ NatGateway natGateway = service.deleteNatGateway(region, p.getFirst("NatGatewayId"));+ XmlBuilder xml = new XmlBuilder()+ .start("DeleteNatGatewayResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("natGateway").raw(natGatewayXml(natGateway)).end("natGateway")+ .end("DeleteNatGatewayResponse");+ return xmlResponse(xml.build());+ }+// ─── Elastic IP handlers ──────────────────────────────────────────────────private Response handleAllocateAddress(MultivaluedMap<String, String> p, String region) {@@ -1223,6 +1347,125 @@ public class Ec2QueryHandler {return xmlResponse(xml.build());}+ private Response handleDescribeInstanceTypeOfferings(MultivaluedMap<String, String> p, String region) {+ List<String> typeNames = getList(p, "InstanceType");+ Map<String, List<String>> filters = getFilters(p);+ List<Map<String, String>> offerings = service.describeInstanceTypeOfferings(+ region, typeNames, p.getFirst("LocationType"), filters);+ XmlBuilder xml = new XmlBuilder()+ .start("DescribeInstanceTypeOfferingsResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("instanceTypeOfferingSet");+ for (Map<String, String> offering : offerings) {+ xml.start("item")+ .elem("instanceType", offering.get("instanceType"))+ .elem("locationType", offering.get("locationType"))+ .elem("location", offering.get("location"))+ .end("item");+ }+ xml.end("instanceTypeOfferingSet").end("DescribeInstanceTypeOfferingsResponse");+ return xmlResponse(xml.build());+ }++ // ─── Launch Template handlers ─────────────────────────────────────────────++ private Response handleCreateLaunchTemplate(MultivaluedMap<String, String> p, String region) {+ LaunchTemplate launchTemplate = service.createLaunchTemplate(+ region,+ p.getFirst("LaunchTemplateName"),+ p.getFirst("LaunchTemplateData.ImageId"),+ p.getFirst("LaunchTemplateData.InstanceType"),+ p.getFirst("LaunchTemplateData.KeyName"),+ parseLaunchTemplateSecurityGroupIds(p),+ decodeUserData(p.getFirst("LaunchTemplateData.UserData")),+ parseTagsForResource(p, "launch-template"));+ XmlBuilder xml = new XmlBuilder()+ .start("CreateLaunchTemplateResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("launchTemplate").raw(launchTemplateXml(launchTemplate)).end("launchTemplate")+ .end("CreateLaunchTemplateResponse");+ return xmlResponse(xml.build());+ }++ private Response handleCreateLaunchTemplateVersion(MultivaluedMap<String, String> p, String region) {+ LaunchTemplate launchTemplate = service.createLaunchTemplateVersion(+ region,+ p.getFirst("LaunchTemplateId"),+ p.getFirst("LaunchTemplateName"),+ p.getFirst("LaunchTemplateData.ImageId"),+ p.getFirst("LaunchTemplateData.InstanceType"),+ p.getFirst("LaunchTemplateData.KeyName"),+ parseLaunchTemplateSecurityGroupIds(p),+ decodeUserData(p.getFirst("LaunchTemplateData.UserData")),+ p.getFirst("SourceVersion"));+ XmlBuilder xml = new XmlBuilder()+ .start("CreateLaunchTemplateVersionResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("launchTemplateVersion").raw(launchTemplateVersionXml(launchTemplate)).end("launchTemplateVersion")+ .end("CreateLaunchTemplateVersionResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDescribeLaunchTemplates(MultivaluedMap<String, String> p, String region) {+ List<String> ids = getList(p, "LaunchTemplateId");+ List<String> names = getList(p, "LaunchTemplateName");+ Map<String, List<String>> filters = getFilters(p);+ List<LaunchTemplate> launchTemplates = service.describeLaunchTemplates(region, ids, names, filters);+ XmlBuilder xml = new XmlBuilder()+ .start("DescribeLaunchTemplatesResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("launchTemplates");+ for (LaunchTemplate launchTemplate : launchTemplates) {+ xml.start("item").raw(launchTemplateXml(launchTemplate)).end("item");+ }+ xml.end("launchTemplates").end("DescribeLaunchTemplatesResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDescribeLaunchTemplateVersions(MultivaluedMap<String, String> p, String region) {+ String id = p.getFirst("LaunchTemplateId");+ String name = p.getFirst("LaunchTemplateName");+ List<LaunchTemplate> launchTemplates = service.describeLaunchTemplateVersions(+ region,+ id,+ name,+ getList(p, "Versions"));+ XmlBuilder xml = new XmlBuilder()+ .start("DescribeLaunchTemplateVersionsResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("launchTemplateVersionSet");+ for (LaunchTemplate launchTemplate : launchTemplates) {+ xml.start("item").raw(launchTemplateVersionXml(launchTemplate)).end("item");+ }+ xml.end("launchTemplateVersionSet").end("DescribeLaunchTemplateVersionsResponse");+ return xmlResponse(xml.build());+ }++ private Response handleModifyLaunchTemplate(MultivaluedMap<String, String> p, String region) {+ LaunchTemplate launchTemplate = service.modifyLaunchTemplate(+ region,+ p.getFirst("LaunchTemplateId"),+ p.getFirst("LaunchTemplateName"),+ p.getFirst("DefaultVersion"));+ XmlBuilder xml = new XmlBuilder()+ .start("ModifyLaunchTemplateResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("launchTemplate").raw(launchTemplateXml(launchTemplate)).end("launchTemplate")+ .end("ModifyLaunchTemplateResponse");+ return xmlResponse(xml.build());+ }++ private Response handleDeleteLaunchTemplate(MultivaluedMap<String, String> p, String region) {+ LaunchTemplate launchTemplate = service.deleteLaunchTemplate(+ region, p.getFirst("LaunchTemplateId"), p.getFirst("LaunchTemplateName"));+ XmlBuilder xml = new XmlBuilder()+ .start("DeleteLaunchTemplateResponse", AwsNamespaces.EC2)+ .elem("requestId", UUID.randomUUID().toString())+ .start("launchTemplate").raw(launchTemplateXml(launchTemplate)).end("launchTemplate")+ .end("DeleteLaunchTemplateResponse");+ return xmlResponse(xml.build());+ }+// ─── Network Interface handlers ───────────────────────────────────────────private Response handleDescribeNetworkInterfaces(MultivaluedMap<String, String> p, String region) {@@ -1564,6 +1807,143 @@ public class Ec2QueryHandler {return xml.build();}+ private String natGatewayXml(NatGateway natGateway) {+ XmlBuilder xml = new XmlBuilder()+ .elem("natGatewayId", natGateway.getNatGatewayId())+ .elem("subnetId", natGateway.getSubnetId())+ .elem("vpcId", natGateway.getVpcId())+ .elem("state", natGateway.getState())+ .elem("connectivityType", natGateway.getConnectivityType());+ if (natGateway.getCreateTime() != null) {+ xml.elem("createTime", ISO_FMT.format(natGateway.getCreateTime()));+ }+ if (natGateway.getAllocationId() != null) {+ xml.start("natGatewayAddressSet")+ .start("item")+ .elem("allocationId", natGateway.getAllocationId())+ .end("item")+ .end("natGatewayAddressSet");+ } else {+ xml.start("natGatewayAddressSet").end("natGatewayAddressSet");+ }+ xml.raw(tagSetXml(natGateway.getTags()));+ return xml.build();+ }++ private String launchTemplateXml(LaunchTemplate launchTemplate) {+ XmlBuilder xml = new XmlBuilder()+ .elem("launchTemplateId", launchTemplate.getLaunchTemplateId())+ .elem("launchTemplateName", launchTemplate.getLaunchTemplateName());+ if (launchTemplate.getCreateTime() != null) {+ xml.elem("createTime", ISO_FMT.format(launchTemplate.getCreateTime()));+ }+ xml.elem("createdBy", launchTemplate.getCreatedBy())+ .elem("defaultVersionNumber", launchTemplate.getDefaultVersionNumber())+ .elem("latestVersionNumber", launchTemplate.getLatestVersionNumber())+ .raw(tagSetXml(launchTemplate.getTags()));+ return xml.build();+ }++ private String launchTemplateVersionXml(LaunchTemplate launchTemplate) {+ XmlBuilder xml = new XmlBuilder()+ .elem("launchTemplateId", launchTemplate.getLaunchTemplateId())+ .elem("launchTemplateName", launchTemplate.getLaunchTemplateName())+ .elem("versionNumber", launchTemplate.getLatestVersionNumber())+ .elem("defaultVersion", String.valueOf(Objects.equals(+ launchTemplate.getDefaultVersionNumber(), launchTemplate.getLatestVersionNumber())));+ if (launchTemplate.getCreateTime() != null) {+ xml.elem("createTime", ISO_FMT.format(launchTemplate.getCreateTime()));+ }+ xml.elem("createdBy", launchTemplate.getCreatedBy())+ .start("launchTemplateData")+ .elem("imageId", launchTemplate.getImageId())+ .elem("instanceType", launchTemplate.getInstanceType());+ if (launchTemplate.getKeyName() != null) {+ xml.elem("keyName", launchTemplate.getKeyName());+ }+ if (launchTemplate.getUserData() != null) {+ xml.elem("userData", launchTemplate.getUserData());+ }+ xml.start("securityGroupIdSet");+ for (String securityGroupId : launchTemplate.getSecurityGroupIds()) {+ xml.elem("item", securityGroupId);+ }+ xml.end("securityGroupIdSet")+ .end("launchTemplateData");+ return xml.build();+ }++ private List<String> parseLaunchTemplateSecurityGroupIds(MultivaluedMap<String, String> p) {+ LinkedHashSet<String> groups = new LinkedHashSet<>(getList(p, "LaunchTemplateData.SecurityGroupId"));+ for (int i = 1; ; i++) {+ boolean sawInterface = false;+ for (String prefix : List.of(+ "LaunchTemplateData.NetworkInterface." + i + ".Groups",+ "LaunchTemplateData.NetworkInterface." + i + ".GroupId",+ "LaunchTemplateData.NetworkInterface." + i + ".SecurityGroupId")) {+ List<String> values = getList(p, prefix);+ if (!values.isEmpty()) {+ sawInterface = true;+ groups.addAll(values);+ }+ }+ if (!sawInterface && p.getFirst("LaunchTemplateData.NetworkInterface." + i + ".DeviceIndex") == null) {+ break;+ }+ }+ return new ArrayList<>(groups);+ }++ private String decodeUserData(String userDataEncoded) {+ if (userDataEncoded == null || userDataEncoded.isBlank()) {+ return null;+ }+ byte[] decoded;+ try {+ decoded = Base64.getDecoder().decode(userDataEncoded);+ } catch (IllegalArgumentException e) {+ throw new AwsException("InvalidParameterValue", "UserData is not valid base64 content.", 400);+ }+ if (decoded.length >= 2 && (decoded[0] & 0xff) == 0x1f && (decoded[1] & 0xff) == 0x8b) {+ try (GZIPInputStream gzip = new GZIPInputStream(new ByteArrayInputStream(decoded))) {+ decoded = gzip.readAllBytes();+ }+ catch (IOException e) {+ throw new AwsException("InvalidParameterValue", "UserData is not valid gzip content.", 400);+ }+ }+ return new String(decoded, StandardCharsets.UTF_8);+ }++ private String vpcEndpointXml(VpcEndpoint endpoint) {+ XmlBuilder xml = new XmlBuilder()+ .elem("vpcEndpointId", endpoint.getVpcEndpointId())+ .elem("vpcEndpointType", endpoint.getVpcEndpointType())+ .elem("vpcId", endpoint.getVpcId())+ .elem("serviceName", endpoint.getServiceName())+ .elem("state", endpoint.getState());+ if (endpoint.getCreationTimestamp() != null) {+ xml.elem("creationTimestamp", ISO_FMT.format(endpoint.getCreationTimestamp()));+ }+ xml.start("routeTableIdSet");+ for (String routeTableId : endpoint.getRouteTableIds()) {+ xml.start("item").elem("routeTableId", routeTableId).end("item");+ }+ xml.end("routeTableIdSet")+ .start("subnetIdSet");+ for (String subnetId : endpoint.getSubnetIds()) {+ xml.start("item").elem("subnetId", subnetId).end("item");+ }+ xml.end("subnetIdSet")+ .start("groupSet");+ for (String securityGroupId : endpoint.getSecurityGroupIds()) {+ xml.start("item").elem("groupId", securityGroupId).end("item");+ }+ xml.end("groupSet")+ .raw(tagSetXml(endpoint.getTags()));+ return xml.build();+ }+private String addressXml(Address addr) {XmlBuilder xml = new XmlBuilder().elem("publicIp", addr.getPublicIp())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 4e522f444c..153048e0a3 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@@ -9,6 +9,7 @@ import java.util.Base64;import java.util.Collections;import java.util.HashSet;import java.util.LinkedHashMap;+import java.util.LinkedHashSet;import java.util.List;import java.util.Map;import java.util.Objects;@@ -40,6 +41,9 @@ import io.github.hectorvent.floci.services.ec2.model.InternetGatewayAttachment;import io.github.hectorvent.floci.services.ec2.model.IpPermission;import io.github.hectorvent.floci.services.ec2.model.IpRange;import io.github.hectorvent.floci.services.ec2.model.KeyPair;+import io.github.hectorvent.floci.services.ec2.model.LaunchTemplate;+import io.github.hectorvent.floci.services.ec2.model.LaunchTemplateData;+import io.github.hectorvent.floci.services.ec2.model.NatGateway;import io.github.hectorvent.floci.services.ec2.model.Placement;import io.github.hectorvent.floci.services.ec2.model.Reservation;import io.github.hectorvent.floci.services.ec2.model.Route;@@ -53,6 +57,7 @@ import io.github.hectorvent.floci.services.ec2.model.Volume;import io.github.hectorvent.floci.services.ec2.model.VolumeAttachment;import io.github.hectorvent.floci.services.ec2.model.Vpc;import io.github.hectorvent.floci.services.ec2.model.VpcCidrBlockAssociation;+import io.github.hectorvent.floci.services.ec2.model.VpcEndpoint;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;@@ -67,6 +72,7 @@ public class Ec2Service {private final EmulatorConfig config;private final Ec2ContainerManager containerManager;private final AmiImageResolver amiImageResolver;+ private final Ec2ImageCatalog imageCatalog;// region::id → resourceprivate final Map<String, Vpc> vpcs = new ConcurrentHashMap<>();@@ -79,6 +85,9 @@ public class Ec2Service {private final Map<String, Address> addresses = new ConcurrentHashMap<>();private final Map<String, Instance> instances = new ConcurrentHashMap<>();private final Map<String, Volume> volumes = new ConcurrentHashMap<>();+ private final Map<String, LaunchTemplate> launchTemplates = new ConcurrentHashMap<>();+ private final Map<String, VpcEndpoint> vpcEndpoints = new ConcurrentHashMap<>();+ private final Map<String, NatGateway> natGateways = new ConcurrentHashMap<>();// resourceId → List<Tag>private final Map<String, List<Tag>> tags = new ConcurrentHashMap<>();private final Set<String> seededRegions = ConcurrentHashMap.newKeySet();@@ -87,11 +96,12 @@ public class Ec2Service {@Injectpublic Ec2Service(EmulatorConfig config, Ec2ContainerManager containerManager,- AmiImageResolver amiImageResolver) {+ AmiImageResolver amiImageResolver, Ec2ImageCatalog imageCatalog) {this.accountId = config.defaultAccountId();this.config = config;this.containerManager = containerManager;this.amiImageResolver = amiImageResolver;+ this.imageCatalog = imageCatalog;}// ─── Default resource seeding ──────────────────────────────────────────────@@ -628,6 +638,78 @@ public class Ec2Service {}}+ // ─── VPC Endpoints ────────────────────────────────────────────────────────++ public VpcEndpoint createVpcEndpoint(String region, String vpcId, String serviceName, String endpointType,+ List<String> routeTableIds, List<String> subnetIds,+ List<String> securityGroupIds, List<Tag> endpointTags) {+ ensureDefaultResources(region);+ getRequiredVpc(region, vpcId);+ for (String routeTableId : routeTableIds) {+ getRequiredRouteTable(region, routeTableId);+ }+ for (String subnetId : subnetIds) {+ requireSubnet(region, subnetId);+ }+ for (String securityGroupId : securityGroupIds) {+ getRequiredSecurityGroup(region, securityGroupId);+ }++ VpcEndpoint endpoint = new VpcEndpoint();+ endpoint.setVpcEndpointId("vpce-" + randomHex(17));+ endpoint.setVpcId(vpcId);+ endpoint.setServiceName(serviceName);+ endpoint.setVpcEndpointType(endpointType != null && !endpointType.isBlank() ? endpointType : "Gateway");+ endpoint.setCreationTimestamp(Instant.now());+ endpoint.setRegion(region);+ endpoint.setRouteTableIds(new ArrayList<>(routeTableIds));+ endpoint.setSubnetIds(new ArrayList<>(subnetIds));+ endpoint.setSecurityGroupIds(new ArrayList<>(securityGroupIds));+ if (endpointTags != null && !endpointTags.isEmpty()) {+ endpoint.setTags(new ArrayList<>(endpointTags));+ tags.put(endpoint.getVpcEndpointId(), new ArrayList<>(endpointTags));+ }+ vpcEndpoints.put(key(region, endpoint.getVpcEndpointId()), endpoint);+ return endpoint;+ }++ public List<VpcEndpoint> describeVpcEndpoints(String region, List<String> endpointIds,+ Map<String, List<String>> filters) {+ ensureDefaultResources(region);+ if (!endpointIds.isEmpty()) {+ for (String endpointId : endpointIds) {+ getRequiredVpcEndpoint(region, endpointId);+ }+ }+ return vpcEndpoints.values().stream()+ .filter(endpoint -> endpoint.getRegion().equals(region))+ .filter(endpoint -> endpointIds.isEmpty() || endpointIds.contains(endpoint.getVpcEndpointId()))+ .filter(endpoint -> matchesFilters(endpoint, filters, region))+ .collect(Collectors.toList());+ }++ public List<VpcEndpoint> deleteVpcEndpoints(String region, List<String> endpointIds) {+ ensureDefaultResources(region);+ List<VpcEndpoint> deleted = new ArrayList<>();+ for (String endpointId : endpointIds) {+ VpcEndpoint endpoint = getRequiredVpcEndpoint(region, endpointId);+ endpoint.setState("deleted");+ vpcEndpoints.remove(key(region, endpointId));+ tags.remove(endpointId);+ deleted.add(endpoint);+ }+ return deleted;+ }++ private VpcEndpoint getRequiredVpcEndpoint(String region, String endpointId) {+ VpcEndpoint endpoint = vpcEndpoints.get(key(region, endpointId));+ if (endpoint == null) {+ throw new AwsException("InvalidVpcEndpointId.NotFound",+ "The vpcEndpoint ID '" + endpointId + "' does not exist", 400);+ }+ return endpoint;+ }+// ─── Subnets ───────────────────────────────────────────────────────────────public Subnet createSubnet(String region, String vpcId, String cidrBlock, String availabilityZone) {@@ -923,46 +1005,284 @@ public class Ec2Service {// ─── AMIs ──────────────────────────────────────────────────────────────────public List<Image> describeImages(String region, List<String> imageIds, List<String> owners) {- List<Image> staticImages = new ArrayList<>();-- Image al2 = new Image();- al2.setImageId("ami-0abcdef1234567890");- al2.setName("amzn2-ami-hvm-2.0.20230404.0-x86_64-gp2");- al2.setDescription("Amazon Linux 2 AMI");- al2.setArchitecture("x86_64");- al2.setCreationDate("2023-04-04T00:00:00.000Z");- staticImages.add(al2);-- Image al2023 = new Image();- al2023.setImageId("ami-0abcdef1234567891");- al2023.setName("al2023-ami-2023.0.20230315.0-kernel-6.1-x86_64");- al2023.setDescription("Amazon Linux 2023 AMI");- al2023.setArchitecture("x86_64");- al2023.setCreationDate("2023-03-15T00:00:00.000Z");- staticImages.add(al2023);-- Image ubuntu = new Image();- ubuntu.setImageId("ami-0abcdef1234567892");- ubuntu.setName("ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-20230324");- ubuntu.setDescription("Canonical, Ubuntu, 20.04 LTS");- ubuntu.setArchitecture("x86_64");- ubuntu.setCreationDate("2023-03-24T00:00:00.000Z");- staticImages.add(ubuntu);-- Image windows = new Image();- windows.setImageId("ami-0abcdef1234567893");- windows.setName("Windows_Server-2022-English-Full-Base-2023.04.12");- windows.setDescription("Microsoft Windows Server 2022 Full Locale English AMI");- windows.setArchitecture("x86_64");- windows.setPlatform("windows");- windows.setCreationDate("2023-04-12T00:00:00.000Z");- staticImages.add(windows);-- return staticImages.stream()- .filter(img -> imageIds.isEmpty() || imageIds.contains(img.getImageId()))+ return describeImages(region, imageIds, owners, Map.of());+ }++ public List<Image> describeImages(String region, List<String> imageIds, List<String> owners, Map<String, List<String>> filters) {+ return imageCatalog.images().stream()+ .filter(Ec2ImageCatalog.CatalogImage::advertised)+ .filter(img -> img.matchesIdOrAlias(imageIds))+ .filter(img -> img.matchesOwner(owners))+ .filter(img -> matchesImageFilters(img, filters))+ .map(Ec2ImageCatalog.CatalogImage::toImage).collect(Collectors.toList());}+ // ─── Launch Templates ─────────────────────────────────────────────────────++ public LaunchTemplate createLaunchTemplate(String region, String name, String imageId,+ String instanceType, String keyName,+ List<String> securityGroupIds, String userData,+ List<Tag> launchTemplateTags) {+ ensureDefaultResources(region);+ if (name == null || name.isBlank()) {+ throw new AwsException("MissingParameter", "The request must contain the parameter LaunchTemplateName", 400);+ }+ boolean exists = launchTemplates.values().stream()+ .anyMatch(lt -> lt.getRegion().equals(region) && name.equals(lt.getLaunchTemplateName()));+ if (exists) {+ throw new AwsException("InvalidLaunchTemplateName.AlreadyExistsException",+ "Launch template name already in use.", 400);+ }++ LaunchTemplate launchTemplate = new LaunchTemplate();+ launchTemplate.setLaunchTemplateId("lt-" + randomHex(17));+ launchTemplate.setLaunchTemplateName(name);+ launchTemplate.setCreateTime(Instant.now());+ launchTemplate.setCreatedBy("arn:aws:iam::" + accountId + ":root");+ launchTemplate.setRegion(region);+ launchTemplate.setImageId(imageId);+ launchTemplate.setInstanceType(instanceType);+ launchTemplate.setKeyName(keyName);+ launchTemplate.setUserData(userData);+ if (securityGroupIds != null) {+ launchTemplate.setSecurityGroupIds(new ArrayList<>(securityGroupIds));+ }+ if (launchTemplateTags != null && !launchTemplateTags.isEmpty()) {+ launchTemplate.setTags(new ArrayList<>(launchTemplateTags));+ tags.put(launchTemplate.getLaunchTemplateId(), new ArrayList<>(launchTemplateTags));+ }+ launchTemplate.getVersions().put("1", dataFrom(launchTemplate));+ launchTemplates.put(key(region, launchTemplate.getLaunchTemplateId()), launchTemplate);+ return launchTemplate;+ }++ public LaunchTemplate createLaunchTemplateVersion(String region, String id, String name,+ String imageId, String instanceType, String keyName,+ List<String> securityGroupIds, String userData,+ String sourceVersion) {+ ensureDefaultResources(region);+ LaunchTemplate launchTemplate = findLaunchTemplate(region, id, name);+ int latestVersion = parseLaunchTemplateVersion(launchTemplate.getLatestVersionNumber()) + 1;+ LaunchTemplateData data = new LaunchTemplateData(versionData(launchTemplate,+ resolveLaunchTemplateVersion(launchTemplate, sourceVersion, launchTemplate.getLatestVersionNumber())));+ launchTemplate.setLatestVersionNumber(String.valueOf(latestVersion));+ if (imageId != null && !imageId.isBlank()) {+ data.setImageId(imageId);+ }+ if (instanceType != null && !instanceType.isBlank()) {+ data.setInstanceType(instanceType);+ }+ if (keyName != null && !keyName.isBlank()) {+ data.setKeyName(keyName);+ }+ if (userData != null && !userData.isBlank()) {+ data.setUserData(userData);+ }+ if (securityGroupIds != null && !securityGroupIds.isEmpty()) {+ data.setSecurityGroupIds(securityGroupIds);+ }+ launchTemplate.getVersions().put(String.valueOf(latestVersion), data);+ applyData(launchTemplate, data);+ return launchTemplate;+ }++ public List<LaunchTemplate> describeLaunchTemplateVersions(String region, String id, String name,+ List<String> requestedVersions) {+ List<LaunchTemplate> templates = describeLaunchTemplates(+ region,+ id != null && !id.isBlank() ? List.of(id) : List.of(),+ name != null && !name.isBlank() ? List.of(name) : List.of(),+ Map.of());+ List<LaunchTemplate> versions = new ArrayList<>();+ for (LaunchTemplate launchTemplate : templates) {+ List<String> effectiveVersions = requestedVersions == null || requestedVersions.isEmpty()+ ? List.of(launchTemplate.getLatestVersionNumber())+ : requestedVersions;+ for (String requestedVersion : effectiveVersions) {+ String resolvedVersion = resolveLaunchTemplateVersion(+ launchTemplate, requestedVersion, launchTemplate.getLatestVersionNumber());+ versions.add(copyForVersion(launchTemplate, resolvedVersion));+ }+ }+ return versions;+ }++ public LaunchTemplate modifyLaunchTemplate(String region, String id, String name, String defaultVersion) {+ ensureDefaultResources(region);+ LaunchTemplate launchTemplate = findLaunchTemplate(region, id, name);+ if (defaultVersion != null && !defaultVersion.isBlank()) {+ String resolved = switch (defaultVersion) {+ case "$Latest" -> launchTemplate.getLatestVersionNumber();+ case "$Default" -> launchTemplate.getDefaultVersionNumber();+ default -> defaultVersion;+ };+ int requested = parseLaunchTemplateVersion(resolved);+ int latest = parseLaunchTemplateVersion(launchTemplate.getLatestVersionNumber());+ if (requested < 1 || requested > latest) {+ throw new AwsException("InvalidLaunchTemplateVersion.NotFound",+ "The specified launch template version does not exist.", 400);+ }+ launchTemplate.setDefaultVersionNumber(String.valueOf(requested));+ }+ return launchTemplate;+ }++ public List<LaunchTemplate> describeLaunchTemplates(String region, List<String> ids,+ List<String> names, Map<String, List<String>> filters) {+ ensureDefaultResources(region);+ return launchTemplates.values().stream()+ .filter(lt -> lt.getRegion().equals(region))+ .filter(lt -> ids.isEmpty() || ids.contains(lt.getLaunchTemplateId()))+ .filter(lt -> names.isEmpty() || names.contains(lt.getLaunchTemplateName()))+ .filter(lt -> matchesFilters(lt, filters, region))+ .collect(Collectors.toList());+ }++ public LaunchTemplate deleteLaunchTemplate(String region, String id, String name) {+ ensureDefaultResources(region);+ LaunchTemplate launchTemplate = findLaunchTemplate(region, id, name);+ launchTemplates.remove(key(region, launchTemplate.getLaunchTemplateId()));+ tags.remove(launchTemplate.getLaunchTemplateId());+ return launchTemplate;+ }++ private LaunchTemplate findLaunchTemplate(String region, String id, String name) {+ if (id != null && !id.isBlank()) {+ LaunchTemplate launchTemplate = launchTemplates.get(key(region, id));+ if (launchTemplate != null) {+ return launchTemplate;+ }+ } else if (name != null && !name.isBlank()) {+ return launchTemplates.values().stream()+ .filter(lt -> lt.getRegion().equals(region) && name.equals(lt.getLaunchTemplateName()))+ .findFirst()+ .orElseThrow(() -> new AwsException("InvalidLaunchTemplateName.NotFoundException",+ "The specified launch template does not exist.", 400));+ }+ throw new AwsException("InvalidLaunchTemplateId.NotFoundException",+ "The specified launch template does not exist.", 400);+ }++ private int parseLaunchTemplateVersion(String version) {+ try {+ return Integer.parseInt(version);+ } catch (NumberFormatException e) {+ throw new AwsException("InvalidLaunchTemplateVersion.Malformed",+ "The specified launch template version is not valid.", 400);+ }+ }++ private String resolveLaunchTemplateVersion(LaunchTemplate launchTemplate, String requestedVersion,+ String defaultWhenMissing) {+ if (launchTemplate.getVersions().isEmpty()) {+ launchTemplate.getVersions().put(launchTemplate.getLatestVersionNumber(), dataFrom(launchTemplate));+ }+ String candidate = requestedVersion == null || requestedVersion.isBlank() ? defaultWhenMissing : requestedVersion;+ String resolved = switch (candidate) {+ case "$Latest" -> launchTemplate.getLatestVersionNumber();+ case "$Default" -> launchTemplate.getDefaultVersionNumber();+ default -> candidate;+ };+ int requested = parseLaunchTemplateVersion(resolved);+ int latest = parseLaunchTemplateVersion(launchTemplate.getLatestVersionNumber());+ if (requested < 1 || requested > latest || !launchTemplate.getVersions().containsKey(resolved)) {+ throw new AwsException("InvalidLaunchTemplateVersion.NotFound",+ "The specified launch template version does not exist.", 400);+ }+ return resolved;+ }++ private LaunchTemplateData versionData(LaunchTemplate launchTemplate, String version) {+ return launchTemplate.getVersions().get(version);+ }++ private LaunchTemplateData dataFrom(LaunchTemplate launchTemplate) {+ LaunchTemplateData data = new LaunchTemplateData();+ data.setImageId(launchTemplate.getImageId());+ data.setInstanceType(launchTemplate.getInstanceType());+ data.setKeyName(launchTemplate.getKeyName());+ data.setUserData(launchTemplate.getUserData());+ data.setSecurityGroupIds(launchTemplate.getSecurityGroupIds());+ return data;+ }++ private void applyData(LaunchTemplate launchTemplate, LaunchTemplateData data) {+ launchTemplate.setImageId(data.getImageId());+ launchTemplate.setInstanceType(data.getInstanceType());+ launchTemplate.setKeyName(data.getKeyName());+ launchTemplate.setUserData(data.getUserData());+ launchTemplate.setSecurityGroupIds(new ArrayList<>(data.getSecurityGroupIds()));+ }++ private LaunchTemplate copyForVersion(LaunchTemplate source, String versionNumber) {+ LaunchTemplate copy = new LaunchTemplate();+ copy.setLaunchTemplateId(source.getLaunchTemplateId());+ copy.setLaunchTemplateName(source.getLaunchTemplateName());+ copy.setDefaultVersionNumber(source.getDefaultVersionNumber());+ copy.setLatestVersionNumber(versionNumber);+ copy.setCreateTime(source.getCreateTime());+ copy.setCreatedBy(source.getCreatedBy());+ copy.setRegion(source.getRegion());+ copy.setTags(source.getTags());+ applyData(copy, versionData(source, versionNumber));+ return copy;+ }++ private boolean matchesImageFilters(Ec2ImageCatalog.CatalogImage image, Map<String, List<String>> filters) {+ if (filters == null || filters.isEmpty()) {+ return true;+ }+ for (Map.Entry<String, List<String>> filter : filters.entrySet()) {+ if (!matchesImageFilter(image, filter.getKey(), filter.getValue())) {+ return false;+ }+ }+ return true;+ }++ private boolean matchesImageFilter(Ec2ImageCatalog.CatalogImage catalogImage, String name, List<String> values) {+ Image image = catalogImage.toImage();+ return switch (name) {+ case "architecture" -> matchesFilterValue(values, image.getArchitecture());+ case "hypervisor" -> matchesFilterValue(values, image.getHypervisor());+ case "image-id" -> catalogImage.idsAndAliases().stream().anyMatch(id -> matchesFilterValue(values, id));+ case "image-type" -> matchesFilterValue(values, "machine");+ case "is-public" -> matchesFilterValue(values, String.valueOf(image.isPublic()));+ case "name" -> matchesFilterValue(values, image.getName());+ case "owner-alias" -> matchesFilterValue(values, image.getImageOwnerAlias());+ case "owner-id" -> matchesFilterValue(values, image.getOwnerId());+ case "root-device-name" -> matchesFilterValue(values, image.getRootDeviceName());+ case "root-device-type" -> matchesFilterValue(values, image.getRootDeviceType());+ case "state" -> matchesFilterValue(values, image.getState());+ case "virtualization-type" -> matchesFilterValue(values, image.getVirtualizationType());+ default -> true;+ };+ }++ private boolean matchesFilterValue(List<String> patterns, String value) {+ if (patterns == null || patterns.isEmpty()) {+ return true;+ }+ if (value == null) {+ return false;+ }+ return patterns.stream().anyMatch(pattern -> wildcardMatches(pattern, value));+ }++ private boolean wildcardMatches(String pattern, String value) {+ if (pattern == null) {+ return false;+ }+ if (!pattern.contains("*")) {+ return pattern.equals(value);+ }+ String regex = pattern.chars()+ .mapToObj(ch -> ch == '*' ? ".*" : java.util.regex.Pattern.quote(String.valueOf((char) ch)))+ .collect(Collectors.joining());+ return value.matches(regex);+ }+// ─── Tags ──────────────────────────────────────────────────────────────────public void createTags(String region, List<String> resourceIds, List<Tag> tagList) {@@ -1007,7 +1327,13 @@ public class Ec2Service {RouteTable rt = routeTables.get(key(region, resourceId));if (rt != null) { rt.setTags(new ArrayList<>(tagList)); return; }KeyPair kp = keyPairs.get(key(region, resourceId));- if (kp != null) { kp.setTags(new ArrayList<>(tagList)); }+ if (kp != null) { kp.setTags(new ArrayList<>(tagList)); return; }+ LaunchTemplate lt = launchTemplates.get(key(region, resourceId));+ if (lt != null) { lt.setTags(new ArrayList<>(tagList)); return; }+ VpcEndpoint endpoint = vpcEndpoints.get(key(region, resourceId));+ if (endpoint != null) { endpoint.setTags(new ArrayList<>(tagList)); return; }+ NatGateway natGateway = natGateways.get(key(region, resourceId));+ if (natGateway != null) { natGateway.setTags(new ArrayList<>(tagList)); }}public List<Map<String, String>> describeTags(String region, Map<String, List<String>> filters) {@@ -1055,6 +1381,9 @@ public class Ec2Service {if (resourceId.startsWith("rtb-")) return "route-table";if (resourceId.startsWith("key-")) return "key-pair";if (resourceId.startsWith("eipalloc-")) return "elastic-ip";+ if (resourceId.startsWith("lt-")) return "launch-template";+ if (resourceId.startsWith("vpce-")) return "vpc-endpoint";+ if (resourceId.startsWith("nat-")) return "natgateway";return "unknown";}@@ -1196,6 +1525,66 @@ public class Ec2Service {return rt;}+ // ─── NAT Gateways ─────────────────────────────────────────────────────────++ public NatGateway createNatGateway(String region, String subnetId, String allocationId,+ String connectivityType, List<Tag> natGatewayTags) {+ ensureDefaultResources(region);+ Subnet subnet = requireSubnet(region, subnetId);+ if (allocationId != null && !allocationId.isBlank()) {+ getRequiredAddress(region, allocationId);+ }++ NatGateway natGateway = new NatGateway();+ natGateway.setNatGatewayId("nat-" + randomHex(17));+ natGateway.setSubnetId(subnetId);+ natGateway.setVpcId(subnet.getVpcId());+ natGateway.setAllocationId(allocationId);+ natGateway.setConnectivityType(connectivityType != null && !connectivityType.isBlank() ? connectivityType : "public");+ natGateway.setCreateTime(Instant.now());+ natGateway.setRegion(region);+ if (natGatewayTags != null && !natGatewayTags.isEmpty()) {+ natGateway.setTags(new ArrayList<>(natGatewayTags));+ tags.put(natGateway.getNatGatewayId(), new ArrayList<>(natGatewayTags));+ }+ natGateways.put(key(region, natGateway.getNatGatewayId()), natGateway);+ return natGateway;+ }++ public List<NatGateway> describeNatGateways(String region, List<String> natGatewayIds,+ Map<String, List<String>> filters) {+ ensureDefaultResources(region);+ if (!natGatewayIds.isEmpty()) {+ for (String natGatewayId : natGatewayIds) {+ getRequiredNatGateway(region, natGatewayId);+ }+ }+ return natGateways.values().stream()+ .filter(natGateway -> natGateway.getRegion().equals(region))+ .filter(natGateway -> natGatewayIds.isEmpty()+ || natGatewayIds.contains(natGateway.getNatGatewayId()))+ .filter(natGateway -> matchesFilters(natGateway, filters, region))+ .collect(Collectors.toList());+ }++ public NatGateway deleteNatGateway(String region, String natGatewayId) {+ ensureDefaultResources(region);+ NatGateway natGateway = getRequiredNatGateway(region, natGatewayId);+ natGateway.setState("deleted");+ natGateways.remove(key(region, natGatewayId));+ tags.remove(natGatewayId);+ return natGateway;+ }++ private NatGateway getRequiredNatGateway(String region, String natGatewayId) {+ NatGateway natGateway = natGateways.get(key(region, natGatewayId));+ if (natGateway == null) {+ throw new AwsException("NatGatewayNotFound",+ "NatGateway " + natGatewayId + " was not found", 400);+ }+ return natGateway;+ }+// ─── Elastic IPs ───────────────────────────────────────────────────────────public Address allocateAddress(String region) {@@ -1296,6 +1685,9 @@ public class Ec2Service {allTypes.add(buildInstanceType("t3.small", 2, 2048));allTypes.add(buildInstanceType("t3.medium", 2, 4096));allTypes.add(buildInstanceType("m5.large", 2, 8192));+ allTypes.add(buildInstanceType("t4g.micro", 2, 1024, List.of("arm64")));+ allTypes.add(buildInstanceType("t4g.small", 2, 2048, List.of("arm64")));+ allTypes.add(buildInstanceType("t4g.medium", 2, 4096, List.of("arm64")));if (instanceTypeNames.isEmpty()) {return allTypes;@@ -1306,15 +1698,55 @@ public class Ec2Service {}private Map<String, Object> buildInstanceType(String name, int vcpu, int memMib) {+ return buildInstanceType(name, vcpu, memMib, List.of("x86_64"));+ }++ private Map<String, Object> buildInstanceType(String name, int vcpu, int memMib,+ List<String> supportedArchitectures) {Map<String, Object> t = new LinkedHashMap<>();t.put("instanceType", name);t.put("vcpu", vcpu);t.put("memoryMib", memMib);- t.put("supportedArchitectures", List.of("x86_64"));+ t.put("supportedArchitectures", supportedArchitectures);t.put("currentGeneration", true);return t;}+ public List<Map<String, String>> describeInstanceTypeOfferings(String region, List<String> instanceTypeNames,+ String locationType,+ Map<String, List<String>> filters) {+ List<String> effectiveTypeNames = new ArrayList<>(new LinkedHashSet<>(instanceTypeNames));+ if (filters != null && filters.containsKey("instance-type")) {+ effectiveTypeNames.addAll(filters.get("instance-type"));+ effectiveTypeNames = new ArrayList<>(new LinkedHashSet<>(effectiveTypeNames));+ }+ String effectiveLocationType = locationType != null && !locationType.isBlank()+ ? locationType+ : "availability-zone";+ List<String> locations = "region".equals(effectiveLocationType)+ ? List.of(region)+ : describeAvailabilityZones(region).stream()+ .map(zone -> zone.get("zoneName"))+ .toList();+ List<String> locationFilter = filters != null ? filters.get("location") : null;++ List<Map<String, String>> offerings = new ArrayList<>();+ for (Map<String, Object> type : describeInstanceTypes(effectiveTypeNames)) {+ String instanceType = (String) type.get("instanceType");+ for (String location : locations) {+ if (locationFilter != null && !matchesValue(location, locationFilter)) {+ continue;+ }+ Map<String, String> offering = new LinkedHashMap<>();+ offering.put("instanceType", instanceType);+ offering.put("locationType", effectiveLocationType);+ offering.put("location", location);+ offerings.add(offering);+ }+ }+ return offerings;+ }+// ─── Filter matching ───────────────────────────────────────────────────────private boolean matchesValue(String resourceValue, List<String> filterValues) {@@ -1452,6 +1884,37 @@ public class Ec2Service {default -> true;};}+ if (resource instanceof LaunchTemplate lt) {+ return switch (filterName) {+ case "launch-template-id" -> matchesValue(values, lt.getLaunchTemplateId());+ case "launch-template-name" -> matchesValue(values, lt.getLaunchTemplateName());+ default -> true;+ };+ }+ if (resource instanceof VpcEndpoint endpoint) {+ return switch (filterName) {+ case "service-name" -> matchesValue(values, endpoint.getServiceName());+ case "vpc-endpoint-id" -> matchesValue(values, endpoint.getVpcEndpointId());+ case "vpc-endpoint-type" -> matchesValue(values, endpoint.getVpcEndpointType());+ case "vpc-id" -> matchesValue(values, endpoint.getVpcId());+ case "state" -> matchesValue(values, endpoint.getState());+ case "route-table-id" -> endpoint.getRouteTableIds().stream()+ .anyMatch(routeTableId -> matchesValue(values, routeTableId));+ case "subnet-id" -> endpoint.getSubnetIds().stream()+ .anyMatch(subnetId -> matchesValue(values, subnetId));+ default -> true;+ };+ }+ if (resource instanceof NatGateway natGateway) {+ return switch (filterName) {+ case "nat-gateway-id" -> matchesValue(values, natGateway.getNatGatewayId());+ case "subnet-id" -> matchesValue(values, natGateway.getSubnetId());+ case "vpc-id" -> matchesValue(values, natGateway.getVpcId());+ case "state" -> matchesValue(values, natGateway.getState());+ case "connectivity-type" -> matchesValue(values, natGateway.getConnectivityType());+ default -> true;+ };+ }if (resource instanceof Volume vol) {return switch (filterName) {case "volume-id" -> matchesValue(values, vol.getVolumeId());@@ -1496,6 +1959,9 @@ public class Ec2Service {if (resource instanceof Address addr) return addr.getTags();if (resource instanceof Volume vol) return vol.getTags();if (resource instanceof NetworkInterface ni) return ni.getTagSet();+ if (resource instanceof LaunchTemplate lt) return lt.getTags();+ if (resource instanceof VpcEndpoint endpoint) return endpoint.getTags();+ if (resource instanceof NatGateway natGateway) return natGateway.getTags();return Collections.emptyList();}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplate.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplate.javanew file mode 100644index 0000000000..a7acc08cc8--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplate.java@@ -0,0 +1,76 @@+package io.github.hectorvent.floci.services.ec2.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class LaunchTemplate {++ private String launchTemplateId;+ private String launchTemplateName;+ private String defaultVersionNumber = "1";+ private String latestVersionNumber = "1";+ private Instant createTime;+ private String createdBy;+ private String region;+ private String imageId;+ private String instanceType;+ private String keyName;+ private String userData;+ private List<String> securityGroupIds = new ArrayList<>();+ private List<Tag> tags = new ArrayList<>();+ private Map<String, LaunchTemplateData> versions = new LinkedHashMap<>();++ public LaunchTemplate() {}++ public String getLaunchTemplateId() { return launchTemplateId; }+ public void setLaunchTemplateId(String launchTemplateId) { this.launchTemplateId = launchTemplateId; }++ public String getLaunchTemplateName() { return launchTemplateName; }+ public void setLaunchTemplateName(String launchTemplateName) { this.launchTemplateName = launchTemplateName; }++ public String getDefaultVersionNumber() { return defaultVersionNumber; }+ public void setDefaultVersionNumber(String defaultVersionNumber) { this.defaultVersionNumber = defaultVersionNumber; }++ public String getLatestVersionNumber() { return latestVersionNumber; }+ public void setLatestVersionNumber(String latestVersionNumber) { this.latestVersionNumber = latestVersionNumber; }++ public Instant getCreateTime() { return createTime; }+ public void setCreateTime(Instant createTime) { this.createTime = createTime; }++ public String getCreatedBy() { return createdBy; }+ public void setCreatedBy(String createdBy) { this.createdBy = createdBy; }++ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }++ public String getImageId() { return imageId; }+ public void setImageId(String imageId) { this.imageId = imageId; }++ public String getInstanceType() { return instanceType; }+ public void setInstanceType(String instanceType) { this.instanceType = instanceType; }++ public String getKeyName() { return keyName; }+ public void setKeyName(String keyName) { this.keyName = keyName; }++ public String getUserData() { return userData; }+ public void setUserData(String userData) { this.userData = userData; }++ public List<String> getSecurityGroupIds() { return securityGroupIds; }+ public void setSecurityGroupIds(List<String> securityGroupIds) { this.securityGroupIds = securityGroupIds; }++ public List<Tag> getTags() { return tags; }+ public void setTags(List<Tag> tags) { this.tags = tags; }++ public Map<String, LaunchTemplateData> getVersions() { return versions; }+ public void setVersions(Map<String, LaunchTemplateData> versions) {+ this.versions = versions != null ? new LinkedHashMap<>(versions) : new LinkedHashMap<>();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplateData.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplateData.javanew file mode 100644index 0000000000..5f167aa1f3--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/LaunchTemplateData.java@@ -0,0 +1,45 @@+package io.github.hectorvent.floci.services.ec2.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.ArrayList;+import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class LaunchTemplateData {++ private String imageId;+ private String instanceType;+ private String keyName;+ private String userData;+ private List<String> securityGroupIds = new ArrayList<>();++ public LaunchTemplateData() {}++ public LaunchTemplateData(LaunchTemplateData source) {+ this.imageId = source.imageId;+ this.instanceType = source.instanceType;+ this.keyName = source.keyName;+ this.userData = source.userData;+ this.securityGroupIds = new ArrayList<>(source.securityGroupIds);+ }++ public String getImageId() { return imageId; }+ public void setImageId(String imageId) { this.imageId = imageId; }++ public String getInstanceType() { return instanceType; }+ public void setInstanceType(String instanceType) { this.instanceType = instanceType; }++ public String getKeyName() { return keyName; }+ public void setKeyName(String keyName) { this.keyName = keyName; }++ public String getUserData() { return userData; }+ public void setUserData(String userData) { this.userData = userData; }++ public List<String> getSecurityGroupIds() { return securityGroupIds; }+ public void setSecurityGroupIds(List<String> securityGroupIds) {+ this.securityGroupIds = securityGroupIds != null ? new ArrayList<>(securityGroupIds) : new ArrayList<>();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/NatGateway.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/NatGateway.javanew file mode 100644index 0000000000..f9c8274068--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/NatGateway.java@@ -0,0 +1,52 @@+package io.github.hectorvent.floci.services.ec2.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.ArrayList;+import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class NatGateway {++ private String natGatewayId;+ private String subnetId;+ private String vpcId;+ private String allocationId;+ private String state = "available";+ private String connectivityType = "public";+ private Instant createTime;+ private String region;+ private List<Tag> tags = new ArrayList<>();++ public NatGateway() {}++ public String getNatGatewayId() { return natGatewayId; }+ public void setNatGatewayId(String natGatewayId) { this.natGatewayId = natGatewayId; }++ public String getSubnetId() { return subnetId; }+ public void setSubnetId(String subnetId) { this.subnetId = subnetId; }++ public String getVpcId() { return vpcId; }+ public void setVpcId(String vpcId) { this.vpcId = vpcId; }++ public String getAllocationId() { return allocationId; }+ public void setAllocationId(String allocationId) { this.allocationId = allocationId; }++ public String getState() { return state; }+ public void setState(String state) { this.state = state; }++ public String getConnectivityType() { return connectivityType; }+ public void setConnectivityType(String connectivityType) { this.connectivityType = connectivityType; }++ public Instant getCreateTime() { return createTime; }+ public void setCreateTime(Instant createTime) { this.createTime = createTime; }++ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }++ public List<Tag> getTags() { return tags; }+ public void setTags(List<Tag> tags) { this.tags = tags; }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcEndpoint.java b/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcEndpoint.javanew file mode 100644index 0000000000..51a2a81ffd--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/model/VpcEndpoint.java@@ -0,0 +1,60 @@+package io.github.hectorvent.floci.services.ec2.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;+import java.util.ArrayList;+import java.util.List;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class VpcEndpoint {++ private String vpcEndpointId;+ private String vpcId;+ private String serviceName;+ private String vpcEndpointType = "Gateway";+ private String state = "available";+ private Instant creationTimestamp;+ private String region;+ private List<String> routeTableIds = new ArrayList<>();+ private List<String> subnetIds = new ArrayList<>();+ private List<String> securityGroupIds = new ArrayList<>();+ private List<Tag> tags = new ArrayList<>();++ public VpcEndpoint() {}++ public String getVpcEndpointId() { return vpcEndpointId; }+ public void setVpcEndpointId(String vpcEndpointId) { this.vpcEndpointId = vpcEndpointId; }++ public String getVpcId() { return vpcId; }+ public void setVpcId(String vpcId) { this.vpcId = vpcId; }++ public String getServiceName() { return serviceName; }+ public void setServiceName(String serviceName) { this.serviceName = serviceName; }++ public String getVpcEndpointType() { return vpcEndpointType; }+ public void setVpcEndpointType(String vpcEndpointType) { this.vpcEndpointType = vpcEndpointType; }++ public String getState() { return state; }+ public void setState(String state) { this.state = state; }++ public Instant getCreationTimestamp() { return creationTimestamp; }+ public void setCreationTimestamp(Instant creationTimestamp) { this.creationTimestamp = creationTimestamp; }++ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }++ public List<String> getRouteTableIds() { return routeTableIds; }+ public void setRouteTableIds(List<String> routeTableIds) { this.routeTableIds = routeTableIds; }++ public List<String> getSubnetIds() { return subnetIds; }+ public void setSubnetIds(List<String> subnetIds) { this.subnetIds = subnetIds; }++ public List<String> getSecurityGroupIds() { return securityGroupIds; }+ public void setSecurityGroupIds(List<String> securityGroupIds) { this.securityGroupIds = securityGroupIds; }++ public List<Tag> getTags() { return tags; }+ public void setTags(List<Tag> tags) { this.tags = tags; }+}diff --git a/src/main/resources/META-INF/native-image/resource-config.json b/src/main/resources/META-INF/native-image/resource-config.jsonindex ef87efa2c0..d369a7a83c 100644--- a/src/main/resources/META-INF/native-image/resource-config.json+++ b/src/main/resources/META-INF/native-image/resource-config.json@@ -2,6 +2,7 @@"resources": {"includes": [{"pattern": "META-INF/services/java.security.Provider"},+ {"pattern": "ec2/.*\\.yaml"},{"pattern": "org/apache/velocity/runtime/defaults/velocity.properties"}]},diff --git a/src/main/resources/ec2/image-catalog.yaml b/src/main/resources/ec2/image-catalog.yamlnew file mode 100644index 0000000000..82b887c702--- /dev/null+++ b/src/main/resources/ec2/image-catalog.yaml@@ -0,0 +1,82 @@+defaultDockerImage: public.ecr.aws/amazonlinux/amazonlinux:2023++images:+ - imageId: ami-0abcdef1234567890+ aliases:+ - ami-amazonlinux2+ dockerImage: public.ecr.aws/amazonlinux/amazonlinux:2+ name: amzn2-ami-hvm-2.0.20230404.0-x86_64-gp2+ description: Amazon Linux 2 AMI+ architecture: x86_64+ creationDate: "2023-04-04T00:00:00.000Z"++ - imageId: ami-0abcdef1234567891+ aliases:+ - ami-amazonlinux2023+ dockerImage: public.ecr.aws/amazonlinux/amazonlinux:2023+ name: al2023-ami-2023.0.20230315.0-kernel-6.1-x86_64+ description: Amazon Linux 2023 AMI+ architecture: x86_64+ creationDate: "2023-03-15T00:00:00.000Z"++ - imageId: ami-0abcdef1234567892+ aliases:+ - ami-ubuntu2004+ dockerImage: public.ecr.aws/docker/library/ubuntu:20.04+ name: ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-20230324+ description: Canonical, Ubuntu, 20.04 LTS+ ownerId: "099720109477"+ imageOwnerAlias: canonical+ architecture: x86_64+ creationDate: "2023-03-24T00:00:00.000Z"++ - imageId: ami-ubuntu2204+ dockerImage: public.ecr.aws/docker/library/ubuntu:22.04+ name: ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-20230420+ description: Canonical, Ubuntu, 22.04 LTS+ ownerId: "099720109477"+ imageOwnerAlias: canonical+ architecture: x86_64+ creationDate: "2023-04-20T00:00:00.000Z"++ - imageId: ami-ubuntu2404-arm64+ aliases:+ - ami-ubuntu2404+ dockerImage: public.ecr.aws/docker/library/ubuntu:24.04+ name: ubuntu/images/hvm-ssd-gp3/ubuntu-noble-24.04-arm64-server-20260515+ description: Canonical, Ubuntu, 24.04 LTS+ ownerId: "099720109477"+ imageOwnerAlias: canonical+ architecture: arm64+ creationDate: "2026-05-15T00:00:00.000Z"++ - imageId: ami-ubuntu2404-amd64+ dockerImage: public.ecr.aws/docker/library/ubuntu:24.04+ name: ubuntu/images/hvm-ssd-gp3/ubuntu-noble-24.04-amd64-server-20260515+ description: Canonical, Ubuntu, 24.04 LTS+ ownerId: "099720109477"+ imageOwnerAlias: canonical+ architecture: x86_64+ creationDate: "2026-05-15T00:00:00.000Z"++ - imageId: ami-debian12+ dockerImage: public.ecr.aws/docker/library/debian:12+ name: debian-12-amd64-20230411+ description: Debian 12 AMI+ architecture: x86_64+ creationDate: "2023-04-11T00:00:00.000Z"++ - imageId: ami-alpine+ dockerImage: public.ecr.aws/docker/library/alpine:latest+ name: alpine-linux-latest-x86_64+ description: Alpine Linux AMI+ architecture: x86_64+ creationDate: "2023-04-01T00:00:00.000Z"++ - imageId: ami-0abcdef1234567893+ dockerImage: public.ecr.aws/amazonlinux/amazonlinux:2023+ name: Windows_Server-2022-English-Full-Base-2023.04.12+ description: Microsoft Windows Server 2022 Full Locale English AMI+ architecture: x86_64+ platform: windows+ creationDate: "2023-04-12T00:00:00.000Z"diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ImageCatalogTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ImageCatalogTest.javanew file mode 100644index 0000000000..219aff741c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2ImageCatalogTest.java@@ -0,0 +1,64 @@+package io.github.hectorvent.floci.services.ec2;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;++import java.util.List;+import java.util.Set;+import java.util.stream.Collectors;++import org.junit.jupiter.api.Test;++import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;++@QuarkusTest+class Ec2ImageCatalogTest {++ @Inject+ Ec2ImageCatalog imageCatalog;++ @Inject+ AmiImageResolver amiImageResolver;++ @Test+ void catalogContainsCurrentEc2ImagesAndFlociAliases() {+ Set<String> imageIds = imageCatalog.images().stream()+ .map(image -> image.imageId)+ .collect(Collectors.toSet());++ assertEquals(Set.of(+ "ami-0abcdef1234567890",+ "ami-0abcdef1234567891",+ "ami-0abcdef1234567892",+ "ami-ubuntu2204",+ "ami-ubuntu2404-arm64",+ "ami-ubuntu2404-amd64",+ "ami-debian12",+ "ami-alpine",+ "ami-0abcdef1234567893"), imageIds);++ assertTrue(imageCatalog.findByIdOrAlias("ami-amazonlinux2").isPresent());+ assertTrue(imageCatalog.findByIdOrAlias("ami-amazonlinux2023").isPresent());+ assertTrue(imageCatalog.findByIdOrAlias("ami-ubuntu2004").isPresent());+ assertTrue(imageCatalog.findByIdOrAlias("ami-ubuntu2404").isPresent());+ }++ @Test+ void resolverUsesCatalogDockerImagesForIdsAndAliases() {+ imageCatalog.images()+ .forEach(image -> assertEquals(image.dockerImage, amiImageResolver.resolve(image.imageId)));++ List.of("ami-amazonlinux2", "ami-amazonlinux2023", "ami-ubuntu2004", "ami-ubuntu2404")+ .forEach(alias -> assertEquals(+ imageCatalog.findByIdOrAlias(alias).orElseThrow().dockerImage,+ amiImageResolver.resolve(alias)));+ }++ @Test+ void unknownImageUsesCatalogDefault() {+ assertFalse(imageCatalog.findByIdOrAlias("ami-unknown").isPresent());+ assertEquals(imageCatalog.defaultDockerImage(), amiImageResolver.resolve("ami-unknown"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.javaindex e642a6099f..62cffeb18f 100644--- a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2IntegrationTest.java@@ -9,7 +9,12 @@ import static org.hamcrest.Matchers.notNullValue;import static org.hamcrest.Matchers.startsWith;import static org.hamcrest.Matchers.containsString;+import java.io.ByteArrayOutputStream;+import java.io.IOException;+import java.nio.charset.StandardCharsets;+import java.util.Base64;import java.util.List;+import java.util.zip.GZIPOutputStream;import org.junit.jupiter.api.MethodOrderer;import org.junit.jupiter.api.Order;import org.junit.jupiter.api.Test;@@ -43,6 +48,9 @@ class Ec2IntegrationTest {private static String volumeId;private static String rootVolumeId;private static String networkInterfaceId;+ private static String launchTemplateId;+ private static String vpcEndpointId;+ private static String natGatewayId;// =========================================================================// Default resources@@ -167,6 +175,52 @@ class Ec2IntegrationTest {@Test@Order(8)+ void describeImagesWithCatalogFilters() {+ given()+ .formParam("Action", "DescribeImages")+ .formParam("Owner.1", "099720109477")+ .formParam("Filter.1.Name", "name")+ .formParam("Filter.1.Value.1", "ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*")+ .formParam("Filter.2.Name", "architecture")+ .formParam("Filter.2.Value.1", "x86_64")+ .formParam("Filter.3.Name", "state")+ .formParam("Filter.3.Value.1", "available")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .contentType("application/xml")+ .body("DescribeImagesResponse.imagesSet.item.size()", equalTo(1))+ .body("DescribeImagesResponse.imagesSet.item.imageId", equalTo("ami-0abcdef1234567892"))+ .body("DescribeImagesResponse.imagesSet.item.architecture", equalTo("x86_64"));+ }++ @Test+ @Order(9)+ void describeImagesWithUbuntu2404Arm64Filters() {+ given()+ .formParam("Action", "DescribeImages")+ .formParam("Owner.1", "099720109477")+ .formParam("Filter.1.Name", "name")+ .formParam("Filter.1.Value.1", "ubuntu/images/hvm-ssd-gp3/ubuntu-noble-24.04-arm64-server-*")+ .formParam("Filter.2.Name", "architecture")+ .formParam("Filter.2.Value.1", "arm64")+ .formParam("Filter.3.Name", "state")+ .formParam("Filter.3.Value.1", "available")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .contentType("application/xml")+ .body("DescribeImagesResponse.imagesSet.item.size()", equalTo(1))+ .body("DescribeImagesResponse.imagesSet.item.imageId", equalTo("ami-ubuntu2404-arm64"))+ .body("DescribeImagesResponse.imagesSet.item.architecture", equalTo("arm64"));+ }++ @Test+ @Order(17)void describeInstanceTypes() {given().formParam("Action", "DescribeInstanceTypes")@@ -179,6 +233,50 @@ class Ec2IntegrationTest {.body("DescribeInstanceTypesResponse.instanceTypeSet.item.size()", greaterThan(0));}+ @Test+ @Order(18)+ void describeInstanceTypeOfferings() {+ given()+ .formParam("Action", "DescribeInstanceTypeOfferings")+ .formParam("LocationType", "availability-zone")+ .formParam("InstanceType.1", "m5.large")+ .formParam("Filter.1.Name", "instance-type")+ .formParam("Filter.1.Value.1", "m5.large")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .contentType("application/xml")+ .body("DescribeInstanceTypeOfferingsResponse.instanceTypeOfferingSet.item.size()", equalTo(3))+ .body("DescribeInstanceTypeOfferingsResponse.instanceTypeOfferingSet.item[0].instanceType",+ equalTo("m5.large"))+ .body("DescribeInstanceTypeOfferingsResponse.instanceTypeOfferingSet.item[0].location",+ startsWith("us-east-1"));+ }++ @Test+ @Order(19)+ void describeArmInstanceTypeOfferingByRegion() {+ given()+ .formParam("Action", "DescribeInstanceTypeOfferings")+ .formParam("LocationType", "region")+ .formParam("Filter.1.Name", "instance-type")+ .formParam("Filter.1.Value.1", "t4g.medium")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .contentType("application/xml")+ .body("DescribeInstanceTypeOfferingsResponse.instanceTypeOfferingSet.item[0].instanceType",+ equalTo("t4g.medium"))+ .body("DescribeInstanceTypeOfferingsResponse.instanceTypeOfferingSet.item[0].locationType",+ equalTo("region"))+ .body("DescribeInstanceTypeOfferingsResponse.instanceTypeOfferingSet.item[0].location",+ equalTo("us-east-1"));+ }+// =========================================================================// VPCs// =========================================================================@@ -293,6 +391,19 @@ class Ec2IntegrationTest {.statusCode(200);}+ @Test+ @Order(15)+ void describeNatGatewaysInitiallyEmpty() {+ given()+ .formParam("Action", "DescribeNatGateways")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeNatGatewaysResponse.natGatewaySet.item.size()", equalTo(0));+ }+// =========================================================================// Subnets// =========================================================================@@ -465,7 +576,7 @@ class Ec2IntegrationTest {}@Test- @Order(42)+ @Order(39)void importKeyPair() {given().formParam("Action", "ImportKeyPair")@@ -480,6 +591,200 @@ class Ec2IntegrationTest {.body("ImportKeyPairResponse.keyPairId", startsWith("key-"));}+ @Test+ @Order(42)+ void createLaunchTemplateRejectsMalformedUserData() {+ given()+ .formParam("Action", "CreateLaunchTemplate")+ .formParam("LaunchTemplateName", "bad-user-data-template")+ .formParam("LaunchTemplateData.ImageId", "ami-0abcdef1234567890")+ .formParam("LaunchTemplateData.InstanceType", "t3.micro")+ .formParam("LaunchTemplateData.UserData", "not-valid-base64")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(400)+ .body("Response.Errors.Error.Code", equalTo("InvalidParameterValue"));+ }++ @Test+ @Order(43)+ void createLaunchTemplate()+ throws IOException {+ launchTemplateId = given()+ .formParam("Action", "CreateLaunchTemplate")+ .formParam("LaunchTemplateName", "sample-template")+ .formParam("LaunchTemplateData.ImageId", "ami-0abcdef1234567890")+ .formParam("LaunchTemplateData.InstanceType", "t3.micro")+ .formParam("LaunchTemplateData.KeyName", "test-key")+ .formParam("LaunchTemplateData.SecurityGroupId.1", securityGroupId)+ .formParam("LaunchTemplateData.UserData", gzipBase64("#!/bin/sh\necho launch-template\n"))+ .formParam("TagSpecification.1.ResourceType", "launch-template")+ .formParam("TagSpecification.1.Tag.1.Key", "Name")+ .formParam("TagSpecification.1.Tag.1.Value", "sample-template")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateLaunchTemplateResponse.launchTemplate.launchTemplateId", startsWith("lt-"))+ .body("CreateLaunchTemplateResponse.launchTemplate.launchTemplateName",+ equalTo("sample-template"))+ .extract().path("CreateLaunchTemplateResponse.launchTemplate.launchTemplateId");+ }++ @Test+ @Order(44)+ void describeLaunchTemplateById() {+ given()+ .formParam("Action", "DescribeLaunchTemplates")+ .formParam("LaunchTemplateId.1", launchTemplateId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeLaunchTemplatesResponse.launchTemplates.item.launchTemplateId",+ equalTo(launchTemplateId))+ .body("DescribeLaunchTemplatesResponse.launchTemplates.item.launchTemplateName",+ equalTo("sample-template"));+ }++ @Test+ @Order(45)+ void describeLaunchTemplateVersionsById() {+ given()+ .formParam("Action", "DescribeLaunchTemplateVersions")+ .formParam("LaunchTemplateId", launchTemplateId)+ .formParam("Versions.1", "$Latest")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateId",+ equalTo(launchTemplateId))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.imageId",+ equalTo("ami-0abcdef1234567890"))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.instanceType",+ equalTo("t3.micro"))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.userData",+ equalTo("#!/bin/sh\necho launch-template\n"));+ }++ @Test+ @Order(46)+ void createLaunchTemplateVersion()+ throws IOException {+ given()+ .formParam("Action", "CreateLaunchTemplateVersion")+ .formParam("LaunchTemplateId", launchTemplateId)+ .formParam("SourceVersion", "$Latest")+ .formParam("VersionDescription", "updated by test")+ .formParam("LaunchTemplateData.ImageId", "ami-0abcdef1234567890")+ .formParam("LaunchTemplateData.InstanceType", "t3.small")+ .formParam("LaunchTemplateData.KeyName", "test-key")+ .formParam("LaunchTemplateData.SecurityGroupId.1", securityGroupId)+ .formParam("LaunchTemplateData.UserData", gzipBase64("#!/bin/sh\necho launch-template-version\n"))+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateLaunchTemplateVersionResponse.launchTemplateVersion.launchTemplateId",+ equalTo(launchTemplateId))+ .body("CreateLaunchTemplateVersionResponse.launchTemplateVersion.versionNumber",+ equalTo("2"))+ .body("CreateLaunchTemplateVersionResponse.launchTemplateVersion.defaultVersion",+ equalTo("false"))+ .body("CreateLaunchTemplateVersionResponse.launchTemplateVersion.launchTemplateData.instanceType",+ equalTo("t3.small"))+ .body("CreateLaunchTemplateVersionResponse.launchTemplateVersion.launchTemplateData.userData",+ equalTo("#!/bin/sh\necho launch-template-version\n"));++ given()+ .formParam("Action", "DescribeLaunchTemplateVersions")+ .formParam("LaunchTemplateId", launchTemplateId)+ .formParam("Versions.1", "1")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.versionNumber",+ equalTo("1"))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.defaultVersion",+ equalTo("true"))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.instanceType",+ equalTo("t3.micro"));+ }++ @Test+ @Order(47)+ void modifyLaunchTemplateDefaultVersion() {+ given()+ .formParam("Action", "ModifyLaunchTemplate")+ .formParam("LaunchTemplateId", launchTemplateId)+ .formParam("DefaultVersion", "2")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("ModifyLaunchTemplateResponse.launchTemplate.launchTemplateId",+ equalTo(launchTemplateId))+ .body("ModifyLaunchTemplateResponse.launchTemplate.defaultVersionNumber",+ equalTo("2"))+ .body("ModifyLaunchTemplateResponse.launchTemplate.latestVersionNumber",+ equalTo("2"));+ }++ @Test+ @Order(48)+ void describeUpdatedLaunchTemplateVersionById() {+ given()+ .formParam("Action", "DescribeLaunchTemplateVersions")+ .formParam("LaunchTemplateId", launchTemplateId)+ .formParam("Versions.1", "$Latest")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.versionNumber",+ equalTo("2"))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.defaultVersion",+ equalTo("true"))+ .body("DescribeLaunchTemplateVersionsResponse.launchTemplateVersionSet.item.launchTemplateData.instanceType",+ equalTo("t3.small"));+ }++ @Test+ @Order(49)+ void deleteLaunchTemplate() {+ given()+ .formParam("Action", "DeleteLaunchTemplate")+ .formParam("LaunchTemplateId", launchTemplateId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DeleteLaunchTemplateResponse.launchTemplate.launchTemplateId",+ equalTo(launchTemplateId));+ }++ private static String gzipBase64(String value)+ throws IOException+ {+ ByteArrayOutputStream buffer = new ByteArrayOutputStream();+ try (GZIPOutputStream gzip = new GZIPOutputStream(buffer)) {+ gzip.write(value.getBytes(StandardCharsets.UTF_8));+ }+ return Base64.getEncoder().encodeToString(buffer.toByteArray());+ }+// =========================================================================// Internet Gateways// =========================================================================@@ -626,6 +931,60 @@ class Ec2IntegrationTest {.body("DescribeRouteTablesResponse.routeTableSet.item.routeTableId", equalTo(routeTableId));}+ @Test+ @Order(66)+ void createVpcEndpoint() {+ vpcEndpointId = given()+ .formParam("Action", "CreateVpcEndpoint")+ .formParam("VpcId", vpcId)+ .formParam("ServiceName", "com.amazonaws.us-east-1.s3")+ .formParam("VpcEndpointType", "Gateway")+ .formParam("RouteTableId.1", routeTableId)+ .formParam("TagSpecification.1.ResourceType", "vpc-endpoint")+ .formParam("TagSpecification.1.Tag.1.Key", "Name")+ .formParam("TagSpecification.1.Tag.1.Value", "sample-s3")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateVpcEndpointResponse.vpcEndpoint.vpcEndpointId", startsWith("vpce-"))+ .body("CreateVpcEndpointResponse.vpcEndpoint.vpcId", equalTo(vpcId))+ .body("CreateVpcEndpointResponse.vpcEndpoint.routeTableIdSet.item.routeTableId",+ equalTo(routeTableId))+ .extract().path("CreateVpcEndpointResponse.vpcEndpoint.vpcEndpointId");+ }++ @Test+ @Order(67)+ void describeVpcEndpointById() {+ given()+ .formParam("Action", "DescribeVpcEndpoints")+ .formParam("VpcEndpointId.1", vpcEndpointId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeVpcEndpointsResponse.vpcEndpointSet.item.vpcEndpointId",+ equalTo(vpcEndpointId))+ .body("DescribeVpcEndpointsResponse.vpcEndpointSet.item.serviceName",+ equalTo("com.amazonaws.us-east-1.s3"));+ }++ @Test+ @Order(68)+ void deleteVpcEndpoint() {+ given()+ .formParam("Action", "DeleteVpcEndpoints")+ .formParam("VpcEndpointId.1", vpcEndpointId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }+// =========================================================================// Elastic IPs// =========================================================================@@ -660,6 +1019,51 @@ class Ec2IntegrationTest {.body("DescribeAddressesResponse.addressesSet.item.allocationId", equalTo(allocationId));}+ @Test+ @Order(72)+ void createDescribeAndDeleteNatGateway() {+ natGatewayId = given()+ .formParam("Action", "CreateNatGateway")+ .formParam("SubnetId", subnetId)+ .formParam("AllocationId", allocationId)+ .formParam("TagSpecification.1.ResourceType", "natgateway")+ .formParam("TagSpecification.1.Tag.1.Key", "Name")+ .formParam("TagSpecification.1.Tag.1.Value", "sample-nat")+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateNatGatewayResponse.natGateway.natGatewayId", startsWith("nat-"))+ .body("CreateNatGatewayResponse.natGateway.subnetId", equalTo(subnetId))+ .body("CreateNatGatewayResponse.natGateway.natGatewayAddressSet.item.allocationId",+ equalTo(allocationId))+ .extract().path("CreateNatGatewayResponse.natGateway.natGatewayId");++ given()+ .formParam("Action", "DescribeNatGateways")+ .formParam("NatGatewayId.1", natGatewayId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeNatGatewaysResponse.natGatewaySet.item.natGatewayId",+ equalTo(natGatewayId))+ .body("DescribeNatGatewaysResponse.natGatewaySet.item.state", equalTo("available"));++ given()+ .formParam("Action", "DeleteNatGateway")+ .formParam("NatGatewayId", natGatewayId)+ .header("Authorization", AUTH_HEADER)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DeleteNatGatewayResponse.natGateway.natGatewayId", equalTo(natGatewayId))+ .body("DeleteNatGatewayResponse.natGateway.state", equalTo("deleted"));+ }+// =========================================================================// Instances// =========================================================================