Lesson 21: Docker & Containerization for Spring Boot

Spring Boot 4: From Basics to Advanced

Part 6: Microservices & Production

xdev.asia

Introduction

Containerization is the first step to bring Spring Boot applications to production. This article guides from basic Dockerfile to multi-stage builds, Cloud Native Buildpacks, GraalVM Native Image, and Docker Compose for local development.

---

1. Dockerfile Multi-Stage Build

1.1 Basic Dockerfile

# Stage 1: Build
FROM eclipse-temurin:21-jdk-alpine AS builder
WORKDIR /app
COPY gradle/ gradle/
COPY gradlew build.gradle.kts settings.gradle.kts ./
RUN ./gradlew dependencies --no-daemon
COPY src/ src/
RUN ./gradlew bootJar --no-daemon -x test

# Stage 2: Runtime
FROM eclipse-temurin:21-jre-alpine
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
WORKDIR /app
COPY --from=builder /app/build/libs/*.jar app.jar
USER appuser
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

1.2 Optimized Layered Dockerfile

Spring Boot creates layered JARs, allowing Docker to cache effectively:

FROM eclipse-temurin:21-jre-alpine AS builder
WORKDIR /app
COPY build/libs/*.jar app.jar
RUN java -Djarmode=tools -jar app.jar extract --layers --destination extracted

FROM eclipse-temurin:21-jre-alpine
RUN addgroup -S app && adduser -S app -G app
WORKDIR /app
COPY --from=builder /app/extracted/dependencies/ ./
COPY --from=builder /app/extracted/spring-boot-loader/ ./
COPY --from=builder /app/extracted/snapshot-dependencies/ ./
COPY --from=builder /app/extracted/application/ ./
USER app
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

---

2. Cloud Native Buildpacks

Spring Boot supports buildpacks — create Docker images without Dockerfile:

# Gradle
./gradlew bootBuildImage --imageName=myapp:latest

# Maven
./mvnw spring-boot:build-image -Dspring-boot.build-image.imageName=myapp:latest

// build.gradle.kts — Customize
tasks.bootBuildImage {
    imageName.set("registry.example.com/myapp:${version}")
    environment.set(mapOf(
        "BP_JVM_VERSION" to "21",
        "BPE_JAVA_TOOL_OPTIONS" to "-XX:MaxRAMPercentage=75"
    ))
}

---

3. GraalVM Native Image

3.1 Build Native Image

// build.gradle.kts
plugins {
    id("org.graalvm.buildtools.native") version "0.10.6"
}

# Build native executable
./gradlew nativeCompile

# Build native Docker image
./gradlew bootBuildImage --imageName=myapp-native:latest

3.2 Compare JVM vs Native

Metrics	JVM	Native Image
Startup time	2-5s	50-200ms
Memory (RSS)	200-400MB	50-100MB
Build time	10-30s	3-10 minutes
Peak throughput	Highest	~10-20% lower
Best for	Long-running services	Serverless, CLI

---

4. Docker Compose for Development

# docker-compose.yml
services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      SPRING_PROFILES_ACTIVE: docker
      SPRING_DATASOURCE_URL: jdbc:postgresql://db:5432/myapp
      SPRING_DATASOURCE_USERNAME: postgres
      SPRING_DATASOURCE_PASSWORD: postgres
      SPRING_DATA_REDIS_HOST: redis
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started

  db:
    image: postgres:17-alpine
    ports:
      - "5432:5432"
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

volumes:
  postgres_data:

4.1 Spring Boot Docker Compose Support

// build.gradle.kts
developmentOnly("org.springframework.boot:spring-boot-docker-compose")

# application.yml
spring:
  docker:
    compose:
      lifecycle-management: start-and-stop
      file: docker-compose.yml

Spring Boot automatically starts Docker Compose when running the app and configure connection properties.

---

5. Container Best Practices

5.1 JVM tuning for Containers

ENTRYPOINT ["java", \
  "-XX:MaxRAMPercentage=75", \
  "-XX:+UseZGC", \
  "-XX:+ZGenerational", \
  "-Djava.security.egd=file:/dev/./urandom", \
  "-jar", "app.jar"]

5.2 Health check in Docker

HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD wget -qO- http://localhost:8080/actuator/health || exit 1

5.3 .dockerignore

.git
.gradle
build/
!build/libs/*.jar
.idea
*.iml
node_modules

---

Summary

• Multi-stage Dockerfile: separate build and runtime stages, significantly reducing image size
• Cloud Native Buildpacks: create Docker images without Dockerfile, ./gradlew bootBuildImage
• GraalVM Native Image: startup 50-200ms, memory 50-100MB — ideal for serverless
• Docker Compose + Spring Boot Docker Compose Support: automatically start dependencies when developing

Exercises

1. Write multi-stage Dockerfile for Spring Boot app with layered extraction. Compare image size with single-stage
2. Create full docker-compose.yml: app + PostgreSQL + Redis. Configure healthcheck and depends_on
3. Build GraalVM Native Image, measure startup time and memory usage, compare with JVM mode