Light, fluffy, and always free - The AWS Local Emulator alternative
feat(eks): stop shipping a default storage class in clusters (#5061)
Simone Primarosadc3e9cacec96
diff --git a/docs/services/eks.md b/docs/services/eks.mdindex d6bbf4f217..94d35ee784 100644--- a/docs/services/eks.md+++ b/docs/services/eks.md@@ -510,6 +510,14 @@ Floci derives the availability zone from the cluster region (for example, `<regiThe 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`.+#### Storage classes++Stock Amazon EKS clusters historically define a default `gp2` StorageClass pointing to the legacy in-tree `kubernetes.io/aws-ebs` plugin, but run no active storage provisioner without the EBS CSI driver. Unqualified PersistentVolumeClaims remain `Pending` on EKS because nothing can provision them. Floci matches this behavior by disabling k3s's bundled `local-path` provisioner and StorageClass, preventing unqualified claims from silently binding to the node filesystem.++Callers requiring dynamic volume provisioning can install a driver (such as the `aws-ebs-csi-driver` addon) and define their desired StorageClass.++For local testing workflows that rely on automatic volume binding without a CSI driver, set `floci.services.eks.default-storage-class: true` (or `FLOCI_SERVICES_EKS_DEFAULT_STORAGE_CLASS=true`) to retain k3s's bundled `local-path` provisioner and default StorageClass.+## Configuration| Variable | Default | Description |@@ -528,6 +536,8 @@ The node name, the instance ID in `spec.providerID`, and the synthetic EC2 insta| `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_DISABLE_CNI` | `false` | Start k3s without bundled flannel, network policy, and kube-proxy so an external CNI can take over |+| `FLOCI_SERVICES_EKS_DEFAULT_STORAGE_CLASS` | `false` | Retain k3s bundled local-path provisioner and default StorageClass (default false matches EKS with no default class) || `FLOCI_SERVICES_EKS_IRSA_SIGNING_KEY` | `true` | Pass the cluster OIDC signing key to k3s so in-cluster projected service account tokens can assume IAM roles via Floci STS || `FLOCI_SERVICES_EKS_POD_IDENTITY_WEBHOOK` | `true` | Register a mutating admission webhook that injects pod identity credentials. Needs `FLOCI_TLS_ENABLED=true` || `FLOCI_SERVICES_EKS_IMDS` | `false` | Enable link-local IMDS (`169.254.169.254`) proxy in cluster containers |diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 3cb90ccc28..45b1965285 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -3276,13 +3276,25 @@ public interface EmulatorConfig {* --disable-kube-proxy} instead of its bundled networking stack. k3s's default flannel CNI* and kube-proxy run embedded in the k3s server process itself (not separate, killable* DaemonSets), so a real CNI (e.g. Cilium) can only cleanly take over if k3s never starts- * its own in the first place — there is no way to evict them after the fact. CoreDNS,+ * its own in the first place: there is no way to evict them after the fact. CoreDNS,* local-path-provisioner, and metrics-server are unaffected; they don't depend on which CNI* is in place.*/@WithDefault("false")boolean disableCni();+ /**+ * When false (default), starts k3s with {@code --disable=local-storage} so clusters match+ * AWS EKS by starting with no default StorageClass and no host-path provisioner. When true,+ * retains k3s's bundled local-path provisioner and default StorageClass for local workloads+ * that rely on automatic volume binding without installing a CSI driver.+ *+ * <p>Like {@link #disableCni()}, k3s's local-path-provisioner runs embedded in the k3s server+ * process itself, so this flag must be set at startup rather than applied afterwards.+ */+ @WithDefault("false")+ boolean defaultStorageClass();+/*** 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.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 ac4ea15efe..4175ee3ea2 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@@ -99,6 +99,7 @@ public class EksClusterManagerprivate static final int K3S_API_SERVER_PORT = 6443;static final String DEFAULT_NODE_INSTANCE_TYPE = "m5.large";private static final String NODE_CAPACITY_LABEL = "io.floci.eks.node-capacity";+ private static final String DEFAULT_STORAGE_CLASS_LABEL = "io.floci.eks.default-storage-class";private static final String WEBHOOK_CONFIG_DIR = "/etc";private static final String WEBHOOK_CONFIG_FILE = "token-webhook.yaml";@@ -490,7 +491,18 @@ public class EksClusterManager? cluster.getPodCidr(): DEFAULT_POD_CIDR;- List<String> serverArgs = buildServerArgs(config.services().eks().disableCni(), serviceCidr, clusterCidr);+ boolean defaultStorageClass = cluster != null && cluster.getDefaultStorageClass() != null+ ? cluster.getDefaultStorageClass()+ : config.services().eks().defaultStorageClass();+ if (cluster != null) {+ cluster.setDefaultStorageClass(defaultStorageClass);+ }++ List<String> serverArgs = buildServerArgs(+ config.services().eks().disableCni(),+ defaultStorageClass,+ serviceCidr,+ clusterCidr);EksNodeCapacity.Limits nodeLimits = resolveNodeCapacity(cluster);if (nodeLimits != null) {@@ -532,6 +544,7 @@ public class EksClusterManagerMap<String, String> labels = new LinkedHashMap<>(ContainerStorageHelper.resourceIdentityLabels("eks", cluster.getName(), labelAccountId, clusterRegion(cluster)));labels.put(NODE_CAPACITY_LABEL, capacityLabel(cluster, nodeLimits));+ labels.put(DEFAULT_STORAGE_CLASS_LABEL, String.valueOf(defaultStorageClass));ContainerBuilder.Builder specBuilder = containerBuilder.newContainer(image).withName(containerName).withEnv("K3S_KUBECONFIG_MODE", "644")@@ -678,6 +691,13 @@ public class EksClusterManagerif (existing.isEmpty()) {LOG.infov("No surviving k3s container for EKS cluster {0}; recreating it "+ "(a surviving data volume is reused)", cluster.getName());+ if (cluster.getDefaultStorageClass() == null) {+ boolean targetSetting = config.services().eks().defaultStorageClass();+ LOG.infov("Recreating EKS cluster {0} with defaultStorageClass={1} "+ + "(set floci.services.eks.default-storage-class: true to retain bundled local-path)",+ cluster.getName(), String.valueOf(targetSetting));+ cluster.setDefaultStorageClass(targetSetting);+ }startCluster(cluster);return;}@@ -686,6 +706,14 @@ public class EksClusterManagerMap<String, String> existingLabels = existing.get().getLabels();boolean capacityChanged = existingLabels == null|| !desiredCapacity.equals(existingLabels.get(NODE_CAPACITY_LABEL));+ if (existingLabels != null && existingLabels.containsKey(DEFAULT_STORAGE_CLASS_LABEL)) {+ cluster.setDefaultStorageClass(Boolean.parseBoolean(existingLabels.get(DEFAULT_STORAGE_CLASS_LABEL)));+ } else if (cluster.getDefaultStorageClass() == null) {+ // Surviving container was created before defaultStorageClass was configurable:+ // preserve prior behavior with local-storage enabled.+ cluster.setDefaultStorageClass(true);+ LOG.infov("Adopting pre-upgrade EKS cluster {0} with local-storage enabled", cluster.getName());+ }if (!adoptSurvivingCluster(cluster, existing.get().getId())) {startCluster(cluster);return;@@ -1319,14 +1347,20 @@ public class EksClusterManager}/**- * Builds the k3s {@code server} command-line args. When {@code disableCni} is true, flannel,- * k3s's default network policy controller, and kube-proxy are all disabled up front: see the- * {@code disableCni} config javadoc for why this must happen at startup, not after the fact.+ * Builds the k3s {@code server} command-line args. When {@code defaultStorageClass} is false,+ * k3s's bundled local-path provisioner is disabled so clusters match AWS EKS by starting with+ * no default StorageClass. When {@code disableCni} is true, flannel, k3s's default network+ * policy controller, and kube-proxy are all disabled up front: see the {@code disableCni}+ * config javadoc for why this must happen at startup, not after the fact.*/- static List<String> buildServerArgs(boolean disableCni, String serviceCidr, String clusterCidr) {+ static List<String> buildServerArgs(boolean disableCni, boolean defaultStorageClass,+ String serviceCidr, String clusterCidr) {List<String> serverArgs = new ArrayList<>(List.of("server","--disable=traefik","--tls-san=localhost"));+ if (!defaultStorageClass) {+ serverArgs.add("--disable=local-storage");+ }if (disableCni) {serverArgs.add("--flannel-backend=none");serverArgs.add("--disable-network-policy");@@ -1341,8 +1375,12 @@ public class EksClusterManagerreturn serverArgs;}+ static List<String> buildServerArgs(boolean disableCni, String serviceCidr, String clusterCidr) {+ return buildServerArgs(disableCni, false, serviceCidr, clusterCidr);+ }+static List<String> buildServerArgs(boolean disableCni) {- return buildServerArgs(disableCni, null, null);+ return buildServerArgs(disableCni, false, null, null);}/**diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksController.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksController.javaindex f7f9722f95..d322be5cff 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/EksController.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksController.java@@ -92,13 +92,15 @@ public class EksController {* causes Jackson to omit the property due to @JsonInclude(NON_DEFAULT).*/private Cluster toClusterResponse(Cluster cluster) {- if (cluster == null || (!cluster.isExplicitVersion() && cluster.getNodeInstanceType() == null && cluster.getClusterArgs() == null)) {+ if (cluster == null || (!cluster.isExplicitVersion() && cluster.getNodeInstanceType() == null+ && cluster.getClusterArgs() == null && cluster.getDefaultStorageClass() == null)) {return cluster;}Cluster response = cluster.copy();response.setExplicitVersion(false);response.setNodeInstanceType(null);response.setClusterArgs(null);+ response.setDefaultStorageClass(null);return response;}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/Cluster.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/Cluster.javaindex 26e4f950c6..c7bb3bbf8d 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/model/Cluster.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/Cluster.java@@ -110,6 +110,15 @@ public class Cluster {@JsonInclude(JsonInclude.Include.NON_EMPTY)private List<String> clusterArgs;+ /**+ * Internal setting indicating whether the cluster was started with k3s's bundled+ * local-path provisioner and default StorageClass. Persisted to storage so restored+ * clusters preserve their storage behavior across container recreations.+ */+ @JsonProperty("defaultStorageClass")+ @JsonInclude(JsonInclude.Include.NON_NULL)+ private Boolean defaultStorageClass;+private AccessConfig accessConfig;public AccessConfig getAccessConfig() { return accessConfig; }@@ -189,6 +198,9 @@ public class Cluster {public boolean isExplicitVersion() { return explicitVersion; }public void setExplicitVersion(boolean explicitVersion) { this.explicitVersion = explicitVersion; }+ public Boolean getDefaultStorageClass() { return defaultStorageClass; }+ public void setDefaultStorageClass(Boolean defaultStorageClass) { this.defaultStorageClass = defaultStorageClass; }+public Cluster copy() {Cluster c = new Cluster();c.name = this.name;@@ -215,6 +227,7 @@ public class Cluster {c.dockerName = this.dockerName;c.nodeInstanceType = this.nodeInstanceType;c.clusterArgs = this.clusterArgs != null ? new ArrayList<>(this.clusterArgs) : null;+ c.defaultStorageClass = this.defaultStorageClass;c.accessConfig = this.accessConfig;return c;}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 3b5950f494..7dc9cb7a18 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -693,6 +693,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+ default-storage-class: false # start k3s without its bundled local-path provisioner to match EKSimds: false # expose link-local IMDS (169.254.169.254) inside the cluster containerimds-pod-network: false # route link-local IMDS traffic from ordinary pod network namespaces (requires imds: true)irsa-signing-key: true # sign k3s service account tokens with the cluster OIDC keydiff --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 a84e89083d..b5eddbfd75 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@@ -235,6 +235,7 @@ class EksClusterManagerTest {List<String> args = EksClusterManager.buildServerArgs(false);assertTrue(args.contains("--disable=traefik"));+ assertTrue(args.contains("--disable=local-storage"));assertFalse(args.contains("--flannel-backend=none"));assertFalse(args.contains("--disable-network-policy"));assertFalse(args.contains("--disable-kube-proxy"));@@ -247,8 +248,27 @@ class EksClusterManagerTest {assertTrue(args.contains("--flannel-backend=none"));assertTrue(args.contains("--disable-network-policy"));assertTrue(args.contains("--disable-kube-proxy"));- // Base args must still be present — disableCni only adds flags, never replaces them.+ // Base args must still be present: disableCni only adds flags, never replaces them.assertTrue(args.contains("--disable=traefik"));+ assertTrue(args.contains("--disable=local-storage"));+ assertTrue(args.contains("--tls-san=localhost"));+ }++ @Test+ void serverArgsRetainLocalStorageWhenDefaultStorageClassEnabled() {+ List<String> args = EksClusterManager.buildServerArgs(false, true, null, null);++ assertTrue(args.contains("--disable=traefik"));+ assertFalse(args.contains("--disable=local-storage"));+ assertTrue(args.contains("--tls-san=localhost"));+ }++ @Test+ void serverArgsDisableLocalStorageWhenDefaultStorageClassDisabled() {+ List<String> args = EksClusterManager.buildServerArgs(false, false, null, null);++ assertTrue(args.contains("--disable=traefik"));+ assertTrue(args.contains("--disable=local-storage"));assertTrue(args.contains("--tls-san=localhost"));}@@ -329,7 +349,8 @@ class EksClusterManagerTest {"io.floci.resource-id", "my-cluster","io.floci.account", "000000000000","io.floci.region", "us-east-1",- "io.floci.eks.node-capacity", "m5.large:unbounded"));+ "io.floci.eks.node-capacity", "m5.large:unbounded",+ "io.floci.eks.default-storage-class", "false"));}@ParameterizedTest@@ -364,6 +385,43 @@ class EksClusterManagerTest {}}+ @ParameterizedTest+ @ValueSource(booleans = {true, false})+ void startClusterDefaultStorageClassFlag(boolean defaultStorageClass) {+ EmulatorConfig config = Mockito.mock(EmulatorConfig.class, Mockito.RETURNS_DEEP_STUBS);+ when(config.services().eks().defaultImage()).thenReturn("rancher/k3s:v1.30.0-k3s1");+ when(config.services().eks().defaultStorageClass()).thenReturn(defaultStorageClass);++ ContainerLifecycleManager lifecycleManager = Mockito.mock(ContainerLifecycleManager.class, Mockito.RETURNS_DEEP_STUBS);+ when(lifecycleManager.create(any())).thenReturn("container-id");++ ContainerBuilder containerBuilder = Mockito.mock(ContainerBuilder.class);+ ContainerBuilder.Builder builder = Mockito.mock(ContainerBuilder.Builder.class, Mockito.RETURNS_SELF);+ when(containerBuilder.newContainer(anyString())).thenReturn(builder);+ when(builder.build()).thenReturn(Mockito.mock(ContainerSpec.class));++ EksClusterManager manager = new EksClusterManager(containerBuilder, lifecycleManager,+ Mockito.mock(ContainerDetector.class), Mockito.mock(PortAllocator.class),+ Mockito.mock(DockerHostResolver.class), Mockito.mock(EcrRegistryManager.class),+ config, new RegionResolver("us-east-1", "000000000000"));++ Cluster cluster = new Cluster();+ cluster.setName("my-cluster");++ manager.startCluster(cluster);++ @SuppressWarnings("unchecked")+ ArgumentCaptor<List<String>> cmdCaptor = ArgumentCaptor.forClass(List.class);+ verify(builder).withCmd(cmdCaptor.capture());+ List<String> cmd = cmdCaptor.getValue();++ if (defaultStorageClass) {+ assertFalse(cmd.contains("--disable=local-storage"));+ } else {+ assertTrue(cmd.contains("--disable=local-storage"));+ }+ }+/** Re-latching persisted clusters after a Floci/Docker restart (#2609), without a Docker daemon. */@Nestedclass RestoreCluster {@@ -461,6 +519,35 @@ class EksClusterManagerTest {verify(lifecycleManager, never()).create(any());}+ @Test+ void restoreClusterPreservesPreUpgradeLocalStorageWhenContainerSurvives() {+ when(lifecycleManager.findByName("floci-eks-demo"))+ .thenReturn(Optional.of(survivingContainer("cid-pre-upgrade")));+ when(lifecycleManager.adopt("cid-pre-upgrade", List.of(6443)))+ .thenReturn(new ContainerInfo("cid-pre-upgrade", Map.of(), Map.of(6443, 6512)));++ Cluster cluster = cluster();+ manager.restoreCluster(cluster);++ assertEquals(Boolean.TRUE, cluster.getDefaultStorageClass());+ }++ @Test+ void restoreClusterPreservesDefaultStorageClassLabelFromSurvivingContainer() {+ Container container = containerFromJson("{\"Id\":\"cid-new\","+ + "\"Labels\":{\"io.floci.eks.node-capacity\":\"m5.large:unbounded\","+ + "\"io.floci.eks.default-storage-class\":\"false\"}}");+ when(lifecycleManager.findByName("floci-eks-demo"))+ .thenReturn(Optional.of(container));+ when(lifecycleManager.adopt("cid-new", List.of(6443)))+ .thenReturn(new ContainerInfo("cid-new", Map.of(), Map.of(6443, 6512)));++ Cluster cluster = cluster();+ manager.restoreCluster(cluster);++ assertEquals(Boolean.FALSE, cluster.getDefaultStorageClass());+ }+@Testvoid recreatesAnOldSurvivorWithoutCapacityLimits() {when(lifecycleManager.findByName("floci-eks-demo"))@@ -2542,6 +2629,7 @@ class EksClusterManagerTest {List<String> args = EksClusterManager.buildServerArgs(false, "172.20.0.0/16", "10.44.0.0/16");assertTrue(args.contains("--service-cidr=172.20.0.0/16"));assertTrue(args.contains("--cluster-cidr=10.44.0.0/16"));+ assertTrue(args.contains("--disable=local-storage"));assertFalse(args.contains("--flannel-backend=none"));}@@ -2551,6 +2639,7 @@ class EksClusterManagerTest {assertTrue(args.contains("--flannel-backend=none"));assertTrue(args.contains("--disable-network-policy"));assertTrue(args.contains("--disable-kube-proxy"));+ assertTrue(args.contains("--disable=local-storage"));assertTrue(args.contains("--service-cidr=10.100.0.0/16"));assertTrue(args.contains("--cluster-cidr=10.42.0.0/16"));}diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksStorageClassDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksStorageClassDockerIntegrationTest.javanew file mode 100644index 0000000000..581d8c9b0b--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksStorageClassDockerIntegrationTest.java@@ -0,0 +1,150 @@+package io.github.hectorvent.floci.services.eks;++import com.github.dockerjava.api.DockerClient;+import io.github.hectorvent.floci.core.common.docker.ContainerExec;+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.time.Instant;+import java.util.Map;+import java.util.UUID;++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;++/**+ * Docker integration test verifying that freshly created clusters start with no StorageClass,+ * no bundled local-path provisioner, and that CoreDNS remains functional.+ */+@QuarkusTest+@TestProfile(EksStorageClassDockerIntegrationTest.Profile.class)+class EksStorageClassDockerIntegrationTest {++ private static final Logger LOG = Logger.getLogger(EksStorageClassDockerIntegrationTest.class);+ private static final String ACCOUNT = "000000000000";++ public static final class Profile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of(+ "floci.services.eks.mock", "false"+ );+ }+ }++ @Inject+ DockerClient dockerClient;++ @Inject+ EksClusterManager eksClusterManager;++ private Cluster cluster;++ @BeforeEach+ void requireDocker() {+ boolean dockerAvailable = isDockerAvailable();+ if (!dockerAvailable) {+ LOG.warn("Docker daemon is not available; skipping EksStorageClassDockerIntegrationTest");+ }+ Assumptions.assumeTrue(dockerAvailable, "Docker daemon must be available for EKS storage class integration test");+ }++ @AfterEach+ void tearDown() {+ if (cluster != null) {+ try {+ eksClusterManager.stopCluster(cluster);+ } catch (Exception e) {+ LOG.warnv("Failed to stop test cluster: {0}", e.getMessage());+ }+ }+ }++ @Test+ void clusterStartsWithoutStorageClassAndCoreDnsRemainsAvailable() throws Exception {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String clusterName = "sc-dock-" + suffix;++ cluster = new Cluster();+ cluster.setName(clusterName);+ cluster.setAccountId(ACCOUNT);+ cluster.setArn("arn:aws:eks:us-east-1:" + ACCOUNT + ":cluster/" + clusterName);+ cluster.setCreatedAt(Instant.now());+ cluster.setRoleArn("arn:aws:iam::" + ACCOUNT + ":role/eks-service-role");++ eksClusterManager.startCluster(cluster);+ assertNotNull(cluster.getContainerId(), "Container ID must not be null");++ // Wait for k3s API server readiness (up to 60s)+ long deadline = System.currentTimeMillis() + 60000;+ boolean ready = false;+ while (System.currentTimeMillis() < deadline) {+ if (eksClusterManager.isReady(cluster)) {+ ready = true;+ break;+ }+ Thread.sleep(2000);+ }+ assertTrue(ready, "k3s API server must become ready within 60 seconds");+ eksClusterManager.finalizeCluster(cluster);++ String containerId = cluster.getContainerId();++ // 1. Verify CoreDNS deployment is present and healthy in kube-system+ long corednsDeadline = System.currentTimeMillis() + 60000;+ boolean corednsRolledOut = false;+ while (System.currentTimeMillis() < corednsDeadline) {+ ContainerExec.Result rolloutResult = execInContainerWithExitCode(containerId,+ new String[]{"kubectl", "rollout", "status", "deployment/coredns", "-n", "kube-system", "--timeout=10s"});+ if (rolloutResult.exitCode() == 0) {+ corednsRolledOut = true;+ break;+ }+ Thread.sleep(2000);+ }+ assertTrue(corednsRolledOut, "CoreDNS deployment must be successfully rolled out");++ // 2. Verify CoreDNS pods are running and ready+ ContainerExec.Result podsResult = execInContainerWithExitCode(containerId,+ new String[]{"kubectl", "get", "pods", "-n", "kube-system", "-l", "k8s-app=kube-dns",+ "-o", "jsonpath={.items[*].status.phase}"});+ assertEquals(0, podsResult.exitCode(), "kubectl get pods failed: " + podsResult.stderr());+ assertTrue(podsResult.stdout().contains("Running"),+ "CoreDNS pod must be in Running phase, but got: " + podsResult.stdout());++ // 3. Verify no StorageClass exists in the cluster after manifests settle+ ContainerExec.Result scResult = execInContainerWithExitCode(containerId,+ new String[]{"kubectl", "get", "storageclass", "-o", "jsonpath={.items[*].metadata.name}"});+ assertEquals(0, scResult.exitCode(), "kubectl get storageclass failed: " + scResult.stderr());+ assertTrue(scResult.stdout().trim().isEmpty(),+ "No StorageClass should exist in newly created cluster, but found: " + scResult.stdout());++ // 4. Explicitly verify local-path StorageClass is absent+ ContainerExec.Result localPathResult = execInContainerWithExitCode(containerId,+ new String[]{"kubectl", "get", "storageclass", "local-path"});+ assertNotEquals(0, localPathResult.exitCode(), "local-path StorageClass must not exist");+ }++ private boolean isDockerAvailable() {+ try {+ dockerClient.pingCmd().exec();+ return true;+ } catch (Exception e) {+ return false;+ }+ }++ private ContainerExec.Result execInContainerWithExitCode(String containerId, String[] cmd) {+ return ContainerExec.run(dockerClient, containerId, cmd, 30).throwIfTimedOut(containerId);+ }+}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex df4d899918..f91147e5c6 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -339,6 +339,7 @@ floci:max-memory-mib: 0max-vcpus: 0ecr-registry-mirror: true+ default-storage-class: falseimds: falseirsa-signing-key: trueembedded-dns: true