Docker Instruction Commands

Docker Instruction Commands are the backbone of creating Docker images. These instructions are written inside a Dockerfile and define how an application environment is built, configured, and executed inside a container. Understanding Dockerfile instructions is essential for anyone working with Docker, DevOps, cloud deployments, or containerized applications.

This guide explains Docker instruction commands clearly and practically, covering real-world use cases, best practices, and hands-on examples suitable for beginners and intermediate learners.

What Are Docker Instruction Commands?

Docker instruction commands are predefined keywords used inside a Dockerfile. Each instruction tells Docker how to build an image step by step. Every instruction creates a new image layer, helping Docker cache and reuse layers efficiently.

Why Docker Instructions Matter

• They define how an application environment is created
• They control application dependencies and runtime behavior
• They improve build performance through image layering
• They ensure consistency across development and production environments

Structure of a Dockerfile

A Dockerfile is a plain text file that contains a sequence of Docker instructions executed in order.

📄

# Sample Dockerfile structure
FROM node:18
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

Core Docker Instruction Commands Explained

FROM Instruction

The FROM instruction defines the base image for your Docker image. Every Dockerfile must start with FROM unless you are creating a scratch image.

📄

FROM ubuntu:22.04

Real-world use case: Choosing an official base image like Ubuntu, Node.js, or Python ensures stability and security.

LABEL Instruction

LABEL adds metadata to Docker images such as author, version, or description.

📄

LABEL maintainer="admin@example.com"
LABEL version="1.0"

RUN Instruction

RUN executes commands during image build time. It is commonly used to install packages or configure the system.

📄

RUN apt-get update && apt-get install -y nginx

Best practice: Combine multiple commands in one RUN to reduce image layers.

WORKDIR Instruction

WORKDIR sets the working directory inside the container. All subsequent instructions run from this directory.

📄

WORKDIR /usr/src/app

COPY Instruction

COPY transfers files from the host machine into the Docker image.

📄

COPY . /app

Use case: Copying application source code into the container.

ADD Instruction

ADD is similar to COPY but supports remote URLs and automatic archive extraction.

📄

ADD app.tar.gz /app

Best practice: Prefer COPY unless ADD features are required.

ENV Instruction

ENV sets environment variables inside the container.

📄

ENV NODE_ENV=production

ARG Instruction

ARG defines build-time variables that can be passed during image creation.

📄

ARG APP_VERSION

EXPOSE Instruction

EXPOSE documents the port that the application listens on.

📄

EXPOSE 8080

VOLUME Instruction

VOLUME creates a mount point for persistent data storage.

📄

VOLUME /data

USER Instruction

USER sets the user for running container processes, improving security.

📄

USER node

CMD Instruction

CMD specifies the default command executed when a container starts.

📄

CMD ["nginx", "-g", "daemon off;"]

ENTRYPOINT Instruction

ENTRYPOINT configures a container to run as an executable.

📄

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

CMD vs ENTRYPOINT

Real-World Dockerfile Example

Dockerfile for a Node.js Application

📄

FROM node:18
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

This Dockerfile builds a production-ready Node.js application image with minimal configuration.

Best Practices for Docker Instruction Commands

• Use official base images
• Minimize image layers
• Use .dockerignore to reduce image size
• Run containers as non-root users
• Use multi-stage builds for optimization

Common Mistakes to Avoid

• Using latest tag blindly
• Installing unnecessary packages
• Ignoring security updates
• Running containers as root

Frequently Asked Questions (FAQs)

1. What are Docker instruction commands?

Docker instruction commands are predefined keywords used inside a Dockerfile to build and configure Docker images step by step.

2. How many Dockerfile instructions are there?

There are around 20 commonly used Dockerfile instructions including FROM, RUN, COPY, CMD, ENTRYPOINT, ENV, ARG, and EXPOSE.

3. What is the difference between RUN and CMD?

RUN executes commands during image build time, while CMD runs when the container starts.

4. Should I use COPY or ADD?

Use COPY for simple file transfers. Use ADD only when you need features like remote URLs or automatic archive extraction.

5. Why is layering important in Docker images?

Layering improves build performance, enables caching, and reduces image rebuild time when only small changes occur.

Docker Instruction Commands form the foundation of containerized application development. By mastering Dockerfile instructions like FROM, RUN, COPY, CMD, and ENTRYPOINT, you can build secure, efficient, and scalable Docker images. Whether you are a beginner or moving toward intermediate Docker usage, understanding these commands will significantly improve your DevOps and cloud deployment workflows.