Building Your First Docker Image for a Java Spring Boot REST service

Discover how to build your first Docker image for a Java Spring Boot REST service. This step-by-step guide covers writing Dockerfiles, building and running Docker images, optimizing for performance, and deploying your Spring Boot application using Docker

In the modern development landscape, Docker has become a vital tool for containerizing applications, making it easier to develop, ship, and run applications in isolated environments. Java Spring Boot is one of the most popular frameworks for building REST services, and with Docker, you can deploy your Spring Boot applications quickly and efficiently. In this blog post, we’ll walk through the steps of building your first Docker image for a Java Spring Boot REST service.

1. Introduction to Docker and Spring Boot  

Before we dive into Dockerizing a Spring Boot application, let’s briefly understand the core concepts of Docker and Spring Boot.

1. Spring Boot simplifies the development of Java applications by providing a framework for creating stand-alone, production-ready applications with minimal configuration. It is widely used for developing RESTful APIs.
2. Docker is an open-source platform that automates the deployment of applications inside containers. Containers are lightweight, portable, and self-sufficient, making them ideal for packaging applications and their dependencies.

By containerizing a Spring Boot application, you ensure it can run on any system that has Docker installed, regardless of its environment.

2. Setting Up Your Spring Boot REST Service  

Let’s start by creating a simple Spring Boot REST service. If you haven’t already set up a Spring Boot application, follow these steps:

1. Create a Spring Boot project: Use Spring Initializr to generate a Spring Boot project. Select Maven as the project type, Java as the language, and choose the Spring Web dependency for creating REST services.
2. Create a REST Controller: In the generated project, create a simple REST endpoint. Below is an example of a HelloController.java:

package com.example.demo;

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

@RestController
public class HelloController {

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

3. Build the project: Navigate to your project directory and build the application using Maven:

   mvn clean package

This will generate a JAR file located in the target directory.

3. Dockerizing the Spring Boot Application  

Once your Spring Boot REST service is ready, the next step is to containerize it using Docker. To do this, we need to write a Dockerfile — a text document containing all the commands required to assemble the image.

4. Writing the Dockerfile  

The Dockerfile serves as the blueprint for building the Docker image. It specifies the base image, copies the necessary files, and defines how the application should run inside the container. Here’s an example of a Dockerfile for a Spring Boot application:

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

# Set the working directory inside the container
WORKDIR /app

# Copy the JAR file from the target directory to the container
COPY target/demo-0.0.1-SNAPSHOT.jar app.jar

# Expose the port on which the application will run
EXPOSE 8080

# Define the command to run the Spring Boot application
ENTRYPOINT ["java", "-jar", "app.jar"]

In this Dockerfile:

1. FROM openjdk:17-jdk-alpine: Specifies the base image, which is a lightweight Alpine Linux distribution with OpenJDK 17.
2. WORKDIR /app: Sets the working directory inside the container.
3. COPY target/demo-0.0.1-SNAPSHOT.jar app.jar: Copies the JAR file from the local machine to the container.
4. EXPOSE 8080: Exposes port 8080 for the Spring Boot application to run on.
5. ENTRYPOINT [“java”, “-jar”, “app.jar”]: Defines the command to run the JAR file using the Java runtime.

5. Building and Running the Docker Image  

Now that the Dockerfile is written, you can proceed with building the Docker image and running the container.

1. Build the Docker Image: In the project directory (where the Dockerfile is located), run the following command to build the Docker image:

   docker build -t springboot-docker-demo .

The -t flag assigns a name (springboot-docker-demo) to the image. The . indicates that the Dockerfile is located in the current directory.

2. Run the Docker Container: Once the image is built, you can run the container using the following command:

   docker run -p 8080:8080 springboot-docker-demo

This command maps port 8080 on the host machine to port 8080 inside the container. After running the command, the application will be accessible at http://localhost:8080/hello.

6. Pushing the Docker Image to a Repository  

If you want to share your Docker image or use it in a CI/CD pipeline, you need to push it to a Docker repository. The most commonly used repository is Docker Hub, but you can also use other repositories like GitHub Container Registry or Amazon ECR.

Here’s how to push the image to Docker Hub:

1. Login to Docker Hub: Use the following command to log in to your Docker Hub account:

   docker login

2. Tag the Image: Before pushing the image, tag it with your Docker Hub username:

   docker tag springboot-docker-demo <your-username>/springboot-docker-demo

3. Push the Image: Push the tagged image to Docker Hub:

   docker push <your-username>/springboot-docker-demo

Once pushed, you can pull and run the image on any machine with Docker installed.

7. Conclusion  

By following the steps outlined in this guide, you’ve successfully created your first Docker image for a Java Spring Boot REST service. Dockerizing your applications ensures that they are portable and can be run consistently across different environments, making deployment and scaling much easier.

To summarize:

1. We built a simple Spring Boot REST service.
2. We wrote a Dockerfile to containerize the Spring Boot application.
3. We built and ran the Docker image.
4. Finally, we pushed the Docker image to a Docker repository for distribution.

With these foundational skills, you can now explore more advanced Docker concepts, such as multi-stage builds, Docker Compose, and Kubernetes for orchestrating containerized applications.