If you are beginning to learn DevOps, cloud computing, or Kubernetes, you will probably encounter Docker early on.

When I first heard about Docker, terms such as containers, images, Dockerfiles, registries, and containerization made it seem more complicated than it was. Once I started using it, the main idea became much clearer:

Docker lets us package an application with what it needs to run, so it can work consistently across different environments.

In this article, I will start with the basics of Docker and then look at some essential commands.

1. What is Docker?

Docker is a platform for building, packaging and running applications in containers.

Think you have a Node.js application and it may depend on:

• A specific Node.js version
• Packages listed in package.json
• Environment variables
• Configuration files
• System level dependencies

node app.js

But inssted of starting the application reports an error:

Error: Cannot find module 'express'

Their environment may be different from yours. They might be using another Node.js version, missing a required package, or lacking a system dependency. This is where Docker helps. Instead of sharing only the application code, you can package it with the environment it needs into a Docker image. You can then use that image to start a container that runs the application.

2. What Problem Does Docker Solve?

I think most developers have heard the phrase:

It works on my computer.

An application may run well on one computer but fail on another because the environments differ. Developers might use different operating systems, runtime versions, libraries, dependencies, configurations or environment variables.

Docker helps reduce these differences. It packages an application and its required runtime and dependencies into an image. That image can be used to start containers on a developer's machine, a test server, or a cloud server.

Because each container starts from the same image, the application has a more consistent environment wherever it runs. This makes its behavior easier to predict, although settings such as environment variables sill need to be configured correctly.

3. What Is Containerization?

Containerization means packaging an application with the runtime and dependencies it needs, then running it in an isolated environment called a container. You can think of a container as a lightweight space set aside for your application.

For a Node.js application, the container might include the application code, a Node.js runtime, and the required packages. Its configuration can be supplied when the container starts.

Docker provides the tools to build the image for that application and run it as a container.

4. Docker Container vs Virtual Machines

A common question when learning Docker is: Is a container the same as a virtual machine?

They both provide isolated environments, but they work differently. A virtual machine (VM) runs its own guest operating system on virtual hardware. A container uses the host system's kernel while keeping its application and processes isolated from other containers.

Because containers do not need a separate guest operating system for each application, they are generally lighter and quicker to start than traditional VMs.

5. What Is a Docker Image?

A Docker image is a read-only package used to create containers. Think of it as a blueprint: it defines what an application needs to run.

For example, an image for a Node.js application might include its code, a Node.js runtime, and the packages it depends on. You can use that one image to start several containers.

Each container is a separate instance of the application, even though all of them were created from the same image.

6. What Is a Docker Container?

A Docker container is an instance created from an image. When you start the container, it runs the application defined by that image.

For example: docker run node:22 node --version

Docker uses the node:22 image to create a container, runs node --version inside it, and displays the result. The container then stops because the command has finished. This shows that a container does not have to keep running indefinitely.

A simple way to remember the difference is:

Image = Blueprint  
Container = Instance created from that blueprint

If you are familiar with object-oriented programming, you can loosely compare an image to a class and a container to an object. The analogy is not technically exact, but it can help you remember the distinction.

7. What Is a Dockerfile?

A Dockerfile is a text file containing instructions that Docker uses to build an image. For a small Node.js application, it might look like this:

FROM node:22-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
EXPOSE 3000
CMD ["node", "app.js"]

This example assumes your project has a package-lock.json file and an app.js file. You can build the image by running this command in the directory containing the Dockerfile:

docker build -t my-node-app .

Then start a container from that image:

docker run -p 3000:3000 my-node-app

The -p 3000:3000 option makes the application's port available on your computer, provided the Node.js app listens on port 3000 inside the container.

The main workflow is simple: Write a Dockerfile, build an image from it, and run a container from that image.

8. What Is a Docker Registry?

So far, we have looked at how to build our own Docker image. But where can we find images that other people have already created?

A container registry is a place where images are stored and shared. One well known public registry is Docker Hub, which hosts images for tools and runtimes such as Node.js, Redis, PostgreSQL, MySQL and Nginx.

For example, you can download a Node.js image with:

docker pull node:22-alpine

You can then use that image to create a container:

docker run --rm node:22-alpine node --version

This command runs node --version inside the container and prints the result. The --rm option removes the container after the command finishes.

The basic flow is: pull an image from a registry then run a container from that image. If the image is not already on your computer, docker run can also download it automatically.

9. Essential Docker Commands: Cheat Sheet

These examples use node:22-alpine and the my-node-app image built in Section 7.

10. Docker Architecture

Docker uses a client–server architecture. When you enter a command such as docker run, the Docker client sends a request to the Docker daemon. The daemon does the work of building images, creating containers, and running them.

The client and daemon usually run on the same computer, but the client can also connect to a daemon on another machine. They communicate through Docker’s API, using a local socket or a network connection.

Docker Compose is another way to work with Docker. It lets you define and manage an application made up of multiple containers, such as a Node.js app and a database.