Learn about the Dockerfile core concepts

Learn about the Dockerfile core concepts

A Dockerfile is a script used to define the steps needed to create a Docker image. It contains a set of instructions that Docker follows to create an image with all the necessary dependencies and configuration for a container.

Let's go through the core concepts of Dockerfile.

1. Base Image

Definition:

The starting point for creating a Docker image. It provides a minimal environment including the necessary OS and runtime.

Example:

FROM node:14-alpine, FROM ubuntu:20.04

2. Instructions

Dockerfile instructions specify what actions should be performed at each step.

Some common instructions include:

1. RUN: Executes commands during image build.

2. COPY: Copies files from the host into the container’s filesystem.

3. ADD: Adds files into the container and extracts them if needed.

4. WORKDIR: Sets the working directory for subsequent instructions.

5. ENTRYPOINT: Defines the command to run when starting a container.

6. CMD: Specifies default arguments to the ENTRYPOINT command.

7. FROM: Specifies the base image.

3. Layers

Definition:

Each instruction in a Dockerfile creates a new layer, which can be cached for efficient builds.

Purpose:

Layers are independent and cached, reducing rebuild times when files or dependencies haven’t changed.

4. Commands

1. RUN: Executes shell commands to install packages or perform other tasks.

xxxxxxxxxx
1
1
RUN apt-get update && apt-get install -y curl

2. COPY: Copies files from the build context into the container.

xxxxxxxxxx
1
1
COPY ./app /app

3. ADD: Adds files and optionally extracts them (e.g., for tar archives).

xxxxxxxxxx
1
1
ADD ./app.tar.gz /app

4. WORKDIR: Sets the working directory for the following instructions.

xxxxxxxxxx
1
1
WORKDIR /app

5. ENTRYPOINT: Defines the main process to run when the container starts.

xxxxxxxxxx
1
1
ENTRYPOINT ["python", "app.py"]

6. CMD: Provides default arguments for the ENTRYPOINT command.

xxxxxxxxxx
1
1
CMD ["--port", "80"]

5. Environment Variables

ENV:

Defines environment variables for the container.

xxxxxxxxxx
1
1
ENV APP_ENV=production

6. Exposing Ports

EXPOSE:

Exposes a port on the container to the host system.

xxxxxxxxxx
1
1
EXPOSE 80

7. Building a Docker Image

A Dockerfile consists of several steps, with each step creating a new image layer. Docker caches layers for performance.

Example Dockerfile

xxxxxxxxxx
17
1
# Step 1: Use a base image
2
FROM node:14-alpine
3

4
# Step 2: Install dependencies
5
RUN apk add --no-cache python3
6

7
# Step 3: Set the working directory
8
WORKDIR /app
9

10
# Step 4: Copy source code
11
COPY . .
12

13
# Step 5: Expose port
14
EXPOSE 3000
15

16
# Step 6: Define default command
17
CMD ["npm", "start"]

Explanation:

1. FROM node:14-alpine starts with a lightweight Node.js base image.

2. RUN installs Python dependencies.

3. WORKDIR sets the working directory to /app.

4. COPY adds the current directory contents to /app.

5. EXPOSE opens port 3000.

6. CMD sets the default command to start the application with npm start.

8. Best Practices

• Use minimal base images to reduce image size.

• Leverage caching by reusing existing layers when files or dependencies don’t change.

• Separate build-time and runtime instructions (e.g., RUN for installing dependencies and COPY for moving files).

Summary

By understanding these core concepts, you can effectively manage and optimize Dockerfiles for creating efficient Docker images.