To reduce a Docker image’s shipped size, keep compilers and other build-only tools out of the final image, copy in only the files the application needs at runtime, choose a trusted compatible runtime base, and avoid copying irrelevant files into the build. Measure the resulting image and verify that the container still works. Build-cache tuning can speed up rebuilds, but it does not by itself make the runtime image smaller.
Find what is making the image large
Start with a baseline so you can tell whether a change affected the artifact you ship. Docker’s multi-stage tutorial uses docker images to display image sizes. For example, inspect a local image with:
As an Amazon Associate I earn from qualifying purchases.
docker images your-image:tagTo investigate how size accumulated, inspect the image history:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
docker history your-image:tagDockerfile instructions create layers, so history can help identify which steps added files or dependencies. A later deletion does not reliably remove bytes committed in an earlier layer. The more effective approach is to prevent unneeded files from entering the final image at all. See Docker’s guidance on build cache and layers and building images.
#1 Best Overall
Use a multi-stage build to keep build tools out of runtime
A multi-stage Dockerfile separates building the application from running it. The builder stage can contain compilers, test tools, package managers, and other build dependencies; the final stage starts from a runtime base and receives only the output and dependencies needed to run the application. Docker’s COPY --from instruction transfers selected files between stages.
A simplified pattern looks like this:
FROM build-image AS builder
WORKDIR /src
COPY . .
RUN build-command
FROM runtime-image
WORKDIR /app
COPY --from=builder /src/output /app
CMD ["./app"]Replace the example image names, build command, output path, and startup command with values that match your application. The final stage must include any runtime libraries, certificates, configuration, and other files the program actually requires; copying only the main executable may not be sufficient.
Docker’s multi-stage tutorial shows its sample Spring application at 880 MB before and 428 MB after a multi-stage change. Those are illustrative docker images outputs for that example, not a typical reduction or a result to expect from another project. Image contents and displayed size vary by build and architecture. Consult Docker’s multi-stage build guide for the pattern and its example.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Choose a runtime base that is small, trusted, and compatible
A smaller base can reduce the files and dependencies shipped, but the smallest image is not automatically the right one. The application may depend on system libraries, a particular runtime, certificates, or other capabilities missing from a minimal base. Compare candidate bases against:
- Runtime compatibility: Confirm that the application and its required libraries work on the base.
- Trust and maintenance: Use a trusted image source and a base that is maintained appropriately.
- Included components: Consider which dependencies and capabilities the image brings into production.
- Final size and rebuild speed: Evaluate these separately; a faster build does not necessarily produce a smaller image.
It is often useful to use a fuller image for building and testing, then a slimmer compatible image for runtime. Docker discusses base-image selection and related trade-offs in its building best practices. Do not copy an example tag from a tutorial without checking that it is supported and suitable for your application.
Exclude files that the build does not need
A .dockerignore file prevents selected files from being sent as part of the build context. Common candidates include .git, local build outputs, and dependency directories that the build restores itself. For example:
.git
build/
dist/
node_modules/This is a starting point, not a universal ignore list. Exclude a path only if the build does not need it. Limiting the context can reduce transfer and avoid accidental copies; it reduces final image size when those files would otherwise have been copied into an image layer. Docker’s best practices explain build-context guidance, and its Docker Offload optimization guidance discusses context exclusions.
Rebuild, compare, and test the runtime behavior
- Record the starting point. Note the image tag and displayed size from
docker images; inspectdocker historyif you need to locate large layers. - Refine the context. Add or adjust
.dockerignore, excluding only files that are not needed during the build. - Separate build and runtime. Put build-only tools in an earlier stage and copy required outputs into the final stage with
COPY --from. - Check the runtime base. Ensure the final stage contains the libraries and system capabilities the application requires.
- Build and compare. Rebuild the image, then compare its displayed size with your baseline.
- Run the application and relevant checks. Confirm that startup, core behavior, and any required health checks work in the final image.
Make changes incrementally when practical. That makes it easier to identify which Dockerfile change affected size or broke runtime behavior. Docker’s multi-stage tutorial demonstrates comparing the image before and after its change, but its sample values are specific to that tutorial.
Treat cache optimization as a separate goal
Docker’s build cache can avoid repeating work when relevant inputs have not changed. Ordering Dockerfile steps and managing cache can improve rebuild efficiency, particularly in CI environments with little persistent local state. These changes help build time; they are not evidence that fewer runtime files are shipped. See Docker’s guides to using the build cache, cache storage backends, and cache invalidation.
Also distinguish two build options: --no-cache rebuilds without using cached layers, while --pull attempts to fetch a newer base image. Neither option, by itself, is a method for shrinking the final image. Docker explains these and related practices in its build best practices.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Recommended Free Tools
