Dockerizing a Spring Boot Application

Dockerizing a Spring Boot application involves creating a Docker image for the application, which can then be run in a Docker container. This tutorial will guide you through the steps to dockerize a Spring Boot application, including creating a Dockerfile, building the Docker image, and running the application 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 dependencies:

• Spring Web

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

1.2 Create a Simple REST Controller

Create a simple REST controller to test the application.

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, World!";
    }
}

Explanation:

• @RestController: Marks the class as a REST controller.
• @GetMapping("/hello"): Maps HTTP GET requests to the hello method.

1.3 Configure application.properties

Set up the application properties for your project. This file is located in the src/main/resources directory.

# src/main/resources/application.properties

server.port=8080

Step 2: Create a Dockerfile

A Dockerfile is a script that contains a series of instructions on how to build a Docker image for your application.

2.1 Create the Dockerfile

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

# Use an official JDK runtime as a parent image
FROM openjdk:17-jdk-alpine

# Set the working directory inside the container
WORKDIR /app

# Copy the application's jar file to the container
COPY target/demo-0.0.1-SNAPSHOT.jar app.jar

# Expose the port the application runs on
EXPOSE 8080

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

Explanation:

• FROM openjdk:17-jdk-alpine: Uses an official JDK runtime as the base image.
• WORKDIR /app: Sets the working directory inside the container.
• COPY target/demo-0.0.1-SNAPSHOT.jar app.jar: Copies the application's jar file to the container.
• EXPOSE 8080: Exposes port 8080 to allow communication to/from the container.
• ENTRYPOINT ["java", "-jar", "app.jar"]: Runs the jar file when the container starts.

Step 3: Build the Application

3.1 Package the Application

Build and package your Spring Boot application using Maven or Gradle.

For Maven:

./mvnw clean package

For Gradle:

./gradlew clean build

Explanation:

• These commands compile the code, run tests, and package the application into a jar file located in the target (for Maven) or build/libs (for Gradle) directory.

Step 4: Build the Docker Image

4.1 Build the Image

Run the following command to build the Docker image. Make sure you are in the root directory of your project where the Dockerfile is located.

docker build -t spring-boot-docker-demo .

Explanation:

• docker build -t spring-boot-docker-demo .: Builds a Docker image with the tag spring-boot-docker-demo using the Dockerfile in the current directory.

Step 5: Run the Docker Container

5.1 Run the Container

Run the Docker container using the following command:

docker run -p 8080:8080 spring-boot-docker-demo

Explanation:

• docker run -p 8080:8080 spring-boot-docker-demo: Runs the Docker container, mapping port 8080 on your local machine to port 8080 in the container.

Step 6: Test the Application

6.1 Access the Application

Open your browser and navigate to http://localhost:8080/hello. You should see the following response:

Hello, World!

Step 7: Using Docker Compose (Optional)

Docker Compose is a tool for defining and running multi-container Docker applications. You can use Docker Compose to run your Spring Boot application along with other services like databases.

7.1 Create a docker-compose.yml File

Create a file named docker-compose.yml in the root directory of your project.

version: '3.8'

services:
  app:
    image: spring-boot-docker-demo
    ports:
      - "8080:8080"

7.2 Build and Run with Docker Compose

Run the following commands to build and run the application with Docker Compose:

docker-compose build
docker-compose up

Explanation:

• docker-compose build: Builds the services defined in the docker-compose.yml file.
• docker-compose up: Starts the services defined in the docker-compose.yml file.

Conclusion

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

• Setting up a Spring Boot project.
• Creating a Dockerfile to build a Docker image.
• Building and running the Docker image.
• Testing the application running in a Docker container.
• Using Docker Compose to manage multi-container applications (optional).

By following these steps, you can easily package and deploy your Spring Boot applications using Docker, ensuring a consistent runtime environment across different deployment platforms.