Connecting AWS RDS to Spring Boot

Introduction

In this article, I will walk through the process of setting up an AWS RDS MySQL instance after configuring the security group and connecting it to your Spring Boot application, and testing the connection.

Step 1: Create a New Security Group

Before setting up the RDS instance, you need to ensure that the instance is accessible. You can do this by configuring an AWS Security Group. The security group acts as a virtual firewall to control inbound and outbound traffic.

• Access AWS Console: Go to the EC2 Dashboard > Security Groups > Create Security Group.
• Inbound Rules:
  • Choose the type as MYSQL/Aurora (Becuase I'm planning to use MySQL), which opens port 3306 (MySQL default port).
  • Set the Source to My IP then it will automatically get your IP Address to connect with the RDS instance.
• Outbound Rules:
  • Set to allow all traffic to ensure that the instance can communicate freely with other resources.

Once the security group is set up, move on to configuring the RDS instance.

Step 2: Configure RDS Instance

• Choose the Database Engine: In this case, select MySQL.

• Choose a Template: For simplicity, you can use the Free tier because I'm going to setup a demo application.

• Set Up DB Instance:
  • Select Single DB instance (if you don’t require high availability).
  • Define DB Instance Identifier, Master Username (I used default name "admin"), and Password.

• Choose a DB Instance class:
  • I selected db.t3.micro (minimum resources option) because no need more CPU or RAM.

• Choose a storage type:
  • General Purpose SSD and 20 GB storage value enough for my demo application.

Note : I do not need a specific EC2 instance for this DB because there is no need to allocate compute resources.

After configuring these settings, click on Create Database to start provisioning the RDS instance. It will take a couple of minutes for creation.

Step 3: Configure Spring Boot Application

Now that your RDS MySQL instance is up and running, you can proceed to configure your Spring Boot application to connect to it.

I'm not going to deep dive into Spring boot, I just show a few Java files and configurations to get an idea. If youre new to Spring boot, please get a basic idea about Spring boot applications before that implementation.

3.1. Update application.properties

In your Spring Boot project, you will need to add the necessary database connection details in the application.properties file. The connection will use the endpoint (under the connectivity and security of RDS instance) along with the credentials set during the RDS setup.

spring.application.name=DevOps
spring.datasource.url=jdbc:mysql://<End Point>/devops
spring.datasource.username=admin
spring.datasource.password=<Password>
spring.jpa.hibernate.ddl-auto=update

• spring.datasource.url: This is the URL of your RDS instance (replace the host with the actual RDS endpoint you received).
• spring.datasource.username: The admin user or the master username you configured during the setup.
• spring.datasource.password: The password that you configured for your RDS instance.
• spring.jpa.hibernate.ddl-auto: Set to update to automatically update your schema (ideal for development).

3.2. Add MySQL Dependency

Ensure that you have the MySQL driver dependency in your pom.xml for Maven or build.gradle for Gradle.

For Maven:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

For Gradle:

implementation 'mysql:mysql-connector-java'

Note : Ensure that you add spring-boot-starter-data-jpa dependency as well.

3.3. Define JPA Entity and Repository

You can now define your JPA entity and the corresponding repository. For example, to create a User entity:

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    <getters, setters and constructions>
}

And a repository interface:

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

---

Step 4: Create a Simple REST Controller

Create a controller to handle requests related to the User entity. The following code shows how to create a simple POST method for saving user data:

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping
    public String saveUser(@RequestBody User user){
        try {
            userService.saveUser(user);
            return "Success!";
        } catch (Exception e) {
            return e.getMessage();
        }
    }
}

The UserService class handles saving the data to the database.

spring.application.name=DevOps
spring.datasource.url=jdbc:mysql://<End Point>/devops
spring.datasource.username=admin
spring.datasource.password=<Password>
spring.jpa.hibernate.ddl-auto=update

---

Step 5: Verifying the Connection in MySQL Workbench

You can verify the connection by using MySQL Workbench to connect to the AWS RDS instance. Enter the connection details as follows:

• Host: The endpoint of your RDS instance.
• Username: The admin username.
• Password: The password you set for your database.
• Port: 3306.

Once connected, you can browse the databases and tables to confirm that your Spring Boot application is interacting with the MySQL database.

---

---

Step 6: Testing with Postman

You can test the POST endpoint using Postman. Send a POST request to http://localhost:8080/user with a JSON body:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

You should see a response "Success!" if everything is set up correctly.

---

---

Conclusion

You have now successfully connected your Spring Boot application to an AWS RDS MySQL instance. By following the above steps, you were able to:

• Set up an AWS RDS instance for MySQL.
• Configure the necessary security groups for access control.
• Connect your Spring Boot application to the RDS instance via JDBC.
• Test the setup by sending POST requests through Postman and verifying the database entries.

This setup ensures a seamless and scalable database backend for your Spring Boot application hosted on AWS.

Let me know if you need any further assistance or if you have any ideas to improve the setup!

Thank you!

The above is the detailed content of Connecting AWS RDS to Spring Boot. For more information, please follow other related articles on the PHP Chinese website!