Great question! The issue you're seeing likely happens because deleting the old user/prj:1.0 image removed shared layers that user/prj:1.1 still needs, forcing Docker to re-pull those layers from scratch. Here are actionable best practices to speed up future pulls:

• Optimize your Dockerfile for layer reuse
  Docker builds images in layers, and it will reuse existing local layers if they match exactly. Structure your Dockerfile to put the least frequently changing parts first:

  # Keep base image and dependencies at the top (rarely changes)
  FROM ubuntu:14.04
  RUN apt-get update && apt-get install -y --no-install-recommends your-dependencies
  # Copy application code last (changes often)
  COPY . /app
  RUN make build
  

  This way, when you update to a new version like 1.1 or 2.0, only the layers with your application code will need to be pulled—all the base and dependency layers will be reused from your local cache (as long as you don't delete them prematurely).

• Avoid premature deletion of old images
  When you run docker rmi user/prj:1.0, Docker will delete any layers that aren't used by other images. If user/prj:1.1 shares most layers with 1.0 (which it should if your Dockerfile is optimized), deleting 1.0 first means those shared layers get wiped, and you have to re-pull them for 1.1. Wait until after you've pulled and verified the new image before cleaning up old ones.

• Switch to a lighter base image
  Ubuntu 14.04 is a full-fledged OS image with lots of unnecessary files for most applications. Consider using a slimmed-down variant like ubuntu:14.04-slim or even a tiny distro like Alpine (if your app supports it). These images are significantly smaller, so pulling them takes much less time.

• Set up a local private registry
  If you're pulling images frequently within a team or organization, hosting a private Docker registry on your local network eliminates the need to pull from public registries like Docker Hub. You can push your built images to this local registry once, and all subsequent pulls will be over your fast internal network. To set one up, just run:

  docker run -d -p 5000:5000 --restart=always --name registry registry:2
  

  Then tag your images for the local registry and push them:

  docker tag user/prj:1.1 localhost:5000/user/prj:1.1
  docker push localhost:5000/user/prj:1.1
  

• Tweak Docker's download concurrency
  By default, Docker limits concurrent layer downloads. You can increase this to pull multiple layers at once, which speeds up the process. Edit (or create) /etc/docker/daemon.json and add:

  {
    "max-concurrent-downloads": 10
  }
  

  Then restart the Docker daemon:

  sudo systemctl restart docker
  

• Ensure image compression is enabled
  Most modern Docker registries (including Docker Hub) compress images by default, but if you're using a custom registry, double-check that compression is turned on. Compressed images are much smaller, reducing the amount of data you need to download.

• Use incremental updates for application code
  Instead of copying your entire codebase with COPY . /app, consider using tools like rsync or Docker's multi-stage builds to only copy changed files. Multi-stage builds also let you strip out build-time dependencies from the final image, making it smaller overall.

内容的提问来源于stack exchange，提问作者user9405697