Building Images with Dockerfile

A Dockerfile is a plain-text script containing a series of instructions that Docker executes in order to build an image. Every line in a Dockerfile creates a new layer in the image. Understanding how to write efficient Dockerfiles is one of the most important Docker skills.

Dockerfile Basics

# Start from an official base image
FROM node:20-alpine

# Set the working directory inside the container
WORKDIR /app

# Copy dependency manifests first (for layer caching)
COPY package.json package-lock.json ./

# Install dependencies
RUN npm ci --omit=dev

# Copy the rest of the application source
COPY . .

# Expose the port the app listens on
EXPOSE 3000

# Default command to run when the container starts
CMD ["node", "src/index.js"]

Key Dockerfile Instructions

• FROM — specifies the base image. Every Dockerfile must start with FROM. Choose a minimal base like alpine or slim variants where possible.
• WORKDIR — sets the working directory for subsequent instructions. Creates the directory if it does not exist.
• COPY — copies files from the build context (your local machine) into the image.
• RUN — executes a shell command during the build and commits the result as a new layer.
• ENV — sets environment variables that persist at runtime.
• EXPOSE — documents which port the container listens on (informational only; does not publish the port).
• CMD — the default command to run when the container starts. Can be overridden at runtime.
• ENTRYPOINT — similar to CMD but harder to override; used for containers designed to run as executables.

Building an Image

# Build an image from a Dockerfile in the current directory
# -t gives the image a name and optional tag
docker build -t my-app:1.0 .

# Build with a specific Dockerfile
docker build -f Dockerfile.prod -t my-app:prod .

# View the image you just built
docker images my-app

# Run the image to test it
docker run --rm -p 3000:3000 my-app:1.0

Layer Caching

Docker caches each layer. When you rebuild an image, Docker reuses cached layers for every instruction that has not changed. Once a layer is invalidated — because a file it depends on changed — all subsequent layers are rebuilt.