Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Git, DevOps & ToolingMid19 phút đọc

Docker cho Spring Boot: image, Dockerfile nhiều stage, JVM trong container và Compose

Ôn 16 thẻ
Trong bài này

Phỏng vấn hay hỏi những chỗ container Java hay hỏng: image 1 GB build 8 phút, pod bị OOMKilled, request bị cắt mỗi lần deploy. Bài này đi từ container là gì tới một Dockerfile production cho Spring Boot và một compose.yaml cho máy dev. Phần kernel đã có ở bài hệ điều hành và bộ nhớ ảo và JVM; ở đây chỉ nối chúng vào Dockerfile.

1. Container là gì: process bị cô lập, không phải máy ảo

Ý chính: container là một process (hoặc nhóm process) mà kernel cho “nhìn thấy” một thế giới riêng bằng namespace, và giới hạn CPU, RAM bằng cgroup. Không có kernel thứ hai, nên khởi động trong mili giây.

Namespace là cách kernel cho mỗi nhóm process một bản riêng của tài nguyên hệ thống:

Namespace Process trong container thấy gì riêng
pid cây process riêng, ứng dụng là PID 1
net card mạng, IP, port, bảng route riêng
mnt cây thư mục riêng (file system của image)
uts hostname riêng
ipc shared memory, semaphore riêng
user UID riêng (root trong container có thể là user thường ngoài host)
cgroup chỉ thấy cgroup của chính mình

Cgroup (control group) giới hạn và đếm tài nguyên của cả nhóm: memory.max, cpu.max, pids.max. Cách CPU quota gây throttle đã có ở bài hệ điều hành, cách vượt memory.max dẫn tới OOM killer ở bài bộ nhớ ảo.

flowchart LR
  subgraph VM["Máy ảo"]
    H1[Hypervisor] --> G1[Kernel khách A] --> A1[JVM A]
    H1 --> G2[Kernel khách B] --> B1[JVM B]
  end
  subgraph CT["Container"]
    K[Một kernel Linux của host] --> C1["JVM A (namespace + cgroup)"]
    K --> C2["JVM B (namespace + cgroup)"]
  end

2. Image và layer: vì sao thứ tự lệnh quyết định tốc độ build

Ý chính: mỗi lệnh RUN, COPY, ADD tạo một layer chỉ đọc trên nền image của FROM; Docker dùng lại layer nếu lệnh và file đầu vào không đổi. Một layer đổi thì mọi layer phía sau build lại, nên thứ ít thay đổi phải đứng trước.

  • Image = các layer + cấu hình (ENTRYPOINT, ENV, USER). Layer dùng chung giữa các image, chỉ tải phần chưa có.
  • Container = image + một layer ghi được trên cùng (overlayfs). Xoá container là mất layer này; dữ liệu cần giữ phải nằm trong volume.
  • Cache key của COPY là nội dung file, của RUN là chuỗi lệnh (nên RUN apt-get update không tự chạy lại khi có gói mới).
  • .dockerignore loại target/, .git khỏi build context: build nhanh hơn, không lọt file nhạy cảm.

3. Dockerfile nhiều stage cho Spring Boot

Ý chính: stage đầu có JDK và Maven để build, stage cuối chỉ có JRE và kết quả đã tách layer. Image chạy không chứa compiler, mã nguồn hay kho .m2.

# syntax=docker/dockerfile:1
FROM eclipse-temurin:21-jdk AS build
WORKDIR /src
COPY mvnw pom.xml ./
COPY .mvn .mvn
RUN --mount=type=cache,target=/root/.m2 ./mvnw -B -ntp dependency:go-offline
COPY src src
RUN --mount=type=cache,target=/root/.m2 ./mvnw -B -ntp package -DskipTests \
 && java -Djarmode=tools -jar target/*.jar extract --layers --destination /extracted

FROM eclipse-temurin:21-jre
RUN groupadd --system app && useradd --system --gid app --no-create-home app
WORKDIR /app
COPY --from=build /extracted/dependencies/ ./
COPY --from=build /extracted/spring-boot-loader/ ./
COPY --from=build /extracted/snapshot-dependencies/ ./
COPY --from=build /extracted/application/ ./
USER app
ENV JAVA_TOOL_OPTIONS="-XX:MaxRAMPercentage=75 -XX:+ExitOnOutOfMemoryError"
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "orders-0.0.1-SNAPSHOT.jar"]

extract --layers (Spring Boot 3.3+) chia jar thành bốn thư mục theo tần suất thay đổi: dependencies, spring-boot-loader, snapshot-dependencies, application; mỗi COPY là một layer. Với app Spring Boot 4.0.9 mình chạy thử: dependencies 21 MB, application 4 KB, nên sửa code chỉ đẩy layer 4 KB.

Ở CI, stage build thường thay bằng bước Maven có sẵn, Dockerfile chỉ copy jar đã test (bài CI/CD). Đặt <finalName>app</finalName> trong POM để tên jar gọn (Maven).

4. Chọn base image: JRE, distroless hay Alpine

Ý chính: base image quyết định kích thước, số lỗ hổng phải vá và cách debug. Mặc định an toàn là JRE trên Debian/Ubuntu; distroless khi muốn bề mặt tấn công nhỏ; Alpine chỉ khi đã kiểm chứng app chạy tốt trên musl.

Base image Kích thước nén (amd64, Docker Hub) Có shell Ghi chú
eclipse-temurin:21-jdk 225 MB có chỉ để build, đừng chạy production
eclipse-temurin:21-jre 116 MB có glibc, mặc định an toàn
eclipse-temurin:21-jre-alpine 74 MB có (ash) musl libc
gcr.io/distroless/java21-debian12 nhỏ, ước lượng gần Alpine không glibc, tag :nonroot chạy UID 65532

Số kích thước lấy từ Docker Hub ngày 18/11/2026; distroless không nằm trên Docker Hub nên chỉ ghi ước lượng.

5. JVM trong container: đặt memory cho đúng

Ý chính: JVM đọc memory limit từ cgroup và mặc định lấy 25% làm heap. Đặt -XX:MaxRAMPercentage=75 cho service web thường, để 25% còn lại cho metaspace, thread stack, direct buffer; con số chính xác phải đo.

Chi tiết từng vùng ngoài heap, thí nghiệm NMT và cách chọn phần trăm đã có ở bài bộ nhớ ảo, page cache và JVM. Phần dành riêng cho Dockerfile:

  • Đặt cờ qua JAVA_TOOL_OPTIONS: JVM tự đọc biến này, nên không cần shell mở rộng $JAVA_OPTS và ENTRYPOINT giữ được dạng exec.
  • Thêm -XX:+ExitOnOutOfMemoryError để JVM chết hẳn khi heap đầy và được khởi động lại, thay vì sống dở.
  • OutOfMemoryError do JVM ném, có stack trace trong log; OOMKilled, exit code 137 là kernel giết vì RSS vượt memory.max, log không để lại gì.

6. Chạy an toàn và tắt êm: non-root, PID 1, healthcheck

Ý chính: chạy bằng user thường, để Java là PID 1 bằng ENTRYPOINT dạng exec, bật server.shutdown=graceful. Healthcheck của Docker hữu ích cho Compose; Kubernetes bỏ qua nó và dùng probe riêng.

  • Non-root: USER app như Dockerfile ở phần 3. Lý do và lỗi “Permission denied” khi ghi volume có ở bài Linux.
  • PID 1 và signal: docker stop và Kubernetes gửi SIGTERM tới PID 1, chờ (Docker mặc định 10 giây, Kubernetes 30 giây) rồi SIGKILL. Dạng shell ENTRYPOINT java -jar app.jar biến sh thành PID 1 và nuốt SIGTERM; cơ chế này có ở bài hệ điều hành.
  • Graceful shutdown: mình gửi SIGTERM khi app đang xử lý request 5 giây: request đó vẫn trả 200, request mới bị từ chối ngay (bài tập 2).

Healthcheck. HEALTHCHECK cho Docker biết container còn khoẻ không (mặc định 30 giây một lần, lỗi 3 lần là unhealthy), hợp với Compose (condition: service_healthy). Kubernetes bỏ qua nó và gọi probe vào /actuator/health/liveness, /actuator/health/readiness; cấu hình probe và chiến lược rollout thuộc bài về chiến lược deploy.

7. Docker Compose cho môi trường dev

Ý chính: một file compose.yaml dựng PostgreSQL và Redis đúng version của production, đợi chúng sẵn sàng rồi mới chạy app. Cả team có cùng môi trường bằng một lệnh docker compose up.

services:
  postgres:
    image: postgres:17
    environment:
      POSTGRES_DB: orders
      POSTGRES_USER: orders
      POSTGRES_PASSWORD: dev-only
    ports: ["5432:5432"]
    volumes: [pgdata:/var/lib/postgresql/data]
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U orders -d orders"]
      interval: 5s
      retries: 10
  redis:
    image: redis:7.4
    ports: ["6379:6379"]
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      retries: 10
  app:
    build: .
    profiles: [full]
    environment:
      SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/orders
      SPRING_DATASOURCE_USERNAME: orders
      SPRING_DATASOURCE_PASSWORD: dev-only
      SPRING_DATA_REDIS_HOST: redis
    ports: ["8080:8080"]
    depends_on:
      postgres: { condition: service_healthy }
      redis: { condition: service_healthy }
volumes:
  pgdata:
  • Trong mạng của Compose, service gọi nhau bằng tên service (postgres), không phải localhost.
  • depends_on không có condition chỉ đợi container khởi động, không đợi PostgreSQL nhận kết nối.
  • profiles: [full]: mặc định chỉ chạy hạ tầng, dev chạy app từ IDE. Với dependency spring-boot-docker-compose (Spring Boot 3.1+), app tự gọi docker compose up và tự nối datasource.
  • Mật khẩu ở đây chỉ cho máy dev; production lấy secret từ môi trường (12-factor).

8. Kích thước image, tag và quét lỗ hổng

Ý chính: image nhỏ thì kéo nhanh, ít gói để vá. Gắn tag bất biến (version hoặc commit SHA), không deploy latest, và quét lỗ hổng trong CI trước khi image được dùng.

  • Nhỏ hơn: multi-stage, JRE thay JDK, gộp apt-get install và dọn cache trong cùng một RUN (xoá ở layer sau không làm image nhỏ đi).
  • Tag: latest chỉ là tên tag mặc định, không phải “mới nhất”, và bị ghi đè được. Deploy theo orders:1.4.2 hay orders:sha-a1b2c3; chắc nhất là theo digest orders@sha256:..., gắn với nội dung.
  • Quét: Trivy, Grype, Docker Scout so các gói trong image với cơ sở dữ liệu CVE; CI chặn lỗ hổng CRITICAL/HIGH đã có bản vá. Xuất SBOM (danh sách thành phần) để tra nhanh image nào dính CVE mới.
  • Build lại định kỳ dù code không đổi, để nhận bản vá của JRE và hệ điều hành.

Bài tập

Bài 1: Review một Dockerfile

Đề. Dockerfile dưới đây build mất 6 phút mỗi lần sửa một dòng code, image hơn 600 MB, và mỗi lần deploy có vài request lỗi. Tìm ít nhất sáu vấn đề và viết lại.

FROM maven:3-eclipse-temurin-21
COPY . /app
WORKDIR /app
RUN mvn package
ENV JAVA_OPTS="-Xmx1g"
EXPOSE 8080
CMD java $JAVA_OPTS -jar target/orders-0.0.1-SNAPSHOT.jar
Lời giải bài 1: tám vấn đề và Dockerfile đã sửa
  1. Một stage: image chạy chứa JDK, Maven, mã nguồn, kho .m2.
  2. COPY . trước khi build: sửa một dòng là tải lại mọi dependency; thiếu .dockerignore.
  3. Tag maven:3-... trôi: tháng sau ra image khác. Ghim version (và digest).
  4. mvn package chạy cả test khi build image: chậm, Testcontainers hỏng vì không có Docker. Test thuộc về CI.
  5. Fat jar một layer: mỗi deploy đẩy lại 20+ MB thay vì vài KB.
  6. Chạy bằng root.
  7. CMD dạng shell: sh là PID 1, Java không nhận SIGTERM, bị SIGKILL, request đang chạy bị cắt: chính là lỗi lúc deploy.
  8. -Xmx1g cứng: không theo limit; limit 1 GiB thì sẽ OOMKilled.

Bản sửa là Dockerfile ở phần 3, kèm .dockerignore:

target/
.git/
.idea/
*.iml
.env

và application.properties có server.shutdown=graceful. Kiểm chứng: docker build lần hai sau khi sửa một file Java chỉ chạy lại từ COPY src; docker history <image> thấy layer application vài KB; docker stop dừng trong vài giây với log “Graceful shutdown complete”, exit code 143 hoặc 0.

Chưa chạy được ở máy mình: Docker daemon không chạy, nên docker build và docker stop chưa thử. Phần đã chạy là ở bài 2.

Bài 2: Đo lợi ích của layered jar và graceful shutdown

Đề. Không cần Docker: build một app Spring Boot nhỏ, chạy extract --layers, đo kích thước từng layer. Rồi chạy app từ thư mục đã tách (giống trong container) và kiểm tra request đang chạy có hoàn tất khi nhận SIGTERM không.

Lời giải bài 2: lệnh, kết quả đo và giải thích

App: Spring Boot 4.0.9, spring-boot-starter-webmvc + actuator, một endpoint /slow ngủ 5 giây, server.shutdown=graceful. JDK 21, macOS.

$ ./mvnw -q package -DskipTests && ls -la target/*.jar
22017207  target/orders-0.0.1-SNAPSHOT.jar
$ java -Djarmode=tools -jar target/orders-0.0.1-SNAPSHOT.jar list-layers
dependencies
spring-boot-loader
snapshot-dependencies
application
$ java -Djarmode=tools -jar target/*.jar extract --layers --destination extracted
$ du -sh extracted/*
4.0K  extracted/application
 21M  extracted/dependencies
  0B  extracted/snapshot-dependencies
  0B  extracted/spring-boot-loader

application chỉ chứa một jar mỏng (orders-0.0.1-SNAPSHOT.jar) có Class-Path trỏ tới lib/; dependencies chứa lib/*.jar. Ở bản này spring-boot-loader rỗng, vì jar mỏng chạy thẳng bằng java -jar mà không cần launcher của Spring Boot.

Chạy thử như trong container (gộp các layer vào một thư mục), gửi SIGTERM khi /slow đang xử lý:

$ java -jar orders-0.0.1-SNAPSHOT.jar &      # Started App in 0.654 seconds
$ curl localhost:8080/slow &                 # request 5 giây
$ kill -TERM <pid>                           # 1 giây sau
$ curl localhost:8080/actuator/health        # request mới: bị từ chối kết nối
done 200 5.014432s                           # request cũ vẫn hoàn tất
INFO ... GracefulShutdown : Commencing graceful shutdown. Waiting for active requests to complete
INFO ... GracefulShutdown : Graceful shutdown complete

Giải thích: ngoài container, kill gửi thẳng tới JVM nên luôn đúng. Trong container, kết quả này chỉ lặp lại khi Java là PID 1 (dạng exec). Với dạng shell, SIGTERM tới sh và không ai chuyển cho Java. Phần chạy trong container chưa thử vì Docker không chạy trên máy này.

Ghi nhớ

  • Giải thích được container khác VM ở đâu: namespace để cô lập, cgroup để giới hạn, chung một kernel.
  • Viết được Dockerfile nhiều stage cho Spring Boot, biết vì sao thứ tự COPY và layered jar làm build và deploy nhanh.
  • Biết khi nào chọn JRE, distroless, Alpine, và vì sao musl có thể gây lỗi.
  • Phân biệt OOMKilled với OutOfMemoryError, biết đặt MaxRAMPercentage qua JAVA_TOOL_OPTIONS.
  • Kiểm tra được graceful shutdown: dạng exec, non-root, server.shutdown=graceful, và healthcheck nào dùng ở Compose, cái nào ở Kubernetes.

Câu hỏi phỏng vấn

Junior

Container khác máy ảo thế nào?

Container là process dùng chung kernel của host, được cô lập bằng namespace và giới hạn bằng cgroup; máy ảo có kernel riêng chạy trên hypervisor.

Vì không boot kernel, container khởi động trong mili giây và nhẹ hơn nhiều. Đổi lại, ranh giới bảo mật yếu hơn VM, và container Linux cần kernel Linux (trên Mac/Windows, Docker chạy trong một VM Linux).

CMD và ENTRYPOINT khác nhau thế nào?

ENTRYPOINT là chương trình luôn chạy; CMD là tham số mặc định, bị thay bởi phần sau tên image trong docker run.

Kết hợp hay gặp: ENTRYPOINT ["java", "-jar", "app.jar"] và CMD ["--spring.profiles.active=prod"]. Cả hai nên viết dạng exec (mảng JSON) để process là PID 1 và nhận được signal; dạng shell chạy qua /bin/sh -c.

COPY và ADD khác nhau thế nào? Nên dùng cái nào?

Dùng COPY. ADD làm thêm hai việc ngầm: tải từ URL và tự giải nén file tar cục bộ.

Hành vi ngầm làm Dockerfile khó đoán (một file .tar.gz bị bung ra mà người đọc không ngờ), và tải URL bằng ADD khó kiểm checksum, khó cache. Cần tải thì dùng RUN curl kèm kiểm checksum trong stage build.

Mid

Vì sao không nên deploy image với tag latest?

Vì latest là một nhãn có thể bị ghi đè: không biết production đang chạy code nào, hai node có thể kéo hai image khác nhau, và rollback không xác định được.

latest chỉ là tên tag mặc định, không phải “bản mới nhất”. Hãy tag theo version hoặc commit SHA, và deploy theo digest (@sha256:...) để chắc nội dung không đổi. Tag bất biến còn giúp truy ngược: thấy lỗi ở image nào là biết commit nào.

Vì sao không chạy container bằng root?

Vì nếu ứng dụng bị khai thác, kẻ tấn công có root trong container, gần host hơn một bước khi có lỗi kernel hoặc cấu hình lỏng.

Tạo user hệ thống trong Dockerfile và USER app; trên Kubernetes thêm runAsNonRoot: true và readOnlyRootFilesystem: true với emptyDir cho /tmp. Ứng dụng Spring Boot không cần quyền root vì port 8080 không phải port đặc quyền.

Senior

Pod Spring Boot restart liên tục với exit code 137, log không có lỗi. Bạn điều tra thế nào?

137 là chết vì SIGKILL: thường là kernel OOM killer vì RSS vượt memory limit, hoặc bị kill sau grace period vì không dừng kịp khi nhận SIGTERM.

  • kubectl describe pod: Last State: Terminated, Reason: OOMKilled thì là memory. So -Xmx hoặc MaxRAMPercentage với limit; đo RSS và NMT để thấy phần ngoài heap (metaspace, thread, direct buffer).
  • Không phải OOMKilled mà restart lúc deploy: kiểm tra ENTRYPOINT dạng shell và thời gian graceful shutdown so với terminationGracePeriodSeconds.
  • Liveness probe quá gắt cũng gây restart (pod bị giết khi GC dừng lâu).
  • Sửa: đặt phần trăm heap hợp lý, ExitOnOutOfMemoryError, limit = phần đo được cộng dư 20–30%.
Image Spring Boot 900 MB, mỗi lần build 8 phút. Bạn tối ưu thế nào?

Tách stage build và runtime, dùng JRE, sắp layer theo tần suất thay đổi, tách jar thành layer, và cache dependency Maven.

  • Multi-stage: image chạy chỉ có JRE và app, bỏ JDK, Maven, mã nguồn.
  • COPY pom.xml và tải dependency trước COPY src; cache mount /root/.m2 với BuildKit; .dockerignore.
  • extract --layers: sửa code chỉ đổi layer application vài KB.
  • Trong CI: cache layer của BuildKit (cache-from/cache-to), không chạy test hai lần (test ở bước CI, Dockerfile chỉ đóng gói).
  • Đo trước và sau bằng docker history và thời gian build, không đoán.
Bạn chọn Alpine hay distroless cho service Java production?

Thường là distroless hoặc JRE trên Debian/Ubuntu, không phải Alpine, vì Alpine đổi glibc lấy musl mà chỉ tiết kiệm vài chục MB.

musl có thể làm hỏng thư viện native build cho glibc và có khác biệt khi phân giải DNS. Distroless vẫn dùng glibc, rất ít gói nên ít CVE, nhưng không có shell: phải dùng dạng exec, debug bằng kubectl debug hoặc tag :debug. Nếu team cần shell để vận hành, JRE trên Ubuntu là thoả hiệp hợp lý.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
namespace /ˈneɪm.speɪs/ không gian tên, cô lập tầm nhìn “Namespaces decide what a container can see; cgroups decide how much it can use.”
control group (cgroup) /kənˈtroʊl ɡruːp/ nhóm giới hạn tài nguyên “The memory limit is just memory.max on the container’s cgroup.”
layer /ˈleɪ.ɚ/ lớp của image “Changing one layer invalidates every layer after it.”
build context /bɪld ˈkɑːn.tekst/ thư mục gửi cho Docker khi build “A .dockerignore keeps the build context small.”
multi-stage build /ˌmʌl.ti ˈsteɪdʒ bɪld/ build nhiều giai đoạn “A multi-stage build keeps the JDK out of the runtime image.”
base image /beɪs ˈɪm.ɪdʒ/ image nền “We picked a JRE base image over Alpine to stay on glibc.”
distroless /ˈdɪs.troʊ.ləs/ image không có bản phân phối Linux đầy đủ “Distroless images have no shell, so the entrypoint must be in exec form.”
exec form /ɪɡˈzek fɔːrm/ dạng mảng JSON của lệnh “Use exec form so the JVM is PID 1 and receives SIGTERM.”
digest /ˈdaɪ.dʒest/ mã băm nội dung image “We deploy by digest, because tags can be moved.”
vulnerability scanning /ˌvʌl.nɚ.əˈbɪl.ə.ti ˈskæn.ɪŋ/ quét lỗ hổng “The pipeline fails on fixable critical vulnerabilities.”
graceful shutdown /ˈɡreɪs.fəl ˈʃʌt.daʊn/ tắt êm “With graceful shutdown, in-flight requests finish before the JVM exits.”

Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.