Optimizing Docker Image Builds: Correct Usage of .dockerignore and RUN Statement Consolidation Strategies

Analysis of Docker Image Size Inflation

During Docker builds, developers often encounter unexpected increases in image size. As shown in the example, after installing Puppet modules, the image expanded from 600MB to 3GB. This growth typically results from build cache invalidation and the cumulative effect of image layers.

Correct Understanding of .dockerignore Files

The mechanism of .dockerignore files is frequently misunderstood. This file only excludes files from the build context, preventing them from being sent to the Docker daemon for building. Its syntax resembles .gitignore, but its functional scope differs. The key point is that .dockerignore does not prevent files generated inside the image, such as those created by RUN commands.

Common syntax examples:

# Exclude the modules directory in the context root
modules

# Exclude modules directories at all levels
**/modules

# Exclude all but re-include specific files
*
!src

Effective method to test build context contents:

docker build -t test-context -f - . <<EOF
FROM busybox
COPY . /context
WORKDIR /context
CMD find .
EOF

RUN Statement Consolidation Optimization Strategy

The fundamental cause of image size inflation is that each RUN statement creates a new image layer. Even if files are deleted later, they remain in historical layers, causing the final image to contain redundant data.

Dockerfile fragment before optimization:

RUN librarian-puppet install
RUN puppet apply --modulepath=/modules -e "class { 'buildslave': jenkins_slave => true,}"
RUN librarian-puppet clean

Consolidated solution after optimization:

RUN librarian-puppet install &&\
 puppet apply --modulepath=/modules -e "class { 'buildslave': jenkins_slave => true,}" &&\
 librarian-puppet clean

By using && to chain multiple commands, all operations complete within a single RUN layer. This ensures temporary files are cleaned up within the same layer and not retained in the final image.

Comprehensive Optimization Practices

Combining .dockerignore with RUN consolidation strategies, the complete optimization approach includes:

1. Creating a .dockerignore file in the build context root to exclude unnecessary local files
2. Consolidating related RUN commands into single statements to reduce image layers
3. Completing installation, configuration, and cleanup operations within individual RUN layers
4. Utilizing multi-stage builds for further optimization of final images

Practical testing shows that through these optimizations, the example image size can be significantly reduced from 3GB while maintaining effective build cache utilization.