Docker with Spring and Spring Boot

A new approach to deploying the application

How does Traditional Deployment work?

Deployment process described in a document
Operations teams follow the steps:
- Setup Hardware
- Setup OS (Linux, Windows, Mac, …)
- Install Software (Java, PHP, NodeJs, Python,…)
- Setup Applications Dependencies
- Install Application
Manual approach
- Takes a lot of time
- High chance of making mistakes

But now we have a new approach to deploying the application. We must install Docker and if we want to have our own containers we must create an account in Docker Hub.

Creating Docker Images

Dockerfile

FROM openjdk:18.0-slim
COPY target/*.jar app.jar
EXPOSE 5000
ENTRYPOINT ["java","-jar","/app.jar"]

Dockerfile contains instructions to create Docker images
- FROM: Set a base image.
- COPY: Copies new files or directories into the image.
- EXPOSE: Inform Docker about the port that the container listens on at runtime.
- ENTRYPOINT: Configure a command that will be run at container launch.

Spring Boot Dockerfile

Build a Docker image and run

So if you are not in the specific folder, you can do a CD to this specific folder.

cd [Spring Boot project folder]

docker --version

ls

docker container ls

docker build -t jlvbcoop/hello-world-docker:v1 .

docker run -d -p 5000:5000 jlvbcoop/hello-world-docker:v1

docker container ls

docker build command

http://localhost:5000

Spring Boot application

This approach is not correct

One of the things that we have done is that the JAR file creation was done separately. We ran an even clean install on our local machine and then we copied the jar into the Docker image.
The best practice is to build everything that is needed inside the Docker image.
It is not recommended to build something on your local machine and copy it into a docker image. If you do something on the local machine and copy it into a local image, then there is every chance that if you run it on somebody else’s machine, the output would be a little different.

Building Spring Boot Docker Image using Multi Stage Dockerfile

Multi Stage Dockerfile

FROM maven:3.8.6-openjdk-18-slim AS build
WORKDIR /home/app
COPY . /home/app
RUN mvn -f /home/app/pom.xml clean package

FROM openjdk:18.0-slim
EXPOSE 5000
COPY --from=build /home/app/target/*.jar app.jar
ENTRYPOINT [ "sh", "-c", "java -jar /app.jar" ]

Build the jar file as part of the creation of Docker Image
BUILD STAGE.

What would happen is at the end of this stage we will have a jar file that is created.

Just OpenJDK is not sufficient. We would want to be able to build the Java file and to build the Java file we need Maven.
```
FROM maven:3.8.6-openjdk-18-slim AS build 
```
Setting the working directory.

WORKDIR /home/app

Copying everything from the current directory into /home/app.

COPY . /home/app

Run mvn clean package command.

RUN mvn -f /home/app/pom.xml clean package
SECOND STAGE.

Using a new image. Maven image might contain a lot of other things other than just the OpenJDK. And when I’m running a container, I would want to use as small a container image as possible.
```
FROM openjdk:18.0-slim
```
Copy created jar file into the target folder.
```
COPY --from=build /home/app/target/*.jar app.jar
```
The first stage is to build the jar file and the second stage is to run it.

Your build does not make use of anything built on your local machine.

Dockerfile

Build a Docker image and run
So if you are not in the specific folder, you can do a CD to this specific folder.
```
docker container ls

docker container stop [containerID]

docker build -t jlvbcoop/hello-world-docker:v2 .
```
You would see that the mvn clean install is now running as part of the Docker image and this would take a long time.
```
docker image list

docker container run -d -p 5000:5000 jlvbcoop/hello-world-docker:v2

docker container ls
```

Dockerfile

docker run

Docker container

http://localhost:5000

Dockerfile

There is one problem with this approach.

The thing is, we already saw that the build takes a long time. Even if you make a small change here and you run the build again, it will again take more than 5 minutes.

Building Spring Boot Docker Image – Optimizing Dockerfile

In the last step, we went to a multi-stage approach and we saw that the build took a long time. Even if I was making a small code change, it was causing the entire application to be rebuilt again.

How can we stop that from happening?

Building Spring Boot Docker Image - Optimizing Dockerfile

FROM maven:3.8.6-openjdk-18-slim AS build
WORKDIR /home/app

COPY ./pom.xml /home/app/pom.xml
COPY ./src/main/java/com/jlvbcoop/rest/webservices/restfulwebservices/RestfulWebServicesApplication.java /home/app/src/main/java/com/jlvbcoop/rest/webservices/restfulwebservices/RestfulWebServicesApplication.java

RUN mvn -f /home/app/pom.xml clean package

COPY . /home/app
RUN mvn -f /home/app/pom.xml clean package

FROM openjdk:18.0-slim
EXPOSE 5000
COPY --from=build /home/app/target/*.jar app.jar
ENTRYPOINT [ "sh", "-c", "java -jar /app.jar" ]

Docker uses something called layering
Docker Image Layers

One of the most important things that you need to understand is that Docker uses something called layering. Each command you execute here can create a separate layer. And what Docker tries to do is to reuse layers as much as possible.

So the most important thing that you need to ensure is that all the important things which do not change are present at the start of your build.

When it comes to Java applications, the step, which takes a long time, is downloading the dependencies. However, the great thing is that you don’t change dependencies very, very often. And that’s why what we are trying to do is to copy a couple of files in and do the mvn clean package first.
```
COPY ./pom.xml /home/app/pom.xml
COPY ./src/main/java/com/jlvbcoop/rest/webservices/restfulwebservices/RestfulWebServicesApplication.java /home/app/src/main/java/com/jlvbcoop/rest/webservices/restfulwebservices/RestfulWebServicesApplication.java
```
The pom.xml and the Spring Boot Application Class files. These two files will not change often. All the other codes would change very, very often. And that’s why what we are doing is we are copying these two files and we are triggering off a build first.
```
RUN mvn -f /home/app/pom.xml clean package
```
Once we trigger that build, we are copying all the files in again and then we are triggering off another build.
```
COPY . /home/app
RUN mvn -f /home/app/pom.xml clean package
```
Caches layers to reuse.

The great thing about this approach is if we do not make any changes to convert pom.xml or RestfulWebServicesApplication.java, the five first layers will be reused and the only thing that would happen is the next step, which is the mvn clean package.
The great thing is that this first mvn clean package would download all the dependencies for us. All the MAVEN dependencies will be downloaded by this one, and this is the one that takes a lot of time. And what we are trying to do is to ensure that this is run only when there is a change in either pom.xml or in the application class.

So what we are talking about is the fact that Docker caches every layer and tries to reuse it and let’s make use of this feature to make our build efficient.

Dockerfile

Build a Docker image and run
So if you are not in the specific folder, you can do a CD to this specific folder.
```
docker container ls

docker container stop [containerID]

docker build -t jlvbcoop/hello-world-docker:v3 .
```
This is the first build. So this is obviously something that would take time.
```
docker image list

docker container run -d -p 5000:5000 jlvbcoop/hello-world-docker:v3

docker container ls
```
If we make changes to the code, without modifying the pom.xml or the application file the next build will take much less time.
```
docker container stop [containerID]

docker build -t jlvbcoop/hello-world-docker:v4 .
```

Building Docker Image with Spring Boot Maven Plugin

Spring Boot Maven plugin is one of the most popular MAVEN plugins out there. This is automatically included in your pom.xml.

The great thing about the build image of the Spring Boot Maven plugin is that you don’t need to create a docker file. We will no longer need the Dockerfile file and therefore we delete it.

Delete Dockerfile

Spring Boot Maven Plugin - Create Docker Image
Spring Boot Maven Plugin: Provides Spring Boot support in Apache Maven.

Command to build a container image:
```
mvn spring-boot:build-image
```
One of the important things to remember about this Spring Boot build Image command is that it will create a very efficient image. It will create an image that is much smaller than the earlier images that we have created.

And another thing is this build image process is also efficient. The first build will take a long time and from then on you see that the subsequent builds are much faster.

Build a Docker image and run

docker container ls

docker container stop [containerID]

docker container run -d -p 5000:5000 hello-world-java:0.0.1-SNAPSHOT

0 replies

Want to join the discussion?
Feel free to contribute!

Docker with Spring and Spring Boot

A new approach to deploying the application

How does Traditional Deployment work?

Deployment process described in a document

Operations teams follow the steps:

Manual approach

Creating Docker Images

Dockerfile

Dockerfile contains instructions to create Docker images

Build a Docker image and run

This approach is not correct

Building Spring Boot Docker Image using Multi Stage Dockerfile

Multi Stage Dockerfile

Build the jar file as part of the creation of Docker Image

Build a Docker image and run

There is one problem with this approach.

Building Spring Boot Docker Image – Optimizing Dockerfile

Building Spring Boot Docker Image - Optimizing Dockerfile

Docker uses something called layering

Docker Image Layers

Caches layers to reuse.

Build a Docker image and run

Building Docker Image with Spring Boot Maven Plugin

Spring Boot Maven Plugin - Create Docker Image

Build a Docker image and run

Leave a Reply

Leave a Reply Cancel reply

Search

Suscribe to our Blog

JlvbCoop

Docker with Spring and Spring Boot

A new approach to deploying the application

How does Traditional Deployment work?

Compartir esta entrada

Creating Docker Images

This approach is not correct

Building Spring Boot Docker Image using Multi Stage Dockerfile

There is one problem with this approach.

Building Spring Boot Docker Image – Optimizing Dockerfile

Docker Image Layers

Caches layers to reuse.

Building Docker Image with Spring Boot Maven Plugin

Leave a Reply

Leave a Reply Cancel reply

Search

Suscribe to our Blog

JlvbCoop