Dockerizing a Spring Boot Application: A Step-by-Step Guide

author : Sai K

Dockerizing your Spring Boot application can provide numerous benefits, including consistent deployment

environments, ease of scaling, and simplified dependency management. This guide will walk you through the

process of creating a Docker image for your Spring Boot application and running it in a Docker container.

Prerequisites

• JDK 17 or later


• Maven or Gradle


• Docker installed on your machine


• IDE (IntelliJ IDEA, Eclipse, etc.)

Step 1: Set Up a Spring Boot Project

1.1 Create a New Spring Boot Project

Use Spring Initializr to create a new project with the following configuration:

• Project: Maven Project


• Language: Java


• Spring Boot: 3.2.x


• Dependencies: Spring Web

Download and unzip the project, then open it in your IDE.

Example Spring Boot Application

Create a simple Spring Boot application that includes a REST controller.

1.1 Application Class

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}
 

1.2 REST Controller

Create a REST controller class named HelloController in the com.example.demo.controller package.

package com.example.demo.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Docker!";
    }
} 

1.3 Maven Configuration

Ensure that your pom.xml is configured correctly. The default configuration provided by Spring Initializr should

suffice.

    < dependencies>
        < dependency>
            < groupId>org.springframework.boot< /groupId>
            < artifactId>spring-boot-starter-web< /artifactId>
        < /dependency>
        
    < /dependencies>
    
    < build>
        < plugins>
            < plugin>
                < groupId>org.springframework.boot< /groupId>
                < artifactId>spring-boot-maven-plugin< /artifactId>
            < /plugin>
        < /plugins>
    < /build>    

Step 2: Create a Dockerfile

A Dockerfile is a script that contains instructions to assemble a Docker image.

2.1 Create a Dockerfile

Create a file named Dockerfile in the root directory of your project.

# Use the official OpenJDK base image
FROM openjdk:17-jdk-alpine

# Set the working directory inside the container
WORKDIR /app

# Copy the built jar file into the container
COPY target/demo-0.0.1-SNAPSHOT.jar app.jar

# Expose port 8080
EXPOSE 8080

# Run the application
ENTRYPOINT ["java", "-jar", "app.jar"]

Explanation:

• FROM openjdk:17-jdk-alpine: Uses the official OpenJDK base image with JDK 17.


• WORKDIR /app: Sets the working directory inside the container to /app.


• COPY target/demo-0.0.1-SNAPSHOT.jar app.jar: Copies the built jar file from the target directory into the
  
  container.


• EXPOSE 8080: Exposes port 8080 to the host.


• ENTRYPOINT ["java", "-jar", "app.jar"]: Specifies the command to run the application.

Step 3: Build the Spring Boot Application

3.1 Build the Jar File

Run the following command to build the jar file of your Spring Boot application:

./mvnw clean package

This command will generate a jar file in the target directory, for example, target/demo-0.0.1-SNAPSHOT.jar.

Step 4: Build the Docker Image

4.1 Build the Docker Image

Run the following command to build the Docker image:

docker build -t demo-app .

Explanation:

• docker build: The Docker command to build an image.


• -t demo-app: Tags the image with the name demo-app.


• .: Specifies the current directory as the build context.

Step 5: Run the Docker Container

5.1 Run the Docker Container

Run the following command to start a Docker container from the image:

docker run -p 8080:8080 demo-app

Explanation:

• docker run: The Docker command to run a container.


• -p 8080:8080: Maps port 8080 of the container to port 8080 on the host machine.


• demo-app: The name of the Docker image to run.

Step 6: Test the Application

6.1 Access the Application

Open a web browser or a tool like Postman and navigate to the following URL:

http://localhost:8080/hello

You should see the message "Hello, Docker!" returned from the HelloController.

Step 7: Additional Docker Commands

7.1 List Docker Images

To list all Docker images on your system, run:

docker images

7.2 List Running Containers

To list all running Docker containers, run:

docker ps

7.3 Stop a Running Container

To stop a running Docker container, run:

docker stop 

eplace with the actual container ID obtained from the docker ps command.

7.4 Remove a Docker Container

To remove a Docker container, run:

docker rm 

Replace with the actual container ID.

7.5 Remove a Docker Image

To remove a Docker image, run:

docker rmi demo-app 

Conclusion

In this guide, you have learned how to dockerize a Spring Boot application. We covered:

• Setting up a Spring Boot project.


• Creating a Dockerfile.


• Building the Spring Boot application.


• Building the Docker image.


• Running the Docker container.


• Testing the application.

By following these steps, you can easily package your Spring Boot application into a Docker container, providing

a consistent and portable deployment environment.

Related Spring and Spring Boot Tutorials/Guides: