🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

In this tutorial, we will learn step by step how to Dockerize Spring Boot MySQL Application.

For deploying Spring Boot + MySQL application to docker, we will need to consider Spring Boot Application and MySQL as two different services. Basically, we are going to deploy the Spring Boot Application service and MySQL service into two separate docker containers. And we will run these containers in the same Docker network so that they can communicate with each other.

Prerequisites

First, you need to set up the Spring boot CRUD project using below GitHub repository:

https://github.com/RameshMF/springboot-docker-course/tree/main/springboot-restful-webservices

Tutorial for above GitHub repository: Spring Boot CRUD RESTful WebServices with MySQL Database

Deploy Spring Boot MySQL Application to Docker

Since are going to create two docker containers that should communicate with each other, we will need to start them on the same Docker network.

1. Deploy MySQL Image in a Container

Let's first deploy the MySQL image in a docker container.

Step1: Pull MySQL Image

Here is the docker command to pull the latest MySQL docker image:

docker pull mysql

Step 2: Create a docker network to communicate Spring boot application and MySQL database

Here is the docker command to create a new network:

docker network create springboot-mysql-net

Here springboot-mysql-net is the network name.

Use the below command to list the networks:

docker network ls

Step 3: Run MySQL image in a docker container in the same network

Here is the docker command to run MySQL image in a container in the same network:

docker run --name mysqldb --network springboot-mysql-net -e MYSQL_ROOT_PASSWORD=root -e MYSQL_DATABASE=employeedb -d mysql

Step 4: Access the MySQL database in a container

Here is the command to access the MySQL database in a container:

docker exec -it mysqldb bash

For example:

rameshfadatare@Rameshs-MacBook-Air springboot-restful-webservices % docker exec -it mysqldb bash
bash-4.4# mysql -u root -p
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 38
Server version: 8.0.31 MySQL Community Server - GPL

Copyright (c) 2000, 2022, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| employeedb         |
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
5 rows in set (0.08 sec)

That's it. Once the MySQL image is deployed in a docker container. Next, we will deploy the Spring boot application in a docker container.

2. Deploy Spring Boot Application in a Docker Container

I assume that you have downloaded the Spring boot project from the GitHub repository and set up the project in your IDE.

Next, use the following command to maven build this project:

mvn clean package

Once maven builds success, go target folder and you will be able to see the

springboot-restful-webservices-0.0.1-SNAPSHOT.jar file generated under the target folder.

Step 5: Create Dockerfile to Build the docker image

Docker builds images automatically by reading the instructions from a Dockerfile. The Dockerfile is a text file that contains all commands, in order, needed to build a given image.

Let's go to the project root directory and create a file named Dockerfile and the following content to it:

FROM eclipse-temurin:17

LABEL mentainer="javaguides.net@gmail.com"

WORKDIR /app

COPY target/springboot-restful-webservices-0.0.1-SNAPSHOT.jar /app/springboot-restful-webservices.jar

ENTRYPOINT ["java", "-jar", "springboot-restful-webservices.jar"]

FROM: A docker image can use another image available in the docker registry as its base or parent image. In the above example, we use the openjdk:11 image as our base image.

LABEL: The LABEL instruction is used to add metadata to the image. In the above Dockerfile, we have added some info about the maintainer of the image through LABEL instruction.

WORKDIR: This instruction creates a working directory in a docker container.

COPY: The COPY instruction copies new files or directories and adds them to the filesystem of the container at the path.

ENTRYPOINT: This is where you configure how the application is executed inside the container.

Step 6: Adding Profile to Deploy in Docker Environment

Let's implement the profile in the Spring boot application to deploy it in a docker environment.

Let's create an application-docker.properties file under the resources folder and the below property to active docker profile in the application.properties file:

spring.profiles.active=docker

Next, let's change the application-docker.properties file as per the docker environment:

spring.datasource.url=jdbc:mysql://mysqldb:3306/employeedb
spring.datasource.username=root
spring.datasource.password=root

#spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect
spring.jpa.hibernate.ddl-auto=update

The localhost won't work in the docker network so let's change it to the container name that is mysqldb.

spring.datasource.url=jdbc:mysql://mysqldb:3306/employeedb

Also, no need to configure MySQLDialect in Spring boot 3, Hibernate 8 will automatically configure dialect based on the database that we are using.

Next, use the following command to maven build this project:

mvn clean package

Once maven builds success, go target folder and you will be able to see the

spring-boot-restful-web services-0.0.1-SNAPSHOT.jar file generated under the target folder.

Step 7: Build Docker Image from Dockerfile

Now that we have defined the Dockerfile, let’s build a docker image for our application.

Before building the docker image, you need to make sure that you’ve packaged the application in the form of a jar file using maven.

Let’s now build the docker image by typing the following command:

docker build -t springboot-restful-webservices .

The file path . defines the location of the Dockerfile in the current directory, and the -t argument tags the resulting image, where the image name is the springboot-restful-webservices and the tag is the latest.

After the build is successfully finished, we can check to see if it appears in the list of docker images available locally. To do so, we can execute the below command.

docker images

Step 8: Run a docker image in a docker container in the same network

Once you have a docker image, you can run it using the docker run command like so:

docker run --network springboot-mysql-net --name springboot-mysql-container -p 8080:8080 springboot-restful-webservices

Note that we are running the Spring boot application in a container in the same docker network (springboot-mysql-net).

Test CRUD RESTful WebServices using Postman Client

Create User REST API:

Request URL: http://localhost:8080/api/users

HTTP Method: POST
Request Body:

{
    "firstName": "ramesh",
    "lastName":"fadatare",
    "email": "ramesh@gmail.com"
}

Refer to this screenshot to test Create User REST API:

Get User REST API:

Request URL: http://localhost:8080/api/users/1
HTTP Method: GET

Refer to this screenshot to test GET User REST API:

Update User REST API:

Request URL: http://localhost:8080/api/users/1

HTTP Method: PUT
Request Body:

{
    "firstName": "ram",
    "lastName":"fadatare",
    "email": "ram@gmail.com"
}

Refer to this screenshot to test the Update User REST API:

Get All Users REST API:

Request URL: http://localhost:8080/api/users
HTTP Method: GET

Refer to this screenshot to test GET All User REST API:

DELETE User REST API:

Request URL: http://localhost:8080/api/users/1
HTTP Method: DELETE

Refer to this screenshot to test Delete User REST API:

Source Code on GitHub

The source code of this tutorial is available on my GitHub repository at https://github.com/RameshMF/springboot-docker-course/tree/main/springboot-restful-webservices

Conclusion

In this tutorial, we have seen step-by-step how to deploy Spring Boot MySQL Application to docker using the Docker network.

Spring Boot DTO Example Tutorial
Spring Boot ModelMapper Example
Spring Boot MapStruct Example Tutorial

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Deploy Spring Boot MySQL Application to Docker

Prerequisites

Deploy Spring Boot MySQL Application to Docker

1. Deploy MySQL Image in a Container

Step1: Pull MySQL Image

Step 2: Create a docker network to communicate Spring boot application and MySQL database

Step 3: Run MySQL image in a docker container in the same network

Step 4: Access the MySQL database in a container

2. Deploy Spring Boot Application in a Docker Container

mvn clean packageOnce maven builds success, go target folder and you will be able to see thespringboot-restful-webservices-0.0.1-SNAPSHOT.jar file generated under the target folder.

Step 5: Create Dockerfile to Build the docker image

Step 6: Adding Profile to Deploy in Docker Environment

mvn clean packageOnce maven builds success, go target folder and you will be able to see thespring-boot-restful-web services-0.0.1-SNAPSHOT.jar file generated under the target folder.

Step 7: Build Docker Image from Dockerfile

Step 8: Run a docker image in a docker container in the same network

Test CRUD RESTful WebServices using Postman Client

Create User REST API:

Request URL: http://localhost:8080/api/usersHTTP Method: POSTRequest Body:{ "firstName": "ramesh", "lastName":"fadatare", "email": "ramesh@gmail.com" }Refer to this screenshot to test Create User REST API:

Get User REST API:

Request URL: http://localhost:8080/api/users/1HTTP Method: GETRefer to this screenshot to test GET User REST API:

Update User REST API:

Request URL: http://localhost:8080/api/users/1HTTP Method: PUTRequest Body:{ "firstName": "ram", "lastName":"fadatare", "email": "ram@gmail.com" }Refer to this screenshot to test the Update User REST API:

Get All Users REST API:

Request URL: http://localhost:8080/api/usersHTTP Method: GETRefer to this screenshot to test GET All User REST API:

DELETE User REST API:

Request URL: http://localhost:8080/api/users/1HTTP Method: DELETERefer to this screenshot to test Delete User REST API:

Source Code on GitHub

The source code of this tutorial is available on my GitHub repository at https://github.com/RameshMF/springboot-docker-course/tree/main/springboot-restful-webservices

Conclusion

In this tutorial, we have seen step-by-step how to deploy Spring Boot MySQL Application to docker using the Docker network.

Further Reading

Spring Boot DTO Example TutorialSpring Boot ModelMapper ExampleSpring Boot MapStruct Example Tutorial

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Build REST APIs with Spring Boot 4, Spring Security 7, and JWT

[NEW] Learn Apache Maven with IntelliJ IDEA and Java 25

ChatGPT + Generative AI + Prompt Engineering for Beginners

Spring 7 and Spring Boot 4 for Beginners (Includes 8 Projects)

Building Real-Time REST APIs with Spring Boot - Blog App

Building Microservices with Spring Boot and Spring Cloud

Java Full-Stack Developer Course with Spring Boot and React JS

Build 5 Spring Boot Projects with Java: Line-by-Line Coding

Testing Spring Boot Application with JUnit and Mockito

Spring Boot Thymeleaf Real-Time Web Application - Blog App

Master Spring Data JPA with Hibernate

Spring Boot + Apache Kafka Course - The Practical Guide

Java Testing: Mastering JUnit 5 Framework

Reactive Programming in Java: Spring WebFlux and Testing

Spring Boot + RabbitMQ Course - The Practical Guide

Functional Programming in Java (Includes Java Collections)

ChatGPT for Java Developers: Boost Your Productivity with AI

Comments

Post a Comment

Spring Boot 3 Paid Course Published for Free on my Java Guides YouTube Channel

`mvn clean package`
Once maven builds success, go target folder and you will be able to see the
springboot-restful-webservices-0.0.1-SNAPSHOT.jar file generated under the target folder.

`mvn clean package`
Once maven builds success, go target folder and you will be able to see the
spring-boot-restful-web services-0.0.1-SNAPSHOT.jar file generated under the target folder.

Request URL: http://localhost:8080/api/users
HTTP Method: POST
Request Body:
`{ "firstName": "ramesh", "lastName":"fadatare", "email": "ramesh@gmail.com" }`
Refer to this screenshot to test Create User REST API:

Request URL: http://localhost:8080/api/users/1
HTTP Method: GET

Refer to this screenshot to test GET User REST API:

Request URL: http://localhost:8080/api/users/1
HTTP Method: PUT
Request Body:
`{ "firstName": "ram", "lastName":"fadatare", "email": "ram@gmail.com" }`
Refer to this screenshot to test the Update User REST API:

Request URL: http://localhost:8080/api/users
HTTP Method: GET

Refer to this screenshot to test GET All User REST API:

Request URL: http://localhost:8080/api/users/1
HTTP Method: DELETE

Refer to this screenshot to test Delete User REST API:

Spring Boot DTO Example Tutorial
Spring Boot ModelMapper Example
Spring Boot MapStruct Example Tutorial

Spring Boot 3 Paid Course Published for Free
on my Java Guides YouTube Channel