Streamline Development: Step-by-Step Dockerization of Spring Boot Apps

How to dockerize a Spring Boot application

Dockerizing a Spring Boot application is an essential skill for software developers, as it enables the efficient deployment and management of applications in a containerized environment.

Embark on the journey of Dockerizing your Spring Boot application—a must-have skill for any software developer seeking streamlined deployment and effortless management in a containerized realm.

By encapsulating your Spring Boot masterpiece into a Docker container, you unlock a world of benefits: seamless behavior across diverse platforms, effortless scalability, and turbocharged development.

Let this guide be your trusted companion as you navigate through the process of Dockerization. From crafting the perfect Dockerfile to fine-tuning essential configurations, to finally unleashing your container into the digital wild—every step promises to elevate your Spring Boot application's performance and upkeep.

To execute these actions, you’ll need:

• JDK 11 for compiling the project
• Docker Engine to create Spring Boot containers
• Any cmd bash to run some commands (Git Bash is optional)
• Apache Maven to run some commands to compile the project

Containerization has become an essential part of modern application development. Docker allows us to package applications and their dependencies into lightweight, portable containers that run seamlessly across different environments. This guide walks you through Dockerizing a Spring Boot application step by step.

While I use Spring Tool Suite (STS), you can follow these steps using any IDE of your choice, such as IntelliJ IDEA, Eclipse, or VS Code. Let’s dive in!

Prerequisites

Before we start, ensure you have the following tools installed:

• JDK 11
  • Download from Oracle JDK or OpenJDK.
  • Verify installation: java -version
• Docker
  • Download and install Docker Desktop from Docker's official website.
  • Verify installation: docker --version
• Apache Maven (Optional if not already integrated with your IDE)
  • Verify installation: mvn -version
• An IDE
  • Use any IDE you’re comfortable with. I use STS, but the steps are applicable to any IDE.

Step 1: Set Up or Open Your Spring Boot Application

Creating a New Project:

• Go to Spring Initializr and generate a Spring Boot project with dependencies like Spring Web. Import the project into your IDE.

Opening an Existing Project:

• Import your existing Spring Boot project into your IDE (STS, IntelliJ IDEA, Eclipse, or VS Code).

Step 2: Build the Application

To package your Spring Boot application into a JAR file:

1. Navigate to the project’s root directory in your terminal or use your IDE's terminal.
2. Run the following Maven command:

   mvn clean package

   This generates a .jar file in the target directory (e.g., my-application-1.0.jar).

Step 3: Create a Dockerfile

The Dockerfile is a text document containing instructions for building your Docker image.

1. Create a file named Dockerfile in the project’s root directory.
2. Add the following content:

   # Use an official OpenJDK runtime as a base image
   FROM openjdk:11-jdk-slim
   
   # Set the working directory in the container
   WORKDIR /app
   
   # Copy the JAR file into the container
   COPY target/my-application-1.0.jar app.jar
   
   # Expose the application's port
   EXPOSE 8080
   
   # Command to run the application
   ENTRYPOINT ["java", "-jar", "app.jar"]

   Replace my-application-1.0.jar with the actual name of your JAR file.

Step 4: Build the Docker Image

Open a terminal in the project’s root directory and run:

docker build -t spring-boot-app:1.0 .

This command creates a Docker image named spring-boot-app with version 1.0.

Step 5: Run the Docker Container

Start the container using:

docker run -p 8080:8080 spring-boot-app:1.0

Access your application at http://localhost:8080.

Step 6: Verify and Manage the Container

Useful Docker commands:

• docker ps: Check running containers.
• docker logs <container_id>: View logs of the container.
• docker stop <container_id>: Stop the container.

Step 7: Push the Docker Image to a Registry (Optional)

1. Tag the image:

   docker tag spring-boot-app:1.0 your-dockerhub-username/spring-boot-app:1.0

2. Push the image:

   docker push your-dockerhub-username/spring-boot-app:1.0

Conclusion

By following this guide, you’ve successfully Dockerized your Spring Boot application. Containerization ensures portability, consistency, and ease of deployment. Explore advanced tools like Docker Compose and Kubernetes to further enhance your workflows. Happy coding!