Chapter 2: Docker Containerization
Introduction
Docker allows you to package your application with all its dependencies. "It works on my machine" becomes "It works everywhere".
🎯 Chapter Objectives
By the end of this chapter, you will know how to:
- ✅ Create a Dockerfile for Spring Boot
- ✅ Optimize with multi-stage builds
- ✅ Use Docker Compose
- ✅ Manage configurations
- ✅ Optimize image size
1. Basic Dockerfile
Simple Version
FROM eclipse-temurin:17-jre
WORKDIR /app
COPY target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]
Build and Run
# Compile the application
mvn clean package -DskipTests
# Build the image
docker build -t myapp:1.0 .
# Run
docker run -p 8080:8080 myapp:1.0
2. Multi-Stage Build (Recommended)
Optimized Dockerfile
# ===== STAGE 1: Build =====
FROM maven:3.9-eclipse-temurin-17 AS builder
WORKDIR /app
# Copy dependency files first (Docker cache)
COPY pom.xml .
RUN mvn dependency:go-offline -B
# Copy source code and compile
COPY src ./src
RUN mvn clean package -DskipTests
# ===== STAGE 2: Runtime =====
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
# Create a non-root user
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring
# Copy the JAR from the previous stage
COPY --from=builder /app/target/*.jar app.jar
# Configuration
EXPOSE 8080
ENV JAVA_OPTS="-Xms256m -Xmx512m"
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]
Advantages of Multi-Stage
Simple image: ~500 MB (with Maven + JDK)
Multi-stage image: ~200 MB (only JRE)
Alpine image: ~150 MB (minimal Alpine JRE)
3. Dockerfile with Layers
Spring Boot 2.3+ supports layers for optimized Docker cache:
# ===== STAGE 1: Build =====
FROM maven:3.9-eclipse-temurin-17 AS builder
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline -B
COPY src ./src
RUN mvn clean package -DskipTests
# Extract layers
RUN java -Djarmode=layertools -jar target/*.jar extract
# ===== STAGE 2: Runtime =====
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring
# Copy layers (in order of change frequency)
COPY --from=builder /app/dependencies/ ./
COPY --from=builder /app/spring-boot-loader/ ./
COPY --from=builder /app/snapshot-dependencies/ ./
COPY --from=builder /app/application/ ./
EXPOSE 8080
ENTRYPOINT ["java", "org.springframework.boot.loader.launch.JarLauncher"]
Enable Layers
<!-- pom.xml -->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<layers>
<enabled>true</enabled>
</layers>
</configuration>
</plugin>
4. Docker Compose
docker-compose.yml
version: '3.8'
services:
app:
build: .
ports:
- "8080:8080"
environment:
- SPRING_PROFILES_ACTIVE=docker
- DATABASE_URL=jdbc:postgresql://db:5432/mydb
- DB_USERNAME=postgres
- DB_PASSWORD=secret
depends_on:
db:
condition: service_healthy
networks:
- backend
db:
image: postgres:15-alpine
environment:
- POSTGRES_DB=mydb
- POSTGRES_USER=postgres
- POSTGRES_PASSWORD=secret
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres"]
interval: 5s
timeout: 5s
retries: 5
networks:
- backend
volumes:
postgres_data:
networks:
backend:
driver: bridge
Docker Compose Commands
# Start all services
docker-compose up -d
# View logs
docker-compose logs -f app
# Stop
docker-compose down
# Rebuild
docker-compose up -d --build
5. Docker Profile
application-docker.properties
# Configuration for Docker
spring.datasource.url=${DATABASE_URL}
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}
# Flyway
spring.flyway.enabled=true
# Actuator
management.endpoints.web.exposure.include=health,info,prometheus
# Logging
logging.level.root=INFO
6. .dockerignore
# Build
target/
!target/*.jar
# IDE
.idea/
*.iml
.vscode/
# Git
.git/
.gitignore
# Docker
Dockerfile
docker-compose*.yml
.dockerignore
# Logs
*.log
logs/
# Tests
src/test/
7. Optimizations
Alpine Image (lighter)
FROM eclipse-temurin:17-jre-alpine
Non-Root User
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring
Health Check
HEALTHCHECK --interval=30s --timeout=3s --start-period=30s --retries=3 \
CMD wget --quiet --tries=1 --spider http://localhost:8080/actuator/health || exit 1
Resource Limits
# docker-compose.yml
services:
app:
deploy:
resources:
limits:
cpus: '1'
memory: 512M
reservations:
cpus: '0.5'
memory: 256M
8. Docker Build with BuildKit
Enable BuildKit
# Environment variable
export DOCKER_BUILDKIT=1
docker build -t myapp .
# Or in Docker Desktop: Settings > Docker Engine
{
"features": {
"buildkit": true
}
}
Maven Dependency Cache
FROM maven:3.9-eclipse-temurin-17 AS builder
WORKDIR /app
# Cache dependencies with BuildKit
COPY pom.xml .
RUN --mount=type=cache,target=/root/.m2 mvn dependency:go-offline -B
COPY src ./src
RUN --mount=type=cache,target=/root/.m2 mvn clean package -DskipTests
9. Useful Commands
Build
# Simple build
docker build -t myapp:latest .
# Build with tag
docker build -t myapp:1.0.0 -t myapp:latest .
# Build without cache
docker build --no-cache -t myapp .
# Build with arguments
docker build --build-arg JAR_FILE=target/*.jar -t myapp .
Run
# Basic run
docker run -p 8080:8080 myapp
# Run in background
docker run -d -p 8080:8080 --name myapp-container myapp
# Run with environment variables
docker run -d -p 8080:8080 \
-e SPRING_PROFILES_ACTIVE=prod \
-e DATABASE_URL=jdbc:postgresql://host:5432/db \
myapp
# Run with .env file
docker run -d -p 8080:8080 --env-file .env myapp
Debug
# Logs
docker logs myapp-container
docker logs -f myapp-container # Follow
# Shell into the container
docker exec -it myapp-container sh
# Inspect
docker inspect myapp-container
10. Summary
Recommended Dockerfile
FROM maven:3.9-eclipse-temurin-17 AS builder
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline -B
COPY src ./src
RUN mvn clean package -DskipTests
FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring
COPY --from=builder /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]
Docker Checklist
□ Multi-stage build
□ Alpine image (lightweight)
□ Non-root user
□ Configured .dockerignore
□ Environment variables for secrets
□ Health check
□ docker-compose for local dev
🎯 Next Step
The Docker image is ready. Let's automate the build and deployment with CI/CD!
➡️ Chapter 3: CI/CD with GitHub Actions