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">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>3.2.0</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.learnitweb</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Microservice</description>
	<properties>
		<java.version>17</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

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;

@RestController
public class HelloController {

	@GetMapping("/hello")
	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:

http://localhost:8080/hello
http://localhost:8081/hello

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.