2.1 Key Concepts of Dockerfile
Dockerfile is a text file that contains a sequence of commands Docker uses to create an image. It acts like a "recipe," describing how the image should be built—from the base layer to the final state. Understanding the structure and process of creating a Dockerfile is important for effectively using Docker.
Main Concepts of Dockerfile:
- Idempotency: commands in Dockerfile should be idempotent—their repeated execution gives the same result.
- Order: commands are executed sequentially from top to bottom. The order matters since each command creates a new layer for the image.
- Layered Structure: practically every instruction adds a new layer to the image. These layers are cached, which helps optimize the build process.
Structure of a Dockerfile:
A Dockerfile consists of instructions, each performing a specific function. Here are the main ones:
- FROM: sets the base image that will be used to create a new image.
- MAINTAINER: defines the author of the Dockerfile (deprecated, but useful for information).
- RUN: executes commands in the container and creates a new layer.
- COPY: copies files and directories from the build context to the container’s file system.
- ADD: copies files and directories, supports extracting archives and downloading files from URLs.
- WORKDIR: sets a working directory for the subsequent commands.
- ENV: sets environment variables.
- CMD: defines the default command to run when the container starts.
- ENTRYPOINT: defines the command that gets executed when the container starts, with support for passing arguments.
- EXPOSE: declares the ports the container uses.
- VOLUME: creates a mount point for external volumes.
2.2 Creating a Dockerfile
Example of creating a Dockerfile
Let's look at a simple example of creating a Dockerfile for a Node.js web app.
Step 1: Creating a base Dockerfile
Create a file named Dockerfile in the root of your project and add the following lines:
# Use the Node.js base image
FROM node:14
# Set the working directory
WORKDIR /app
# Copy package.json and package-lock.json
COPY package*.json ./
# Install dependencies
RUN npm install
# Copy all project files
COPY . .
# Specify the port the app will use
EXPOSE 3000
# Define the command to run the app
CMD ["node", "app.js"]
This Dockerfile does the following:
- FROM node:14: uses the official
Node.jsimage version 14 as the base. - WORKDIR /app: sets the working directory for subsequent commands.
- COPY package*.json ./: copies the
package.jsonandpackage-lock.jsonfiles to the working directory. - RUN npm install: installs dependencies from
package.json. - COPY . .: copies all project files into the container's working directory.
- EXPOSE 3000: specifies that the app will use port 3000.
- CMD ["node", "app.js"]: defines the command to run the app.
Step 2: Building the Image
After creating the Dockerfile, build the image using the docker build command:
docker build -t my-node-app .
This command will create an image named my-node-app using the Dockerfile from the current directory.
Step 3: Running the Container
Run a container based on the created image using the docker run command:
docker run -d -p 3000:3000 my-node-app
This example runs the container in detached mode, mapping the container's port 3000 to port 3000 on your host machine. Now you can access the app at http://localhost:3000.
2.3 Additional Dockerfile Instructions
1. Setting up environment variables
You can set environment variables that will be available in the container using the ENV instruction.
ENV NODE_ENV=production
2. Using multiple RUN commands
Sometimes it's worth combining several commands into one RUN instruction to reduce the number of layers, shrink the image size, and speed up the build process.
RUN apt-get update && apt-get install -y \
curl \
git \
&& rm -rf /var/lib/apt/lists/*
Helpful! If the command doesn't fit on one line, you can use the \ symbol to continue on the next line. This will be interpreted as one command.
Helpful! To write multiple commands on one line, you can use &&: command1 && command2 && command3. This allows you to execute several commands sequentially.
Optimizing command order
For efficient use of Docker cache, first copy files that rarely change (like package.json) and install dependencies before adding the rest of the project files.
Example of an advanced Dockerfile
In more complex projects, an advanced Dockerfile with additional settings might be required.
# Using a minimal base Node.js image
FROM node:14-alpine
# Setting the working directory
WORKDIR /usr/src/app
# Copying package.json and installing dependencies
COPY package*.json ./
RUN npm install --only=production
# Copying the source code
COPY . .
# Specifying the port to work on
EXPOSE 8080
# Setting environment variables
ENV NODE_ENV=production
# Running the application
CMD ["node", "server.js"]
GO TO FULL VERSION