Light, fluffy, and always free - The AWS Local Emulator alternative
fix(rds): apply Aurora IAM changes to existing members (#5608)
David Phillips966da1d7faac
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsClusterIamStateTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsClusterIamStateTest.javanew file mode 100644index 0000000000..6d70a9d958--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/RdsClusterIamStateTest.java@@ -0,0 +1,48 @@+package com.floci.test;++import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.rds.RdsClient;++import static org.assertj.core.api.Assertions.assertThat;++class RdsClusterIamStateTest {++ @Test+ @DisplayName("Aurora IAM authentication changes reach existing members")+ void clusterIamAuthenticationUpdatesMembers() {+ String clusterId = TestFixtures.uniqueName("sdk-iam-cluster");+ String memberId = TestFixtures.uniqueName("sdk-iam-member");+ try (RdsClient rds = TestFixtures.rdsClient()) {+ boolean clusterCreated = false;+ boolean memberCreated = false;+ try {+ rds.createDBCluster(request -> request.dbClusterIdentifier(clusterId)+ .engine("aurora-postgresql").masterUsername("admin")+ .masterUserPassword("Secret12345").enableIAMDatabaseAuthentication(false));+ clusterCreated = true;+ rds.createDBInstance(request -> request.dbInstanceIdentifier(memberId)+ .dbClusterIdentifier(clusterId).dbInstanceClass("db.r5.large")+ .engine("aurora-postgresql"));+ memberCreated = true;+ for (boolean enabled : new boolean[] {true, false}) {+ assertThat(rds.modifyDBCluster(request -> request.dbClusterIdentifier(clusterId)+ .enableIAMDatabaseAuthentication(enabled).applyImmediately(true))+ .dbCluster().iamDatabaseAuthenticationEnabled()).isEqualTo(enabled);+ assertThat(rds.describeDBInstances(request -> request.dbInstanceIdentifier(memberId))+ .dbInstances().get(0).iamDatabaseAuthenticationEnabled()).isEqualTo(enabled);+ }+ } finally {+ try {+ if (memberCreated) {+ rds.deleteDBInstance(request -> request.dbInstanceIdentifier(memberId).skipFinalSnapshot(true));+ }+ } finally {+ if (clusterCreated) {+ rds.deleteDBCluster(request -> request.dbClusterIdentifier(clusterId).skipFinalSnapshot(true));+ }+ }+ }+ }+ }+}diff --git a/docs/services/rds.md b/docs/services/rds.mdindex 9b96f3cd6f..a3c3f38861 100644--- a/docs/services/rds.md+++ b/docs/services/rds.md@@ -748,6 +748,12 @@ The RDS auth proxy validates the master username and password at the proxy layerIAM database authentication is also supported. Set `--enable-iam-database-authentication` at instance creation time and use `aws rds generate-db-auth-token` to obtain a token.+Changing `EnableIAMDatabaseAuthentication` with `ModifyDBCluster` updates existing+Aurora members and applies to new connections through the cluster and member+endpoints. Omitting the flag preserves the current setting. Existing connections+are not disconnected.++A token can be signed with an access key or with temporary credentials: an assumed role's, or the execution role credentials Floci hands a Lambda function. A token signed with temporary credentials carries their session token in `X-Amz-Security-Token`, and it is accepted while that session is valid and only with the session token issued alongside the access key.On RDS, a token is only good for the endpoint it was generated for: the hostname, port and region passed to `generate-db-auth-token` are the ones the instance (or cluster, or RDS Proxy) publishes. MySQL and MariaDB endpoints in Floci always refuse a token generated for another endpoint. PostgreSQL endpoints do the same by default; set `FLOCI_SERVICES_RDS_IAM_TOKEN_ENDPOINT_BINDING=false` to accept a token generated for another name, for clients that generate tokens for a container name or DNS alias the endpoint does not publish. Either way, the username must match the `DBUser` in the token exactly. Because clients on the host reach the same proxy over the loopback interface, a token generated for `localhost` or `127.0.0.1` on the published port is accepted as well. Clients on a Docker network connect by Floci's container name, so set `FLOCI_SERVICES_RDS_ENDPOINT_HOST` to that name (see [Docker Compose](#docker-compose)) so it is what the endpoint publishes and tokens are generated for. With [IAM enforcement](iam.md#iam-enforcement-mode) turned on, the token's principal must also be allowed `rds-db:connect` on the database user, scoped the way AWS scopes it:diff --git a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.javaindex a2fe670bf5..2d45881e57 100644--- a/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/rds/RdsService.java@@ -86,6 +86,7 @@ import java.util.Optional;import java.util.Set;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;+import java.util.function.Consumer;import java.util.function.Predicate;import java.util.regex.Matcher;import java.util.regex.Pattern;@@ -4665,23 +4666,34 @@ public class RdsService implements Resettable, ResourceProvider {if (passwordRotated) {proxyManager.updateMasterPassword(rdsResourceRelayKey(cluster.getDbClusterArn(), id), newPassword);- for (String memberId : cluster.getDbClusterMembers()) {- DbInstance member = findInstanceForScope(- currentAccountId(), effectiveRegion, memberId);- if (member == null) {- continue;- }- member.setMasterPassword(newPassword);- putInstanceForScope(currentAccountId(), effectiveRegion, memberId, member);- proxyManager.updateMasterPassword(- rdsResourceRelayKey(member.getDbInstanceArn(), memberId), newPassword);- }+ updateClusterMembers(cluster, effectiveRegion,+ member -> member.setMasterPassword(newPassword),+ relayKey -> proxyManager.updateMasterPassword(relayKey, newPassword));+ }++ if (iamEnabled != null) {+ proxyManager.updateIamEnabled(rdsResourceRelayKey(cluster.getDbClusterArn(), id), iamEnabled);+ updateClusterMembers(cluster, effectiveRegion,+ member -> member.setIamDatabaseAuthenticationEnabled(iamEnabled),+ relayKey -> proxyManager.updateIamEnabled(relayKey, iamEnabled));}LOG.infov("DB cluster {0} modified", id);return cluster;}+ private void updateClusterMembers(DbCluster cluster, String region,+ Consumer<DbInstance> change, Consumer<String> updateProxy) {+ String accountId = currentAccountId();+ for (DbInstance member : listDbInstances(null, region)) {+ if (Objects.equals(cluster.getDbClusterIdentifier(), member.getDbClusterIdentifier())) {+ change.accept(member);+ putInstanceForScope(accountId, region, member.getDbInstanceIdentifier(), member);+ updateProxy.accept(rdsResourceRelayKey(member.getDbInstanceArn(), member.getDbInstanceIdentifier()));+ }+ }+ }+public synchronized void deleteDbCluster(String id) {deleteDbCluster(id, regionResolver.getDefaultRegion());}diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsIamAuthLambdaSessionIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsIamAuthLambdaSessionIntegrationTest.javaindex d42dee4545..1c31779744 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsIamAuthLambdaSessionIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsIamAuthLambdaSessionIntegrationTest.java@@ -110,6 +110,79 @@ class RdsIamAuthLambdaSessionIntegrationTest {}}+ @Test+ void clusterIamToggleChangesAuthenticationAtExistingClusterAndMemberEndpoints() throws Exception {+ String suffix = Long.toString(System.nanoTime(), 36);+ String clusterId = "iam-cluster-" + suffix;+ String memberId = "iam-member-" + suffix;+ String accessKeyId = "ASIA" + suffix.toUpperCase();+ try {+ int clusterPort = rds("CreateDBCluster")+ .formParam("DBClusterIdentifier", clusterId)+ .formParam("Engine", "aurora-postgresql")+ .formParam("MasterUsername", MASTER_USER)+ .formParam("MasterUserPassword", MASTER_PASSWORD)+ .formParam("DatabaseName", DATABASE)+ .formParam("EnableIAMDatabaseAuthentication", "false")+ .when().post("/").then().statusCode(200)+ .extract().xmlPath()+ .getInt("CreateDBClusterResponse.CreateDBClusterResult.DBCluster.Port");+ int memberPort = rds("CreateDBInstance")+ .formParam("DBInstanceIdentifier", memberId)+ .formParam("DBClusterIdentifier", clusterId)+ .formParam("DBInstanceClass", "db.r5.large")+ .formParam("Engine", "aurora-postgresql")+ .formParam("MasterUsername", MASTER_USER)+ .formParam("MasterUserPassword", MASTER_PASSWORD)+ .formParam("DBName", DATABASE)+ .formParam("AllocatedStorage", "20")+ .when().post("/").then().statusCode(200)+ .extract().xmlPath()+ .getInt("CreateDBInstanceResponse.CreateDBInstanceResult.DBInstance.Endpoint.Port");+ iamService.registerLambdaExecutionRoleSession(ACCOUNT_ID, accessKeyId, SESSION_SECRET, SESSION_TOKEN,+ "arn:aws:iam::" + ACCOUNT_ID + ":role/cluster-connect-with-iam");+ for (int port : new int[]{clusterPort, memberPort}) {+ await().atMost(Duration.ofSeconds(60)).ignoreExceptions().until(() -> {+ try (Connection connection = connect(port, MASTER_PASSWORD)) {+ return connection.isValid(5);+ }+ });+ String token = SigV4TokenTestHelper.createRdsToken("127.0.0.1", port, MASTER_USER,+ accessKeyId, SESSION_SECRET, Instant.now().minusSeconds(60), 900, SESSION_TOKEN);+ assertThrows(SQLException.class, () -> connect(port, token).close());+ }+ for (boolean enabled : new boolean[]{true, false}) {+ rds("ModifyDBCluster")+ .formParam("DBClusterIdentifier", clusterId)+ .formParam("EnableIAMDatabaseAuthentication", Boolean.toString(enabled))+ .when().post("/").then().statusCode(200);+ for (int port : new int[]{clusterPort, memberPort}) {+ String token = SigV4TokenTestHelper.createRdsToken("127.0.0.1", port, MASTER_USER,+ accessKeyId, SESSION_SECRET, Instant.now().minusSeconds(60), 900, SESSION_TOKEN);+ if (enabled) {+ try (Connection connection = connect(port, token);+ Statement statement = connection.createStatement();+ ResultSet rows = statement.executeQuery("SELECT current_user")) {+ assertTrue(rows.next());+ assertEquals(MASTER_USER, rows.getString(1));+ }+ } else {+ assertThrows(SQLException.class, () -> connect(port, token).close());+ }+ try (Connection connection = connect(port, MASTER_PASSWORD)) {+ assertTrue(connection.isValid(5));+ }+ }+ }+ } finally {+ iamService.unregisterSession(ACCOUNT_ID, accessKeyId);+ rds("DeleteDBInstance").formParam("DBInstanceIdentifier", memberId)+ .formParam("SkipFinalSnapshot", "true").when().post("/");+ rds("DeleteDBCluster").formParam("DBClusterIdentifier", clusterId)+ .formParam("SkipFinalSnapshot", "true").when().post("/");+ }+ }+private static Connection connect(int port, String password) throws SQLException {Properties properties = new Properties();properties.setProperty("user", MASTER_USER);diff --git a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.javaindex eb3200a143..91d6204306 100644--- a/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/rds/RdsServiceTest.java@@ -94,6 +94,7 @@ import static org.mockito.Mockito.spy;import static org.mockito.Mockito.times;import static org.mockito.Mockito.verify;import static org.mockito.Mockito.verifyNoInteractions;+import static org.mockito.Mockito.verifyNoMoreInteractions;import static org.mockito.Mockito.when;class RdsServiceTest {@@ -352,6 +353,108 @@ class RdsServiceTest {}}+ @ParameterizedTest+ @CsvSource({"aurora-postgresql,16.3,false", "aurora-mysql,8.0,false",+ "aurora-postgresql,16.3,true", "aurora-mysql,8.0,true"})+ void modifyClusterIamAuthenticationUpdatesExistingMembers(String engine, String version, boolean mockMode) {+ when(rdsConfig.mock()).thenReturn(mockMode);+ DbCluster cluster = rdsService.createDbCluster("iam-cluster", engine, version,+ "admin", "password", "dbname", false, null);+ DbInstance member = rdsService.createDbInstance("iam-member", engine, version,+ "admin", "password", "dbname", "db.r5.large",+ 20, false, null, null, "iam-cluster", null, false, false, null,+ Map.of(), List.of(), null, null, true, DbInstanceSettings.defaults());+ cluster.getDbClusterMembers().add("missing-member");+ clearInvocations(proxyManager);++ for (boolean enabled : List.of(true, false)) {+ rdsService.modifyDbCluster("iam-cluster", null, enabled);++ assertEquals(enabled, rdsService.getDbCluster("iam-cluster").isIamDatabaseAuthenticationEnabled());+ assertEquals(enabled, rdsService.getDbInstance("iam-member").isIamDatabaseAuthenticationEnabled());+ verify(proxyManager).updateIamEnabled("rds-resource:" + cluster.getDbClusterArn(), enabled);+ verify(proxyManager).updateIamEnabled("rds-resource:" + member.getDbInstanceArn(), enabled);+ clearInvocations(proxyManager);+ rdsService.modifyDbCluster("iam-cluster", null, null);+ assertEquals(enabled, rdsService.getDbInstance("iam-member").isIamDatabaseAuthenticationEnabled());+ verifyNoInteractions(proxyManager);+ }+ }++ @ParameterizedTest+ @CsvSource({"aurora-postgresql,16.3,false", "aurora-mysql,8.0,false",+ "aurora-postgresql,16.3,true", "aurora-mysql,8.0,true"})+ void modifyClusterIamAuthenticationFindsMembersMissingFromClusterList(+ String engine, String version, boolean mockMode) {+ when(rdsConfig.mock()).thenReturn(mockMode);+ DbCluster cluster = rdsService.createDbCluster("iam-cluster", engine, version,+ "admin", "password", "dbname", false, null);+ DbInstance member = rdsService.createDbInstance("iam-member", engine, version,+ "admin", "password", "dbname", "db.r5.large",+ 20, false, null, null, "iam-cluster", null, false, false, null,+ Map.of(), List.of(), null, null, true, DbInstanceSettings.defaults());+ rdsService.createDbInstance("standalone", engine, version,+ "admin", "password", "dbname", "db.r5.large",+ 20, false, null, null, null);+ cluster.getDbClusterMembers().clear();+ clearInvocations(proxyManager);++ for (boolean enabled : List.of(true, false)) {+ rdsService.modifyDbCluster("iam-cluster", null, enabled);++ assertEquals(enabled, rdsService.getDbInstance("iam-member").isIamDatabaseAuthenticationEnabled());+ assertFalse(rdsService.getDbInstance("standalone").isIamDatabaseAuthenticationEnabled());+ verify(proxyManager).updateIamEnabled("rds-resource:" + cluster.getDbClusterArn(), enabled);+ verify(proxyManager).updateIamEnabled("rds-resource:" + member.getDbInstanceArn(), enabled);+ verifyNoMoreInteractions(proxyManager);+ clearInvocations(proxyManager);+ }+ }++ @Test+ void modifyClusterIamAuthenticationKeepsOtherAccountsAndRegionsUnchanged() {+ InMemoryStorage<String, DbInstance> rawInstances = new InMemoryStorage<>();+ InMemoryStorage<String, DbCluster> rawClusters = new InMemoryStorage<>();+ String accountA = "111111111111";+ String accountB = "222222222222";+ RdsService serviceA = new RdsService(containerManager, proxyManager, ec2Service,+ new RegionResolver("us-east-1", accountA), config,+ new AccountAwareStorageBackend<>(rawInstances, null, accountA),+ new AccountAwareStorageBackend<>(rawClusters, null, accountA),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>());+ RdsService serviceB = new RdsService(containerManager, proxyManager, ec2Service,+ new RegionResolver("us-east-1", accountB), config,+ new AccountAwareStorageBackend<>(rawInstances, null, accountB),+ new AccountAwareStorageBackend<>(rawClusters, null, accountB),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>());+ for (RdsService service : List.of(serviceA, serviceB)) {+ for (String region : List.of("us-east-1", "us-west-2")) {+ service.createDbCluster("shared-cluster", "aurora-postgresql", "16.3",+ "admin", "password", "dbname", false, null, null, null, false, region);+ service.createDbInstance("shared-member", "aurora-postgresql", "16.3",+ "admin", "password", "dbname", "db.r5.large", 20, false, null, null,+ "shared-cluster", null, false, false, null, Map.of(), List.of(), region);+ }+ }+ clearInvocations(proxyManager);++ serviceA.modifyDbCluster("shared-cluster", null, true, "us-east-1");++ for (String account : List.of(accountA, accountB)) {+ for (String region : List.of("us-east-1", "us-west-2")) {+ boolean enabled = account.equals(accountA) && region.equals("us-east-1");+ DbCluster cluster = rawClusters.get(account + "/" + region + "::shared-cluster").orElseThrow();+ DbInstance member = rawInstances.get(account + "/" + region + "::shared-member").orElseThrow();+ assertEquals(enabled, cluster.isIamDatabaseAuthenticationEnabled());+ assertEquals(enabled, member.isIamDatabaseAuthenticationEnabled());+ verify(proxyManager, times(enabled ? 1 : 0))+ .updateIamEnabled("rds-resource:" + cluster.getDbClusterArn(), true);+ verify(proxyManager, times(enabled ? 1 : 0))+ .updateIamEnabled("rds-resource:" + member.getDbInstanceArn(), true);+ }+ }+ }+@Testvoid createDbInstanceLeavesPostgresIamTokensUnboundWhenTheBindingIsTurnedOff() {when(rdsConfig.iamTokenEndpointBinding()).thenReturn(false);@@ -2062,6 +2165,31 @@ class RdsServiceTest {verify(proxyManager, never()).stopProxy(anyString());}+ @Test+ void modifyDbClusterUpdatesPasswordAndIamTogetherForExistingMembers() {+ DbCluster cluster = rdsService.createDbCluster("cluster1", "aurora-postgresql", "16.3",+ "admin", "original-password", "dbname", false, null);+ cluster.setContainerId("container-1");+ cluster.setDockerVolumeName("volume-1");+ DbInstance member = rdsService.createDbInstance("member-1", "aurora-postgresql", "16.3",+ "admin", "original-password", "dbname", "db.r5.large",+ 20, false, null, null, "cluster1");+ cluster.getDbClusterMembers().add("missing-member");+ cluster.getDbClusterMembers().clear();+ clearInvocations(proxyManager);++ rdsService.modifyDbCluster("cluster1", "rotated-password", true);++ DbInstance stored = rdsService.getDbInstance("member-1");+ assertEquals("rotated-password", stored.getMasterPassword());+ assertTrue(stored.isIamDatabaseAuthenticationEnabled());+ verify(proxyManager).updateMasterPassword("rds-resource:" + cluster.getDbClusterArn(), "rotated-password");+ verify(proxyManager).updateMasterPassword("rds-resource:" + member.getDbInstanceArn(), "rotated-password");+ verify(proxyManager).updateIamEnabled("rds-resource:" + cluster.getDbClusterArn(), true);+ verify(proxyManager).updateIamEnabled("rds-resource:" + member.getDbInstanceArn(), true);+ verifyNoMoreInteractions(proxyManager);+ }+@Testvoid modifyDbClusterSamePasswordDoesNotTouchBackendOrProxy() {DbCluster cluster = rdsService.createDbCluster("cluster1", "aurora-postgresql", "16.3",