Light, fluffy, and always free - The AWS Local Emulator alternative
fix(eks): store and return encryptionConfig and logging on clusters (#4007)
Simone Primarosaaede31c99c10
diff --git a/docs/services/eks.md b/docs/services/eks.mdindex 13cb29fd5e..586f3bc8e4 100644--- a/docs/services/eks.md+++ b/docs/services/eks.md@@ -100,6 +100,56 @@ Floci tags the cluster security group with the standard AWS system tags:- **Backfill**: Existing persisted clusters that were created before this feature receive an auto-generated cluster security group during startup backfill if their VPC is present.- **Rules**: In accordance with AWS EKS behavior, the cluster security group includes a self-referencing inbound rule allowing all traffic from members of the same security group to enable control plane and node communication, a self-referencing outbound rule for Elastic Fabric Adapter (EFA) traffic, and the standard EC2 outbound rule.+## Encryption and logging configuration++EKS clusters support configuring KMS envelope encryption for secrets and control plane logging export.++### Encryption configuration++`CreateCluster` accepts an `encryptionConfig` array specifying the encryption provider for Kubernetes resources:++```json+{+ "encryptionConfig": [+ {+ "resources": ["secrets"],+ "provider": {+ "keyArn": "arn:aws:kms:us-east-1:000000000000:key/12345678-1234-1234-1234-123456789012"+ }+ }+ ]+}+```++- **Supported resources**: Only `["secrets"]` is supported by AWS EKS. Specifying any other resource or leaving resources empty causes `InvalidParameterException` (HTTP 400).+- **Provider**: `provider.keyArn` must be non-empty.+- **Cardinality**: AWS allows at most one encryption configuration entry. Specifying more than one causes `InvalidParameterException` (HTTP 400).+- **Omission**: When omitted at creation time, `encryptionConfig` is not populated and is omitted from `DescribeCluster` responses (null or omitted, no synthetic default).+- **Scope**: Floci stores and returns the encryption configuration faithfully. Envelope encryption of Secrets at the Kubernetes storage layer and KMS cryptographic operations are out of scope.++### Logging configuration++`CreateCluster` accepts control plane logging configuration in `logging.clusterLogging`:++```json+{+ "logging": {+ "clusterLogging": [+ {+ "types": ["api", "audit"],+ "enabled": true+ }+ ]+ }+}+```++- **Supported log types**: The valid EKS log types are `api`, `audit`, `authenticator`, `controllerManager`, and `scheduler`. Specifying an unrecognized type causes `InvalidParameterException` (HTTP 400).+- **Response normalization**: AWS EKS always returns the status of all five log types. Enabled types are returned first (`enabled: true`), followed by disabled types (`enabled: false`).+- **Default logging**: When omitted or empty at creation time, Floci returns all five log types disabled in a single entry (`enabled: false`).+- **Backfill**: Existing persisted clusters created before this feature was introduced are automatically backfilled on startup with default disabled logging.+- **Scope**: Floci stores and returns control plane logging configuration. Shipping log streams to Amazon CloudWatch Logs log groups is out of scope.+## Modes### Mock mode (`mock: true`)@@ -565,5 +615,4 @@ The following EKS features are not yet supported:- `UpdateClusterConfig` / `UpdateClusterVersion`- Add-ons (`CreateAddon`, `DescribeAddon`, `ListAddons`)- Identity provider configs-- Access entries and policies-- Encryption config+- Access policiesdiff --git a/src/main/java/io/github/hectorvent/floci/services/eks/EksService.java b/src/main/java/io/github/hectorvent/floci/services/eks/EksService.javaindex 27ddc6386c..c6b91b9d98 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/EksService.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/EksService.java@@ -19,16 +19,20 @@ import io.github.hectorvent.floci.services.eks.model.Cluster;import io.github.hectorvent.floci.services.eks.model.AccessConfig;import io.github.hectorvent.floci.services.eks.model.ClusterIdentity;import io.github.hectorvent.floci.services.eks.model.ClusterStatus;-import io.github.hectorvent.floci.services.eks.model.OidcIdentity;import io.github.hectorvent.floci.services.eks.model.CreateClusterRequest;import io.github.hectorvent.floci.services.eks.model.CreateFargateProfileRequest;import io.github.hectorvent.floci.services.eks.model.CreateNodeGroupRequest;+import io.github.hectorvent.floci.services.eks.model.EncryptionConfig;import io.github.hectorvent.floci.services.eks.model.FargateProfile;import io.github.hectorvent.floci.services.eks.model.FargateProfileStatus;import io.github.hectorvent.floci.services.eks.model.KubernetesNetworkConfig;+import io.github.hectorvent.floci.services.eks.model.LogSetup;+import io.github.hectorvent.floci.services.eks.model.Logging;import io.github.hectorvent.floci.services.eks.model.Nodegroup;import io.github.hectorvent.floci.services.eks.model.NodegroupScalingConfig;import io.github.hectorvent.floci.services.eks.model.NodegroupStatus;+import io.github.hectorvent.floci.services.eks.model.OidcIdentity;+import io.github.hectorvent.floci.services.eks.model.Provider;import io.github.hectorvent.floci.services.eks.model.ResourcesVpcConfig;import com.fasterxml.jackson.core.type.TypeReference;import jakarta.annotation.PostConstruct;@@ -40,8 +44,10 @@ import org.jboss.logging.Logger;import java.time.Instant;import java.util.ArrayList;import java.util.HashMap;+import java.util.HashSet;import java.util.HexFormat;import java.util.LinkedHashMap;+import java.util.LinkedHashSet;import java.util.List;import java.util.Map;import java.util.Optional;@@ -61,6 +67,10 @@ public class EksService implements TagHandler, ResourceProvider {private static final Logger LOG = Logger.getLogger(EksService.class);+ private static final List<String> ALL_LOG_TYPES = List.of(+ "api", "audit", "authenticator", "controllerManager", "scheduler"+ );+/** The AWS charset for EKS cluster names. It admits no dot, which the Docker-name account* qualifier relies on — see EksClusterManager#accountQualifiedName. */static final String CLUSTER_NAME_REGEX = "[0-9A-Za-z][A-Za-z0-9\\-_]*";@@ -104,6 +114,7 @@ public class EksService implements TagHandler, ResourceProvider {public void init() {backfillOidcIdentities();backfillClusterSecurityGroups();+ backfillLogging();if (!config.services().eks().mock()) {restorePersistedClusters();startReadinessPoller();@@ -323,6 +334,23 @@ public class EksService implements TagHandler, ResourceProvider {}}+ void backfillLogging() {+ for (AccountAwareStorageBackend.AccountEntry<Cluster> entry : allClusterEntries()) {+ Cluster cluster = entry.value();+ if (cluster.getLogging() != null) {+ continue;+ }+ String accountId = entry.accountId();+ if (cluster.getAccountId() == null) {+ cluster.setAccountId(accountId);+ }+ cluster.setLogging(defaultLogging());+ putClusterForAccount(accountId, cluster);+ LOG.infov("Backfilled default logging for existing EKS cluster {0} in account {1}",+ cluster.getName(), accountId);+ }+ }+private String resolveClusterRegion(Cluster cluster) {if (cluster.getArn() != null && !cluster.getArn().isBlank()) {try {@@ -408,6 +436,8 @@ public class EksService implements TagHandler, ResourceProvider {}cluster.setResourcesVpcConfig(vpcConfig);cluster.setKubernetesNetworkConfig(buildNetworkConfig(request.getKubernetesNetworkConfig()));+ cluster.setLogging(buildLogging(request.getLogging()));+ cluster.setEncryptionConfig(buildEncryptionConfig(request.getEncryptionConfig()));cluster.setStatus(ClusterStatus.CREATING);cluster.setTags(request.getTags() != null ? new HashMap<>(request.getTags()) : new HashMap<>());cluster.setPlatformVersion("eks.1");@@ -467,9 +497,13 @@ public class EksService implements TagHandler, ResourceProvider {}public Cluster describeCluster(String name) {- return storage.get(name)+ Cluster cluster = storage.get(name).orElseThrow(() -> new AwsException("ResourceNotFoundException","No cluster found for name: " + name, 404));+ if (cluster.getLogging() == null) {+ cluster.setLogging(defaultLogging());+ }+ return cluster;}public List<String> listClusters() {@@ -783,6 +817,81 @@ public class EksService implements TagHandler, ResourceProvider {return config;}+ static Logging defaultLogging() {+ return new Logging(List.of(new LogSetup(new ArrayList<>(ALL_LOG_TYPES), false)));+ }++ private Logging buildLogging(Logging requestedLogging) {+ if (requestedLogging == null || requestedLogging.getClusterLogging() == null+ || requestedLogging.getClusterLogging().isEmpty()) {+ return defaultLogging();+ }++ Set<String> enabledTypes = new LinkedHashSet<>();+ Set<String> specifiedTypes = new HashSet<>();++ for (LogSetup setup : requestedLogging.getClusterLogging()) {+ if (setup == null || setup.getTypes() == null) {+ continue;+ }+ for (String type : setup.getTypes()) {+ if (!ALL_LOG_TYPES.contains(type)) {+ throw new AwsException("InvalidParameterException",+ "'" + type + "' is not a valid log type", 400);+ }+ specifiedTypes.add(type);+ if (Boolean.TRUE.equals(setup.getEnabled())) {+ enabledTypes.add(type);+ } else {+ enabledTypes.remove(type);+ }+ }+ }++ if (specifiedTypes.isEmpty()) {+ return defaultLogging();+ }++ List<String> enabledList = ALL_LOG_TYPES.stream()+ .filter(enabledTypes::contains)+ .collect(Collectors.toList());+ List<String> disabledList = ALL_LOG_TYPES.stream()+ .filter(t -> !enabledTypes.contains(t))+ .collect(Collectors.toList());++ List<LogSetup> entries = new ArrayList<>();+ if (!enabledList.isEmpty()) {+ entries.add(new LogSetup(enabledList, true));+ }+ if (!disabledList.isEmpty()) {+ entries.add(new LogSetup(disabledList, false));+ }++ return new Logging(entries);+ }++ private List<EncryptionConfig> buildEncryptionConfig(List<EncryptionConfig> requestedConfigs) {+ if (requestedConfigs == null || requestedConfigs.isEmpty()) {+ return null;+ }+ if (requestedConfigs.size() > 1) {+ throw new AwsException("InvalidParameterException",+ "Only one encryption configuration is allowed", 400);+ }+ EncryptionConfig config = requestedConfigs.getFirst();+ if (config == null || config.getResources() == null || config.getResources().isEmpty()+ || !List.of("secrets").equals(config.getResources())) {+ throw new AwsException("InvalidParameterException",+ "Invalid k8s resource and provider for encryption", 400);+ }+ if (config.getProvider() == null || config.getProvider().getKeyArn() == null+ || config.getProvider().getKeyArn().isBlank()) {+ throw new AwsException("InvalidParameterException",+ "Invalid k8s resource and provider for encryption", 400);+ }+ return List.of(new EncryptionConfig(List.of("secrets"), new Provider(config.getProvider().getKeyArn())));+ }+private String nodeGroupKey(String clusterName, String nodegroupName) {return clusterName + "/" + nodegroupName;}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 42a4c05a63..08da352b36 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@@ -3,10 +3,12 @@ package io.github.hectorvent.floci.services.eks.model;import com.fasterxml.jackson.annotation.JsonFormat;import com.fasterxml.jackson.annotation.JsonIgnore;import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonInclude;import com.fasterxml.jackson.annotation.JsonProperty;import io.quarkus.runtime.annotations.RegisterForReflection;import java.time.Instant;+import java.util.List;import java.util.Map;@RegisterForReflection@@ -38,6 +40,13 @@ public class Cluster {@JsonProperty("kubernetesNetworkConfig")private KubernetesNetworkConfig kubernetesNetworkConfig;+ @JsonProperty("logging")+ private Logging logging;++ @JsonProperty("encryptionConfig")+ @JsonInclude(JsonInclude.Include.NON_EMPTY)+ private List<EncryptionConfig> encryptionConfig;+@JsonProperty("status")private ClusterStatus status;@@ -131,6 +140,12 @@ public class Cluster {public int getHostPort() { return hostPort; }public void setHostPort(int hostPort) { this.hostPort = hostPort; }+ public Logging getLogging() { return logging; }+ public void setLogging(Logging logging) { this.logging = logging; }++ public List<EncryptionConfig> getEncryptionConfig() { return encryptionConfig; }+ public void setEncryptionConfig(List<EncryptionConfig> encryptionConfig) { this.encryptionConfig = encryptionConfig; }+public String getDockerName() { return dockerName; }public void setDockerName(String dockerName) { this.dockerName = dockerName; }}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/CreateClusterRequest.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/CreateClusterRequest.javaindex e67debeca0..ece677f390 100644--- a/src/main/java/io/github/hectorvent/floci/services/eks/model/CreateClusterRequest.java+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/CreateClusterRequest.java@@ -4,6 +4,7 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties;import com.fasterxml.jackson.annotation.JsonProperty;import io.quarkus.runtime.annotations.RegisterForReflection;+import java.util.List;import java.util.Map;@RegisterForReflection@@ -25,6 +26,12 @@ public class CreateClusterRequest {@JsonProperty("kubernetesNetworkConfig")private KubernetesNetworkConfig kubernetesNetworkConfig;+ @JsonProperty("encryptionConfig")+ private List<EncryptionConfig> encryptionConfig;++ @JsonProperty("logging")+ private Logging logging;+@JsonProperty("tags")private Map<String, String> tags;@@ -56,6 +63,12 @@ public class CreateClusterRequest {public Map<String, String> getTags() { return tags; }public void setTags(Map<String, String> tags) { this.tags = tags; }+ public List<EncryptionConfig> getEncryptionConfig() { return encryptionConfig; }+ public void setEncryptionConfig(List<EncryptionConfig> encryptionConfig) { this.encryptionConfig = encryptionConfig; }++ public Logging getLogging() { return logging; }+ public void setLogging(Logging logging) { this.logging = logging; }+public String getClientRequestToken() { return clientRequestToken; }public void setClientRequestToken(String clientRequestToken) { this.clientRequestToken = clientRequestToken; }}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/EncryptionConfig.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/EncryptionConfig.javanew file mode 100644index 0000000000..85e9c45aff--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/EncryptionConfig.java@@ -0,0 +1,59 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonProperty;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;+import java.util.Objects;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class EncryptionConfig {++ @JsonProperty("resources")+ private List<String> resources;++ @JsonProperty("provider")+ private Provider provider;++ public EncryptionConfig() {}++ public EncryptionConfig(List<String> resources, Provider provider) {+ this.resources = resources;+ this.provider = provider;+ }++ public List<String> getResources() {+ return resources;+ }++ public void setResources(List<String> resources) {+ this.resources = resources;+ }++ public Provider getProvider() {+ return provider;+ }++ public void setProvider(Provider provider) {+ this.provider = provider;+ }++ @Override+ public boolean equals(Object o) {+ if (this == o) {+ return true;+ }+ if (o == null || getClass() != o.getClass()) {+ return false;+ }+ EncryptionConfig that = (EncryptionConfig) o;+ return Objects.equals(resources, that.resources) && Objects.equals(provider, that.provider);+ }++ @Override+ public int hashCode() {+ return Objects.hash(resources, provider);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/LogSetup.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/LogSetup.javanew file mode 100644index 0000000000..c9c1b44988--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/LogSetup.java@@ -0,0 +1,59 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonProperty;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;+import java.util.Objects;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class LogSetup {++ @JsonProperty("types")+ private List<String> types;++ @JsonProperty("enabled")+ private Boolean enabled;++ public LogSetup() {}++ public LogSetup(List<String> types, Boolean enabled) {+ this.types = types;+ this.enabled = enabled;+ }++ public List<String> getTypes() {+ return types;+ }++ public void setTypes(List<String> types) {+ this.types = types;+ }++ public Boolean getEnabled() {+ return enabled;+ }++ public void setEnabled(Boolean enabled) {+ this.enabled = enabled;+ }++ @Override+ public boolean equals(Object o) {+ if (this == o) {+ return true;+ }+ if (o == null || getClass() != o.getClass()) {+ return false;+ }+ LogSetup logSetup = (LogSetup) o;+ return Objects.equals(types, logSetup.types) && Objects.equals(enabled, logSetup.enabled);+ }++ @Override+ public int hashCode() {+ return Objects.hash(types, enabled);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/Logging.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/Logging.javanew file mode 100644index 0000000000..b032976145--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/Logging.java@@ -0,0 +1,47 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonProperty;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;+import java.util.Objects;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class Logging {++ @JsonProperty("clusterLogging")+ private List<LogSetup> clusterLogging;++ public Logging() {}++ public Logging(List<LogSetup> clusterLogging) {+ this.clusterLogging = clusterLogging;+ }++ public List<LogSetup> getClusterLogging() {+ return clusterLogging;+ }++ public void setClusterLogging(List<LogSetup> clusterLogging) {+ this.clusterLogging = clusterLogging;+ }++ @Override+ public boolean equals(Object o) {+ if (this == o) {+ return true;+ }+ if (o == null || getClass() != o.getClass()) {+ return false;+ }+ Logging logging = (Logging) o;+ return Objects.equals(clusterLogging, logging.clusterLogging);+ }++ @Override+ public int hashCode() {+ return Objects.hash(clusterLogging);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/eks/model/Provider.java b/src/main/java/io/github/hectorvent/floci/services/eks/model/Provider.javanew file mode 100644index 0000000000..2963734cb5--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/eks/model/Provider.java@@ -0,0 +1,46 @@+package io.github.hectorvent.floci.services.eks.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import com.fasterxml.jackson.annotation.JsonProperty;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.Objects;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class Provider {++ @JsonProperty("keyArn")+ private String keyArn;++ public Provider() {}++ public Provider(String keyArn) {+ this.keyArn = keyArn;+ }++ public String getKeyArn() {+ return keyArn;+ }++ public void setKeyArn(String keyArn) {+ this.keyArn = keyArn;+ }++ @Override+ public boolean equals(Object o) {+ if (this == o) {+ return true;+ }+ if (o == null || getClass() != o.getClass()) {+ return false;+ }+ Provider provider = (Provider) o;+ return Objects.equals(keyArn, provider.keyArn);+ }++ @Override+ public int hashCode() {+ return Objects.hash(keyArn);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksEncryptionLoggingIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksEncryptionLoggingIntegrationTest.javanew file mode 100644index 0000000000..bf7fb4cef6--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksEncryptionLoggingIntegrationTest.java@@ -0,0 +1,185 @@+package io.github.hectorvent.floci.services.eks;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsInAnyOrder;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasSize;+import static org.hamcrest.Matchers.nullValue;++@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class EksEncryptionLoggingIntegrationTest {++ private static final String JSON = "application/json";+ private static final String CLUSTER_WITH_ENC_LOG = "it-enc-log-cluster";+ private static final String CLUSTER_DEFAULT = "it-default-enc-log-cluster";+ private static final String KMS_KEY_ARN =+ "arn:aws:kms:us-east-1:000000000000:key/12345678-1234-1234-1234-123456789012";++ @Test+ @Order(1)+ void createClusterWithEncryptionConfigAndLoggingReturnsBothInWireResponse() {+ String payload = "{"+ + "\"name\":\"" + CLUSTER_WITH_ENC_LOG + "\","+ + "\"roleArn\":\"arn:aws:iam::000000000000:role/eks-role\","+ + "\"encryptionConfig\":[{"+ + " \"resources\":[\"secrets\"],"+ + " \"provider\":{\"keyArn\":\"" + KMS_KEY_ARN + "\"}"+ + "}],"+ + "\"logging\":{"+ + " \"clusterLogging\":[{"+ + " \"types\":[\"api\",\"audit\"],"+ + " \"enabled\":true"+ + " }]"+ + "}"+ + "}";++ given().contentType(JSON)+ .body(payload)+ .when().post("/clusters")+ .then().statusCode(200)+ .body("cluster.name", equalTo(CLUSTER_WITH_ENC_LOG))+ .body("cluster.encryptionConfig", hasSize(1))+ .body("cluster.encryptionConfig[0].resources", hasSize(1))+ .body("cluster.encryptionConfig[0].resources[0]", equalTo("secrets"))+ .body("cluster.encryptionConfig[0].provider.keyArn", equalTo(KMS_KEY_ARN))+ .body("cluster.logging.clusterLogging", hasSize(2))+ .body("cluster.logging.clusterLogging[0].enabled", equalTo(true))+ .body("cluster.logging.clusterLogging[0].types", containsInAnyOrder("api", "audit"))+ .body("cluster.logging.clusterLogging[1].enabled", equalTo(false))+ .body("cluster.logging.clusterLogging[1].types", containsInAnyOrder("authenticator", "controllerManager", "scheduler"));+ }++ @Test+ @Order(2)+ void describeClusterReturnsEncryptionConfigAndLoggingInWireResponse() {+ given().contentType(JSON)+ .when().get("/clusters/" + CLUSTER_WITH_ENC_LOG)+ .then().statusCode(200)+ .body("cluster.name", equalTo(CLUSTER_WITH_ENC_LOG))+ .body("cluster.encryptionConfig", hasSize(1))+ .body("cluster.encryptionConfig[0].resources", hasSize(1))+ .body("cluster.encryptionConfig[0].resources[0]", equalTo("secrets"))+ .body("cluster.encryptionConfig[0].provider.keyArn", equalTo(KMS_KEY_ARN))+ .body("cluster.logging.clusterLogging", hasSize(2))+ .body("cluster.logging.clusterLogging[0].enabled", equalTo(true))+ .body("cluster.logging.clusterLogging[0].types", containsInAnyOrder("api", "audit"))+ .body("cluster.logging.clusterLogging[1].enabled", equalTo(false))+ .body("cluster.logging.clusterLogging[1].types", containsInAnyOrder("authenticator", "controllerManager", "scheduler"));+ }++ @Test+ @Order(3)+ void deleteClusterWithEncryptionAndLoggingCleansUp() {+ given().contentType(JSON)+ .when().delete("/clusters/" + CLUSTER_WITH_ENC_LOG)+ .then().statusCode(200);+ }++ @Test+ @Order(4)+ void createClusterWithoutEncryptionConfigOrLoggingOmitsEncryptionConfigAndPopulatesDefaultLogging() {+ String payload = "{"+ + "\"name\":\"" + CLUSTER_DEFAULT + "\","+ + "\"roleArn\":\"arn:aws:iam::000000000000:role/eks-role\""+ + "}";++ given().contentType(JSON)+ .body(payload)+ .when().post("/clusters")+ .then().statusCode(200)+ .body("cluster.name", equalTo(CLUSTER_DEFAULT))+ .body("cluster.encryptionConfig", nullValue())+ .body("cluster.logging.clusterLogging", hasSize(1))+ .body("cluster.logging.clusterLogging[0].enabled", equalTo(false))+ .body("cluster.logging.clusterLogging[0].types",+ containsInAnyOrder("api", "audit", "authenticator", "controllerManager", "scheduler"));+ }++ @Test+ @Order(5)+ void describeClusterWithoutEncryptionConfigOmitsEncryptionConfigAndReturnsDefaultLogging() {+ given().contentType(JSON)+ .when().get("/clusters/" + CLUSTER_DEFAULT)+ .then().statusCode(200)+ .body("cluster.name", equalTo(CLUSTER_DEFAULT))+ .body("cluster.encryptionConfig", nullValue())+ .body("cluster.logging.clusterLogging", hasSize(1))+ .body("cluster.logging.clusterLogging[0].enabled", equalTo(false))+ .body("cluster.logging.clusterLogging[0].types",+ containsInAnyOrder("api", "audit", "authenticator", "controllerManager", "scheduler"));+ }++ @Test+ @Order(6)+ void deleteClusterDefaultCleansUp() {+ given().contentType(JSON)+ .when().delete("/clusters/" + CLUSTER_DEFAULT)+ .then().statusCode(200);+ }++ @Test+ @Order(7)+ void createClusterWithInvalidLogTypeReturns400() {+ String payload = "{"+ + "\"name\":\"it-invalid-log\","+ + "\"roleArn\":\"arn:aws:iam::000000000000:role/eks-role\","+ + "\"logging\":{"+ + " \"clusterLogging\":[{"+ + " \"types\":[\"invalidLogType\"],"+ + " \"enabled\":true"+ + " }]"+ + "}"+ + "}";++ given().contentType(JSON)+ .body(payload)+ .when().post("/clusters")+ .then().statusCode(400)+ .body("message", equalTo("'invalidLogType' is not a valid log type"));+ }++ @Test+ @Order(8)+ void createClusterWithInvalidEncryptionResourcesReturns400() {+ String payload = "{"+ + "\"name\":\"it-invalid-enc-res\","+ + "\"roleArn\":\"arn:aws:iam::000000000000:role/eks-role\","+ + "\"encryptionConfig\":[{"+ + " \"resources\":[\"configmaps\"],"+ + " \"provider\":{\"keyArn\":\"" + KMS_KEY_ARN + "\"}"+ + "}]"+ + "}";++ given().contentType(JSON)+ .body(payload)+ .when().post("/clusters")+ .then().statusCode(400)+ .body("message", equalTo("Invalid k8s resource and provider for encryption"));+ }++ @Test+ @Order(9)+ void createClusterWithMissingEncryptionKeyArnReturns400() {+ String payload = "{"+ + "\"name\":\"it-invalid-enc-key\","+ + "\"roleArn\":\"arn:aws:iam::000000000000:role/eks-role\","+ + "\"encryptionConfig\":[{"+ + " \"resources\":[\"secrets\"],"+ + " \"provider\":{\"keyArn\":\"\"}"+ + "}]"+ + "}";++ given().contentType(JSON)+ .body(payload)+ .when().post("/clusters")+ .then().statusCode(400)+ .body("message", equalTo("Invalid k8s resource and provider for encryption"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/eks/EksServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/eks/EksServiceTest.javaindex 3859201232..0c692476d9 100644--- a/src/test/java/io/github/hectorvent/floci/services/eks/EksServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/eks/EksServiceTest.java@@ -23,12 +23,16 @@ import io.github.hectorvent.floci.services.eks.model.OidcIdentity;import io.github.hectorvent.floci.services.eks.model.CreateClusterRequest;import io.github.hectorvent.floci.services.eks.model.CreateFargateProfileRequest;import io.github.hectorvent.floci.services.eks.model.CreateNodeGroupRequest;+import io.github.hectorvent.floci.services.eks.model.EncryptionConfig;import io.github.hectorvent.floci.services.eks.model.FargateProfile;import io.github.hectorvent.floci.services.eks.model.FargateProfileStatus;import io.github.hectorvent.floci.services.eks.model.Cluster;+import io.github.hectorvent.floci.services.eks.model.LogSetup;+import io.github.hectorvent.floci.services.eks.model.Logging;import io.github.hectorvent.floci.services.eks.model.Nodegroup;import io.github.hectorvent.floci.services.eks.model.NodegroupScalingConfig;import io.github.hectorvent.floci.services.eks.model.NodegroupStatus;+import io.github.hectorvent.floci.services.eks.model.Provider;import io.github.hectorvent.floci.services.eks.model.ResourcesVpcConfig;import com.fasterxml.jackson.core.type.TypeReference;import com.fasterxml.jackson.databind.ObjectMapper;@@ -1518,4 +1522,229 @@ class EksServiceTest {boolean leaked = allSgs.stream().anyMatch(sg -> sg.getGroupName().startsWith("eks-cluster-sg-cluster-tag-fail-"));assertFalse(leaked, "Cluster security group should have been deleted when tagging failed");}++ private CreateClusterRequest createTestClusterRequest(String name) {+ CreateClusterRequest req = new CreateClusterRequest();+ req.setName(name);+ req.setRoleArn("arn:aws:iam::000000000000:role/eks-role");+ req.setVersion("1.29");+ return req;+ }++ @Test+ void createClusterWithEncryptionConfigAndLogging() {+ CreateClusterRequest req = createTestClusterRequest("enc-log-cluster");+ req.setEncryptionConfig(List.of(+ new EncryptionConfig(List.of("secrets"), new Provider("arn:aws:kms:us-east-1:000000000000:key/12345678-1234-1234-1234-123456789012"))+ ));+ req.setLogging(new Logging(List.of(+ new LogSetup(List.of("api", "audit"), true),+ new LogSetup(List.of("authenticator", "controllerManager", "scheduler"), false)+ )));++ Cluster created = eksService.createCluster(req);+ assertNotNull(created.getEncryptionConfig());+ assertEquals(1, created.getEncryptionConfig().size());+ assertEquals(List.of("secrets"), created.getEncryptionConfig().getFirst().getResources());+ assertEquals("arn:aws:kms:us-east-1:000000000000:key/12345678-1234-1234-1234-123456789012",+ created.getEncryptionConfig().getFirst().getProvider().getKeyArn());++ assertNotNull(created.getLogging());+ List<LogSetup> logSetups = created.getLogging().getClusterLogging();+ assertEquals(2, logSetups.size());+ assertEquals(List.of("api", "audit"), logSetups.get(0).getTypes());+ assertTrue(logSetups.get(0).getEnabled());+ assertEquals(List.of("authenticator", "controllerManager", "scheduler"), logSetups.get(1).getTypes());+ assertFalse(logSetups.get(1).getEnabled());++ Cluster described = eksService.describeCluster("enc-log-cluster");+ assertEquals(created.getEncryptionConfig(), described.getEncryptionConfig());+ assertEquals(created.getLogging(), described.getLogging());+ }++ @Test+ void createClusterWithoutEncryptionConfigOrLoggingUsesDefaults() {+ CreateClusterRequest req = createTestClusterRequest("default-cluster");++ Cluster created = eksService.createCluster(req);+ assertNull(created.getEncryptionConfig());++ assertNotNull(created.getLogging());+ List<LogSetup> logSetups = created.getLogging().getClusterLogging();+ assertEquals(1, logSetups.size());+ assertEquals(List.of("api", "audit", "authenticator", "controllerManager", "scheduler"),+ logSetups.getFirst().getTypes());+ assertFalse(logSetups.getFirst().getEnabled());++ Cluster described = eksService.describeCluster("default-cluster");+ assertNull(described.getEncryptionConfig());+ assertNotNull(described.getLogging());+ assertEquals(logSetups, described.getLogging().getClusterLogging());+ }++ @Test+ void createClusterWithPartiallyEnabledLoggingSplitsEntries() {+ CreateClusterRequest req = createTestClusterRequest("partial-log-cluster");+ req.setLogging(new Logging(List.of(+ new LogSetup(List.of("authenticator", "api"), true)+ )));++ Cluster created = eksService.createCluster(req);+ assertNotNull(created.getLogging());+ List<LogSetup> logSetups = created.getLogging().getClusterLogging();+ assertEquals(2, logSetups.size());+ assertEquals(List.of("api", "authenticator"), logSetups.get(0).getTypes());+ assertTrue(logSetups.get(0).getEnabled());+ assertEquals(List.of("audit", "controllerManager", "scheduler"), logSetups.get(1).getTypes());+ assertFalse(logSetups.get(1).getEnabled());+ }++ @Test+ void createClusterWithInvalidLogTypeThrowsInvalidParameterException() {+ CreateClusterRequest req = createTestClusterRequest("invalid-log-cluster");+ req.setLogging(new Logging(List.of(+ new LogSetup(List.of("nonexistentLogType"), true)+ )));++ AwsException ex = assertThrows(AwsException.class, () -> eksService.createCluster(req));+ assertEquals("InvalidParameterException", ex.getErrorCode());+ assertEquals(400, ex.getHttpStatus());+ }++ @Test+ void createClusterWithInvalidEncryptionResourcesThrowsInvalidParameterException() {+ CreateClusterRequest req1 = createTestClusterRequest("invalid-enc-res-1");+ req1.setEncryptionConfig(List.of(+ new EncryptionConfig(List.of("configmaps"), new Provider("arn:aws:kms:us-east-1:000000000000:key/12345678"))+ ));+ AwsException ex1 = assertThrows(AwsException.class, () -> eksService.createCluster(req1));+ assertEquals("InvalidParameterException", ex1.getErrorCode());+ assertEquals(400, ex1.getHttpStatus());++ CreateClusterRequest req2 = createTestClusterRequest("invalid-enc-res-2");+ req2.setEncryptionConfig(List.of(+ new EncryptionConfig(List.of("Secrets"), new Provider("arn:aws:kms:us-east-1:000000000000:key/12345678"))+ ));+ AwsException ex2 = assertThrows(AwsException.class, () -> eksService.createCluster(req2));+ assertEquals("InvalidParameterException", ex2.getErrorCode());+ assertEquals(400, ex2.getHttpStatus());+ }++ @Test+ void createClusterWithMultipleEncryptionConfigsThrowsInvalidParameterException() {+ CreateClusterRequest req = createTestClusterRequest("multiple-enc-cluster");+ req.setEncryptionConfig(List.of(+ new EncryptionConfig(List.of("secrets"), new Provider("arn:aws:kms:us-east-1:000000000000:key/1")),+ new EncryptionConfig(List.of("secrets"), new Provider("arn:aws:kms:us-east-1:000000000000:key/2"))+ ));+ AwsException ex = assertThrows(AwsException.class, () -> eksService.createCluster(req));+ assertEquals("InvalidParameterException", ex.getErrorCode());+ assertEquals(400, ex.getHttpStatus());+ }++ @Test+ void createClusterWithMissingEncryptionKeyArnThrowsInvalidParameterException() {+ CreateClusterRequest req1 = createTestClusterRequest("missing-keyarn-1");+ req1.setEncryptionConfig(List.of(+ new EncryptionConfig(List.of("secrets"), null)+ ));+ AwsException ex1 = assertThrows(AwsException.class, () -> eksService.createCluster(req1));+ assertEquals("InvalidParameterException", ex1.getErrorCode());+ assertEquals(400, ex1.getHttpStatus());++ CreateClusterRequest req2 = createTestClusterRequest("missing-keyarn-2");+ req2.setEncryptionConfig(List.of(+ new EncryptionConfig(List.of("secrets"), new Provider(""))+ ));+ AwsException ex2 = assertThrows(AwsException.class, () -> eksService.createCluster(req2));+ assertEquals("InvalidParameterException", ex2.getErrorCode());+ assertEquals(400, ex2.getHttpStatus());+ }++ @Test+ void backfillLoggingPopulatesDefaultLoggingForPreExistingClusters() {+ StorageBackend<String, Cluster> rawClusters = new InMemoryStorage<>();+ AccountAwareStorageBackend<Cluster> clusterStore =+ new AccountAwareStorageBackend<>(rawClusters, null, "000000000000");++ Cluster legacyCluster = new Cluster();+ legacyCluster.setName("legacy-eks");+ legacyCluster.setArn("arn:aws:eks:us-east-1:000000000000:cluster/legacy-eks");+ legacyCluster.setAccountId("000000000000");+ legacyCluster.setStatus(ClusterStatus.ACTIVE);+ legacyCluster.setLogging(null);+ legacyCluster.setEncryptionConfig(null);+ clusterStore.putForAccount("000000000000", "legacy-eks", legacyCluster);++ StorageFactory storageFactory = fixedStorageFactory(clusterStore);+ RegionResolver regionResolver = new RegionResolver("us-east-1", "000000000000");+ EksService service = new EksService(storageFactory, testConfig(true), regionResolver, null,+ realEc2Service(), new EksOidcService(fixedStorageFactory(new InMemoryStorage<String, ClusterOidcKey>()), new ObjectMapper()), mock(EksAccessEntryService.class));++ assertDoesNotThrow(service::init);++ Cluster described = service.describeCluster("legacy-eks");+ assertNotNull(described.getLogging());+ assertEquals(1, described.getLogging().getClusterLogging().size());+ assertEquals(List.of("api", "audit", "authenticator", "controllerManager", "scheduler"),+ described.getLogging().getClusterLogging().getFirst().getTypes());+ assertFalse(described.getLogging().getClusterLogging().getFirst().getEnabled());+ assertNull(described.getEncryptionConfig());+ }++ @Test+ void backfillLoggingPreservesExistingLogging() {+ StorageBackend<String, Cluster> rawClusters = new InMemoryStorage<>();+ AccountAwareStorageBackend<Cluster> clusterStore =+ new AccountAwareStorageBackend<>(rawClusters, null, "000000000000");++ Cluster existingCluster = new Cluster();+ existingCluster.setName("custom-logging-eks");+ existingCluster.setArn("arn:aws:eks:us-east-1:000000000000:cluster/custom-logging-eks");+ existingCluster.setAccountId("000000000000");+ existingCluster.setStatus(ClusterStatus.ACTIVE);+ Logging customLogging = new Logging(List.of(new LogSetup(List.of("api"), true)));+ existingCluster.setLogging(customLogging);+ clusterStore.putForAccount("000000000000", "custom-logging-eks", existingCluster);++ StorageFactory storageFactory = fixedStorageFactory(clusterStore);+ RegionResolver regionResolver = new RegionResolver("us-east-1", "000000000000");+ EksService service = new EksService(storageFactory, testConfig(true), regionResolver, null,+ realEc2Service(), new EksOidcService(fixedStorageFactory(new InMemoryStorage<String, ClusterOidcKey>()), new ObjectMapper()), mock(EksAccessEntryService.class));++ assertDoesNotThrow(service::init);++ Cluster described = service.describeCluster("custom-logging-eks");+ assertEquals(customLogging, described.getLogging());+ }++ @Test+ void restartRoundTripPreservesEncryptionConfigAndLogging() {+ StorageBackend<String, Cluster> rawClusters = new InMemoryStorage<>();+ AccountAwareStorageBackend<Cluster> clusterStore =+ new AccountAwareStorageBackend<>(rawClusters, null, "000000000000");+ StorageFactory storageFactory = fixedStorageFactory(clusterStore);+ RegionResolver regionResolver = new RegionResolver("us-east-1", "000000000000");++ EksService service1 = new EksService(storageFactory, testConfig(true), regionResolver, null,+ realEc2Service(), new EksOidcService(fixedStorageFactory(new InMemoryStorage<String, ClusterOidcKey>()), new ObjectMapper()), mock(EksAccessEntryService.class));+ service1.init();++ CreateClusterRequest req = createTestClusterRequest("restart-cluster");+ req.setEncryptionConfig(List.of(+ new EncryptionConfig(List.of("secrets"), new Provider("arn:aws:kms:us-east-1:000000000000:key/persist-key"))+ ));+ req.setLogging(new Logging(List.of(+ new LogSetup(List.of("api", "audit"), true)+ )));+ Cluster created = service1.createCluster(req);++ EksService service2 = new EksService(storageFactory, testConfig(true), regionResolver, null,+ realEc2Service(), new EksOidcService(fixedStorageFactory(new InMemoryStorage<String, ClusterOidcKey>()), new ObjectMapper()), mock(EksAccessEntryService.class));+ service2.init();++ Cluster described = service2.describeCluster("restart-cluster");+ assertEquals(created.getEncryptionConfig(), described.getEncryptionConfig());+ assertEquals(created.getLogging(), described.getLogging());+ }}