Before proceeding, let's create a basic Spring Boot App with the latest stable release at the time of writing, which is version 3.1.2.
It involves accessing the initializer service at https://start.spring.io, providing some basic details in regard to the App, selecting the required dependencies then hitting on the GENERATE button to have the basic structure of the project as follows:
You can quickly determine the following dependencies that come packaged in the Maven project:
- Spring Data JPA: Persist data in SQL stores with Java Persistence API using Spring Data and Hibernate.
- Spring Web: Build web, including RESTful, applications using Spring MVC. Uses Apache Tomcat as the default embedded container.
- MySQL Driver: MySQL JDBC driver.
Open the generated project in your favorite IDE or editor (I'm mainly using IntelliJ IDEA and VsCode), from there you can tweak it a bit to have some entities, controllers, and business logic.
Hosted on GitHub, here's the source code of the Spring Boot application that we'll be using to setup Docker along with a MySQL database.
The application.properties file holds some App configurations, it's not uncommon to see sensitive credentials in it, here's its content:
# Server port server.port=8090 # Datasource connection spring.datasource.platform=mysql spring.datasource.initialization-mode=always spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect # Hibernate spring.jpa.hibernate.ddl-auto=update spring.jpa.hibernate.show-sql=true # Logging logging.level.org.springframework=ERROR logging.level.com.numericaideas=DEBUG logging.level.org.hibernate.SQL=DEBUG logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE
Let's build the App to make sure it compiles as expected, the following command must be run from the project root folder:
./mvnw clean install -DskipTests
At the end of the execution, the Maven build output should look like this:
Other Bash scripts are available within the project for convenience:
build.sh: to build the project.up.sh: to start the project using Docker Compose.down.sh: to shut everything down.
For our demo, the port in use is 8090 and we have implemented the CRUD operations for the User entity as well as a Ping endpoint, we won't go deeper on that since it's out of scope and you can follow the next sections of this guide with an existing Spring Boot (Maven) project too.
The Dockerfile should be provided to build an image of the Spring Boot Application, it contains the following lines:
# Use a base image with Java 17
FROM openjdk:17
# Copy the JAR package into the image
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
# Expose the application port
EXPOSE 8090
# Run the App
ENTRYPOINT ["java", "-jar", "/app.jar"]
It's straightforward, the Dockerfile uses an image based on Java 17, it copies into the image the executable JAR file that resulted from the build in the previous step, exposes the port the App is running on, then provides the entry point which is the bash command to run at the end to start the container.
By building your image with the command docker build ., a successful output should be similar to the next image:
By this stage, we have the App image and since we'll use an official MySQL Docker image, we can manually spin up both components and link them together by using the database credentials to run the App, but to make the process easier we'll link their deployments together by using Docker Compose in the next section.
To run the App via Docker Compose, open a terminal, navigate to the project's root directory, and execute the following command in which we provide the environment variables directly:
MYSQL_DATABASE=mydatabase MYSQL_PASSWORD=rootpassword docker-compose up
In case you would like to provide the environment variables from a hidden .env file, feel free to create it from the .env.sample file and put it close to the docker-compose.yml within the project.
This being done, the command to run will change a bit to the following:
docker-compose up
Docker Compose will build the Spring Boot and MySQL images, create the containers, and start them. You'll see logs from both the application and the database. To stop the containers, press Ctrl+C.
Using Docker Desktop enables you to view a nice summary of your Docker state in which we can see our running containers as illustrated below:
The complete source code of the project is available on GitHub.
Open POSTMAN and create a POST request to the URL localhost:8090/api/users with a random user object to be persisted in the DB:
Let's list all users which includes the one we just created:
A ping endpoint is also available:
If you are interested in related content, take a look at the following which explains how to Quickly Dockerizing NodeJS Application using docker init command.
