Light, fluffy, and always free - The AWS Local Emulator alternative
feat(eks): expose IMDS on 169.254.169.254 inside cluster containers (#3693)
Simone Primarosaa2fddaf08da0
diff --git a/docs/services/eks.md b/docs/services/eks.mdindex cf52fd52b8..8af5ad37ac 100644--- a/docs/services/eks.md+++ b/docs/services/eks.md@@ -115,6 +115,7 @@ back (for example Docker is unavailable), the cluster is marked `FAILED` instead| `FLOCI_SERVICES_EKS_ENDPOINT_MODE` | `host` | `describe-cluster` endpoint: `host` (`localhost:<hostPort>`) or `network` (container DNS) || `FLOCI_SERVICES_EKS_IAM_AUTH_WEBHOOK` | `true` | Wire a token-auth webhook into k3s so `aws eks get-token` works || `FLOCI_SERVICES_EKS_ECR_REGISTRY_MIRROR` | `true` | Inject a containerd `registries.yaml` so pods can pull images pushed to [Floci ECR](ecr.md) |+| `FLOCI_SERVICES_EKS_IMDS` | `false` | Enable link-local IMDS (`169.254.169.254`) proxy in cluster containers |### Pulling images from Floci ECR@@ -172,6 +173,39 @@ services:FLOCI_SERVICES_EKS_MOCK: "true"```+## Instance Metadata Service (IMDS)++When enabled (`FLOCI_SERVICES_EKS_IMDS=true`), each k3s cluster container exposes the AWS Instance Metadata Service on the link-local address `169.254.169.254:80`. Inside the container, Floci adds `169.254.169.254/32` to the loopback interface (`lo`) and runs a lightweight `socat` TCP relay forwarding metadata requests to Floci's IMDS server.++Both IMDSv1 and IMDSv2 (`PUT /latest/api/token`) are supported. The cluster container is registered as a synthesized EC2 instance node (type `m5.large`, image `ami-eks-k3s`) associated with the cluster's IAM role:++```bash+# IMDSv2: obtain token+TOKEN=$(curl -s -X PUT "http://169.254.169.254/latest/api/token" \+ -H "x-aws-ec2-metadata-token-ttl-seconds: 21600")++# Read node instance ID+curl -s -H "x-aws-ec2-metadata-token: $TOKEN" \+ http://169.254.169.254/latest/meta-data/instance-id+```++### Reachability and network namespaces++The link-local proxy attaches to the loopback interface of the k3s container network namespace (the node network namespace).++- **Reachable from node network namespace:** Workloads configured with `hostNetwork: true` share the node network namespace and can reach `169.254.169.254:80`. This allows local testing of host-network security policies, intrusion-detection rules, and credential exfiltration defenses.+- **Not reachable from ordinary pods:** Pods running in separate pod network namespaces cannot reach `169.254.169.254` through this loopback alias because link-local addresses are non-routable across network namespaces. Pod-CIDR DNAT routing is not implemented.++### Configuration++IMDS proxy initialization is disabled by default (`floci.services.eks.imds=false`). Set `FLOCI_SERVICES_EKS_IMDS=true` to enable the proxy setup inside the k3s container.++A failure to configure the proxy (for example on custom minimal images lacking network utilities) logs a warning and allows cluster startup to continue.++### Hop limits++EC2 metadata options store `HttpPutResponseHopLimit`, but the userspace TCP proxy relay terminates the incoming connection and opens a new connection to Floci, regenerating the IP packet TTL. Hop limits are recorded on the instance metadata options model but are not enforced by the userspace proxy.+## IRSA (IAM Roles for Service Accounts)Every cluster gets an OIDC identity provider, so the full IRSA flow (trust policy, service-account token, `sts:AssumeRoleWithWebIdentity`) works end to end without mocked or hardcoded tokens.diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 3f2602d139..0b10cd7369 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -2727,6 +2727,13 @@ public interface EmulatorConfig {*/@WithDefault("false")boolean disableCni();++ /**+ * When true, exposes an IMDS link-local proxy (169.254.169.254:80) inside the cluster container's+ * network namespace that relays to Floci's EC2 metadata service.+ */+ @WithDefault("false")+ boolean imds();}/**diff --git a/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.java b/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.javaindex 9b3bfa58e5..95d0b2db9c 100644--- a/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.java+++ b/src/main/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycle.java@@ -215,7 +215,7 @@ public class EmulatorLifecycle {elbClassicService.restorePersistedRuntime();}- if (config.services().ec2().enabled() && !config.services().ec2().mock()) {+ if (isMetadataServerNeeded()) {ec2MetadataServer.start().exceptionally(ex -> {LOG.warnv("EC2 IMDS server failed to start: {0}", ex.getMessage());return null;@@ -304,7 +304,7 @@ public class EmulatorLifecycle {// still runs at the end to stop the flush schedulers and capture any shutdown-time writes.runCleanup("storage flush", storageFactory::flushAll);runCleanup("EC2 metadata server", () -> {- if (config.services().ec2().enabled() && !config.services().ec2().mock()) {+ if (isMetadataServerNeeded()) {ec2MetadataServer.stop();}});@@ -345,4 +345,16 @@ public class EmulatorLifecycle {LOG.warnv(e, "Shutdown cleanup failed for {0}; continuing with the remaining steps", resource);}}++ private boolean isMetadataServerNeeded() {+ if (config == null || config.services() == null) {+ return false;+ }+ EmulatorConfig.Ec2ServiceConfig ec2 = config.services().ec2();+ if (ec2 != null && ec2.enabled() && !ec2.mock()) {+ return true;+ }+ EmulatorConfig.EksServiceConfig eks = config.services().eks();+ return eks != null && eks.enabled() && !eks.mock() && eks.imds();+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2ContainerManager.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2ContainerManager.javaindex ea0a2562e0..6b33720db1 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2ContainerManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2ContainerManager.java@@ -1788,50 +1788,14 @@ public class Ec2ContainerManager {}static String[] metadataProxyInstallCommand() {- return new String[]{"sh", "-c", String.join("\n",- "set -eu",- "if command -v ip >/dev/null 2>&1 && command -v socat >/dev/null 2>&1 && command -v curl >/dev/null 2>&1; then exit 0; fi",- "if command -v apt-get >/dev/null 2>&1; then",- " apt-get update -qq >/dev/null",- " DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends iproute2 socat curl ca-certificates >/dev/null",- "elif command -v dnf >/dev/null 2>&1; then",- // --allowerasing lets dnf swap the curl-minimal that- // public.ecr.aws/amazonlinux/amazonlinux:2023 ships by default for the full- // curl package this proxy needs. Without it, dnf aborts the whole transaction- // on a curl/curl-minimal conflict and iproute+socat never install either, even- // though neither of them conflicts with anything.- " dnf install -y --allowerasing iproute socat curl ca-certificates >/dev/null",- // Same gap as the sshd probe: Amazon Linux 2 has only yum, so on an instance- // launched from ami-amazonlinux2 this chain reached its else branch and exited 1- // with "No supported package manager found for IMDS proxy dependencies" --- // leaving the instance without a link-local IMDS endpoint.- "elif command -v yum >/dev/null 2>&1; then",- " yum install -y iproute socat curl ca-certificates >/dev/null",- "elif command -v apk >/dev/null 2>&1; then",- " apk add --no-cache iproute2 socat curl ca-certificates >/dev/null",- "else",- " echo 'No supported package manager found for IMDS proxy dependencies' >&2",- " exit 1",- "fi")};+ return Ec2MetadataProxy.installCommand();}static String[] metadataProxyStartCommand(String flociHost, int imdsPort) {- return new String[]{"sh", "-c", String.join("\n",- "set -eu",- "ip addr show dev lo | grep -q '169.254.169.254/32' || ip addr add 169.254.169.254/32 dev lo",- "if [ -f /tmp/floci-imds-proxy.pid ] && kill -0 \"$(cat /tmp/floci-imds-proxy.pid)\" 2>/dev/null; then",- " exit 0",- "fi",- "nohup socat TCP-LISTEN:80,bind=169.254.169.254,fork,reuseaddr TCP:" + flociHost + ":" + imdsPort + " >/tmp/floci-imds-proxy.log 2>&1 &",- "echo $! > /tmp/floci-imds-proxy.pid",- "for i in 1 2 3 4 5 6 7 8 9 10 11 12; do",- " curl -fsS --max-time 1 http://169.254.169.254/latest/meta-data/instance-id >/dev/null && exit 0",- " sleep 1",- "done",- "cat /tmp/floci-imds-proxy.log >&2 || true",- "exit 1")};+ return Ec2MetadataProxy.startCommand(flociHost, imdsPort);}+static List<String> localAwsEnvironment(String region, String serviceEndpoint, String imdsEndpoint) {return List.of("AWS_EC2_METADATA_SERVICE_ENDPOINT=" + imdsEndpoint,@@ -2054,26 +2018,7 @@ public class Ec2ContainerManager {}static Optional<String> preferredMetadataSourceIp(Map<String, ContainerNetwork> networks) {- if (networks == null || networks.isEmpty()) {- return Optional.empty();- }- Optional<String> configuredNetworkIp = networks.entrySet().stream()- .filter(entry -> !"bridge".equals(entry.getKey()))- .map(Map.Entry::getValue)- .map(ContainerNetwork::getIpAddress)- .filter(ip -> ip != null && !ip.isBlank())- .findFirst();- if (configuredNetworkIp.isPresent()) {- return configuredNetworkIp;- }- ContainerNetwork bridge = networks.get("bridge");- if (bridge != null && bridge.getIpAddress() != null && !bridge.getIpAddress().isBlank()) {- return Optional.of(bridge.getIpAddress());- }- return networks.values().stream()- .map(ContainerNetwork::getIpAddress)- .filter(ip -> ip != null && !ip.isBlank())- .findFirst();+ return Ec2MetadataProxy.preferredMetadataSourceIp(networks);}private byte[] buildSingleFileTar(String filename, byte[] content, int mode) throws IOException {diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataProxy.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataProxy.javanew file mode 100644index 0000000000..8287b789f7--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataProxy.java@@ -0,0 +1,83 @@+package io.github.hectorvent.floci.services.ec2;++import com.github.dockerjava.api.model.ContainerNetwork;++import java.util.Map;+import java.util.Optional;++/**+ * Shared commands and network resolution helpers for installing and starting+ * the link-local IMDS proxy (169.254.169.254:80) inside containers.+ */+public final class Ec2MetadataProxy {++ private Ec2MetadataProxy() {}++ public static String[] installCommand() {+ return new String[]{"sh", "-c", String.join("\n",+ "set -eu",+ "if command -v ip >/dev/null 2>&1 && command -v socat >/dev/null 2>&1 && command -v curl >/dev/null 2>&1; then exit 0; fi",+ "if command -v apt-get >/dev/null 2>&1; then",+ " apt-get update -qq >/dev/null",+ " DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends iproute2 socat curl ca-certificates >/dev/null",+ "elif command -v dnf >/dev/null 2>&1; then",+ // --allowerasing lets dnf swap the curl-minimal that+ // public.ecr.aws/amazonlinux/amazonlinux:2023 ships by default for the full+ // curl package this proxy needs. Without it, dnf aborts the whole transaction+ // on a curl/curl-minimal conflict and iproute+socat never install either, even+ // though neither of them conflicts with anything.+ " dnf install -y --allowerasing iproute socat curl ca-certificates >/dev/null",+ // Same gap as the sshd probe: Amazon Linux 2 has only yum, so on an instance+ // launched from ami-amazonlinux2 this chain reached its else branch and exited 1+ // with "No supported package manager found for IMDS proxy dependencies",+ // leaving the instance without a link-local IMDS endpoint.+ "elif command -v yum >/dev/null 2>&1; then",+ " yum install -y iproute socat curl ca-certificates >/dev/null",+ "elif command -v apk >/dev/null 2>&1; then",+ " apk add --no-cache iproute2 socat curl ca-certificates >/dev/null",+ "else",+ " echo 'No supported package manager found for IMDS proxy dependencies' >&2",+ " exit 1",+ "fi")};+ }++ public static String[] startCommand(String flociHost, int imdsPort) {+ return new String[]{"sh", "-c", String.join("\n",+ "set -eu",+ "ip addr show dev lo | grep -q '169.254.169.254/32' || ip addr add 169.254.169.254/32 dev lo",+ "if [ -f /tmp/floci-imds-proxy.pid ] && kill -0 \"$(cat /tmp/floci-imds-proxy.pid)\" 2>/dev/null; then",+ " exit 0",+ "fi",+ "nohup socat TCP-LISTEN:80,bind=169.254.169.254,fork,reuseaddr TCP:" + flociHost + ":" + imdsPort + " >/tmp/floci-imds-proxy.log 2>&1 &",+ "echo $! > /tmp/floci-imds-proxy.pid",+ "for i in 1 2 3 4 5 6 7 8 9 10 11 12; do",+ " curl -fsS --max-time 1 http://169.254.169.254/latest/meta-data/instance-id >/dev/null && exit 0",+ " sleep 1",+ "done",+ "cat /tmp/floci-imds-proxy.log >&2 || true",+ "exit 1")};+ }++ public static Optional<String> preferredMetadataSourceIp(Map<String, ContainerNetwork> networks) {+ if (networks == null || networks.isEmpty()) {+ return Optional.empty();+ }+ Optional<String> configuredNetworkIp = networks.entrySet().stream()+ .filter(entry -> !"bridge".equals(entry.getKey()))+ .map(Map.Entry::getValue)+ .map(ContainerNetwork::getIpAddress)+ .filter(ip -> ip != null && !ip.isBlank())+ .findFirst();+ if (configuredNetworkIp.isPresent()) {+ return configuredNetworkIp;+ }+ ContainerNetwork bridge = networks.get("bridge");+ if (bridge != null && bridge.getIpAddress() != null && !bridge.getIpAddress().isBlank()) {+ return Optional.of(bridge.getIpAddress());+ }+ return networks.values().stream()+ .map(ContainerNetwork::getIpAddress)+ .filter(ip -> ip != null && !ip.isBlank())+ .findFirst();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.java b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.javaindex ac65a6fb11..cd3c9ebd57 100644--- a/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.java+++ b/src/main/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataServer.java@@ -75,7 +75,7 @@ public class Ec2MetadataServer {}/** Reconcile every Docker attachment without retaining stale addresses after restart. */- void reconcileContainerAddresses(Set<String> addresses, Instance instance) {+ public void reconcileContainerAddresses(Set<String> addresses, Instance instance) {for (String address : addresses) {registerContainer(address, instance.getInstanceId(), instance);}@@ -83,15 +83,20 @@ public class Ec2MetadataServer {entry.getValue() == instance && !addresses.contains(entry.getKey()));}- void unregisterInstance(Instance instance) {- containerIpToInstance.entrySet().removeIf(entry -> entry.getValue() == instance);+ public void unregisterInstance(Instance instance) {+ if (instance != null) {+ containerIpToInstance.entrySet().removeIf(entry -> entry.getValue() == instance);+ }}Optional<Instance> registeredContainer(String containerIp) {return Optional.ofNullable(containerIpToInstance.get(containerIp));}- public CompletableFuture<Void> start() {+ public synchronized CompletableFuture<Void> start() {+ if (httpServer != null) {+ return CompletableFuture.completedFuture(null);+ }CompletableFuture<Void> future = new CompletableFuture<>();int port = config.services().ec2().imdsPort();@@ -137,9 +142,10 @@ public class Ec2MetadataServer {return future;}- public void stop() {+ public synchronized void stop() {if (httpServer != null) {httpServer.close();+ httpServer = null;}}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksClusterManager.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksClusterManager.javaindex 0ea8535e6c..c2b5d3b7dc 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/EksClusterManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksClusterManager.java@@ -14,9 +14,17 @@ import io.github.hectorvent.floci.core.common.docker.PortAllocator;import io.github.hectorvent.floci.services.ecr.registry.EcrRegistryManager;import io.github.hectorvent.floci.services.eks.model.CertificateAuthority;import io.github.hectorvent.floci.services.eks.model.Cluster;+import com.github.dockerjava.api.DockerClient;import com.github.dockerjava.api.async.ResultCallback;import com.github.dockerjava.api.command.ExecCreateCmdResponse;+import com.github.dockerjava.api.command.InspectContainerResponse;+import com.github.dockerjava.api.model.ContainerNetwork;import com.github.dockerjava.api.model.Frame;+import io.github.hectorvent.floci.services.ec2.Ec2MetadataProxy;+import io.github.hectorvent.floci.services.ec2.Ec2MetadataServer;+import io.github.hectorvent.floci.services.ec2.model.Instance;+import io.github.hectorvent.floci.services.ec2.model.InstanceState;+import io.github.hectorvent.floci.services.ec2.model.Placement;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.apache.commons.compress.archivers.tar.TarArchiveEntry;@@ -33,7 +41,13 @@ import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.Paths;import java.util.ArrayList;+import java.util.LinkedHashSet;import java.util.List;+import java.util.Map;+import java.util.Optional;+import java.util.Set;+import java.util.UUID;+import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.TimeUnit;/**@@ -62,8 +76,9 @@ public class EksClusterManager {private final EcrRegistryManager ecrRegistryManager;private final EmulatorConfig config;private final RegionResolver regionResolver;+ private final Ec2MetadataServer metadataServer;+ private final Map<String, Instance> clusterNodeInstances = new ConcurrentHashMap<>();- @Injectpublic EksClusterManager(ContainerBuilder containerBuilder,ContainerLifecycleManager lifecycleManager,ContainerDetector containerDetector,@@ -72,6 +87,20 @@ public class EksClusterManager {EcrRegistryManager ecrRegistryManager,EmulatorConfig config,RegionResolver regionResolver) {+ this(containerBuilder, lifecycleManager, containerDetector, portAllocator,+ dockerHostResolver, ecrRegistryManager, config, regionResolver, null);+ }++ @Inject+ public EksClusterManager(ContainerBuilder containerBuilder,+ ContainerLifecycleManager lifecycleManager,+ ContainerDetector containerDetector,+ PortAllocator portAllocator,+ DockerHostResolver dockerHostResolver,+ EcrRegistryManager ecrRegistryManager,+ EmulatorConfig config,+ RegionResolver regionResolver,+ Ec2MetadataServer metadataServer) {this.containerBuilder = containerBuilder;this.lifecycleManager = lifecycleManager;this.containerDetector = containerDetector;@@ -80,6 +109,7 @@ public class EksClusterManager {this.ecrRegistryManager = ecrRegistryManager;this.config = config;this.regionResolver = regionResolver;+ this.metadataServer = metadataServer;}/**@@ -222,6 +252,7 @@ public class EksClusterManager {ContainerInfo info = lifecycleManager.startCreated(containerId, spec);applyEndpoints(cluster, containerName, hostPort, info);+ configureLinkLocalMetadataEndpoint(cluster, containerId);LOG.infov("k3s container {0} started for cluster {1} on port {2} (internal: {3})",containerId, cluster.getName(), String.valueOf(hostPort), cluster.getInternalEndpoint());@@ -272,6 +303,7 @@ public class EksClusterManager {cluster.setContainerId(info.containerId());cluster.setHostPort(hostPort);applyEndpoints(cluster, containerName, hostPort, info);+ configureLinkLocalMetadataEndpoint(cluster, info.containerId());LOG.infov("Adopted surviving k3s container {0} for EKS cluster {1} on port {2} (internal: {3})",info.containerId(), cluster.getName(), String.valueOf(hostPort), cluster.getInternalEndpoint());@@ -365,6 +397,7 @@ public class EksClusterManager {* cluster's workloads survive a Floci restart and are re-latched by {@link #restoreCluster}.*/public void stopCluster(Cluster cluster) {+ unregisterMetadataEndpoint(cluster);if (cluster.getContainerId() == null) {return;}@@ -691,8 +724,133 @@ public class EksClusterManager {""".formatted(serverUrl);}- private String execInContainer(String containerId, String[] cmd) throws Exception {- var dockerClient = lifecycleManager.getDockerClient();+ void configureLinkLocalMetadataEndpoint(Cluster cluster, String containerId) {+ if (!config.services().eks().imds()) {+ return;+ }+ try {+ String accountId = cluster.getAccountId() != null+ ? cluster.getAccountId()+ : regionResolver.getAccountId();+ String region = clusterRegion(cluster);++ ContainerIps containerIps = resolveContainerIps(containerId);+ Instance nodeInstance = synthesizeClusterNodeInstance(cluster, containerIps.primaryIp(), region, accountId);+ clusterNodeInstances.put(clusterResourceName(cluster), nodeInstance);++ if (metadataServer != null) {+ metadataServer.reconcileContainerAddresses(containerIps.allIps(), nodeInstance);+ }++ ContainerExecResult install = execInContainerForResult(containerId,+ Ec2MetadataProxy.installCommand(), 180);+ if (install.exitCode() != 0) {+ LOG.warnv("Could not install IMDS proxy dependencies for EKS cluster {0}: {1}",+ cluster.getName(), install.summary());+ return;+ }++ String flociHost = dockerHostResolver.resolve();+ int imdsPort = config.services().ec2().imdsPort();++ ContainerExecResult start = execInContainerForResult(containerId,+ Ec2MetadataProxy.startCommand(flociHost, imdsPort), 30);+ if (start.exitCode() != 0) {+ LOG.warnv("Could not start link-local IMDS proxy for EKS cluster {0}: {1}",+ cluster.getName(), start.summary());+ return;+ }++ LOG.infov("Configured link-local IMDS endpoint for EKS cluster {0}", cluster.getName());+ } catch (Exception e) {+ LOG.warnv("Could not configure link-local IMDS endpoint for EKS cluster {0}: {1}",+ cluster.getName(), e.getMessage());+ }+ }++ void unregisterMetadataEndpoint(Cluster cluster) {+ Instance nodeInstance = clusterNodeInstances.remove(clusterResourceName(cluster));+ if (metadataServer != null && nodeInstance != null) {+ metadataServer.unregisterInstance(nodeInstance);+ }+ }++ private String clusterRegion(Cluster cluster) {+ if (cluster != null && cluster.getArn() != null) {+ String[] parts = cluster.getArn().split(":");+ if (parts.length > 3 && !parts[3].isBlank()) {+ return parts[3];+ }+ }+ return regionResolver.getDefaultRegion();+ }++ Instance synthesizeClusterNodeInstance(Cluster cluster, String containerIp, String region, String accountId) {+ Instance inst = new Instance();+ String safeClusterName = cluster.getName() != null ? cluster.getName() : "eks-cluster";+ String safeAccountId = accountId != null ? accountId : config.defaultAccountId();+ String safeRegion = region != null ? region : clusterRegion(cluster);++ String seed = safeClusterName + "-" + safeAccountId + "-" + safeRegion;+ String hex = UUID.nameUUIDFromBytes(seed.getBytes(StandardCharsets.UTF_8)).toString().replace("-", "");+ String instanceId = "i-" + (hex.length() >= 17 ? hex.substring(0, 17) : (hex + "00000000000000000").substring(0, 17));++ inst.setInstanceId(instanceId);+ inst.setImageId("ami-eks-k3s");+ inst.setInstanceType("m5.large");+ inst.setPlacement(new Placement(safeRegion + "a"));+ inst.setRegion(safeRegion);+ inst.setState(InstanceState.running());++ String ip = (containerIp != null && !containerIp.isBlank()) ? containerIp : "10.0.0.1";+ inst.setPrivateIpAddress(ip);+ inst.setPrivateDnsName("ip-" + ip.replace('.', '-') + "." + safeRegion + ".compute.internal");++ // AWS EKS nodes receive credentials from a node IAM role through an EC2 instance profile,+ // never from the cluster control-plane role (cluster.getRoleArn()). Synthesize a distinct+ // node instance profile identity so /latest/meta-data/iam/info returns a valid profile ARN.+ String nodeProfileName = safeClusterName + "-node-profile";+ inst.setIamInstanceProfileArn("arn:aws:iam::" + safeAccountId + ":instance-profile/" + nodeProfileName);+ return inst;+ }++ record ContainerIps(String primaryIp, Set<String> allIps) {}++ ContainerIps resolveContainerIps(String containerId) {+ Set<String> ips = new LinkedHashSet<>();+ String preferred = null;+ try {+ InspectContainerResponse inspect = lifecycleManager.getDockerClient().inspectContainerCmd(containerId).exec();+ if (inspect.getNetworkSettings() != null) {+ Map<String, ContainerNetwork> networks = inspect.getNetworkSettings().getNetworks();+ if (networks != null) {+ preferred = Ec2MetadataProxy.preferredMetadataSourceIp(networks).orElse(null);+ for (ContainerNetwork network : networks.values()) {+ if (network != null && network.getIpAddress() != null && !network.getIpAddress().isBlank()) {+ ips.add(network.getIpAddress());+ }+ }+ }+ String ip = inspect.getNetworkSettings().getIpAddress();+ if (ip != null && !ip.isBlank()) {+ ips.add(ip);+ if (preferred == null) {+ preferred = ip;+ }+ }+ }+ } catch (Exception e) {+ LOG.warnv("Could not inspect container {0} for IPs: {1}", containerId, e.getMessage());+ }+ return new ContainerIps(preferred != null ? preferred : "10.0.0.1", ips);+ }++ Instance getRegisteredClusterNodeInstance(Cluster cluster) {+ return clusterNodeInstances.get(clusterResourceName(cluster));+ }++ ContainerExecResult execInContainerForResult(String containerId, String[] cmd, int timeoutSeconds) throws Exception {+ DockerClient dockerClient = lifecycleManager.getDockerClient();ExecCreateCmdResponse exec = dockerClient.execCreateCmd(containerId).withCmd(cmd)@@ -705,15 +863,32 @@ public class EksClusterManager {.exec(new ResultCallback.Adapter<Frame>() {@Overridepublic void onNext(Frame frame) {- output.append(new String(frame.getPayload(), StandardCharsets.UTF_8));+ if (frame != null && frame.getPayload() != null) {+ output.append(new String(frame.getPayload(), StandardCharsets.UTF_8));+ }}})- .awaitCompletion(10, TimeUnit.SECONDS);+ .awaitCompletion(timeoutSeconds, TimeUnit.SECONDS);if (!completed) {+ return new ContainerExecResult(-1, "Timed out after " + timeoutSeconds + "s");+ }+ Long exitCode = dockerClient.inspectExecCmd(exec.getId()).exec().getExitCodeLong();+ return new ContainerExecResult(exitCode != null ? exitCode : -1, output.toString());+ }++ record ContainerExecResult(long exitCode, String output) {+ String summary() {+ return output == null || output.isBlank() ? "(no output)" : output.trim();+ }+ }++ private String execInContainer(String containerId, String[] cmd) throws Exception {+ ContainerExecResult result = execInContainerForResult(containerId, cmd, 10);+ if (result.exitCode() == -1 && result.output().startsWith("Timed out")) {throw new RuntimeException("exec timed out in container " + containerId);}- return output.toString();+ return result.output();}private String extractYamlField(String yaml, String fieldName) {diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 3f272adce3..6f870f6dcd 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -581,6 +581,7 @@ floci:iam-auth-webhook: true # validate `aws eks get-token` SigV4 tokens through a k3s webhookecr-registry-mirror: true # inject a registries.yaml so pods can pull images pushed to Floci ECRdisable-cni: false # start k3s without its bundled flannel/kube-proxy so a real CNI (e.g. Cilium) can take over+ imds: false # expose link-local IMDS (169.254.169.254) inside the cluster containermwaa:enabled: truemock: falsediff --git a/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.java b/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.javaindex 3b349ef7ae..ffe0b40c4e 100644--- a/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.java+++ b/src/test/java/io/github/hectorvent/floci/lifecycle/EmulatorLifecycleTest.java@@ -39,6 +39,7 @@ import org.mockito.junit.jupiter.MockitoExtension;import java.io.IOException;import java.util.List;+import java.util.concurrent.CompletableFuture;import java.util.concurrent.CopyOnWriteArrayList;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -59,6 +60,7 @@ class EmulatorLifecycleTest {@Mock private EmulatorConfig.StorageConfig storageConfig;@Mock private EmulatorConfig.ServicesConfig servicesConfig;@Mock private EmulatorConfig.Ec2ServiceConfig ec2ServiceConfig;+ @Mock private EmulatorConfig.EksServiceConfig eksServiceConfig;@Mock private EmulatorConfig.ElbV2ServiceConfig elbv2ServiceConfig;@Mock private EmulatorConfig.ElbServiceConfig elbServiceConfig;@Mock private IamService iamService;@@ -107,6 +109,8 @@ class EmulatorLifecycleTest {Mockito.lenient().when(elastiCacheServiceConfig.enabled()).thenReturn(false);Mockito.lenient().when(servicesConfig.elb()).thenReturn(elbServiceConfig);Mockito.lenient().when(elbServiceConfig.enabled()).thenReturn(false);+ Mockito.lenient().when(servicesConfig.eks()).thenReturn(eksServiceConfig);+ Mockito.lenient().when(eksServiceConfig.enabled()).thenReturn(false);Mockito.lenient().when(config.tls()).thenReturn(tlsConfig);Mockito.lenient().when(tlsConfig.enabled()).thenReturn(false);Mockito.lenient().when(config.port()).thenReturn(4566);@@ -574,4 +578,36 @@ class EmulatorLifecycleTest {assertEquals(1, messages.stream().filter("Ready."::equals).count(),"Exactly one parity \"Ready.\" line must be emitted on the hook path");}++ @Test+ @DisplayName("Should start and stop EC2 metadata server when EKS IMDS is enabled")+ void shouldStartAndStopMetadataServerWhenEksImdsEnabled() {+ stubStorageConfig();+ when(eksServiceConfig.enabled()).thenReturn(true);+ when(eksServiceConfig.mock()).thenReturn(false);+ when(eksServiceConfig.imds()).thenReturn(true);+ when(ec2MetadataServer.start()).thenReturn(CompletableFuture.completedFuture(null));+ when(initializationHooksRunner.hasHooks(InitializationHook.START)).thenReturn(false);+ when(initializationHooksRunner.hasHooks(InitializationHook.READY)).thenReturn(false);++ emulatorLifecycle.onStart(Mockito.mock(StartupEvent.class));+ verify(ec2MetadataServer).start();++ emulatorLifecycle.onStop(Mockito.mock(ShutdownEvent.class));+ verify(ec2MetadataServer).stop();+ }++ @Test+ @DisplayName("Should not start EC2 metadata server when EKS IMDS is disabled")+ void shouldNotStartMetadataServerWhenEksImdsDisabled() {+ stubStorageConfig();+ when(eksServiceConfig.enabled()).thenReturn(true);+ when(eksServiceConfig.mock()).thenReturn(false);+ when(eksServiceConfig.imds()).thenReturn(false);+ when(initializationHooksRunner.hasHooks(InitializationHook.START)).thenReturn(false);+ when(initializationHooksRunner.hasHooks(InitializationHook.READY)).thenReturn(false);++ emulatorLifecycle.onStart(Mockito.mock(StartupEvent.class));+ verify(ec2MetadataServer, never()).start();+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataProxyTest.java b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataProxyTest.javanew file mode 100644index 0000000000..56f043938a--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/ec2/Ec2MetadataProxyTest.java@@ -0,0 +1,74 @@+package io.github.hectorvent.floci.services.ec2;++import com.github.dockerjava.api.model.ContainerNetwork;+import org.junit.jupiter.api.Test;++import java.util.Map;+import java.util.Optional;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++class Ec2MetadataProxyTest {++ @Test+ void installCommandContainsSupportedPackageManagers() {+ String[] command = Ec2MetadataProxy.installCommand();+ assertEquals(3, command.length);+ assertEquals("sh", command[0]);+ assertEquals("-c", command[1]);++ String script = command[2];+ assertTrue(script.contains("command -v ip >/dev/null 2>&1 && command -v socat >/dev/null 2>&1 && command -v curl >/dev/null 2>&1; then exit 0; fi"));+ assertTrue(script.contains("apt-get install -y --no-install-recommends iproute2 socat curl ca-certificates"));+ assertTrue(script.contains("dnf install -y --allowerasing iproute socat curl ca-certificates"));+ assertTrue(script.contains("yum install -y iproute socat curl ca-certificates"));+ assertTrue(script.contains("apk add --no-cache iproute2 socat curl ca-certificates"));+ }++ @Test+ void startCommandAttachesAddressIdempotentlyAndTargetsHostAndPort() {+ String[] command = Ec2MetadataProxy.startCommand("10.0.0.1", 9169);+ assertEquals(3, command.length);+ assertEquals("sh", command[0]);+ assertEquals("-c", command[1]);++ String script = command[2];+ // Attaches address if missing+ assertTrue(script.contains("ip addr show dev lo | grep -q '169.254.169.254/32' || ip addr add 169.254.169.254/32 dev lo"));+ // Idempotent when pid file exists and process is alive+ assertTrue(script.contains("if [ -f /tmp/floci-imds-proxy.pid ] && kill -0 \"$(cat /tmp/floci-imds-proxy.pid)\" 2>/dev/null; then\n exit 0\nfi"));+ // Targets configured Floci host and IMDS port+ assertTrue(script.contains("nohup socat TCP-LISTEN:80,bind=169.254.169.254,fork,reuseaddr TCP:10.0.0.1:9169 >/tmp/floci-imds-proxy.log 2>&1 &"));+ // Verifies via link-local curl+ assertTrue(script.contains("curl -fsS --max-time 1 http://169.254.169.254/latest/meta-data/instance-id >/dev/null && exit 0"));+ }++ @Test+ void preferredMetadataSourceIpPrefersConfiguredNetworkOverBridge() {+ ContainerNetwork bridge = new ContainerNetwork();+ bridge.withIpv4Address("172.17.0.2");+ ContainerNetwork vpc = new ContainerNetwork();+ vpc.withIpv4Address("10.0.0.2");++ Optional<String> ip = Ec2MetadataProxy.preferredMetadataSourceIp(Map.of("bridge", bridge, "custom-net", vpc));+ assertTrue(ip.isPresent());+ assertEquals("10.0.0.2", ip.get());+ }++ @Test+ void preferredMetadataSourceIpFallsBackToBridge() {+ ContainerNetwork bridge = new ContainerNetwork();+ bridge.withIpv4Address("172.17.0.2");++ Optional<String> ip = Ec2MetadataProxy.preferredMetadataSourceIp(Map.of("bridge", bridge));+ assertTrue(ip.isPresent());+ assertEquals("172.17.0.2", ip.get());+ }++ @Test+ void preferredMetadataSourceIpReturnsEmptyWhenNoNetworks() {+ assertTrue(Ec2MetadataProxy.preferredMetadataSourceIp(null).isEmpty());+ assertTrue(Ec2MetadataProxy.preferredMetadataSourceIp(Map.of()).isEmpty());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterManagerTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterManagerTest.javaindex a41f734b64..76037be657 100644--- a/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterManagerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterManagerTest.java@@ -16,9 +16,21 @@ import io.github.hectorvent.floci.services.eks.model.Cluster;import com.fasterxml.jackson.core.JsonProcessingException;import com.fasterxml.jackson.databind.ObjectMapper;import com.github.dockerjava.api.DockerClient;+import com.github.dockerjava.api.async.ResultCallback;import com.github.dockerjava.api.command.CopyArchiveToContainerCmd;+import com.github.dockerjava.api.command.ExecCreateCmd;+import com.github.dockerjava.api.command.ExecCreateCmdResponse;+import com.github.dockerjava.api.command.ExecStartCmd;+import com.github.dockerjava.api.command.InspectContainerCmd;+import com.github.dockerjava.api.command.InspectContainerResponse;+import com.github.dockerjava.api.command.InspectExecCmd;+import com.github.dockerjava.api.command.InspectExecResponse;import com.github.dockerjava.api.command.InspectVolumeCmd;import com.github.dockerjava.api.model.Container;+import com.github.dockerjava.api.model.Frame;+import com.github.dockerjava.api.model.NetworkSettings;+import io.github.hectorvent.floci.services.ec2.Ec2MetadataServer;+import io.github.hectorvent.floci.services.ec2.model.Instance;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Nested;import org.junit.jupiter.api.Test;@@ -26,12 +38,17 @@ import org.junit.jupiter.api.io.TempDir;import org.mockito.Mockito;import java.nio.file.Path;+import java.util.ArrayList;+import java.util.Arrays;import java.util.List;import java.util.Map;import java.util.Optional;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNotEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertNull;import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.anyString;@@ -598,4 +615,180 @@ class EksClusterManagerTest {verify(copyCmd).exec();}}++ @Nested+ class ConfigureLinkLocalMetadataEndpoint {++ private EmulatorConfig config;+ private EmulatorConfig.EksServiceConfig eks;+ private EmulatorConfig.Ec2ServiceConfig ec2;+ private ContainerLifecycleManager lifecycleManager;+ private DockerClient dockerClient;+ private Ec2MetadataServer metadataServer;+ private DockerHostResolver dockerHostResolver;+ private RegionResolver regionResolver;+ private EksClusterManager manager;+ private ExecCreateCmd execCreate;+ private List<String[]> capturedCmds;++ @BeforeEach+ void setUp() {+ config = Mockito.mock(EmulatorConfig.class);+ EmulatorConfig.ServicesConfig services = Mockito.mock(EmulatorConfig.ServicesConfig.class);+ eks = Mockito.mock(EmulatorConfig.EksServiceConfig.class);+ ec2 = Mockito.mock(EmulatorConfig.Ec2ServiceConfig.class);+ when(config.services()).thenReturn(services);+ when(config.defaultAccountId()).thenReturn("000000000000");+ when(services.eks()).thenReturn(eks);+ when(services.ec2()).thenReturn(ec2);+ when(ec2.imdsPort()).thenReturn(9169);+ when(eks.imds()).thenReturn(true);++ lifecycleManager = Mockito.mock(ContainerLifecycleManager.class);+ dockerClient = Mockito.mock(DockerClient.class);+ when(lifecycleManager.getDockerClient()).thenReturn(dockerClient);++ metadataServer = Mockito.mock(Ec2MetadataServer.class);+ dockerHostResolver = Mockito.mock(DockerHostResolver.class);+ when(dockerHostResolver.resolve()).thenReturn("floci-host");++ regionResolver = Mockito.mock(RegionResolver.class);+ when(regionResolver.getAccountId()).thenReturn("000000000000");+ when(regionResolver.getDefaultRegion()).thenReturn("us-east-1");++ capturedCmds = new ArrayList<>();+ execCreate = Mockito.mock(ExecCreateCmd.class, Mockito.withSettings().defaultAnswer(Mockito.RETURNS_SELF));+ ExecCreateCmdResponse execResponse = Mockito.mock(ExecCreateCmdResponse.class);+ when(execResponse.getId()).thenReturn("exec-123");+ when(dockerClient.execCreateCmd(anyString())).thenReturn(execCreate);+ when(execCreate.withCmd(any(String[].class))).thenAnswer(inv -> {+ Object[] args = inv.getArguments();+ if (args.length == 1 && args[0] instanceof String[] command) {+ capturedCmds.add(command);+ } else {+ capturedCmds.add(Arrays.copyOf(args, args.length, String[].class));+ }+ return execCreate;+ });+ when(execCreate.exec()).thenReturn(execResponse);++ ExecStartCmd execStart = Mockito.mock(ExecStartCmd.class);+ when(dockerClient.execStartCmd(anyString())).thenReturn(execStart);+ when(execStart.exec(any())).thenAnswer(inv -> {+ ResultCallback<Frame> cb = inv.getArgument(0);+ cb.onComplete();+ return cb;+ });++ InspectExecCmd inspectExec = Mockito.mock(InspectExecCmd.class);+ InspectExecResponse inspectResponse = Mockito.mock(InspectExecResponse.class);+ when(inspectResponse.getExitCodeLong()).thenReturn(0L);+ when(inspectExec.exec()).thenReturn(inspectResponse);+ when(dockerClient.inspectExecCmd(anyString())).thenReturn(inspectExec);++ InspectContainerCmd inspectContainer = Mockito.mock(InspectContainerCmd.class);+ InspectContainerResponse containerResponse = Mockito.mock(InspectContainerResponse.class);+ NetworkSettings netSettings = Mockito.mock(NetworkSettings.class);+ when(inspectContainer.exec()).thenReturn(containerResponse);+ when(dockerClient.inspectContainerCmd(anyString())).thenReturn(inspectContainer);+ when(containerResponse.getNetworkSettings()).thenReturn(netSettings);+ when(netSettings.getIpAddress()).thenReturn("172.17.0.2");++ manager = new EksClusterManager(+ Mockito.mock(ContainerBuilder.class), lifecycleManager,+ Mockito.mock(ContainerDetector.class), Mockito.mock(PortAllocator.class),+ dockerHostResolver, Mockito.mock(EcrRegistryManager.class),+ config, regionResolver, metadataServer);+ }++ @Test+ void synthesizesClusterNodeInstance() {+ Cluster cluster = new Cluster();+ cluster.setName("prod-cluster");+ cluster.setRoleArn("arn:aws:iam::123456789012:role/eks-node-role");++ Instance instance = manager.synthesizeClusterNodeInstance(cluster, "172.17.0.2", "us-west-2", "123456789012");+ assertNotNull(instance);+ assertTrue(instance.getInstanceId().startsWith("i-"));+ assertTrue(instance.getInstanceId().length() >= 19);+ assertEquals("ami-eks-k3s", instance.getImageId());+ assertEquals("m5.large", instance.getInstanceType());+ assertEquals("us-west-2a", instance.getPlacement().getAvailabilityZone());+ assertEquals("us-west-2", instance.getRegion());+ assertEquals("172.17.0.2", instance.getPrivateIpAddress());+ assertEquals("ip-172-17-0-2.us-west-2.compute.internal", instance.getPrivateDnsName());+ assertEquals("arn:aws:iam::123456789012:instance-profile/prod-cluster-node-profile", instance.getIamInstanceProfileArn());+ assertNotEquals(cluster.getRoleArn(), instance.getIamInstanceProfileArn());+ assertEquals("running", instance.getState().getName());+ }++ @Test+ void sameNameClustersInDifferentRegionsGetDistinctInstanceIds() {+ Cluster cluster = new Cluster();+ cluster.setName("prod-cluster");++ Instance inst1 = manager.synthesizeClusterNodeInstance(cluster, "172.17.0.2", "us-east-1", "123456789012");+ Instance inst2 = manager.synthesizeClusterNodeInstance(cluster, "172.17.0.2", "us-west-2", "123456789012");++ assertNotNull(inst1);+ assertNotNull(inst2);+ assertNotEquals(inst1.getInstanceId(), inst2.getInstanceId());+ }++ @Test+ void configuresMetadataProxyWhenEnabled() {+ Cluster cluster = new Cluster();+ cluster.setName("test-cluster");++ manager.configureLinkLocalMetadataEndpoint(cluster, "container-42");++ verify(metadataServer).reconcileContainerAddresses(any(), any());+ assertEquals(2, capturedCmds.size());+ // First command: install probe+ assertTrue(capturedCmds.get(0)[2].contains("command -v socat"));+ // Second command: start command with 169.254.169.254+ assertTrue(capturedCmds.get(1)[2].contains("169.254.169.254"));+ assertTrue(capturedCmds.get(1)[2].contains("TCP:floci-host:9169"));++ assertNotNull(manager.getRegisteredClusterNodeInstance(cluster));+ }++ @Test+ void skipsWhenImdsIsDisabled() {+ when(eks.imds()).thenReturn(false);++ Cluster cluster = new Cluster();+ cluster.setName("test-cluster");++ manager.configureLinkLocalMetadataEndpoint(cluster, "container-42");++ verifyNoInteractions(metadataServer);+ verifyNoInteractions(dockerClient);+ assertNull(manager.getRegisteredClusterNodeInstance(cluster));+ }++ @Test+ void failureToWireLogsAndDoesNotAbort() {+ when(dockerClient.execCreateCmd(anyString())).thenThrow(new RuntimeException("docker exec failed"));++ Cluster cluster = new Cluster();+ cluster.setName("test-cluster");++ // Failure to wire proxy should log warning and continue without throwing+ manager.configureLinkLocalMetadataEndpoint(cluster, "container-42");+ }++ @Test+ void unregisterMetadataEndpointRemovesInstance() {+ Cluster cluster = new Cluster();+ cluster.setName("test-cluster");++ manager.configureLinkLocalMetadataEndpoint(cluster, "container-42");+ assertNotNull(manager.getRegisteredClusterNodeInstance(cluster));++ manager.unregisterMetadataEndpoint(cluster);+ verify(metadataServer).unregisterInstance(any());+ assertNull(manager.getRegisteredClusterNodeInstance(cluster));+ }+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksImdsDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksImdsDockerIntegrationTest.javanew file mode 100644index 0000000000..e9a7361848--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksImdsDockerIntegrationTest.java@@ -0,0 +1,199 @@+package io.github.hectorvent.floci.services.eks;++import com.github.dockerjava.api.DockerClient;+import com.github.dockerjava.api.async.ResultCallback;+import com.github.dockerjava.api.command.ExecCreateCmdResponse;+import com.github.dockerjava.api.model.Frame;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;+import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;+import io.github.hectorvent.floci.core.common.docker.ContainerSpec;+import io.github.hectorvent.floci.services.ec2.Ec2MetadataServer;+import io.github.hectorvent.floci.services.eks.model.Cluster;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.QuarkusTestProfile;+import io.quarkus.test.junit.TestProfile;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.Assumptions;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.nio.charset.StandardCharsets;+import java.util.List;+import java.util.Map;+import java.util.UUID;+import java.util.concurrent.TimeUnit;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertTrue;++@QuarkusTest+@TestProfile(EksImdsDockerIntegrationTest.Profile.class)+class EksImdsDockerIntegrationTest {++ public static final class Profile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of("floci.services.eks.imds", "true");+ }+ }++ private static final Logger LOG = Logger.getLogger(EksImdsDockerIntegrationTest.class);+ private static final String TEST_IMAGE = "alpine:3.21";++ @Inject+ DockerClient dockerClient;++ @Inject+ ContainerBuilder containerBuilder;++ @Inject+ ContainerLifecycleManager lifecycleManager;++ @Inject+ EmulatorConfig config;++ @Inject+ Ec2MetadataServer metadataServer;++ @Inject+ EksClusterManager eksClusterManager;++ private String containerId;+ private Cluster cluster;++ @BeforeEach+ void requireDockerAndStartMetadataServer() {+ boolean dockerAvailable = isDockerAvailable();+ if (!dockerAvailable) {+ LOG.warn("Docker daemon is not available; skipping EksImdsDockerIntegrationTest");+ }+ Assumptions.assumeTrue(dockerAvailable, "Docker daemon must be available for EKS IMDS integration test");+ metadataServer.start().join();+ }++ @AfterEach+ void tearDown() {+ if (cluster != null) {+ eksClusterManager.unregisterMetadataEndpoint(cluster);+ }+ if (containerId != null) {+ try {+ lifecycleManager.stopAndRemove(containerId, null);+ } catch (Exception ignored) {+ }+ }+ }++ @Test+ void linkLocalImdsEndpointAnswersInsideClusterContainer() throws Exception {+ String clusterName = "imds-it-" + UUID.randomUUID().toString().substring(0, 8);+ cluster = new Cluster();+ cluster.setName(clusterName);+ cluster.setRoleArn("arn:aws:iam::000000000000:role/eks-it-role");++ ContainerSpec spec = containerBuilder.newContainer(TEST_IMAGE)+ .withName("floci-eks-imds-test-" + clusterName)+ .withPrivileged(true)+ .withHostDockerInternalOnLinux()+ .withCmd(List.of("sleep", "300"))+ .build();++ containerId = lifecycleManager.createAndStart(spec).containerId();+ assertNotNull(containerId, "Container ID must not be null");++ // Ensure curl dependency is installed in the test fixture if absent+ execInContainer(containerId, new String[]{"sh", "-c",+ "command -v curl >/dev/null 2>&1 || apk add --no-cache curl"});++ eksClusterManager.configureLinkLocalMetadataEndpoint(cluster, containerId);++ // IMDSv2 token test+ String tokenCmd = "curl -s -f -X PUT http://169.254.169.254/latest/api/token -H 'x-aws-ec2-metadata-token-ttl-seconds: 21600'";+ String token = execInContainer(containerId, new String[]{"sh", "-c", tokenCmd});+ assertNotNull(token, "IMDSv2 token response should not be null");+ assertTrue(!token.isBlank(), "IMDSv2 token should not be blank");++ // IMDSv2 instance-id metadata test+ String instanceIdCmd = "curl -s -f -H 'x-aws-ec2-metadata-token: " + token.trim() + "' http://169.254.169.254/latest/meta-data/instance-id";+ String instanceId = execInContainer(containerId, new String[]{"sh", "-c", instanceIdCmd});+ assertNotNull(instanceId, "instance-id response should not be null");+ assertTrue(instanceId.trim().startsWith("i-"), "Instance ID should start with 'i-': " + instanceId);++ // IMDSv1 fallback test using wget (tool guaranteed by alpine:3.21 image)+ String imdsv1Cmd = "wget -q -O - http://169.254.169.254/latest/meta-data/instance-id";+ String v1InstanceId = execInContainer(containerId, new String[]{"sh", "-c", imdsv1Cmd});+ assertEquals(instanceId.trim(), v1InstanceId.trim(), "IMDSv1 and IMDSv2 instance IDs should match");++ // Pod-isolation test: ordinary pods in their own network namespace cannot reach link-local IMDS+ // Tested using wget (tool guaranteed by alpine:3.21 image)+ String podIsolationCmd = """+ if command -v unshare >/dev/null 2>&1; then+ unshare -n wget -q -O - -T 2 http://169.254.169.254/latest/meta-data/instance-id+ else+ ip netns add pod-test 2>/dev/null || true+ ip netns exec pod-test wget -q -O - -T 2 http://169.254.169.254/latest/meta-data/instance-id+ ret=$?+ ip netns del pod-test 2>/dev/null || true+ exit $ret+ fi+ """;+ ExecResult podResult = execInContainerWithExitCode(containerId, new String[]{"sh", "-c", podIsolationCmd});+ assertNotEquals(0L, podResult.exitCode(), "IMDS should not be reachable from an isolated pod network namespace");+ }++ private boolean isDockerAvailable() {+ try {+ dockerClient.pingCmd().exec();+ return true;+ } catch (Exception e) {+ return false;+ }+ }++ record ExecResult(long exitCode, String stdout, String stderr) {}++ private ExecResult execInContainerWithExitCode(String containerId, String[] cmd) throws Exception {+ ExecCreateCmdResponse exec = dockerClient.execCreateCmd(containerId)+ .withCmd(cmd)+ .withAttachStdout(true)+ .withAttachStderr(true)+ .exec();++ StringBuilder stdout = new StringBuilder();+ StringBuilder stderr = new StringBuilder();+ boolean completed = dockerClient.execStartCmd(exec.getId())+ .exec(new ResultCallback.Adapter<Frame>() {+ @Override+ public void onNext(Frame frame) {+ if (frame != null && frame.getPayload() != null) {+ String text = new String(frame.getPayload(), StandardCharsets.UTF_8);+ if (frame.getStreamType() == com.github.dockerjava.api.model.StreamType.STDERR) {+ stderr.append(text);+ } else {+ stdout.append(text);+ }+ }+ }+ })+ .awaitCompletion(30, TimeUnit.SECONDS);++ if (!completed) {+ throw new RuntimeException("exec timed out in container " + containerId);+ }+ Long exitCode = dockerClient.inspectExecCmd(exec.getId()).exec().getExitCodeLong();+ return new ExecResult(exitCode != null ? exitCode : -1L, stdout.toString(), stderr.toString());+ }++ private String execInContainer(String containerId, String[] cmd) throws Exception {+ ExecResult result = execInContainerWithExitCode(containerId, cmd);+ if (result.exitCode() != 0) {+ throw new RuntimeException("exec failed with code " + result.exitCode() + ": " + result.stderr());+ }+ return result.stdout();+ }+}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex 41858aa365..da90ed2ece 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -303,6 +303,7 @@ floci:enabled: truemock: trueecr-registry-mirror: true+ imds: falsemwaa:enabled: truemock: true