Dockerfile for Spring Boot in Spring Boot - Step-by-Step Execution

Concept Flow - Dockerfile for Spring Boot

Start: Write Dockerfile

↓

Choose base image

↓

Copy jar file into image

↓

Set entrypoint to run jar

↓

Build Docker image

↓

Run container

↓

Spring Boot app runs inside container

This flow shows how a Dockerfile is created and used to build and run a Spring Boot application inside a container.

Execution Sample

Spring Boot

FROM openjdk:17-jdk-slim
COPY target/app.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

This Dockerfile uses an OpenJDK base image, copies the Spring Boot jar, and sets the command to run it.

Execution Table

Step	Dockerfile Instruction	Action	Result
1	FROM openjdk:17-jdk-slim	Select base image with Java 17	Base image ready with Java environment
2	COPY target/app.jar app.jar	Copy Spring Boot jar into image	app.jar available inside image
3	ENTRYPOINT ["java", "-jar", "/app.jar"]	Set container start command	Container will run the jar on start
4	docker build -t springboot-app .	Build Docker image from Dockerfile	Image 'springboot-app' created
5	docker run -p 8080:8080 springboot-app	Run container exposing port 8080	Spring Boot app runs and listens on port 8080

💡 Container runs until stopped; Spring Boot app serves requests on port 8080

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5
Docker Image	None	openjdk:17-jdk-slim	openjdk + app.jar	Configured with ENTRYPOINT	Built as springboot-app	Running container with app

Key Moments - 3 Insights

Why do we use 'COPY target/app.jar app.jar' instead of copying the whole project?

Because the Docker image only needs the compiled jar file to run the app, not the source code. This is shown in execution_table step 2.

What does ENTRYPOINT do in the Dockerfile?

ENTRYPOINT sets the command that runs when the container starts, here it runs the Spring Boot jar. See execution_table step 3.

Why do we expose port 8080 when running the container?

Spring Boot listens on port 8080 by default, so exposing it allows access from outside the container. See execution_table step 5.

Visual Quiz - 3 Questions

Look at the execution table, what is the base image used in step 1?

A openjdk:8-jdk

B ubuntu:latest

C openjdk:17-jdk-slim

D springboot:latest

💡 Hint

Check the Dockerfile Instruction column in step 1 of the execution_table.

At which step is the Spring Boot jar copied into the Docker image?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look for the COPY instruction in the execution_table.

If we change the ENTRYPOINT to run a different jar, which step would change?

A Step 2

B Step 3

C Step 1

D Step 5

💡 Hint

ENTRYPOINT is set in step 3 according to the execution_table.

Concept Snapshot

Dockerfile for Spring Boot:
FROM openjdk:17-jdk-slim
COPY target/app.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]
Build image with 'docker build -t name .'
Run container with 'docker run -p 8080:8080 name'
Spring Boot app runs inside container on port 8080

Full Transcript

This visual execution shows how to create a Dockerfile for a Spring Boot application. First, we select a base image with Java 17. Then we copy the compiled Spring Boot jar file into the image. Next, we set the ENTRYPOINT to run the jar when the container starts. After writing the Dockerfile, we build the Docker image and then run a container exposing port 8080. The Spring Boot app runs inside the container and listens on port 8080. Key points include copying only the jar file, setting the correct ENTRYPOINT, and exposing the right port for access.