Spring Boot MySQL Docker Compose Example

This previous tutorial shows how to deploy the Spring boot MySQL application to Docker using the Docker network.

In this tutorial, we will learn how to deploy the Spring boot MySQL application to docker using docker-compose.

Docker compose overview

Docker compose lets you define and run multi-container docker applications. In the last article, I wrote about how to containerize a simple standalone spring boot application that doesn’t depend on any other service or database. 

But, In the real world, you’ll have applications that interact with a database and also depend on other services. So essentially, you’ll have multiple containers that interact with each other. Docker compose lets you deploy and manage apps involving various containers. It significantly improves the development and testing workflows wherein you can quickly run and test the whole stack together.

With Compose, we use a YAML file to configure our application’s services. Then, with a single command, we create and start all the services from our configuration.

Compose works in all environments: production, staging, development, testing, as well as CI workflows. It also has commands for managing the whole lifecycle of your application: 

• Start, stop, and rebuild services 
• View the status of running services 
• Stream the log output of running services 
• Run a one-off command on a service

Read more about docker-compose at https://docs.docker.com/compose/

Prerequisites

This tutorial is a continuation of my previous tutorial: Deploy Spring Boot MySQL Application to Docker.

Creating the docker-compose.yml configuration

To deploy Spring Boot MySQL application using docker-compose, we need to create a docker-compose.yml file that contains the configuration for all the application services.

Go to the root directory of our project, and create a docker-compose.yml file:

Next, let's add the below configuration to a docker-compose.yml file:

version: "3.8"

services:
  mysqldb:
    container_name: mysqldb
    image: mysql
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: employeedb
    networks:
      springboot-mysql-net:

  springboot-restful-webservices:
    container_name: springboot-restful-webservices
    build:
      context: ./
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    depends_on:
      - mysqldb
    networks:
      springboot-mysql-net:
    restart: on-failure

networks:
  springboot-mysql-net:

Let's understand the above docker-compose.yml file.

We have configured two services:

mysqldb service: It runs MySQL database that runs on port 3306

springboot-restful-webservices service: Deploy Spring boot application in tomcat server on port 8080

build - Specify the location of the Dockerfile.

depends_on - Notice the depends_on keyword in the compose file. Docker compose will make sure that all the dependencies of a service are started first before starting the service itself.

environment – In this section, we are setting the environment variables for MySQL root password and MySQL database name.

ports – Here we are mapping the Host port with the port inside a docker container.

restart: on failure - Restart the container if it stops on failure. 

Running Spring Boot Application and MySQL Database Using Docker Compose

Let's use below single docker-compose command to run the whole setup:

docker-compose up

Let's use the below docker-compose command to start and run all the containers in the background:

docker-compose up -d

For example:

rameshfadatare@Rameshs-MacBook-Air springboot-restful-webservices % docker-compose up -d      
Pulling mysqldb (mysql:)...
latest: Pulling from library/mysql
12a06ca91af8: Pull complete
1fec1cb1944f: Pull complete
aede38c79379: Pull complete
51b980849561: Pull complete
f503d79ed4bc: Pull complete
6fb44db361f7: Pull complete
943b6dcee7de: Pull complete
911277c1fe4b: Pull complete
a477017d0457: Pull complete
84b5061403a5: Pull complete
5ff27d035d66: Pull complete
Digest: sha256:3d7ae561cf6095f6aca8eb7830e1d14734227b1fb4748092f2be2cfbccf7d614
Status: Downloaded newer image for mysql:latest
Building springboot-restful-webservices
[+] Building 2.4s (9/9) FINISHED                                                                                                           
 => [internal] load build definition from Dockerfile                                                                                  0.0s
 => => transferring dockerfile: 37B                                                                                                   0.0s
 => [internal] load .dockerignore                                                                                                     0.0s
 => => transferring context: 2B                                                                                                       0.0s
 => [internal] load metadata for docker.io/library/eclipse-temurin:17                                                                 2.2s
 => [auth] library/eclipse-temurin:pull token for registry-1.docker.io                                                                0.0s
 => [1/3] FROM docker.io/library/eclipse-temurin:17@sha256:cecc3a80a37034b4eaf864ebfb3c3b7a521b27cb398bec8fb41e46e69e6af811           0.0s
 => [internal] load build context                                                                                                     0.0s
 => => transferring context: 106B                                                                                                     0.0s
 => CACHED [2/3] WORKDIR /app                                                                                                         0.0s
 => CACHED [3/3] COPY target/springboot-restful-webservices-0.0.1-SNAPSHOT.jar /app/springboot-restful-webservices.jar                0.0s
 => exporting to image                                                                                                                0.0s
 => => exporting layers                                                                                                               0.0s
 => => writing image sha256:9f994eb1971daea26ae5e2adf0e8eea2fe53d74d468d438b5dce077c8e5efe3f                                          0.0s
 => => naming to docker.io/library/springboot-restful-webservices_springboot-restful-webservices                                      0.0s

Creating mysqldb ... done
Creating springboot-restful-webservices ... done
rameshfadatare@Rameshs-MacBook-Air springboot-restful-webservices % 

Use the below docker command to check the list of currently running containers:

docker ps

For example:

rameshfadatare@Rameshs-MacBook-Air springboot-restful-webservices % docker ps
CONTAINER ID   IMAGE                                                           COMMAND                  CREATED         STATUS         PORTS                                       NAMES
705541a8cc6d   springboot-restful-webservices_springboot-restful-webservices   "java -jar springboo…"   2 minutes ago   Up 2 minutes   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp   springboot-restful-webservices
ea1e825f3867   mysql                                                           "docker-entrypoint.s…"   2 minutes ago   Up 2 minutes   3306/tcp, 33060/tcp                         mysqldb

Use the below docker command to list all the docker images:

docker images

For example:

rameshfadatare@Rameshs-MacBook-Air springboot-restful-webservices % docker images
REPOSITORY                                                      TAG       IMAGE ID       CREATED       SIZE
springboot-restful-webservices_springboot-restful-webservices   latest    9f994eb1971d   5 hours ago   491MB
mysql                                                           latest    7b6f3978ca29   6 days ago    550MB

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 compose.

Further Reading

• Deploy Spring Boot Application on Docker
  
• Deploy Spring Boot MySQL Application to Docker
  
• Spring Boot DTO Example Tutorial
• Spring Boot ModelMapper Example
• Spring Boot MapStruct Example Tutorial