Layer caching and ordering in Docker - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Effect of Dockerfile instruction order on cache usage

Consider this Dockerfile snippet:

FROM python:3.12-slim
COPY requirements.txt /app/
RUN pip install -r /app/requirements.txt
COPY . /app/
CMD ["python", "/app/app.py"]

If you change the order of the COPY instructions to copy the entire app directory before copying requirements.txt, what will happen when you rebuild the image after only changing app.py?

Docker

FROM python:3.12-slim
COPY requirements.txt /app/
RUN pip install -r /app/requirements.txt
COPY . /app/
CMD ["python", "/app/app.py"]

A Docker will reuse the cached layer for pip install because requirements.txt did not change.

B Docker will fail to build because of conflicting COPY instructions.

C Docker will skip copying app.py because it was not changed.

D Docker will rerun pip install because copying the entire app directory first invalidates the cache for requirements.txt.

💡 Hint

Think about how Docker caches layers based on the exact content of files copied before a RUN command.

Docker caches layers based on the exact content of files copied before a RUN command. If you copy the entire app directory before copying requirements.txt, any change in app.py will change the entire directory content, invalidating the cache for the pip install layer.

🧠 Conceptual

intermediate

Why is ordering Dockerfile instructions important for caching?

Which statement best explains why ordering instructions in a Dockerfile affects build speed?

A Docker caches each layer and reuses it only if the instruction and its context have not changed, so ordering stable instructions first maximizes cache reuse.

B Docker executes instructions in parallel, so order does not affect caching.

C Docker ignores file changes when caching layers, so ordering only affects readability.

D Docker rebuilds all layers every time regardless of instruction order.

💡 Hint

Think about what triggers cache invalidation in Docker builds.

Docker caches layers and reuses them only if the instruction and its context (files copied, commands run) have not changed. Placing stable instructions early helps reuse cache and speeds up builds.

❓ Troubleshoot

advanced

Diagnosing unexpected cache invalidation in Docker builds

You notice that your Docker build always reruns RUN npm install even though package.json has not changed. Your Dockerfile snippet is:

FROM node:20
COPY . /app
WORKDIR /app
RUN npm install
CMD ["node", "server.js"]

What is the most likely cause?

Docker

FROM node:20
COPY . /app
WORKDIR /app
RUN npm install
CMD ["node", "server.js"]

A Copying the entire directory before <code>RUN npm install</code> causes cache invalidation if any file changes, even unrelated ones.

B The <code>npm install</code> command always runs and is never cached.

C The <code>WORKDIR</code> instruction invalidates the cache for <code>RUN npm install</code>.

D The <code>CMD</code> instruction causes cache invalidation for previous layers.

💡 Hint

Consider what files affect the cache for the RUN npm install layer.

Copying the entire directory before RUN npm install means any file change invalidates the cache for that layer. To optimize, copy only package.json first, run npm install, then copy the rest.

🔀 Workflow

advanced

Optimizing Dockerfile for faster rebuilds with frequent code changes

You have a Python app with dependencies listed in requirements.txt. You frequently change app.py but rarely change dependencies. Which Dockerfile instruction order best optimizes build caching?

A

COPY . /app
RUN pip install -r /app/requirements.txt
CMD ["python", "/app/app.py"]

B

COPY requirements.txt /app/
RUN pip install -r /app/requirements.txt
COPY . /app/
CMD ["python", "/app/app.py"]

C

RUN pip install -r /app/requirements.txt
COPY . /app/
CMD ["python", "/app/app.py"]

D

COPY app.py /app/
COPY requirements.txt /app/
RUN pip install -r /app/requirements.txt
CMD ["python", "/app/app.py"]

💡 Hint

Think about which files change often and which do not, and how Docker caches layers.

Copying requirements.txt and running pip install first caches dependencies. Then copying the rest means changes to app.py don't invalidate the dependency layer, speeding rebuilds.

✅ Best Practice

expert

Best practice for minimizing Docker image rebuild time with frequent source code changes

Which Dockerfile layering strategy best minimizes rebuild time when source code changes frequently but dependencies rarely change?

A Combine all COPY commands into one to reduce layers and copy everything at once.

B Copy source code first, then dependency files, then install dependencies to ensure latest code is always used.

C Copy dependency files first, run dependency installation, then copy source code separately to maximize cache reuse of dependencies.

D Run dependency installation before any COPY commands to avoid copying unnecessary files.

💡 Hint

Consider how Docker cache invalidation works with file changes and layer order.

Copying dependency files first and installing dependencies before copying source code allows Docker to reuse the cached dependency layer when only source code changes, minimizing rebuild time.