How to Containerise Spring Boot App

During my previous project with a well-known investment bank, we implemented a modern architecture using Spring Boot microservices. It was designed following the 12-factor microservice principles, which helped us build a scalable and resilient system. Let me explain a few of these principles in an easy-to-understand manner:

1. Independent Deployment: Each microservice was developed and deployed separately, allowing us to make changes or updates to a specific service without affecting the others. This flexibility enabled faster development and deployment cycles.

2. Build Parity: We ensured consistency across different environments by using the same build and deployment processes for development, testing, and production. This approach minimized the chances of issues arising due to environment-specific configurations.

3. Port Binding: Each microservice was assigned a unique port number to listen and respond to incoming requests. This allowed multiple services to run simultaneously without conflicting with each other.

4. Dependencies: Docker allows you to package your application along with its dependencies into a container. This ensures that all the required dependencies are isolated and bundled with the application, making it self-contained and eliminating any potential conflicts with other services or environments.

5. Configuration: Docker containers can be configured with environment-specific variables or configuration files, making it easier to manage and maintain configuration settings. This allows you to separate the configuration from the application code, making it more flexible and enabling configuration changes without modifying the application itself.

To further enhance the deployment process, we utilized Containerisation. By containerizing the applications with Docker, we achieved platform independence and simplified deployment across various environments. Docker containers encapsulate the microservices and their dependencies, making it easier to deploy and run them consistently.

By adopting Spring Boot microservices and incorporating the 12-factor principles, along with Dockerization, we created a highly modular and scalable architecture that facilitated efficient development, deployment, and maintenance of the investment bank’s system.

What is Containerization

Containerization is the process of packaging an application and its dependencies into a single unit called a container. This makes it easy to deploy and run the application in any environment, regardless of the underlying operating system or hardware.

Building and deploying a containerized Spring Boot application is like preparing a well-organized lunchbox that contains all the necessary ingredients for a delicious meal. First, you gather your ingredients, which are the different components of your application, such as code, libraries, and configurations. Next, you put everything together, just like mixing the ingredients in a recipe, by packaging them in a container. This container acts as a portable and self-contained unit that can be easily transported and deployed on any system. It’s like having a lunchbox that you can take anywhere and enjoy your meal without worrying about the environment. Once your container is ready, you can serve it to your hungry users by deploying it onto a server or a cloud platform. It’s like handing out lunchboxes to people who are eagerly waiting to taste your delicious creation. And just like how everyone can enjoy their own lunchbox without interfering with others, your containerized application can run independently, without affecting other applications or the underlying system. So, building and deploying a containerized Spring Boot application is a convenient and efficient way to ensure your application is easily portable, scalable, and accessible to users anywhere, just like a perfectly packed lunchbox.

Using Docker as a Container for Spring Boot Applications

Docker is a popular containerization platform that makes it easy to create and manage containers. To use Docker to containerize a Spring Boot application, you will need to create a Dockerfile. The Dockerfile is a text file that tells Docker how to build the container.

For demo purpose, we can take any simple spring boot application. I have added sample code on GitHub here

The following is an example of a Dockerfile for a Spring Boot application:

FROM openjdk:17-jdk-alpine

WORKDIR /springboot-docker

COPY pom.xml .

RUN mvn dependency:go-offline

COPY src ./src

RUN mvn clean install

ENTRYPOINT ["java","-jar","/springboot-docker.jar"]

Once you have created the Dockerfile, you can build the container using the following command:

docker build -t springboot-docker .

Once the container is built, you can run it using the following command:

docker run -p 8080:8080 springboot-docker

This will start the container and expose port 8080 on your local machine. You can then access the application at http://localhost:8080.

Building and Deploying a Containerized Spring Boot Application

To build and deploy a containerized Spring Boot application, you will need to use a CI/CD pipeline. A CI/CD pipeline is a set of automated steps that build, test, and deploy your application.

There are many different CI/CD tools available, such as Jenkins, CircleCI, and TeamCity. Each tool has its own strengths and weaknesses, so you will need to choose the one that best suits your needs.

Once you have chosen a CI/CD tool, you will need to configure it to build and deploy your containerized Spring Boot application. The configuration process will vary depending on the tool you are using.

Once your CI/CD pipeline is configured, you can start building and deploying your application. The pipeline will automatically build the container, test it, and deploy it to your target environment.

Best Practices/ Tips and Tricks

• Automate all manual steps: Reduce human error and save time by automating repetitive tasks involved in containerization processes.

• Use a specific base image tag instead of ‘latest’: Specify a particular version of the base image to ensure consistent and predictable results, avoiding potential compatibility issues.

• Consider using Eclipse Temurin instead of JDK: If feasible, opt for Eclipse Temurin as the Java Development Kit (JDK) for your container, as it provides a reliable and tested distribution of Java.

• Implement Multi-Stage Builds: Utilize the power of multi-stage builds to optimize your container image size and improve the build process efficiency.

• Favor Multi-Architecture Docker Images: Support multiple architectures (e.g., ARM and x86) by using multi-architecture Docker images, enabling your containers to run seamlessly across various hardware platforms.

• Run containers as a non-root user: Enhance security by running containers with non-root user privileges, reducing the risk of unauthorized access or potential exploits.

• Measure performance with OpenTelemetry API: Utilize the OpenTelemetry API to monitor and measure the performance of your containerized applications, gaining valuable insights for optimization and troubleshooting.

Summary

The article discusses the containerization of a Spring Boot application, highlighting its benefits and the process involved. It explains how containerization enables developers to package their application along with its dependencies, libraries, and configurations into a portable and self-contained unit called a container. In addition to its advantages, containerization is shown in the article to align with several important principles for building microservices applications. These principles, known as the “12 Factors,” focus on making apps scalable, resilient, and easy to maintain. Containerization helps with “Dependency Isolation” by keeping the app and its dependencies separate in a container. This reduces conflicts and ensures consistent performance. It also supports “Disposability” by allowing quick and effortless deployment, scaling, and rollback of containers. Additionally, containerization helps achieve “Dev/Prod Parity” as the same container image can be used in different environments, reducing inconsistencies and making testing and deployment more reliable.