Generate and run Docker image of Spring Boot application

1. Introduction

In this tutorial, we’ll create a Docker image of a Spring Boot application. We’ll then see how to run the generated Docker image. The Spring Boot application will be a simple “Hello World” application. We’ll create multiple containers from the image and will access the Spring Boot application from outside the container.

2. Step 1: Create a Spring Boot application

In this tutorial for demonstration purpose, we’ll create a simple Spring Boot application. The application will have a controller which returns a greeting message when invoked.

Following is the source of pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
		<relativePath/> <!-- lookup parent from repository -->
	<description>Demo project for Spring Microservice</description>




Following is the source of HelloController:

package com.learnitweb.demo.controller;

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

public class HelloController {

	public String index() {
		return "Greetings from Spring Boot!";

The endpoint can be invoked using the URL http://localhost:8080/hello.

3. Step 2: Create the Dockerfile

In the same location as pom.xml, create a new file with name Dockerfile. Note that the name should be exactly Dockerfile with no extension.

A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image. Docker can build images automatically by reading the instructions from a Dockerfile.

Following are the contents of the Dockerfile:

FROM openjdk:17-jdk-slim

MAINTAINER learnitweb.com

COPY target/demo-0.0.1-SNAPSHOT.jar demo-0.0.1-SNAPSHOT.jar

ENTRYPOINT ["java","-jar","demo-0.0.1-SNAPSHOT.jar"]

Let’s discuss the contents of the Dockerfile briefly.

  • The FROM instruction initializes a new build stage and sets the Base Image for subsequent instructions. In our case, openjdk is the image and 17-jdk-slim is the tag.
  • The MAINTAINER instruction sets the Author field of the generated images.
  • We are copying the file demo-0.0.1-SNAPSHOT.jar from the target folder to the Docker image.
  • An ENTRYPOINT allows you to configure a container that will run as an executable. The syntax of ENTRYPOINT is:
    ENTRYPOINT ["executable", "param1", "param2"]
    This will allow us to run the “java -jar demo-0.0.1-SNAPSHOT.jar” when a container is created from the image.

4. Step 3: Create a Docker image from the Dockerfile

In the same location as Dockerfile, run the following command to create the Docker image:

docker build . -t learnitweb/demo:v1

In the command -t learnitweb/demo:v1 refers to the tag provided to the image.

5. Step 4: Run the Docker image to create container

You can run the image using the following command:

docker run -p 8080:8080 learnitweb/demo:v1

Here, -p 8080:8080 refers to the port mapping. By default, containers are connected to an isolated network within the Docker host. To access a container from local network, you need to configure port mapping explicitly. Here is first 8080 refers to the localhost port, the second 8080 after ‘:’ refer to the port in the container.

Similarly, you can create more containers from the same image:

docker run -p 8081:8080 learnitweb/demo:v1

You can access the application running in the container using these endpoints:


6. Conclusion

In this tutorial, we generated and run a Docker image of Spring Boot application. This is first step to learn Microservices. Hope this was helpful.