How is caching implemented in Docker?

Caching in Docker during image build occurs at the layer level. Each layer represents the result of executing a single instruction in the Dockerfile. The Docker engine monitors changes in instructions and files. If an instruction and its associated files haven't changed since the last build, Docker uses the cached layer.

How it works:

1. Docker reads the Dockerfile from top to bottom.
2. Each instruction (RUN, COPY, ADD, etc.) is processed as a separate step, creating a new layer.
3. Before executing a step, Docker checks if a cached layer corresponding to this instruction exists.
4. If such a layer is found, and the content of the cached layer and the current step match (hash check), Docker skips executing the instruction and uses the cached layer.
5. If the cached layer is not found or does not match, Docker executes the instruction, creates a new layer, and saves it in the cache.

Main instructions affecting caching:

• FROM: Changing the base image invalidates the cache for all subsequent instructions.
• RUN: Any change in the RUN command invalidates the cache for this and all subsequent layers.
• COPY, ADD: Cache is invalidated if the contents of the copied/added files change. The order of files also matters.
• ENV, ARG, LABEL: Changing these instructions generally does not invalidate the cache for subsequent RUN, COPY, ADD unless they depend on these variables.

Caching optimization strategies:

• Place instructions that change most frequently (e.g., COPY ./src /app) lower in the Dockerfile.
• Combine multiple RUN commands into one using && to reduce the number of layers and potentially improve caching (but be careful, as changing any part of the combined command invalidates the entire layer).
• Use .dockerignore to exclude files that should not be part of the build context, helping prevent unnecessary cache invalidation when these files change.

Example of RUN optimization:

# Poor caching:
RUN apt-get update
RUN apt-get install -y some-package
RUN apt-get clean

# Good caching:
RUN apt-get update && \
    apt-get install -y some-package && \
    rm -rf /var/lib/apt/lists/* # Clean apt cache

Command to build using cache:

docker build -t my-image .

By default, docker build uses cache.

Disabling cache:

docker build --no-cache -t my-image .

Disabling cache forces Docker to execute all instructions anew. This is useful for debugging or if you suspect the cache is outdated.