Skip to main content

Docker Images

Docker images are the core building blocks of Docker containers. They serve as lightweight, stand-alone, and executable software packages that include everything needed to run a piece of software: the code, runtime, libraries, environment variables, and configurations.

Key Characteristics of Docker Images​

  1. Read-Only Layers:

    • Docker images are made up of a series of layers.
    • Each layer corresponds to an instruction in the Dockerfile (e.g., RUN, COPY).
    • Layers are read-only and stacked on top of each other to form the final image.

  2. Immutability:

    • Images are immutable, meaning their contents cannot be altered once created.
    • Any changes to an image result in a new layer, forming a new image.

  3. Portability:

    • Images can be built on one machine, shared, and run on another, ensuring consistent environments across development, testing, and production.

  4. Efficiency:

    • Layers are shared between images, reducing duplication and saving disk space.
    • Only the layers that are not already cached are downloaded when pulling an image.

Components of a Docker Image​

  1. Base Image:

    • The starting point of any Docker image.
    • Can be an official image (like ubuntu or node) or a custom one.

  2. Layers:

    • Each layer is a snapshot of changes made during the image build process.
    • Layers are identified by unique SHA256 hash values.

  3. Image Metadata:

    • Includes details like author, build date, and the command to execute when the container starts.
    • Defined using the LABEL instruction in the Dockerfile.

  4. Manifest:

    • A JSON file describing the image, including its layers and architecture.

Creating a Docker Image​

Docker images are typically created using a Dockerfile, a text document with step-by-step instructions. Here’s a breakdown of the process:

  1. Write a Dockerfile: Example:

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

  2. Build the Image: Run the docker build command:

    docker build -t my-python-app .
    • -t assigns a name (or tag) to the image.
    • The . indicates the build context.

  3. Verify the Image: List all local images using:

    docker images

Docker Image Lifecycle​

  1. Pulling: Downloading an image from a registry (e.g., Docker Hub):

    docker pull ubuntu:latest

  2. Running: Create a container from the image:

    docker run -it ubuntu

  3. Pushing: Uploading an image to a registry:

    docker push myusername/myimage:tag

  4. Deleting: Removing unused images to free up space:

    docker rmi myimage:tag

Common Docker Image Commands​

  • Inspecting an Image:

    docker inspect <image-name>

    Provides detailed metadata about the image.

  • History of an Image:

    docker history <image-name>

    Shows the layers and commands used to create the image.

  • Tagging an Image:

    docker tag myimage:latest myusername/myimage:v1

    Assigns a new tag to the image.

Docker Image Repositories and Registries​

  1. Docker Hub:

    • The default and most widely used registry.
    • Hosts official images like nginx, mysql, and node.

  2. Private Registries:

    • Organizations can host private Docker registries for security and control.
    • Examples include Amazon Elastic Container Registry (ECR), Google Container Registry (GCR), and GitHub Container Registry.

  3. Managing Images in a Registry:

    • Use docker login to authenticate.
    • Push images with docker push.

Optimizing Docker Images​

  1. Use Official Base Images:

    • Leverage lightweight images like alpine for smaller footprints.

  2. Reduce the Number of Layers:

    • Combine commands where possible: 
      RUN apt-get update && apt-get install -y package

  3. Ignore Unnecessary Files:

    • Use a .dockerignore file to exclude files from the build context.

  4. Use Multi-Stage Builds:

    • Build, test, and reduce image size in one Dockerfile:

      FROM golang:1.17 as builder
      WORKDIR /app
      COPY . .
      RUN go build -o myapp

      FROM alpine:latest
      COPY --from=builder /app/myapp /myapp
      CMD ["/myapp"]