CtrlK
BlogDocsLog inGet started
Tessl Logo

giuseppe-trisciuoglio/developer-kit

Comprehensive developer toolkit providing reusable skills for Java/Spring Boot, TypeScript/NestJS/React/Next.js, Python, PHP, AWS CloudFormation, AI/RAG, DevOps, and more.

82

Quality

82%

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Risky

Do not use without reviewing

Validation failed for skills in this tile
One or more skills have errors that need to be fixed before they can move to Implementation and Discovery review.
Overview
Quality
Evals
Security
Files

spring-boot-integration.mdplugins/developer-kit-java/skills/aws-sdk-java-v2-rds/references/

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();
        }
    }
}

plugins

developer-kit-java

skills

aws-sdk-java-v2-rds

references

api-reference.md

lambda-integration.md

spring-boot-integration.md

SKILL.md

README.md

tile.json