Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(eks): name cluster nodes after their EC2 instance (#4916)

Simone Primarosa548f4698c5c2
diff --git a/docs/services/eks.md b/docs/services/eks.md
index 496ec6f2d7..61a3261855 100644
--- a/docs/services/eks.md
+++ b/docs/services/eks.md
@@ -489,9 +489,11 @@ Cleanup only targets this backup namespace; it does not look up old suffix-form
identify another account's live cluster. Verify ownership before manually removing leftover stopped
backups after upgrading.
-#### Cluster node provider ID and topology labels
+#### Cluster node naming, provider ID, and topology labels
-In real mode, cluster nodes carry a Kubernetes `spec.providerID` matching the AWS format:
+In real mode, cluster nodes are named after their backing EC2 instance's private DNS name using AWS resource-based naming. Real EKS nodes take their Kubernetes name from the instance's private DNS name (`system:node:{{EC2PrivateDNSName}}`). Under resource-based naming, this hostname includes the domain: `i-<instance-id>.ec2.internal` in `us-east-1`, or `i-<instance-id>.<region>.compute.internal` in other regions. Floci implements resource-based naming by deriving the instance ID and domain deterministically from the cluster identity, passing `--node-name=<privateDnsName>` to k3s before startup, and assigning the same `PrivateDnsName` to the synthetic EC2 node instance. This keeps the node name stable across container restarts and recreations, and ensures agreement between Kubernetes node queries and EC2 `DescribeInstances`.
+
+Cluster nodes also carry a Kubernetes `spec.providerID` matching the AWS format:
```text
aws:///<availability-zone>/<instance-id>
@@ -506,7 +508,7 @@ Cluster nodes also carry standard Kubernetes topology labels:
Floci derives the availability zone from the cluster region (for example, `<region>a` for `us-east-1`, yielding `us-east-1a`), rather than from node group subnets as real EKS does. The zone matches the availability zone in the node's `spec.providerID` and synthetic EC2 node instance. These labels enable topology-aware scheduling and allow controllers such as the AWS EBS CSI driver to discover the node's availability zone.
-The derived availability zone and instance ID match the synthetic EC2 node instance created for link-local IMDS, ensuring consistent identity across node metadata and kubelet registration. The provider ID enables controllers that reconcile nodes against EC2 (such as CSI drivers) to extract the instance ID. Note that nothing yet resolves that synthetic instance through the EC2 API.
+The node name, the instance ID in `spec.providerID`, and the synthetic EC2 instance (`InstanceId` and `PrivateDnsName`) all describe the same instance. This enables controllers that reconcile nodes against EC2 (such as CSI drivers) to look up the node instance via `DescribeInstances`.
## Configuration
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.java
index 1cdefaec09..b89bd1cafa 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
@@ -9,8 +9,12 @@ import io.github.hectorvent.floci.config.EmulatorConfig;
import io.github.hectorvent.floci.config.FlociCertificateAuthority;
import io.github.hectorvent.floci.core.common.AwsRegions;
import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.common.dns.DnsAnswer;
import io.github.hectorvent.floci.core.common.dns.DnsClientVpcSource;
import io.github.hectorvent.floci.core.common.dns.DnsClientVpcSource.ClientVpc;
+import io.github.hectorvent.floci.core.common.dns.DnsForwardingRule;
+import io.github.hectorvent.floci.core.common.dns.DnsForwardingRuleSource;
+import io.github.hectorvent.floci.core.common.dns.DnsRecordSource;
import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;
import io.github.hectorvent.floci.core.common.docker.ContainerDetector;
import io.github.hectorvent.floci.core.common.docker.ContainerExec;
@@ -70,6 +74,7 @@ import java.util.Base64;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
+import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
@@ -85,7 +90,8 @@ import java.util.stream.Collectors;
*/
@ApplicationScoped
public class EksClusterManager
- implements ClusterNodeInstanceProvider, VpcRouteTableListener, DnsClientVpcSource {
+ implements ClusterNodeInstanceProvider, VpcRouteTableListener, DnsClientVpcSource,
+ DnsRecordSource, DnsForwardingRuleSource {
private static final Logger LOG = Logger.getLogger(EksClusterManager.class);
private static final int K3S_API_SERVER_PORT = 6443;
@@ -205,6 +211,51 @@ public class EksClusterManager
.map(ClusterNodeVpc::clientVpc);
}
+ @Override
+ public Optional<DnsAnswer> resolveIpv4(String queryName) {
+ if (queryName == null || queryName.isBlank()) {
+ return Optional.empty();
+ }
+ String name = queryName.toLowerCase(Locale.ROOT);
+ if (name.endsWith(".")) {
+ name = name.substring(0, name.length() - 1);
+ }
+ for (ClusterNodeRecord record : clusterNodeInstances.values()) {
+ Instance inst = record.instance();
+ if (inst != null && inst.getPrivateDnsName() != null && inst.getPrivateIpAddress() != null
+ && !inst.getPrivateIpAddress().isBlank()) {
+ String nodeDnsName = inst.getPrivateDnsName().toLowerCase(Locale.ROOT);
+ if (name.equals(nodeDnsName)) {
+ return Optional.of(DnsAnswer.records(List.of(inst.getPrivateIpAddress()), DnsAnswer.DEFAULT_TTL_SECONDS));
+ }
+ }
+ }
+ return Optional.empty();
+ }
+
+ @Override
+ public List<DnsForwardingRule> rulesFor(String accountId, String region, String vpcId) {
+ if (vpcId == null || vpcId.isBlank()) {
+ return List.of();
+ }
+ List<DnsForwardingRule> rules = new ArrayList<>();
+ for (ClusterNodeRecord record : clusterNodeInstances.values()) {
+ if (accountId != null && !accountId.isBlank() && !accountId.equals(record.accountId())) {
+ continue;
+ }
+ if (region != null && !region.isBlank() && !region.equals(record.region())) {
+ continue;
+ }
+ Instance inst = record.instance();
+ if (inst != null && inst.getPrivateDnsName() != null && !inst.getPrivateDnsName().isBlank()) {
+ if (vpcId.equals(inst.getVpcId())) {
+ rules.add(DnsForwardingRule.system(inst.getPrivateDnsName()));
+ }
+ }
+ }
+ return List.copyOf(rules);
+ }
+
private void registerClusterNodeVpc(Cluster cluster, String accountId, String region,
Set<String> addresses) {
String clusterKey = clusterResourceName(cluster);
@@ -444,6 +495,15 @@ public class EksClusterManager
nodeLimits.addKubeletArgs(serverArgs);
}
+ try {
+ String nodeName = deriveClusterNodePrivateDnsName(cluster);
+ serverArgs.add("--node-name=" + nodeName);
+ } catch (Exception e) {
+ String clusterName = cluster != null ? cluster.getName() : "unknown";
+ LOG.warnv("EKS node name injection disabled for cluster {0}: could not derive node name: {1}",
+ clusterName, e.getMessage());
+ }
+
try {
String providerId = deriveClusterNodeProviderId(cluster);
serverArgs.add("--kubelet-arg=provider-id=" + providerId);
@@ -813,6 +873,8 @@ public class EksClusterManager
cluster.setCertificateAuthority(new CertificateAuthority(caData.trim()));
}
+ pruneLegacyClusterNodes(cluster, containerId);
+
LOG.infov("Finalized EKS cluster {0} with CA data extracted", cluster.getName());
} catch (Exception e) {
LOG.warnv("Could not extract kubeconfig for cluster {0}: {1}",
@@ -820,6 +882,31 @@ public class EksClusterManager
}
}
+ private void pruneLegacyClusterNodes(Cluster cluster, String containerId) {
+ try {
+ String expectedNodeName = deriveClusterNodePrivateDnsName(cluster);
+ ContainerExec.Result nodeResult = execInContainerForResult(containerId,
+ new String[]{"kubectl", "get", "nodes", "-o",
+ "jsonpath={range .items[*]}{.metadata.name}{\" \"}{range .status.conditions[?(@.type==\"Ready\")]}{.status}{end}{\"\\n\"}{end}"}, 10);
+ if (nodeResult.exitCode() == 0 && nodeResult.stdout() != null && !nodeResult.stdout().isBlank()) {
+ for (String line : nodeResult.stdout().split("\\r?\\n")) {
+ String[] parts = line.trim().split("\\s+");
+ if (parts.length >= 1 && !parts[0].isBlank()) {
+ String node = parts[0];
+ String readyStatus = parts.length > 1 ? parts[1] : "";
+ if (!node.equals(expectedNodeName) && !"True".equalsIgnoreCase(readyStatus)) {
+ execInContainerForResult(containerId,
+ new String[]{"kubectl", "delete", "node", node}, 10);
+ LOG.infov("Removed stale legacy node {0} from EKS cluster {1}", node, cluster.getName());
+ }
+ }
+ }
+ }
+ } catch (Exception e) {
+ LOG.warnv("Could not prune legacy nodes for cluster {0}: {1}", cluster.getName(), e.getMessage());
+ }
+ }
+
/**
* Stops and removes the k3s container for the given cluster. The k3s data volume follows the
* storage prune policy ({@link ContainerStorageHelper#removeNamedVolume}): it is only removed
@@ -2327,6 +2414,12 @@ public class EksClusterManager
return "i-" + (hex.length() >= 17 ? hex.substring(0, 17) : (hex + "00000000000000000").substring(0, 17));
}
+ String deriveClusterNodeInstanceId(Cluster cluster) {
+ String accountId = resolveClusterAccountId(cluster);
+ String region = clusterRegion(cluster);
+ return deriveClusterNodeInstanceId(cluster, region, accountId);
+ }
+
String deriveClusterNodeProviderId(Cluster cluster, String region, String accountId) {
String az = deriveClusterNodeAvailabilityZone(cluster, region);
String instanceId = deriveClusterNodeInstanceId(cluster, region, accountId);
@@ -2339,6 +2432,27 @@ public class EksClusterManager
return deriveClusterNodeProviderId(cluster, region, accountId);
}
+ String deriveClusterNodePrivateDnsDomain(String region) {
+ String safeRegion = (region != null && !region.isBlank()) ? region : "us-east-1"; // partition-literal: fallback for domain derivation
+ return "us-east-1".equals(safeRegion) // partition-literal: ec2.internal is us-east-1's own search domain
+ ? "ec2.internal"
+ : safeRegion + ".compute.internal";
+ }
+
+ String deriveClusterNodePrivateDnsName(Cluster cluster, String region, String accountId) {
+ String safeRegion = (region != null && !region.isBlank())
+ ? region
+ : clusterRegion(cluster);
+ String instanceId = deriveClusterNodeInstanceId(cluster, safeRegion, accountId);
+ return instanceId + "." + deriveClusterNodePrivateDnsDomain(safeRegion);
+ }
+
+ String deriveClusterNodePrivateDnsName(Cluster cluster) {
+ String accountId = resolveClusterAccountId(cluster);
+ String region = clusterRegion(cluster);
+ return deriveClusterNodePrivateDnsName(cluster, region, accountId);
+ }
+
Instance synthesizeClusterNodeInstance(Cluster cluster, String containerIp, String region, String accountId) {
Instance inst = new Instance();
String safeClusterName = (cluster != null && cluster.getName() != null && !cluster.getName().isBlank())
@@ -2353,6 +2467,7 @@ public class EksClusterManager
String instanceId = deriveClusterNodeInstanceId(cluster, safeRegion, safeAccountId);
String az = deriveClusterNodeAvailabilityZone(cluster, safeRegion);
+ String privateDnsName = deriveClusterNodePrivateDnsName(cluster, safeRegion, safeAccountId);
inst.setInstanceId(instanceId);
inst.setImageId("ami-eks-k3s");
@@ -2363,7 +2478,7 @@ public class EksClusterManager
String ip = (containerIp != null && !containerIp.isBlank()) ? containerIp : "10.0.0.1";
inst.setPrivateIpAddress(ip);
- inst.setPrivateDnsName("ip-" + ip.replace('.', '-') + "." + safeRegion + ".compute.internal");
+ inst.setPrivateDnsName(privateDnsName);
// 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
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.java
index c5e2183815..b534ebde40 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
@@ -4,7 +4,9 @@ import io.github.hectorvent.floci.config.EmulatorConfig;
import io.github.hectorvent.floci.config.FlociCertificateAuthority;
import io.github.hectorvent.floci.core.common.AwsRegions;
import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.common.dns.DnsAnswer;
import io.github.hectorvent.floci.core.common.dns.DnsClientVpcSource.ClientVpc;
+import io.github.hectorvent.floci.core.common.dns.DnsForwardingRule;
import io.github.hectorvent.floci.core.common.docker.ContainerBuilder;
import io.github.hectorvent.floci.core.common.docker.ContainerDetector;
import io.github.hectorvent.floci.core.common.docker.ContainerLifecycleManager;
@@ -67,6 +69,7 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
+import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
@@ -1196,7 +1199,7 @@ class EksClusterManagerTest {
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("i-0e413a1bfb5c3cd79.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());
@@ -1213,6 +1216,8 @@ class EksClusterManagerTest {
assertNotNull(inst1);
assertNotNull(inst2);
assertNotEquals(inst1.getInstanceId(), inst2.getInstanceId());
+ assertEquals(inst1.getInstanceId() + ".ec2.internal", inst1.getPrivateDnsName());
+ assertEquals(inst2.getInstanceId() + ".us-west-2.compute.internal", inst2.getPrivateDnsName());
}
@Test
@@ -1246,6 +1251,74 @@ class EksClusterManagerTest {
assertEquals("ap-southeast-1a", manager.deriveClusterNodeAvailabilityZone(cluster));
}
+ @Test
+ void derivesClusterNodeInstanceIdMatchingExpectedAwsFormat() {
+ Cluster cluster = new Cluster();
+ cluster.setName("prod-cluster");
+
+ String instanceId = manager.deriveClusterNodeInstanceId(cluster, "us-west-2", "123456789012");
+ assertEquals("i-0e413a1bfb5c3cd79", instanceId);
+ assertTrue(instanceId.matches("^i-[0-9a-f]{17}$"));
+ }
+
+ @Test
+ void deriveClusterNodeInstanceIdDerivesFromClusterArn() {
+ Cluster cluster = new Cluster();
+ cluster.setName("test-cluster");
+ cluster.setArn("arn:aws:eks:ap-southeast-1:123456789012:cluster/test-cluster");
+
+ String instanceId = manager.deriveClusterNodeInstanceId(cluster);
+ assertNotNull(instanceId);
+ assertEquals(manager.deriveClusterNodeInstanceId(cluster, "ap-southeast-1", "123456789012"), instanceId);
+ }
+
+ @Test
+ void twoClustersGetDistinctNodeNames() {
+ Cluster cluster1 = new Cluster();
+ cluster1.setName("cluster-alpha");
+ cluster1.setArn("arn:aws:eks:us-west-2:123456789012:cluster/cluster-alpha");
+
+ Cluster cluster2 = new Cluster();
+ cluster2.setName("cluster-beta");
+ cluster2.setArn("arn:aws:eks:us-west-2:123456789012:cluster/cluster-beta");
+
+ String name1 = manager.deriveClusterNodePrivateDnsName(cluster1);
+ String name2 = manager.deriveClusterNodePrivateDnsName(cluster2);
+
+ assertNotEquals(name1, name2);
+ }
+
+ @Test
+ void recreatingClusterContainerProducesSameNodeName() {
+ Cluster cluster = new Cluster();
+ cluster.setName("prod-cluster");
+ cluster.setArn("arn:aws:eks:us-west-2:123456789012:cluster/prod-cluster");
+
+ String initialName = manager.deriveClusterNodePrivateDnsName(cluster);
+ String recreatedName = manager.deriveClusterNodePrivateDnsName(cluster);
+
+ assertEquals(initialName, recreatedName);
+ }
+
+ @Test
+ void derivesClusterNodePrivateDnsDomainForUsEast1AndOtherRegions() {
+ assertEquals("ec2.internal", manager.deriveClusterNodePrivateDnsDomain("us-east-1"));
+ assertEquals("us-west-2.compute.internal", manager.deriveClusterNodePrivateDnsDomain("us-west-2"));
+ assertEquals("eu-central-1.compute.internal", manager.deriveClusterNodePrivateDnsDomain("eu-central-1"));
+ }
+
+ @Test
+ void derivesClusterNodePrivateDnsNameMatchingExpectedAwsFormat() {
+ Cluster cluster = new Cluster();
+ cluster.setName("prod-cluster");
+
+ String dnsNameUsEast1 = manager.deriveClusterNodePrivateDnsName(cluster, "us-east-1", "123456789012");
+ assertTrue(dnsNameUsEast1.matches("^i-[0-9a-f]{17}\\.ec2\\.internal$"));
+
+ String dnsNameUsWest2 = manager.deriveClusterNodePrivateDnsName(cluster, "us-west-2", "123456789012");
+ assertEquals("i-0e413a1bfb5c3cd79.us-west-2.compute.internal", dnsNameUsWest2);
+ }
+
@Test
void configuresMetadataProxyWhenEnabled() {
Cluster cluster = new Cluster();
@@ -1408,6 +1481,92 @@ class EksClusterManagerTest {
assertTrue(manager.listInstances("123456789012", "us-east-1").isEmpty());
}
+ @Test
+ void dnsRecordSourceResolvesRegisteredNodePrivateDnsName() {
+ Cluster cluster = new Cluster();
+ cluster.setName("dns-cluster");
+ cluster.setArn("arn:aws:eks:us-east-1:123456789012:cluster/dns-cluster");
+
+ manager.registerClusterNodeInstance(cluster, "container-dns");
+ Instance registered = manager.getRegisteredClusterNodeInstance(cluster);
+ assertNotNull(registered);
+
+ String dnsName = registered.getPrivateDnsName();
+ assertNotNull(dnsName);
+ String ip = registered.getPrivateIpAddress();
+ assertNotNull(ip);
+
+ // Exact match
+ Optional<DnsAnswer> answer = manager.resolveIpv4(dnsName);
+ assertTrue(answer.isPresent());
+ assertEquals(List.of(ip), answer.get().addresses());
+
+ // Case-insensitive match
+ Optional<DnsAnswer> upperAnswer = manager.resolveIpv4(dnsName.toUpperCase(Locale.ROOT));
+ assertTrue(upperAnswer.isPresent());
+ assertEquals(List.of(ip), upperAnswer.get().addresses());
+
+ // Trailing dot match
+ Optional<DnsAnswer> trailingDotAnswer = manager.resolveIpv4(dnsName + ".");
+ assertTrue(trailingDotAnswer.isPresent());
+ assertEquals(List.of(ip), trailingDotAnswer.get().addresses());
+
+ // Unknown host
+ assertTrue(manager.resolveIpv4("unknown.ec2.internal").isEmpty());
+ assertTrue(manager.resolveIpv4(null).isEmpty());
+ assertTrue(manager.resolveIpv4("").isEmpty());
+
+ // Other DNS types preserve ownership
+ assertTrue(manager.resolve(dnsName, 1).isPresent());
+ assertTrue(manager.resolve(dnsName, 28).isPresent());
+
+ // After unregistering, name no longer resolves
+ manager.unregisterMetadataEndpoint(cluster);
+ assertTrue(manager.resolveIpv4(dnsName).isEmpty());
+ }
+
+ @Test
+ void dnsForwardingRuleSourceEmitsSystemRuleForRegisteredNode() {
+ Cluster cluster = new Cluster();
+ cluster.setName("fwd-cluster");
+ cluster.setArn("arn:aws:eks:us-east-1:123456789012:cluster/fwd-cluster");
+ ResourcesVpcConfig vpcConfig = new ResourcesVpcConfig();
+ vpcConfig.setVpcId("vpc-12345678");
+ cluster.setResourcesVpcConfig(vpcConfig);
+
+ manager.registerClusterNodeInstance(cluster, "container-fwd");
+ Instance registered = manager.getRegisteredClusterNodeInstance(cluster);
+ assertNotNull(registered);
+
+ String dnsName = registered.getPrivateDnsName();
+ assertNotNull(dnsName);
+
+ // Matching VPC and account
+ List<DnsForwardingRule> rules = manager.rulesFor("123456789012", "us-east-1", "vpc-12345678");
+ assertEquals(1, rules.size());
+ assertEquals(DnsForwardingRule.system(dnsName), rules.getFirst());
+ assertFalse(rules.getFirst().forwards());
+
+ // Wrong account or VPC returns no rules
+ assertTrue(manager.rulesFor("999999999999", "us-east-1", "vpc-12345678").isEmpty());
+ assertTrue(manager.rulesFor("123456789012", "us-east-1", "vpc-other").isEmpty());
+ assertTrue(manager.rulesFor("123456789012", "us-east-1", null).isEmpty());
+ assertTrue(manager.rulesFor("123456789012", "us-east-1", "").isEmpty());
+
+ // Cluster without VPC does not emit rules for any VPC
+ Cluster clusterNoVpc = new Cluster();
+ clusterNoVpc.setName("novpc-cluster");
+ clusterNoVpc.setArn("arn:aws:eks:us-east-1:123456789012:cluster/novpc-cluster");
+ manager.registerClusterNodeInstance(clusterNoVpc, "container-novpc");
+ assertTrue(manager.rulesFor("123456789012", "us-east-1", "vpc-12345678").stream()
+ .noneMatch(r -> r.domainName().contains("novpc-cluster")));
+ manager.unregisterMetadataEndpoint(clusterNoVpc);
+
+ // After unregistering, rule disappears
+ manager.unregisterMetadataEndpoint(cluster);
+ assertTrue(manager.rulesFor("123456789012", "us-east-1", "vpc-12345678").isEmpty());
+ }
+
@Test
void failureToWireLogsAndDoesNotAbort() {
when(dockerClient.execCreateCmd(anyString())).thenThrow(new RuntimeException("docker exec failed"));
@@ -1799,6 +1958,77 @@ class EksClusterManagerTest {
verify(copyCmd).withHostResource(pubFile.toString());
}
+ @Test
+ void startClusterConfiguresNodeNameArg() {
+ Cluster cluster = new Cluster();
+ cluster.setName("prod-cluster");
+ cluster.setAccountId("123456789012");
+ cluster.setArn("arn:aws:eks:us-west-2:123456789012:cluster/prod-cluster");
+
+ manager.startCluster(cluster);
+
+ @SuppressWarnings("unchecked")
+ ArgumentCaptor<List<String>> cmdCaptor = ArgumentCaptor.forClass(List.class);
+ verify(builder).withCmd(cmdCaptor.capture());
+ List<String> cmd = cmdCaptor.getValue();
+
+ String expectedNodeName = manager.deriveClusterNodePrivateDnsName(cluster);
+ assertEquals("i-0e413a1bfb5c3cd79.us-west-2.compute.internal", expectedNodeName);
+ assertTrue(cmd.contains("--node-name=" + expectedNodeName));
+ }
+
+ @Test
+ void startClusterContinuesWhenNodeNameDerivationFails() {
+ EksClusterManager spyManager = Mockito.spy(manager);
+ Mockito.doThrow(new RuntimeException("derivation failure"))
+ .when(spyManager).deriveClusterNodePrivateDnsName(any());
+
+ Cluster cluster = new Cluster();
+ cluster.setName("fail-cluster");
+
+ assertDoesNotThrow(() -> spyManager.startCluster(cluster));
+
+ @SuppressWarnings("unchecked")
+ ArgumentCaptor<List<String>> cmdCaptor = ArgumentCaptor.forClass(List.class);
+ verify(builder).withCmd(cmdCaptor.capture());
+ List<String> cmd = cmdCaptor.getValue();
+
+ assertFalse(cmd.stream().anyMatch(arg -> arg.startsWith("--node-name=")));
+ }
+
+ @Test
+ void nodeNameMatchesProviderIdInstanceId() {
+ Cluster cluster = new Cluster();
+ cluster.setName("prod-cluster");
+ cluster.setAccountId("123456789012");
+ cluster.setArn("arn:aws:eks:eu-central-1:123456789012:cluster/prod-cluster");
+
+ manager.startCluster(cluster);
+
+ @SuppressWarnings("unchecked")
+ ArgumentCaptor<List<String>> cmdCaptor = ArgumentCaptor.forClass(List.class);
+ verify(builder).withCmd(cmdCaptor.capture());
+ List<String> cmd = cmdCaptor.getValue();
+
+ String nodeNameArg = cmd.stream()
+ .filter(arg -> arg.startsWith("--node-name="))
+ .findFirst()
+ .orElseThrow(() -> new AssertionError("node-name arg missing"));
+ String nodeName = nodeNameArg.substring("--node-name=".length());
+
+ String providerIdArg = cmd.stream()
+ .filter(arg -> arg.startsWith("--kubelet-arg=provider-id="))
+ .findFirst()
+ .orElseThrow(() -> new AssertionError("provider-id arg missing"));
+ String providerId = providerIdArg.substring("--kubelet-arg=provider-id=".length());
+ String[] parts = providerId.split("/");
+ String providerInstanceId = parts[parts.length - 1];
+
+ assertEquals(providerInstanceId, manager.deriveClusterNodeInstanceId(cluster));
+ assertEquals(nodeName, manager.deriveClusterNodePrivateDnsName(cluster));
+ assertTrue(nodeName.startsWith(providerInstanceId + "."));
+ }
+
@Test
void startClusterConfiguresKubeletProviderIdArg() {
Cluster cluster = new Cluster();
diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterNodeInstanceIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterNodeInstanceIntegrationTest.java
index ff7c72ae29..db6286bcbd 100644
--- a/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterNodeInstanceIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksClusterNodeInstanceIntegrationTest.java
@@ -11,6 +11,9 @@ import java.util.UUID;
import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.hasItem;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
@QuarkusTest
class EksClusterNodeInstanceIntegrationTest {
@@ -181,6 +184,76 @@ class EksClusterNodeInstanceIntegrationTest {
.body("Response.Errors.Error.Code", equalTo("InvalidInstanceID.NotFound"));
}
+ @Test
+ void nodeNameProviderIdAndEc2DescribeInstancesAgreeAcrossReRegistration() {
+ String account = "123456789012";
+ String clusterName1 = "node-aggr-" + UUID.randomUUID().toString().substring(0, 8);
+ Cluster cluster1 = new Cluster();
+ cluster1.setName(clusterName1);
+ cluster1.setArn("arn:aws:eks:us-east-1:" + account + ":cluster/" + clusterName1);
+
+ String nodeName1 = eksClusterManager.deriveClusterNodePrivateDnsName(cluster1);
+ String instanceId1 = eksClusterManager.deriveClusterNodeInstanceId(cluster1);
+ String providerId1 = eksClusterManager.deriveClusterNodeProviderId(cluster1);
+ String az1 = eksClusterManager.deriveClusterNodeAvailabilityZone(cluster1);
+
+ // Verify AWS format and agreement between node name, provider ID and AZ
+ assertTrue(instanceId1.matches("^i-[0-9a-f]{17}$"));
+ assertEquals(instanceId1 + ".ec2.internal", nodeName1);
+ assertEquals("aws:///" + az1 + "/" + instanceId1, providerId1);
+
+ // Initial node registration
+ eksClusterManager.registerClusterNodeInstance(cluster1, "container-gen-1");
+ Instance instGen1 = eksClusterManager.getRegisteredClusterNodeInstance(cluster1);
+ assertEquals(instanceId1, instGen1.getInstanceId());
+ assertEquals(nodeName1, instGen1.getPrivateDnsName());
+
+ try {
+ // DescribeInstances returns the node instance matching nodeName and instanceId
+ given().header("Authorization", auth(account, "ec2"))
+ .formParam("Action", "DescribeInstances")
+ .formParam("InstanceId.1", instanceId1)
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeInstancesResponse.reservationSet.item.instancesSet.item.instanceId",
+ equalTo(instanceId1))
+ .body("DescribeInstancesResponse.reservationSet.item.instancesSet.item.privateDnsName",
+ equalTo(nodeName1));
+
+ // Subsequent registration with a new container ID produces the exact same node name and instance ID
+ eksClusterManager.registerClusterNodeInstance(cluster1, "container-gen-2");
+ String nodeNameAfterRecreate = eksClusterManager.deriveClusterNodePrivateDnsName(cluster1);
+ assertEquals(nodeName1, nodeNameAfterRecreate);
+
+ Instance instGen2 = eksClusterManager.getRegisteredClusterNodeInstance(cluster1);
+ assertEquals(instanceId1, instGen2.getInstanceId());
+ assertEquals(nodeName1, instGen2.getPrivateDnsName());
+
+ given().header("Authorization", auth(account, "ec2"))
+ .formParam("Action", "DescribeInstances")
+ .formParam("InstanceId.1", instanceId1)
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("DescribeInstancesResponse.reservationSet.item.instancesSet.item.instanceId",
+ equalTo(instanceId1))
+ .body("DescribeInstancesResponse.reservationSet.item.instancesSet.item.privateDnsName",
+ equalTo(nodeName1));
+
+ // Distinct cluster gets a distinct node name
+ String clusterName2 = "node-aggr-" + UUID.randomUUID().toString().substring(0, 8);
+ Cluster cluster2 = new Cluster();
+ cluster2.setName(clusterName2);
+ cluster2.setArn("arn:aws:eks:us-east-1:" + account + ":cluster/" + clusterName2);
+
+ String nodeName2 = eksClusterManager.deriveClusterNodePrivateDnsName(cluster2);
+ assertNotEquals(nodeName1, nodeName2);
+ } finally {
+ eksClusterManager.unregisterMetadataEndpoint(cluster1);
+ }
+ }
+
private static String auth(String account, String service) {
return "AWS4-HMAC-SHA256 Credential=" + account
+ "/20260917/us-east-1/" + service + "/aws4_request, SignedHeaders=host, Signature=abc";
diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksIrsaDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksIrsaDockerIntegrationTest.java
index f3a1bed37b..91c3de741f 100644
--- a/src/test/java/io/github/hectorvent/floci/services/eks/EksIrsaDockerIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksIrsaDockerIntegrationTest.java
@@ -21,6 +21,7 @@ import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.containsString;
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.assertTrue;
@@ -209,6 +210,12 @@ class EksIrsaDockerIntegrationTest {
assertEquals(eksClusterManager.deriveClusterNodeProviderId(cluster), nodeResult.stdout().trim(),
"Node providerID must match the derived AWS provider ID");
+ ContainerExec.Result nodeNameResult = execInContainerWithExitCode(containerId,
+ new String[]{"kubectl", "get", "nodes", "-o", "jsonpath={.items[0].metadata.name}"});
+ assertEquals(0, nodeNameResult.exitCode(), "kubectl get nodes failed");
+ assertEquals(eksClusterManager.deriveClusterNodePrivateDnsName(cluster), nodeNameResult.stdout().trim(),
+ "Node name must match the derived cluster node private DNS name");
+
ContainerExec.Result zoneResult = execInContainerWithExitCode(containerId,
new String[]{"kubectl", "get", "nodes", "-o",
"jsonpath={.items[0].metadata.labels.topology\\.kubernetes\\.io/zone}"});
@@ -318,6 +325,34 @@ class EksIrsaDockerIntegrationTest {
.then()
.statusCode(400)
.body(containsString("InvalidIdentityToken"));
+
+ // 5. Container recreation: recreate the cluster container and verify that k3s
+ // reuses the same node name on the existing data volume without duplicate or stale nodes
+ dockerClient.stopContainerCmd(containerId).exec();
+ dockerClient.removeContainerCmd(containerId).exec();
+
+ eksClusterManager.startCluster(cluster);
+ String recreatedContainerId = cluster.getContainerId();
+ assertNotNull(recreatedContainerId);
+ assertNotEquals(containerId, recreatedContainerId);
+
+ long recreateDeadline = System.currentTimeMillis() + 60000;
+ boolean recreateReady = false;
+ while (System.currentTimeMillis() < recreateDeadline) {
+ if (eksClusterManager.isReady(cluster)) {
+ recreateReady = true;
+ break;
+ }
+ Thread.sleep(2000);
+ }
+ assertTrue(recreateReady, "k3s API server must become ready after container recreation");
+ eksClusterManager.finalizeCluster(cluster);
+
+ ContainerExec.Result recreatedNodeResult = execInContainerWithExitCode(recreatedContainerId,
+ new String[]{"kubectl", "get", "nodes", "-o", "jsonpath={.items[*].metadata.name}"});
+ assertEquals(0, recreatedNodeResult.exitCode(), "kubectl get nodes failed on recreated cluster");
+ assertEquals(eksClusterManager.deriveClusterNodePrivateDnsName(cluster), recreatedNodeResult.stdout().trim(),
+ "Recreated cluster must keep the same node name without leaving duplicate or stale nodes");
}
private String createRole(String name, String trustPolicy) {