Health checks in Docker in Spring Boot - Mini Project: Build & Apply

Health checks in Docker with Spring Boot

📖 Scenario: You are deploying a Spring Boot application inside a Docker container. To keep your app reliable, you want Docker to check if your app is healthy and ready to serve requests.This project will guide you to add a simple health check endpoint in your Spring Boot app and configure Docker to use it.

🎯 Goal: Build a Spring Boot app with a health check endpoint at /actuator/health and configure a Dockerfile with a HEALTHCHECK instruction that uses this endpoint.

📋 What You'll Learn

Create a Spring Boot application with the Actuator dependency

Enable the health endpoint at /actuator/health

Write a Dockerfile that builds the Spring Boot app image

Add a Docker HEALTHCHECK instruction that queries http://localhost:8080/actuator/health

💡 Why This Matters

🌍 Real World

Health checks help Docker and orchestration tools know if your app is running well and ready to serve users. This avoids downtime and improves reliability.

💼 Career

Understanding health checks is important for DevOps, backend development, and cloud deployment roles where containerized apps are common.

1

Add Actuator dependency and enable health endpoint

In your Spring Boot build.gradle or pom.xml, add the Actuator dependency. Then, in src/main/resources/application.properties, enable the health endpoint by adding management.endpoints.web.exposure.include=health.

Spring Boot

# Add Actuator dependency and enable health endpoint
# Your code here

Hint

The Actuator dependency provides the health endpoint. You must expose it explicitly in application.properties.

2

Create a Dockerfile to build the Spring Boot app image

Create a Dockerfile that uses openjdk:17-jdk-slim as the base image. Copy the built jar file named app.jar into the container and set the command to run it with java -jar /app.jar.

Spring Boot

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
}

# In src/main/resources/application.properties
management.endpoints.web.exposure.include=health

# Create Dockerfile below
# Your code here

Hint

Use the official OpenJDK 17 slim image. Copy your jar to /app.jar and run it with java -jar.

3

Add a Docker HEALTHCHECK instruction

In the Dockerfile, add a HEALTHCHECK instruction that runs curl -f http://localhost:8080/actuator/health || exit 1 every 30 seconds with a timeout of 5 seconds.

Spring Boot

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
}

# In src/main/resources/application.properties
management.endpoints.web.exposure.include=health

# Dockerfile
FROM openjdk:17-jdk-slim
COPY build/libs/app.jar /app.jar
CMD ["java", "-jar", "/app.jar"]

# Add HEALTHCHECK instruction below
# Your code here

Hint

The HEALTHCHECK runs curl to check the health endpoint. If curl fails, it exits with 1 to mark unhealthy.

4

Complete the Dockerfile with exposed port

In the Dockerfile, add an EXPOSE 8080 instruction so Docker knows the app listens on port 8080.

Spring Boot

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
}

# In src/main/resources/application.properties
management.endpoints.web.exposure.include=health

# Dockerfile
FROM openjdk:17-jdk-slim
COPY build/libs/app.jar /app.jar
CMD ["java", "-jar", "/app.jar"]

HEALTHCHECK --interval=30s --timeout=5s CMD curl -f http://localhost:8080/actuator/health || exit 1

# Add EXPOSE 8080 below
# Your code here

Hint

Expose port 8080 so Docker knows which port the app uses.

Practice

1.

What is the main purpose of adding a HEALTHCHECK instruction in a Dockerfile for a Spring Boot application?

easy

A. To let Docker monitor if the app is running correctly and restart if needed

B. To speed up the app startup time inside the container

C. To reduce the container size by removing unused files

D. To automatically update the Spring Boot version inside the container

Solution

1. Step 1: Understand the role of HEALTHCHECK in Docker

   The HEALTHCHECK instruction tells Docker how to test if the container's app is healthy.

2. Step 2: Connect HEALTHCHECK to app monitoring

   It helps Docker detect problems and restart the app if it stops working properly.

3. Final Answer:

   To let Docker monitor if the app is running correctly and restart if needed -> Option A

4. Quick Check:

   HEALTHCHECK monitors app health [OK]

Hint: HEALTHCHECK = Docker watches app health and restarts if unhealthy [OK]

Common Mistakes:

• Thinking HEALTHCHECK speeds up app startup
• Confusing HEALTHCHECK with image size optimization
• Assuming HEALTHCHECK updates app versions automatically

2.

Which of the following is the correct syntax to add a health check in a Dockerfile for a Spring Boot app that exposes /actuator/health on port 8080?

?

easy

A. HEALTHCHECK RUN curl http://localhost:8080/actuator/health

B. HEALTHCHECK CMD curl --fail http://localhost:8080/actuator/health || exit 1

C. HEALTHCHECK CMD ping localhost:8080/actuator/health

D. HEALTHCHECK EXEC curl http://localhost:8080/actuator/health

Solution

1. Step 1: Identify correct HEALTHCHECK syntax

   The HEALTHCHECK instruction uses CMD followed by a command that returns 0 on success or non-zero on failure.

2. Step 2: Verify the command tests the health endpoint properly

   Using curl with --fail returns error if the endpoint is unhealthy, triggering Docker restart.

3. Final Answer:

   HEALTHCHECK CMD curl --fail http://localhost:8080/actuator/health || exit 1 -> Option B

4. Quick Check:

   HEALTHCHECK CMD + curl --fail = correct syntax [OK]

Hint: Use HEALTHCHECK CMD with curl --fail for health endpoint [OK]

Common Mistakes:

• Using RUN instead of CMD in HEALTHCHECK
• Using ping instead of curl for HTTP check
• Using EXEC keyword which is invalid

3.

Given this Dockerfile snippet, what will Docker report as the container health status if the Spring Boot app's /actuator/health endpoint returns HTTP 500?

HEALTHCHECK CMD curl --fail http://localhost:8080/actuator/health || exit 1

medium

A. healthy

B. unknown

C. starting

D. unhealthy

Solution

1. Step 1: Understand curl --fail behavior on HTTP 500

   The curl --fail option causes curl to exit with error on HTTP status codes 400 or above.

2. Step 2: Connect curl failure to Docker health status

   Since curl fails, the HEALTHCHECK command exits with 1, marking container as unhealthy.

3. Final Answer:

   unhealthy -> Option D

4. Quick Check:

   HTTP 500 triggers curl failure = unhealthy [OK]

Hint: curl --fail fails on HTTP 500, so container becomes unhealthy [OK]

Common Mistakes:

• Assuming HTTP 500 still means healthy
• Confusing 'starting' with unhealthy status
• Thinking Docker ignores health check failures

4.

Identify the error in this Dockerfile health check instruction for a Spring Boot app:

HEALTHCHECK CMD curl http://localhost:8080/actuator/health || exit 1

medium

A. Incorrect URL path for health endpoint

B. Using CMD instead of RUN for HEALTHCHECK

C. Missing --fail option in curl to detect HTTP errors

D. Missing port number in the URL

Solution

1. Step 1: Check curl command correctness for health check

   Without --fail, curl returns success even if HTTP status is error (like 500).

2. Step 2: Understand impact on Docker health status

   Docker will wrongly mark container healthy because curl does not fail on bad HTTP codes.

3. Final Answer:

   Missing --fail option in curl to detect HTTP errors -> Option C

4. Quick Check:

   curl needs --fail to detect HTTP errors [OK]

Hint: Always add --fail to curl in HEALTHCHECK to catch errors [OK]

Common Mistakes:

• Using RUN instead of CMD in HEALTHCHECK
• Wrong health endpoint URL
• Forgetting port number in URL

5.

You want Docker to check your Spring Boot app health every 30 seconds, retry 3 times before marking unhealthy, and start checking only after 10 seconds of container start. Which HEALTHCHECK instruction correctly implements this?

hard

A. HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 CMD curl --fail http://localhost:8080/actuator/health || exit 1

B. HEALTHCHECK --interval=10s --timeout=30s --start-period=3s --retries=5 CMD curl --fail http://localhost:8080/actuator/health || exit 1

C. HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 CMD curl http://localhost:8080/actuator/health || exit 1

D. HEALTHCHECK CMD curl --fail http://localhost:8080/actuator/health || exit 1

Solution

1. Step 1: Match timing parameters to requirements

   Interval 30s means check every 30 seconds, start-period 10s delays first check, retries 3 means try 3 times before unhealthy.

2. Step 2: Verify curl command correctness

   curl uses --fail to detect HTTP errors, with exit 1 to signal failure to Docker.

3. Final Answer:

   HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 CMD curl --fail http://localhost:8080/actuator/health || exit 1 -> Option A

4. Quick Check:

   Correct timing + curl --fail = HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 CMD curl --fail http://localhost:8080/actuator/health || exit 1 [OK]

Hint: Set interval, retries, start-period explicitly with curl --fail [OK]

Common Mistakes:

• Mixing up interval and timeout values
• Omitting --fail in curl command
• Not setting start-period to delay checks