DEV Community

Darshan Vasani
Darshan Vasani Subscriber

Posted on • Edited on

🧩 Docker Layer Caching

#webdev #programming #docker #devops

🧩 Docker Layer Caching: What & Why?

When you build a Docker image, each instruction (like COPY, RUN, etc.) creates a layer. Docker caches these layers 🔄 so it can reuse them in future builds, making things faster!

🔥 Why Layer Order Matters

Docker reads your Dockerfile top to bottom 📜⬇️
The first changed line invalidates the cache for all lines after it ❌🚫

📊 Example: Bad vs Good Sequence

🚫 BAD Dockerfile (Unoptimized Layer Order) 

COPY . .        # ❌ Copies everything first (even changing README breaks cache)
RUN npm install # Cache busts often!
Enter fullscreen mode Exit fullscreen mode

✅ GOOD Dockerfile (Optimized Layer Order) 

COPY package*.json ./  # ✅ Only changes when dependencies change
RUN npm install        # ✅ Reused most of the time
COPY . .               # ✅ Source code comes after
Enter fullscreen mode Exit fullscreen mode

🧠 Why?

  • If you copy the whole source before installing deps, any code change breaks the cache for dependencies!
  • By copying just package.json first, Docker only re-installs when dependencies change.

✅ Recommended Layer Order Cheat Sheet 📝

Layer Why It Comes Here
FROM Base image, foundation layer 🏗️
WORKDIR Set working directory 📁
COPY package*.json ./ Dependency file copied first for caching 🧃
RUN npm ci or RUN npm install Install deps (caches as long as package.json doesn’t change) 📦
COPY . . Now copy the actual app code 🧑‍💻
EXPOSE & ENV Doesn’t affect cache much, but goes here 🔌
CMD Entrypoint, doesn't affect caching 🟢

🧠 Pro Caching Tips

💡 Tip 🛠️ Description
🧩 Use .dockerignore Prevent unnecessary files (e.g. .git, node_modules) from breaking cache.
🧪 Use npm ci Faster and more reproducible in CI/CD than npm install.
🧑‍🏭 Split dev & prod builds Use multi-stage builds to keep production images small and cache efficient.
🔐 Use exact base versions Use node:20-alpine instead of node:alpine to avoid unexpected cache busts.

🚀 Visual Analogy

Think of Docker caching like making layered sandwiches 🥪:

  • 🥖 If you change the base bread (early layers), the whole sandwich needs to be rebuilt.
  • 🧀 But if you change just the top slice of tomato 🍅 (code), you don’t need to rebuild the whole thing.

🔁 Final Thought

💬 Always structure your Dockerfile to keep slow-changing layers at the top and fast-changing layers (like source code) at the bottom — this will save build time ⏱️ and make CI/CD faster ⚡.

Top comments (0)