Docker image layer และ build caching ทำงานอย่างไร?

Question

Accepted Answer

Docker image ถูก build เป็น **layer** — แต่ละคำสั่งใน Dockerfile สร้าง layer และ Docker **cache** layer เพื่อเร่งการ rebuild การเข้าใจ layer และ caching เป็นกุญแจสำคัญในการเขียน Dockerfile ที่มีประสิทธิภาพซึ่ง build เร็วและสร้าง image ที่เล็กลง

## Layer — แต่ละคำสั่งเพิ่ม layer

```text
Each Dockerfile instruction (FROM, RUN, COPY, etc.) creates a read-only LAYER:
  → layers stack to form the image; layers are CACHED and SHARED between images
  → if a layer is unchanged, Docker REUSES the cached layer (skips rebuilding it)
→ Layer caching makes rebuilds fast — only changed layers (and those AFTER) rebuild.
```

## กฎของ caching (ลำดับมีความสำคัญ)

```text
Docker caches layers IN ORDER. When an instruction's input changes, that layer AND
ALL layers AFTER IT are rebuilt (cache invalidated from that point down).
→ Put STABLE things EARLY and FREQUENTLY-CHANGING things LATE in the Dockerfile.
```

## การ optimize แบบคลาสสิก: dependency ก่อนโค้ด

```dockerfile
# ✅ GOOD — copy dependency manifest first, install, THEN copy code
COPY package*.json ./
RUN npm install          # this layer is cached UNLESS package.json changes
COPY . .                 # code changes here don't invalidate the npm install layer

# ❌ BAD — copy everything first
COPY . .                 # ANY code change invalidates...
RUN npm install          # ...so npm install RE-RUNS on every code change (slow!)
```

ด้วยการคัดลอกไฟล์ dependency และติดตั้ง **ก่อน** คัดลอกโค้ดส่วนที่เหลือ layer ติดตั้ง dependency (ที่ช้า) จะยังคงถูก cache ไว้ตลอดการเปลี่ยนแปลงโค้ด — เป็นการ optimize ที่สำคัญอย่างยิ่งซึ่งทำให้การ rebuild เร็ว

## การลดขนาด image

```text
✓ Combine related RUN commands (fewer layers) and clean up in the SAME layer
  RUN apt-get update && apt-get install -y x && rm -rf /var/lib/apt/lists/*
✓ Use small base images (alpine, slim, distroless)
✓ Use .dockerignore to exclude unneeded files from the build context
✓ Use multi-stage builds (build artifacts in one stage, copy only what's needed)
```

## ทำไมจึงสำคัญ

การเข้าใจ Docker layer และ build caching สำคัญต่อการ **เขียน Dockerfile ที่มีประสิทธิภาพ** ซึ่ง build รวดเร็วและสร้าง image ที่เล็กลง จึงเป็นความรู้ปฏิบัติที่มีคุณค่าซึ่งส่งผลอย่างมากต่อประสิทธิภาพการทำงานของ developer และการ deploy

แนวคิดพื้นฐาน — แต่ละคำสั่งใน Dockerfile สร้าง **layer** ที่ถูก cache และนำกลับมาใช้ได้ และ Docker **นำ layer ที่ถูก cache และไม่เปลี่ยนแปลงกลับมาใช้** ในขณะที่ rebuild layer ที่เปลี่ยนแปลงและทุกอย่างหลังจากนั้น — อธิบายวิธีทำให้การ build เร็ว

**กฎ caching สำคัญ** (cache ถูกยกเลิกตั้งแต่คำสั่งแรกที่เปลี่ยนแปลงลงไป ดังนั้นลำดับจึงมีความสำคัญ: สิ่งที่เสถียรไว้ก่อน สิ่งที่เปลี่ยนแปลงบ่อยไว้ทีหลัง) ขับเคลื่อน **การ optimize ที่สำคัญที่สุด**: การคัดลอกไฟล์ dependency และติดตั้ง dependency **ก่อน** คัดลอกโค้ดแอปพลิเคชัน เพื่อให้ layer ติดตั้ง dependency ที่ช้ายังคงถูก cache ไว้ตลอดการเปลี่ยนแปลงโค้ดที่บ่อย (แทนการรัน `npm install`/`pip install` ใหม่ทุกครั้งที่โค้ดเปลี่ยน — ซึ่งเป็นความแตกต่างระหว่างการ rebuild ที่เร็วกับช้าจนทรมาน)

การเข้าใจรูปแบบนี้เพียงอย่างเดียวก็ช่วยปรับปรุงเวลา build ได้อย่างมาก ซึ่งเป็นข้อกังวลด้านประสบการณ์ของ developer ที่มีอยู่ตลอด

การรู้เทคนิคในการ **ลดขนาด image** — การรวมคำสั่ง RUN พร้อมทำความสะอาดใน layer เดียวกัน, การใช้ base image ที่เล็ก (alpine, slim, distroless), `.dockerignore` เพื่อไม่รวมไฟล์ที่ไม่จำเป็น และ multi-stage build — สร้าง image ที่เล็กลงและ deploy ได้เร็วขึ้น (ลดพื้นที่จัดเก็บ, เวลาในการถ่ายโอน และพื้นที่โจมตี)

เนื่องจากการ build Docker เกิดขึ้นตลอดเวลา (ในการพัฒนาและ CI/CD) และการ build ที่ช้าหรือ image ที่ใหญ่เกินไปทำร้ายประสิทธิภาพการทำงานและการ deploy และเนื่องจากการเข้าใจ layer และ caching เป็นสิ่งที่ทำให้เขียน Dockerfile ที่ build เร็วและเล็กได้ การเข้าใจ Docker layer และ build caching — โมเดล layer, กฎ caching ที่ขึ้นกับลำดับ, การ optimize แบบ dependency ก่อนโค้ด และเทคนิคการลดขนาด — จึงเป็นความรู้ที่มีคุณค่าและนำไปใช้บ่อยสำหรับการใช้ Docker อย่างมีประสิทธิภาพ เป็นทักษะสำคัญที่แยกผู้ที่เขียน Dockerfile ที่เร็วและกระชับออกจากผู้ที่ทนทุกข์กับการ build ที่ช้าและ image ที่ใหญ่เกินไป