In the previous article, we explored the magic of Docker and its potential to revolutionize application deployment. Now, let's put this knowledge into practice by containerizing a Spring Boot application that interacts with a MySQL database. Buckle up, as we leverage Docker and Docker Compose to create a portable, scalable, and efficient development environment!
In this article, we have used Spring Boot and MYSQL, but we can use the same techinque to dockerize apps based on other tech stacks.
Understanding the Spring Boot's Application Structure:
Please find the link of the Spring Boot's application, which we are going to containerize in this article
Spring Boot Application Github's Link
Our Spring Boot's application is divided broadly in three layers:
Controller: spring boot controllers act as the entry point for HTTP requests, routing them, binding data, orchestrating business logic, preparing responses, and interacting with clients
Service: perform business logic
Repository: acts as the abstraction layer for interacting with database
The aforementioned, spring boot application contains following API's
saveEmployee
getAllEmployees
getEmployeeById
updateEmployee
deleteEmployee
curl -X POST \
http://localhost:8080/api/employees \
-H 'Content-Type: application/json' \
-d '{
"firstName": "John",
"lastName": "Doe",
"email": "john.doe@example.com"
}'
An employee record with email will be saved to the database.
curl -X GET \
http://localhost:8080/api/employees \
-H 'Content-Type: application/json'
You will get all employees which are persisted in the employees table
Let's Containerize:
To containerize our application, we'll create a Dockerfile. This acts as a blueprint, defining the environment and configuration needed to run the application within a Docker image. Let's start building our Dockerfile.
FROM maven:3.8.4-openjdk-17 AS builder
WORKDIR /app
COPY . .
RUN mvn -B -DskipTests clean package
FROM openjdk:17
VOLUME /tmp
EXPOSE 8080
WORKDIR /app
COPY --from=builder /app/target/*.jar app.jar
ENTRYPOINT ["java","-jar","app.jar"]
With our Dockerfile ready, let's build the image for our application.
docker build -t <Image_Name> .
Running our application directly from the image wouldn't be ideal, as it depends on MySQL. To manage these interconnected services, we'll leverage Docker Compose.
Docker Compose is a tool that simplifies running multi-container applications. It orchestrates the creation and management of linked containers, ensuring they share a network and can communicate seamlessly. Let's create a docker-compose.yml file to define this configuration.
services:
api_service:
restart: always
depends_on:
- mysqldb
build: .
ports:
- "8080:8080"
environment:
spring.datasource.url: 'jdbc:mysql://mysqldb:3306/ems?allowPublicKeyRetrieval=true&useSSL=false'
spring.datasource.username: root
spring.datasource.password: root
mysqldb:
image: "mysql:latest"
ports:
- 3306:3306
environment:
MYSQL_DATABASE: ems
MYSQL_ROOT_PASSWORD: root
volumes:
- mysql-data:/var/lib/mysql
volumes:
mysql-data:
You can bring your multi-container application to life by running the docker-compose up command. This will create and start the services defined in your docker-compose.yml file.
docker-compose up
With Docker Compose managing everything, running docker-compose up will start both the Spring Boot and MySQL containers, establishing the necessary network connection for communication.
Now, let's test our application functionality by attempting to save an employee record.
Now, let's try to fetch all Employees
What's Next:
Our exploration of Docker's layer-based image creation emphasizes the impact each layer has on the final image size. To streamline the build process, consider placing frequently updated sections, such as the "RUN mvn ..." command that builds your application, towards the end of your Dockerfile. This minimizes the number of layers rebuilt during code modifications, leading to faster deployments. By strategically structuring your Dockerfile, you can achieve significant efficiency gains. As part of this optimization, leverage the Multi-Stage File Structure, positioning the least changing elements at the start and frequently changing elements at the end.
