The term Dockerize refers to the process of packaging an application and its dependencies into containers using Docker. Docker is an open-source platform that helps developers automate the deployment of applications into lightweight and portable containers that contain everything needed to run the application, including the source code, libraries, and system tools. In this tutorial, we will learn How to Dockerize Spring Boot application with MySQL database.
Steps to Dockerize Spring Boot application with MySQL
For this tutorial on Dockerizing the Spring Boot application with MySQL, we will be using the employee-services application.
Step 1- How to build docker image of MySQL
First, we need to pull the latest MySQL Docker image from Docker Hub to our local system. We can use any terminal to perform this operation.
docker pull mysql:latest
The above command downloads the latest image of MySQL from Docker Hub.
We can check the Docker images with the help of the following commands:
docker images
It will give all the Docker images available in our system.
Step 2- Create Docker network
In this step, we will create a Docker network that helps communicate the Spring Boot application with the MySQL database. It acts as a bridge between the two services.
docker network create springboot-mysql-network
As we are using the create option with docker network, this will create a network with the name springboot-mysql-network.
We can verify the docker network with the help of following commands:
docker network ls
The above command will list out all the docker networks available in our local system.
Step 3- How to run docker container in docker network
Now, we need to create a MySQL container, connect it to the Docker network, and run this container.
docker run --name employee-service --network springboot-mysql-network -e MYSQL_ROOT_PASSWORD=root -e MYSQL_DATABASE=employee-db -d mysql:latest
Let’s understand the above command in detail:
- docker run
- It is used to run the docker container
- –name mysql-database
- This command set the container name to “employee-service”.
- –network springboot-mysql-network
- Connect the employee-service container to the docker network named “springboot-mysql-network”
- -e MYSQL_ROOT_PASSWORD=root
- It sets an environment variable in the container and configure the MySQL root user’s password to “root.”
- -e MYSQL_DATABASE=employee-db
- This sets an environment variable in the container, creating a MySQL database named “employee-db” when the container starts.
- -d
- Run the container in the background. i.e., detached mode.
- mysql:latest
- Use the official MySQL Docker image with the “latest” tag.
We can verify our container is started and running using the following commands:
docker ps
This command will show all the running containers.
Step 4- Configure application.properties file
We use the following configuration to configure our application.properties file. We need to update our Datasource URL; instead of localhost, we are giving the MySQL container name that we have created above. i.e., employee-service.
#db config
spring.datasource.url=jdbc:mysql://employee-service:3306/employee-db
spring.datasource.username=root
spring.datasource.password=root
As we can see above, we have used the database name that we have configured in our employee-service container and the same password that we have used in our container database.
Step 5- How to create Docker file for Spring Boot project
In this step, we will create a Dockerfile in our application’s root directory and add the following set of instructions that are used to build the Docker container image.
FROM openjdk:21
EXPOSE 9090
ADD target/employee-service-version-1.jar employee-service-version-1.jar
ENTRYPOINT ["java", "-jar", "/employee-service-version-1.jar"]
Step 6- Build Spring Boot Jar
Moving further, we need to build the jar of our Spring Boot application. But, before that, make sure to add the jar or the final name of the application to the pom.xml file. Here, we are using the final name as employee-service-version-1.
mvn install
The above command will create the JAR of the application.
After the build is successful, we can verify that the JAR gets created in the application’s target directory. Also, if the build is failing due to testcases, please remove or skip the testcase.
Step 7- How to create docker image of Spring Boot
We are required to build the Spring Boot docker image. In order to build the docker image we are going to use the following command:
docker build -t employee-service-image .
Note: The dot(.) at the end of the above command tells Docker to look for Docker images in the current directory.
Above command will build the docker image of our Spring boot application and name it as employee-service-image.
We can verify the Docker image using the following command:
docker images
It will list down all the docker images present locally.
Step 8- Start Spring Boot container on Network
In this step, we need to start the Spring Boot container on the same network that we have created above. In this way, we have both our Spring Boot and MySQL containers running on the same network, and we can request that our application use the MySQL database to perform our operations.
docker run --network springboot-mysql-network --name employee-service-container -p 8081:8081 -d employee-service-image
It will create a Spring Boot container, which will be running on the Docker network created in the above steps.
Step 9- Testing – How to check docker logs command
Docker Logs
Now, we have successfully dockerized our Spring Boot application. We can check the logs with the help of following commands:
docker logs <container-id or container-name>
Here, we will be using docker logs employee-service-container to check the application logs running into the docker container.
Requesting application using endpoints
We will test our application’s APIs using the Postman.
Create Request
Get Request
Verify Database
We can also verify the database for the records created above using following commands:
docker exec -it <container-id> bash
mysql -u<user_name> -p<password>
Using the above commands, we will enter the MySQL database of the Docker container.
We use the basic SQL commands to view the employee which we have created above with the help of dockerized Spring Boot application.
We can see our employee-db has been successfully created, which we have used in our application. properties file.
Above, we can see that our records have been successfully created.