Light, fluffy, and always free - The AWS Local Emulator alternative
feat(elbv2): ALB Lambda target type (#730)
Hector Ventura86eac926f98b
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex d29ba2cf52..b405ec50e3 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -9,9 +9,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0### Added+- **elbv2:** Lambda target type — ALB listeners forward requests to Lambda functions using the full ALB→Lambda event format (`httpMethod`, `path`, `queryStringParameters`, `multiValueQueryStringParameters`, `headers`, `multiValueHeaders`, `body`, `isBase64Encoded`); Lambda→ALB response mapping (`statusCode`, `headers`, `multiValueHeaders`, `body`, `isBase64Encoded`); Lambda target groups always report as healthy in `DescribeTargetHealth` without HTTP probing- **ssm:** Run Command — `SendCommand`, `GetCommandInvocation`, `ListCommands`, `ListCommandInvocations`, `CancelCommand`, `DescribeInstanceInformation`; `UpdateInstanceInformation` (agent registration); `ec2messages` polling protocol (`GetMessages`, `AcknowledgeMessage`, `SendReply`, `FailMessage`, `DeleteMessage`, `GetEndpoint`) so the real `amazon-ssm-agent` running inside EC2 containers can register, receive commands, and report output- **codedeploy:** Server platform (Phase 4) — on-premises instance management (`RegisterOnPremisesInstance`, `DeregisterOnPremisesInstance`, `GetOnPremisesInstance`, `BatchGetOnPremisesInstances`, `ListOnPremisesInstances`, `AddTagsToOnPremisesInstances`, `RemoveTagsFromOnPremisesInstances`); Server AppSpec YAML parsing; EC2 and on-premises instance resolution by tag filters; full lifecycle event execution (`ApplicationStop` → `DownloadBundle` → `BeforeInstall` → `Install` → `AfterInstall` → `ApplicationStart` → `ValidateService`); SSM Run Command integration for hook script execution with graceful degradation when SSM is unavailable; per-instance `InstanceTarget` tracking in `ListDeploymentTargets`/`BatchGetDeploymentTargets`-- **elbv2:** Lambda targets — ALB listeners can forward to Lambda functions; ALB event format with `queryStringParameters`, `multiValueQueryStringParameters`, `headers`, `multiValueHeaders`, `body`, `isBase64Encoded`; Lambda→ALB response mapping; Lambda target groups always return healthy without HTTP probing## [1.5.12] - 2026-05-04diff --git a/README.md b/README.mdindex a6cc3865d6..81f44d65b2 100644--- a/README.md+++ b/README.md@@ -247,7 +247,7 @@ All default images are configurable via environment variables, useful for pinnin| **AppConfigData** | In-process | Configuration sessions, dynamic configuration retrieval || **Bedrock Runtime** | In-process (stub) | Dummy Converse and InvokeModel responses for local development; streaming returns 501 || **EKS** | **Real Docker containers** (mock mode available) | Clusters, tagging; real mode starts k3s per cluster with a live Kubernetes API server |-| **ELB v2** | In-process | Application and Network Load Balancers, target groups, listeners, path/host-based routing rules, tags |+| **ELB v2** | In-process | Application and Network Load Balancers, target groups, listeners, path/host-based routing rules, Lambda targets (ALB→Lambda event format), tags || **CodeBuild** | In-process + **real Docker containers** | Projects, report groups, source credentials; `StartBuild` runs real Docker containers, streams logs to CloudWatch, uploads artifacts to S3 via `docker cp` (works in Docker-in-Docker) || **CodeDeploy** | In-process + **Lambda traffic shifting** | Applications, deployment groups, deployment configs; 17 `CodeDeployDefault.*` built-ins pre-seeded; `CreateDeployment` shifts Lambda alias `RoutingConfig` weights, invokes lifecycle hooks, auto-rolls back on failure || **Auto Scaling** | In-process + **background reconciler** | Launch configurations, auto scaling groups with min/max/desired capacity; background loop (10 s) calls `RunInstances` / `TerminateInstances` to meet desired capacity; lifecycle hooks, scaling policies, ELB v2 target group auto-registration |diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EventBridgeReplayTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EventBridgeReplayTest.javaindex 92ac0a238c..5857a32e9c 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EventBridgeReplayTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EventBridgeReplayTest.java@@ -186,7 +186,7 @@ class EventBridgeReplayTest {.build());assertThat(response.replayArn()).contains(replayName);- assertThat(response.state()).isIn(ReplayState.STARTING, ReplayState.RUNNING);+ assertThat(response.state()).isIn(ReplayState.STARTING, ReplayState.RUNNING, ReplayState.COMPLETED);// Poll until completed (up to 5 s)ReplayState state = response.state();diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.javaindex 6da2988151..f09cc8f08c 100644--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.java+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2DataPlane.java@@ -1,5 +1,7 @@package io.github.hectorvent.floci.services.elbv2;+import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.ObjectMapper;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.services.elbv2.model.Action;import io.github.hectorvent.floci.services.elbv2.model.Listener;@@ -7,7 +9,11 @@ import io.github.hectorvent.floci.services.elbv2.model.Rule;import io.github.hectorvent.floci.services.elbv2.model.RuleCondition;import io.github.hectorvent.floci.services.elbv2.model.TargetDescription;import io.github.hectorvent.floci.services.elbv2.model.TargetGroup;+import io.github.hectorvent.floci.services.lambda.LambdaService;+import io.github.hectorvent.floci.services.lambda.model.InvocationType;+import io.github.hectorvent.floci.services.lambda.model.InvokeResult;import io.vertx.core.Vertx;+import io.vertx.core.buffer.Buffer;import io.vertx.core.http.HttpClient;import io.vertx.core.http.HttpClientOptions;import io.vertx.core.http.HttpServer;@@ -19,7 +25,10 @@ import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;+import java.nio.charset.StandardCharsets;import java.util.ArrayList;+import java.util.Base64;+import java.util.HashMap;import java.util.List;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;@@ -49,6 +58,12 @@ public class ElbV2DataPlane {@InjectEmulatorConfig config;+ @Inject+ LambdaService lambdaService;++ @Inject+ ObjectMapper objectMapper;+private final Map<String, HttpServer> servers = new ConcurrentHashMap<>();private final Map<String, AtomicReference<List<CompiledRule>>> ruleChains = new ConcurrentHashMap<>();private final Map<String, AtomicInteger> rrCounters = new ConcurrentHashMap<>();@@ -152,6 +167,18 @@ public class ElbV2DataPlane {req.response().setStatusCode(502).end("Target group not found");return;}++ if ("lambda".equals(tg.getTargetType())) {+ List<TargetDescription> targets = tg.getTargets();+ if (targets.isEmpty()) {+ req.response().setStatusCode(503).end("No Lambda targets registered");+ return;+ }+ String functionArn = targets.get(0).getId();+ invokeLambdaTarget(req, functionArn, region);+ return;+ }+List<TargetDescription> allTargets = tg.getTargets();List<TargetDescription> healthy = allTargets.stream().filter(t -> healthChecker.isHealthy(tgArn, t, ElbV2HealthChecker.effectivePort(t, tg)))@@ -168,6 +195,118 @@ public class ElbV2DataPlane {proxyRequest(req, target.getId(), targetPort);}+ private void invokeLambdaTarget(io.vertx.core.http.HttpServerRequest req, String functionArn, String region) {+ req.bodyHandler(body -> {+ try {+ Map<String, Object> event = buildAlbEvent(req, body);+ byte[] payload = objectMapper.writeValueAsBytes(event);+ InvokeResult result = lambdaService.invoke(region, functionArn, payload, InvocationType.RequestResponse);++ if (result.getFunctionError() != null) {+ req.response().setStatusCode(502).end("Lambda function error: " + result.getFunctionError());+ return;+ }++ if (result.getPayload() == null || result.getPayload().length == 0) {+ req.response().setStatusCode(200).end();+ return;+ }++ Map<String, Object> lambdaResp = objectMapper.readValue(result.getPayload(),+ new TypeReference<Map<String, Object>>() {});++ int statusCode = 200;+ Object sc = lambdaResp.get("statusCode");+ if (sc != null) {+ statusCode = ((Number) sc).intValue();+ }++ req.response().setStatusCode(statusCode);++ Object headers = lambdaResp.get("headers");+ if (headers instanceof Map<?, ?> headerMap) {+ for (Map.Entry<?, ?> entry : headerMap.entrySet()) {+ req.response().putHeader(String.valueOf(entry.getKey()), String.valueOf(entry.getValue()));+ }+ }++ Object multiValueHeaders = lambdaResp.get("multiValueHeaders");+ if (multiValueHeaders instanceof Map<?, ?> mvh) {+ for (Map.Entry<?, ?> entry : mvh.entrySet()) {+ if (entry.getValue() instanceof List<?> values) {+ for (Object v : values) {+ req.response().putHeader(String.valueOf(entry.getKey()), String.valueOf(v));+ }+ }+ }+ }++ Object responseBody = lambdaResp.get("body");+ Boolean isBase64 = (Boolean) lambdaResp.get("isBase64Encoded");+ if (responseBody == null) {+ req.response().end();+ } else if (Boolean.TRUE.equals(isBase64)) {+ byte[] decoded = Base64.getDecoder().decode(String.valueOf(responseBody));+ req.response().end(Buffer.buffer(decoded));+ } else {+ req.response().end(String.valueOf(responseBody));+ }+ } catch (Exception e) {+ LOG.errorf(e, "Error invoking Lambda target %s", functionArn);+ req.response().setStatusCode(502).end("Lambda invocation error");+ }+ });+ }++ private Map<String, Object> buildAlbEvent(io.vertx.core.http.HttpServerRequest req, Buffer body) {+ Map<String, Object> event = new HashMap<>();+ event.put("requestContext", Map.of("elb", Map.of("targetGroupArn", "")));+ event.put("httpMethod", req.method().name());+ event.put("path", req.path() != null ? req.path() : "/");++ Map<String, String> queryParams = new HashMap<>();+ Map<String, List<String>> multiValueQueryParams = new HashMap<>();+ String query = req.query();+ if (query != null && !query.isEmpty()) {+ for (String pair : query.split("&")) {+ int eq = pair.indexOf('=');+ String key = eq >= 0 ? pair.substring(0, eq) : pair;+ String val = eq >= 0 ? pair.substring(eq + 1) : "";+ queryParams.putIfAbsent(key, val);+ multiValueQueryParams.computeIfAbsent(key, k -> new ArrayList<>()).add(val);+ }+ }+ event.put("queryStringParameters", queryParams.isEmpty() ? null : queryParams);+ event.put("multiValueQueryStringParameters", multiValueQueryParams.isEmpty() ? null : multiValueQueryParams);++ Map<String, String> headers = new HashMap<>();+ Map<String, List<String>> multiValueHeaders = new HashMap<>();+ req.headers().forEach(entry -> {+ String key = entry.getKey().toLowerCase();+ headers.putIfAbsent(key, entry.getValue());+ multiValueHeaders.computeIfAbsent(key, k -> new ArrayList<>()).add(entry.getValue());+ });+ event.put("headers", headers);+ event.put("multiValueHeaders", multiValueHeaders);++ boolean isBase64 = false;+ String bodyStr = null;+ if (body != null && body.length() > 0) {+ String contentType = req.getHeader("Content-Type");+ if (contentType != null && !contentType.startsWith("text/") && !contentType.contains("json")+ && !contentType.contains("xml") && !contentType.contains("form")) {+ bodyStr = Base64.getEncoder().encodeToString(body.getBytes());+ isBase64 = true;+ } else {+ bodyStr = body.toString(StandardCharsets.UTF_8);+ }+ }+ event.put("body", bodyStr);+ event.put("isBase64Encoded", isBase64);++ return event;+ }+private String resolveTgArn(Action action) {if (action.getTargetGroupArn() != null) {return action.getTargetGroupArn();diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2HealthChecker.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2HealthChecker.javaindex b176f5af31..4f582ef47d 100644--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2HealthChecker.java+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2HealthChecker.java@@ -49,6 +49,9 @@ public class ElbV2HealthChecker {if (config.services().elbv2().mock()) {return;}+ if ("lambda".equals(tg.getTargetType())) {+ return;+ }String tgArn = tg.getTargetGroupArn();states.computeIfAbsent(tgArn, k -> new ConcurrentHashMap<>());diff --git a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.javaindex 9d208f6442..8e35b5dfb5 100644--- a/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/elbv2/ElbV2Service.java@@ -562,9 +562,15 @@ public class ElbV2Service {List<TargetDescription> candidates = filterTargets != null && !filterTargets.isEmpty()? filterTargets : tg.getTargets();+ boolean isLambdaTg = "lambda".equals(tg.getTargetType());return candidates.stream().map(t -> {TargetHealth th = new TargetHealth();th.setTarget(t);+ if (isLambdaTg) {+ th.setHealthCheckPort("N/A");+ th.setState("healthy");+ return th;+ }int port = ElbV2HealthChecker.effectivePort(t, tg);th.setHealthCheckPort(String.valueOf(port));String state = healthChecker.getState(tgArn, t.getId(), port);diff --git a/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2LambdaTargetIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2LambdaTargetIntegrationTest.javanew file mode 100644index 0000000000..6bb1aaf01c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/elbv2/ElbV2LambdaTargetIntegrationTest.java@@ -0,0 +1,193 @@+package io.github.hectorvent.floci.services.elbv2;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.*;++/**+ * Integration tests for ALB with Lambda target type.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class ElbV2LambdaTargetIntegrationTest {++ private static final String AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260427/us-east-1/elasticloadbalancing/aws4_request";++ private static String lbArn;+ private static String tgArn;+ private static String listenerArn;+ private static String functionArn;++ @Test+ @Order(1)+ void createLambdaFunction() {+ functionArn = given()+ .contentType("application/json")+ .body("""+ {+ "FunctionName": "alb-lambda-target-fn",+ "Runtime": "nodejs20.x",+ "Role": "arn:aws:iam::000000000000:role/lambda-role",+ "Handler": "index.handler"+ }+ """)+ .when()+ .post("/2015-03-31/functions")+ .then()+ .statusCode(201)+ .body("FunctionName", equalTo("alb-lambda-target-fn"))+ .extract()+ .path("FunctionArn");+ }++ @Test+ @Order(2)+ void createLoadBalancer() {+ lbArn = given()+ .formParam("Action", "CreateLoadBalancer")+ .formParam("Name", "lambda-target-lb")+ .formParam("Type", "application")+ .formParam("Scheme", "internet-facing")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.LoadBalancerName",+ equalTo("lambda-target-lb"))+ .extract()+ .path("CreateLoadBalancerResponse.CreateLoadBalancerResult.LoadBalancers.member.LoadBalancerArn");+ }++ @Test+ @Order(3)+ void createLambdaTargetGroup() {+ tgArn = given()+ .formParam("Action", "CreateTargetGroup")+ .formParam("Name", "lambda-tg")+ .formParam("TargetType", "lambda")+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateTargetGroupResponse.CreateTargetGroupResult.TargetGroups.member.TargetGroupName",+ equalTo("lambda-tg"))+ .body("CreateTargetGroupResponse.CreateTargetGroupResult.TargetGroups.member.TargetType",+ equalTo("lambda"))+ .extract()+ .path("CreateTargetGroupResponse.CreateTargetGroupResult.TargetGroups.member.TargetGroupArn");+ }++ @Test+ @Order(4)+ void registerLambdaTarget() {+ given()+ .formParam("Action", "RegisterTargets")+ .formParam("TargetGroupArn", tgArn)+ .formParam("Targets.member.1.Id", functionArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ @Test+ @Order(5)+ void describeLambdaTargetHealth() {+ given()+ .formParam("Action", "DescribeTargetHealth")+ .formParam("TargetGroupArn", tgArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeTargetHealthResponse.DescribeTargetHealthResult.TargetHealthDescriptions.member.Target.Id",+ equalTo(functionArn));+ }++ @Test+ @Order(6)+ void createListenerWithLambdaForwardAction() {+ listenerArn = given()+ .formParam("Action", "CreateListener")+ .formParam("LoadBalancerArn", lbArn)+ .formParam("Protocol", "HTTP")+ .formParam("Port", "7780")+ .formParam("DefaultActions.member.1.Type", "forward")+ .formParam("DefaultActions.member.1.TargetGroupArn", tgArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateListenerResponse.CreateListenerResult.Listeners.member.Protocol", equalTo("HTTP"))+ .body("CreateListenerResponse.CreateListenerResult.Listeners.member.Port", equalTo("7780"))+ .extract()+ .path("CreateListenerResponse.CreateListenerResult.Listeners.member.ListenerArn");+ }++ @Test+ @Order(7)+ void describeListenerShowsLambdaTarget() {+ given()+ .formParam("Action", "DescribeListeners")+ .formParam("ListenerArns.member.1", listenerArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("DescribeListenersResponse.DescribeListenersResult.Listeners.member.ListenerArn",+ equalTo(listenerArn));+ }++ @Test+ @Order(8)+ void deregisterLambdaTarget() {+ given()+ .formParam("Action", "DeregisterTargets")+ .formParam("TargetGroupArn", tgArn)+ .formParam("Targets.member.1.Id", functionArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ @Test+ @Order(90)+ void cleanup() {+ given()+ .formParam("Action", "DeleteListener")+ .formParam("ListenerArn", listenerArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .formParam("Action", "DeleteLoadBalancer")+ .formParam("LoadBalancerArn", lbArn)+ .header("Authorization", AUTH)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .delete("/2015-03-31/functions/alb-lambda-target-fn")+ .then()+ .statusCode(anyOf(equalTo(204), equalTo(200)));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeReplayIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeReplayIntegrationTest.javaindex 48586124c2..6e77842162 100644--- a/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeReplayIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/eventbridge/EventBridgeReplayIntegrationTest.java@@ -203,7 +203,7 @@ class EventBridgeReplayIntegrationTest {.when().post("/").then().statusCode(200).body("ReplayArn", notNullValue())- .body("State", anyOf(equalTo("STARTING"), equalTo("RUNNING")));+ .body("State", anyOf(equalTo("STARTING"), equalTo("RUNNING"), equalTo("COMPLETED")));// poll until COMPLETED (up to 5 s)String state = "STARTING";