Aws Sdk Java V2 Rds

AWS SDK for Java v2 - RDS Management

Overview

This skill provides comprehensive guidance for working with Amazon RDS (Relational Database Service) using the AWS SDK for Java 2.x, covering database instance management, snapshots, parameter groups, and RDS operations.

When to Use

• Creating, modifying, or deleting RDS database instances
• Managing DB snapshots, parameter groups, and configurations
• Setting up Multi-AZ deployments and automated backups
• Connecting Lambda functions to RDS databases
• Monitoring instance status and performance

Instructions

Follow these steps to work with Amazon RDS:

1. Add Dependencies - Include AWS RDS SDK dependency and database drivers 2. Create RDS Client - Instantiate RdsClient with proper region and credentials 3. Create DB Instance - Use createDBInstance() with appropriate configuration 4. Configure Security - Set up VPC security groups and encryption 5. Set Up Backups - Configure automated backup windows and retention 6. Monitor Status - Use describeDBInstances() to check instance state 7. Create Snapshots - Take manual snapshots before major changes 8. Handle Failover - Configure Multi-AZ for high availability

Getting Started

RDS Client Setup

The RdsClient is the main entry point for interacting with Amazon RDS.

Basic Client Creation:

import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rds.RdsClient;

RdsClient rdsClient = RdsClient.builder()
    .region(Region.US_EAST_1)
    .build();

// Use client
describeInstances(rdsClient);

// Always close the client
rdsClient.close();

Client with Custom Configuration:

import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.http.apache.ApacheHttpClient;

RdsClient rdsClient = RdsClient.builder()
    .region(Region.US_WEST_2)
    .credentialsProvider(ProfileCredentialsProvider.create("myprofile"))
    .httpClient(ApacheHttpClient.builder()
        .connectionTimeout(Duration.ofSeconds(30))
        .socketTimeout(Duration.ofSeconds(60))
        .build())
    .build();

Describing DB Instances

DescribeDbInstancesResponse response = rdsClient.describeDBInstances();
for (DBInstance instance : response.dbInstances()) {
    System.out.println(instance.dbInstanceArn() + " - " + instance.dbInstanceStatus());
}

Key Operations

Creating DB Instances

CreateDbInstanceRequest request = CreateDbInstanceRequest.builder()
    .dbInstanceIdentifier(dbInstanceIdentifier)
    .dbName(dbName)
    .engine("postgres")
    .engineVersion("15.4")
    .dbInstanceClass("db.t3.micro")
    .allocatedStorage(20)
    .masterUsername(masterUsername)
    .masterUserPassword(masterPassword)
    .publiclyAccessible(false)
    .build();

CreateDbInstanceResponse response = rdsClient.createDBInstance(request);

// VALIDATION CHECKPOINT: Wait for instance to be available
rdsClient.waiter().waitUntilDBInstanceAvailable(
    DescribeDbInstancesRequest.builder().dbInstanceIdentifier(dbInstanceIdentifier).build()
);
System.out.println("Instance " + dbInstanceIdentifier + " is available!");

Managing DB Parameter Groups

CreateDbParameterGroupRequest request = CreateDbParameterGroupRequest.builder()
    .dbParameterGroupName(groupName)
    .dbParameterGroupFamily("postgres15")
    .description(description)
    .build();
rdsClient.createDBParameterGroup(request);

Managing DB Snapshots

CreateDbSnapshotRequest request = CreateDbSnapshotRequest.builder()
    .dbInstanceIdentifier(dbInstanceIdentifier)
    .dbSnapshotIdentifier(snapshotIdentifier)
    .build();
CreateDbSnapshotResponse response = rdsClient.createDBSnapshot(request);

Integration Patterns

Spring Boot Integration

Refer to references/spring-boot-integration.md for complete Spring Boot integration examples including:

• Spring Boot configuration with application properties
• RDS client bean configuration
• Service layer implementation
• REST controller design
• Exception handling
• Testing strategies

Lambda Integration

Refer to references/lambda-integration.md for Lambda integration examples including:

• Traditional Lambda + RDS connections
• Lambda with connection pooling
• Using AWS Secrets Manager for credentials
• Lambda with AWS SDK for RDS management
• Security configuration and best practices

Advanced Operations

Modifying DB Instances

ModifyDbInstanceRequest request = ModifyDbInstanceRequest.builder()
    .dbInstanceIdentifier(dbInstanceIdentifier)
    .dbInstanceClass(newInstanceClass)
    .applyImmediately(false)
    .build();
rdsClient.modifyDBInstance(request);

Deleting DB Instances

// VALIDATION CHECKPOINT: Verify instance exists and check status
DBInstance instance = rdsClient.describeDBInstances(
    DescribeDbInstancesRequest.builder().dbInstanceIdentifier(dbInstanceIdentifier).build()
).dbInstances().get(0);

if ("available".equals(instance.dbInstanceStatus())) {
    DeleteDbInstanceRequest request = DeleteDbInstanceRequest.builder()
        .dbInstanceIdentifier(dbInstanceIdentifier)
        .skipFinalSnapshot(false)
        .finalDBSnapshotIdentifier(snapshotId)
        .build();
    rdsClient.deleteDBInstance(request);
}

Examples

Complete RDS Instance Creation with Validation

public String createSecurePostgreSQLInstance(RdsClient rdsClient,
                                            String instanceIdentifier,
                                            String dbName,
                                            String masterUsername,
                                            String masterPassword,
                                            String vpcSecurityGroupId) {
    // Create instance with security settings
    CreateDbInstanceRequest request = CreateDbInstanceRequest.builder()
        .dbInstanceIdentifier(instanceIdentifier)
        .dbName(dbName)
        .masterUsername(masterUsername)
        .masterUserPassword(masterPassword)
        .engine("postgres")
        .engineVersion("15.4")
        .dbInstanceClass("db.t3.micro")
        .allocatedStorage(20)
        .storageEncrypted(true)
        .vpcSecurityGroupIds(vpcSecurityGroupId)
        .publiclyAccessible(false)
        .multiAZ(true)
        .backupRetentionPeriod(7)
        .deletionProtection(true)
        .build();

    rdsClient.createDBInstance(request);

    // VALIDATION: Wait for instance availability
    rdsClient.waiter().waitUntilDBInstanceAvailable(
        DescribeDbInstancesRequest.builder().dbInstanceIdentifier(instanceIdentifier).build()
    );
    System.out.println("Instance " + instanceIdentifier + " is available!");
    return instanceIdentifier;
}

Best Practices

Security: Enable encryption (storageEncrypted=true), use VPC security groups, disable public access.

High Availability: Enable Multi-AZ for production workloads.

Backups: Configure automated backups with 7+ day retention.

Deletion Protection: Enable deletionProtection(true) for production databases.

Resource Management: Always close clients with try-with-resources:

try (RdsClient rdsClient = RdsClient.builder().region(Region.US_EAST_1).build()) {
    // Use client
}

Dependencies

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>rds</artifactId>
    <version>2.20.0</version>
</dependency>
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.6.0</version>
</dependency>

Reference Documentation

For detailed API reference, see:

• API Reference - Complete API documentation and data models
• Spring Boot Integration - Spring Boot patterns and examples
• Lambda Integration - Lambda function patterns and best practices

Error Handling

See API Reference for comprehensive error handling patterns including common exceptions, error response structure, and pagination support.

Constraints and Warnings

• Instance Limits: Account limits on DB instances per region
• Multi-AZ Costs: Approximately doubles compute costs
• Snapshot Costs: Manual snapshots billed per storage used
• Deletion Protection: Cannot delete instances with protection enabled
• Maintenance Windows: Instances may be unavailable during updates

AWS RDS API Reference

Core API Operations

Describe Operations

• describeDBInstances - List database instances
• describeDBParameterGroups - List parameter groups
• describeDBSnapshots - List database snapshots
• describeDBSubnetGroups - List subnet groups

Instance Management

• createDBInstance - Create new database instance
• modifyDBInstance - Modify existing instance
• deleteDBInstance - Delete database instance

Parameter Groups

• createDBParameterGroup - Create parameter group
• modifyDBParameterGroup - Modify parameters
• deleteDBParameterGroup - Delete parameter group

Snapshots

• createDBSnapshot - Create database snapshot
• restoreDBInstanceFromDBSnapshot - Restore from snapshot
• deleteDBSnapshot - Delete snapshot

Key Data Models

DBInstance

String dbInstanceIdentifier()          // Instance name
String dbInstanceArn()                // ARN identifier
String engine()                        // Database engine
String engineVersion()                // Engine version
String dbInstanceClass()              // Instance type
int allocatedStorage()                 // Storage size in GB
Endpoint endpoint()                   // Connection endpoint
String dbInstanceStatus()             // Instance status
boolean multiAZ()                     // Multi-AZ enabled
boolean storageEncrypted()            // Storage encrypted

DBParameter

String parameterName()                // Parameter name
String parameterValue()               // Parameter value
String description()                 // Description
int applyMethod()                     // Apply method (immediate/reboot)

CreateDbInstanceRequest Builder

CreateDbInstanceRequest.builder()
    .dbInstanceIdentifier(identifier)
    .engine("postgres")                 // Database engine
    .engineVersion("15.2")             // Engine version
    .dbInstanceClass("db.t3.micro")    // Instance type
    .allocatedStorage(20)               // Storage size
    .masterUsername(username)          // Admin username
    .masterUserPassword(password)      // Admin password
    .publiclyAccessible(false)         // Public access
    .storageEncrypted(true)           // Storage encryption
    .multiAZ(true)                    // High availability
    .backupRetentionPeriod(7)          // Backup retention
    .deletionProtection(true)         // Protection from deletion
    .build()

Error Handling

Common Exceptions

• DBInstanceNotFoundFault - Instance doesn't exist
• DBSnapshotAlreadyExistsFault - Snapshot name conflicts
• InsufficientDBInstanceCapacity - Instance type unavailable
• InvalidParameterValueException - Invalid configuration value
• StorageQuotaExceeded - Storage limit reached

Error Response Structure

try {
    rdsClient.createDBInstance(request);
} catch (RdsException e) {
    // AWS specific error handling
    String errorCode = e.awsErrorDetails().errorCode();
    String errorMessage = e.awsErrorDetails().errorMessage();

    switch (errorCode) {
        case "DBInstanceNotFoundFault":
            // Handle missing instance
            break;
        case "InvalidParameterValueException":
            // Handle invalid parameters
            break;
        default:
            // Generic error handling
    }
}

Pagination Support

List Instances with Pagination

DescribeDbInstancesRequest request = DescribeDbInstancesRequest.builder()
    .maxResults(100)                   // Limit results per page
    .build();

String marker = null;
do {
    if (marker != null) {
        request = request.toBuilder()
            .marker(marker)
            .build();
    }

    DescribeDbInstancesResponse response = rdsClient.describeDBInstances(request);
    List<DBInstance> instances = response.dbInstances();

    // Process instances

    marker = response.marker();
} while (marker != null);

AWS Lambda Integration with RDS

Lambda RDS Connection Patterns

1. Traditional Lambda + RDS Connection

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class RdsLambdaHandler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {

    @Override
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent event, Context context) {
        APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();

        try {
            // Get environment variables
            String host = System.getenv("ProxyHostName");
            String port = System.getenv("Port");
            String dbName = System.getenv("DBName");
            String username = System.getenv("DBUserName");
            String password = System.getenv("DBPassword");

            // Create connection string
            String connectionString = String.format(
                "jdbc:mysql://%s:%s/%s?useSSL=true&requireSSL=true",
                host, port, dbName
            );

            // Execute query
            String sql = "SELECT COUNT(*) FROM users";

            try (Connection connection = DriverManager.getConnection(connectionString, username, password);
                 PreparedStatement statement = connection.prepareStatement(sql);
                 ResultSet resultSet = statement.executeQuery()) {

                if (resultSet.next()) {
                    int count = resultSet.getInt(1);
                    response.setStatusCode(200);
                    response.setBody("{\"count\": " + count + "}");
                }
            }
        } catch (Exception e) {
            response.setStatusCode(500);
            response.setBody("{\"error\": \"" + e.getMessage() + "\"}");
        }

        return response;
    }
}

2. Lambda with Connection Pooling

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class RdsLambdaConfig {

    private static DataSource dataSource;

    public static synchronized DataSource getDataSource() {
        if (dataSource == null) {
            HikariConfig config = new HikariConfig();

            String host = System.getenv("ProxyHostName");
            String port = System.getenv("Port");
            String dbName = System.getenv("DBName");
            String username = System.getenv("DBUserName");
            String password = System.getenv("DBPassword");

            config.setJdbcUrl(String.format("jdbc:mysql://%s:%s/%s", host, port, dbName));
            config.setUsername(username);
            config.setPassword(password);

            // Connection pool settings
            config.setMaximumPoolSize(5);
            config.setMinimumIdle(2);
            config.setIdleTimeout(30000);
            config.setConnectionTimeout(20000);
            config.setMaxLifetime(1800000);

            // MySQL-specific settings
            config.addDataSourceProperty("useSSL", true);
            config.addDataSourceProperty("requireSSL", true);
            config.addDataSourceProperty("serverSslCertificate", "rds-ca-2019");
            config.addDataSourceProperty("connectTimeout", "30");

            dataSource = new HikariDataSource(config);
        }
        return dataSource;
    }
}

3. Using AWS Secrets Manager for Credentials

import com.amazonaws.services.secretsmanager.AWSSecretsManager;
import com.amazonaws.services.secretsmanager.AWSSecretsManagerClientBuilder;
import com.amazonaws.services.secretsmanager.model.GetSecretValueRequest;
import com.amazonaws.services.secretsmanager.model.GetSecretValueResult;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

public class RdsSecretsHelper {

    private static final String SECRET_NAME = "prod/rds/db_credentials";
    private static final String REGION = "us-east-1";

    public static Map<String, String> getRdsCredentials() {
        AWSSecretsManager client = AWSSecretsManagerClientBuilder.standard()
            .withRegion(REGION)
            .build();

        GetSecretValueRequest request = GetSecretValueRequest.builder()
            .secretId(SECRET_NAME)
            .build();

        GetSecretValueResult result = client.getSecretValue(request);

        // Parse secret JSON
        ObjectMapper objectMapper = new ObjectMapper();
        Map<String, Object> secretMap = objectMapper.readValue(result.getSecretString(), HashMap.class);

        Map<String, String> credentials = new HashMap<>();
        secretMap.forEach((key, value) -> {
            credentials.put(key, value.toString());
        });

        return credentials;
    }
}

4. Lambda with AWS SDK for RDS

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rds.RdsClient;
import software.amazon.awssdk.services.rds.model.*;

public class RdsManagementLambda implements RequestHandler<ApiRequest, ApiResponse> {

    @Override
    public ApiResponse handleRequest(ApiRequest request, Context context) {
        RdsClient rdsClient = RdsClient.builder()
            .region(Region.US_EAST_1)
            .build();

        try {
            switch (request.getAction()) {
                case "list-instances":
                    return listInstances(rdsClient);
                case "create-snapshot":
                    return createSnapshot(rdsClient, request.getInstanceId(), request.getSnapshotId());
                case "describe-instance":
                    return describeInstance(rdsClient, request.getInstanceId());
                default:
                    return new ApiResponse(400, "Unknown action: " + request.getAction());
            }
        } catch (Exception e) {
            context.getLogger().log("Error: " + e.getMessage());
            return new ApiResponse(500, "Error: " + e.getMessage());
        } finally {
            rdsClient.close();
        }
    }

    private ApiResponse listInstances(RdsClient rdsClient) {
        DescribeDbInstancesResponse response = rdsClient.describeDBInstances();
        return new ApiResponse(200, response.toString());
    }

    private ApiResponse createSnapshot(RdsClient rdsClient, String instanceId, String snapshotId) {
        CreateDbSnapshotRequest request = CreateDbSnapshotRequest.builder()
            .dbInstanceIdentifier(instanceId)
            .dbSnapshotIdentifier(snapshotId)
            .build();

        CreateDbSnapshotResponse response = rdsClient.createDBSnapshot(request);
        return new ApiResponse(200, "Snapshot created: " + response.dbSnapshot().dbSnapshotIdentifier());
    }

    private ApiResponse describeInstance(RdsClient rdsClient, String instanceId) {
        DescribeDbInstancesRequest request = DescribeDbInstancesRequest.builder()
            .dbInstanceIdentifier(instanceId)
            .build();

        DescribeDbInstancesResponse response = rdsClient.describeDBInstances(request);
        return new ApiResponse(200, response.toString());
    }
}

class ApiRequest {
    private String action;
    private String instanceId;
    private String snapshotId;
    // getters and setters
}

class ApiResponse {
    private int statusCode;
    private String body;
    // constructor, getters
}

Best Practices for Lambda + RDS

1. Security Configuration

IAM Role:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "rds:*"
      ],
      "Resource": "*"
    }
  ]
}

Security Group:

• Use security groups to restrict access
• Only allow Lambda function IP ranges
• Use VPC endpoints for private connections

2. Environment Variables

# Environment variables for Lambda
DB_HOST=mydb.abc123.us-east-1.rds.amazonaws.com
DB_PORT=5432
DB_NAME=mydatabase
DB_USERNAME=admin
DB_PASSWORD=${DB_PASSWORD}
DB_CONNECTION_STRING=jdbc:postgresql://${DB_HOST}:${DB_PORT}/${DB_NAME}

3. Error Handling

import com.amazonaws.services.lambda.runtime.LambdaLogger;

public class LambdaErrorHandler {

    public static void handleRdsError(Exception e, LambdaLogger logger) {
        if (e instanceof RdsException) {
            RdsException rdsException = (RdsException) e;
            logger.log("RDS Error: " + rdsException.awsErrorDetails().errorCode());

            switch (rdsException.awsErrorDetails().errorCode()) {
                case "DBInstanceNotFoundFault":
                    logger.log("Database instance not found");
                    break;
                case "InvalidParameterValueException":
                    logger.log("Invalid parameter provided");
                    break;
                case "InstanceAlreadyExistsFault":
                    logger.log("Instance already exists");
                    break;
                default:
                    logger.log("Unknown RDS error: " + rdsException.getMessage());
            }
        } else {
            logger.log("Non-RDS error: " + e.getMessage());
        }
    }
}

4. Performance Optimization

Cold Start Mitigation:

import javax.sql.DataSource;
import java.sql.Connection;

public class RdsConnectionHelper {
    private static DataSource dataSource;
    private static long lastConnectionTime = 0;
    private static final long CONNECTION_TIMEOUT = 300000; // 5 minutes

    public static Connection getConnection() throws SQLException {
        long currentTime = System.currentTimeMillis();

        if (dataSource == null || (currentTime - lastConnectionTime) > CONNECTION_TIMEOUT) {
            dataSource = createDataSource();
            lastConnectionTime = currentTime;
        }

        return dataSource.getConnection();
    }

    private static DataSource createDataSource() {
        // Connection pool creation
    }
}

Batch Processing:

public class RdsBatchProcessor {

    public void processBatch(List<String> userIds) {
        String sql = "SELECT * FROM users WHERE user_id IN (?)";

        try (Connection connection = getConnection();
             PreparedStatement statement = connection.prepareStatement(sql)) {

            // Convert list to SQL IN clause
            String placeholders = userIds.stream()
                .map(id -> "?")
                .collect(Collectors.joining(","));

            String finalSql = sql.replace("?", placeholders);

            // Set parameters
            for (int i = 0; i < userIds.size(); i++) {
                statement.setString(i + 1, userIds.get(i));
            }

            ResultSet resultSet = statement.executeQuery();
            // Process results

        } catch (SQLException e) {
            LambdaErrorHandler.handleRdsError(e, logger);
        }
    }
}

5. Monitoring and Logging

import com.amazonaws.services.cloudwatch.AmazonCloudWatch;
import com.amazonaws.services.cloudwatch.AmazonCloudWatchClientBuilder;
import com.amazonaws.services.cloudwatch.model.MetricDatum;
import com.amazonaws.services.cloudwatch.model.PutMetricDataRequest;

public class RdsMetricsPublisher {

    private static final String NAMESPACE = "RDS/Lambda";
    private AmazonCloudWatch cloudWatch;

    public RdsMetricsPublisher() {
        this.cloudWatch = AmazonCloudWatchClientBuilder.defaultClient();
    }

    public void publishMetric(String metricName, double value) {
        MetricDatum datum = new MetricDatum()
            .withMetricName(metricName)
            .withUnit("Count")
            .withValue(value)
            .withTimestamp(new Date());

        PutMetricDataRequest request = new PutMetricDataRequest()
            .withNamespace(NAMESPACE)
            .withMetricData(Collections.singletonList(datum));

        cloudWatch.putMetricData(request);
    }
}

Spring Boot Integration with AWS RDS

Configuration

application.properties

# AWS Configuration
aws.region=us-east-1
aws.rds.instance-identifier=mydb-instance

# RDS Connection (from RDS endpoint)
spring.datasource.url=jdbc:postgresql://mydb.abc123.us-east-1.rds.amazonaws.com:5432/mydatabase
spring.datasource.username=admin
spring.datasource.password=${DB_PASSWORD}
spring.datasource.driver-class-name=org.postgresql.Driver

# JPA Configuration
spring.jpa.hibernate.ddl-auto=validate
spring.jpa.show-sql=false
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect

# Connection Pool Configuration
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout=30000
spring.datasource.hikari.connection-timeout=20000

AWS Configuration

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rds.RdsClient;

@Configuration
public class AwsRdsConfig {

    @Value("${aws.region}")
    private String awsRegion;

    @Bean
    public RdsClient rdsClient() {
        return RdsClient.builder()
            .region(Region.of(awsRegion))
            .build();
    }
}

Service Layer

import org.springframework.stereotype.Service;
import software.amazon.awssdk.services.rds.RdsClient;
import software.amazon.awssdk.services.rds.model.*;
import java.util.List;

@Service
public class RdsService {

    private final RdsClient rdsClient;

    public RdsService(RdsClient rdsClient) {
        this.rdsClient = rdsClient;
    }

    public List<DBInstance> listInstances() {
        DescribeDbInstancesResponse response = rdsClient.describeDBInstances();
        return response.dbInstances();
    }

    public DBInstance getInstanceDetails(String instanceId) {
        DescribeDbInstancesRequest request = DescribeDbInstancesRequest.builder()
            .dbInstanceIdentifier(instanceId)
            .build();

        DescribeDbInstancesResponse response = rdsClient.describeDBInstances(request);
        return response.dbInstances().get(0);
    }

    public String createSnapshot(String instanceId, String snapshotId) {
        CreateDbSnapshotRequest request = CreateDbSnapshotRequest.builder()
            .dbInstanceIdentifier(instanceId)
            .dbSnapshotIdentifier(snapshotId)
            .build();

        CreateDbSnapshotResponse response = rdsClient.createDBSnapshot(request);
        return response.dbSnapshot().dbSnapshotArn();
    }

    public void modifyInstance(String instanceId, String newInstanceClass) {
        ModifyDbInstanceRequest request = ModifyDbInstanceRequest.builder()
            .dbInstanceIdentifier(instanceId)
            .dbInstanceClass(newInstanceClass)
            .applyImmediately(true)
            .build();

        rdsClient.modifyDBInstance(request);
    }
}

REST Controller

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import software.amazon.awssdk.services.rds.model.DBInstance;
import java.util.List;

@RestController
@RequestMapping("/api/rds")
public class RdsController {

    private final RdsService rdsService;

    public RdsController(RdsService rdsService) {
        this.rdsService = rdsService;
    }

    @GetMapping("/instances")
    public ResponseEntity<List<DBInstance>> listInstances() {
        return ResponseEntity.ok(rdsService.listInstances());
    }

    @GetMapping("/instances/{id}")
    public ResponseEntity<DBInstance> getInstanceDetails(@PathVariable String id) {
        return ResponseEntity.ok(rdsService.getInstanceDetails(id));
    }

    @PostMapping("/snapshots")
    public ResponseEntity<String> createSnapshot(
            @RequestParam String instanceId,
            @RequestParam String snapshotId) {
        String arn = rdsService.createSnapshot(instanceId, snapshotId);
        return ResponseEntity.ok(arn);
    }

    @PutMapping("/instances/{id}")
    public ResponseEntity<String> modifyInstance(
            @PathVariable String id,
            @RequestParam String instanceClass) {
        rdsService.modifyInstance(id, instanceClass);
        return ResponseEntity.ok("Instance modified successfully");
    }
}

Exception Handling

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class RdsExceptionHandler {

    @ExceptionHandler(RdsException.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ErrorResponse handleRdsException(RdsException e) {
        return new ErrorResponse(
            "RDS_ERROR",
            e.getMessage(),
            e.awsErrorDetails().errorCode()
        );
    }

    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ErrorResponse handleGenericException(Exception e) {
        return new ErrorResponse(
            "INTERNAL_ERROR",
            e.getMessage()
        );
    }
}

class ErrorResponse {
    private String code;
    private String message;
    private String details;

    // Constructor, getters, setters
}

Testing

Unit Tests

import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

@ExtendWith(MockitoExtension.class)
class RdsServiceTest {

    @Mock
    private RdsClient rdsClient;

    @Test
    void listInstances_shouldReturnInstances() {
        // Arrange
        DescribeDbInstancesResponse response = DescribeDbInstancesResponse.builder()
            .dbInstances(List.of(createTestInstance()))
            .build();

        when(rdsClient.describeDBInstances()).thenReturn(response);

        RdsService service = new RdsService(rdsClient);

        // Act
        List<DBInstance> result = service.listInstances();

        // Assert
        assertEquals(1, result.size());
        verify(rdsClient).describeDBInstances();
    }

    private DBInstance createTestInstance() {
        return DBInstance.builder()
            .dbInstanceIdentifier("test-instance")
            .engine("postgres")
            .dbInstanceStatus("available")
            .build();
    }
}

Integration Tests

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
@ActiveProfiles = "test"
class RdsServiceIntegrationTest {

    @Autowired
    private RdsService rdsService;

    @Test
    void listInstances_integrationTest() {
        // This test requires actual AWS credentials and RDS instances
        // Should only run with proper test configuration
        assumeTrue(false, "Integration test disabled");

        List<DBInstance> instances = rdsService.listInstances();
        assertNotNull(instances);
    }
}

Best Practices

1. Configuration Management

• Use Spring profiles for different environments
• Externalize sensitive configuration (passwords, keys)
• Use Spring Cloud Config for multi-environment management

2. Connection Pooling

# HikariCP Configuration
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=10
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.connection-test-query=SELECT 1

3. Retry Logic

import org.springframework.retry.annotation.Retryable;
import org.springframework.retry.annotation.Backoff;

@Service
public class RdsServiceWithRetry {

    private final RdsClient rdsClient;

    @Retryable(value = { RdsException.class },
               maxAttempts = 3,
               backoff = @Backoff(delay = 1000))
    public List<DBInstance> listInstancesWithRetry() {
        return rdsClient.describeDBInstances().dbInstances();
    }
}

4. Monitoring

import org.springframework.boot.actuator.health.Health;
import org.springframework.boot.actuator.health.HealthIndicator;
import org.springframework.stereotype.Component;

@Component
public class RdsHealthIndicator implements HealthIndicator {

    private final RdsClient rdsClient;

    public RdsHealthIndicator(RdsClient rdsClient) {
        this.rdsClient = rdsClient;
    }

    @Override
    public Health health() {
        try {
            rdsClient.describeDBInstances();
            return Health.up()
                .withDetail("service", "RDS")
                .build();
        } catch (Exception e) {
            return Health.down()
                .withDetail("error", e.getMessage())
                .build();
        }
    }
}