Useful Docker Commands — Complete Cheat Sheet with Examples

Docker is the standard for containerization in 2026 — used by every major tech company and most modern development teams. But Docker has dozens of commands with confusing aliases (docker ps vs docker container ls, docker rmi vs docker image rm), and remembering which flags to use is half the battle.

This guide is the complete, up-to-date Docker commands cheat sheet you can bookmark and come back to. Every command has a real example, explanation of what it actually does, and notes on common variants. Whether you’re spinning up your first Nginx container or managing production deployments, this covers what you need to know.

💡 If you spot a command that should be added or notice something outdated, leave a comment below — this page is actively maintained.

Docker Basics: Information and Setup Commands

Show all available Docker commands

docker

Lists every top-level command Docker supports. Useful when you forget what’s possible — it’s a self-documenting CLI.

Check Docker version

docker version

Shows both the Docker client and server (daemon) versions. If the daemon isn’t running, only the client info will appear — that’s how you spot a stopped Docker service.

View Docker system information

docker info

Displays detailed runtime info: number of containers, images, storage driver, kernel version, total memory, and more. Great for troubleshooting environment issues.

Check disk usage

docker system df

Shows how much disk space images, containers, and volumes are using. Critical when your machine starts running out of space (which happens often with Docker).

Free up disk space

# Remove stopped containers, unused networks, dangling images, and build cache
docker system prune

# Remove EVERYTHING unused (including unused images, not just dangling ones)
docker system prune -a

# Add volumes too (CAREFUL — destroys data)
docker system prune -a --volumes

docker system prune -a regularly reclaims 10–50GB of disk space on active dev machines.

Working With Docker Containers

List all running containers

docker ps

# Same thing, modern syntax:
docker container ls

Shows only running containers by default. Use this constantly to see what’s active.

List ALL containers (running + stopped)

docker ps -a

# Modern syntax:
docker container ls -a

The -a flag includes stopped/exited containers. Useful for seeing what’s been running historically.

Create and run a container in the foreground (interactive)

docker container run -it -p 80:80 imageName

# Example using nginx:
docker container run -it -p 80:80 nginx

Flag breakdown:

• -i → keep STDIN open (interactive)
• -t → allocate a pseudo-TTY (terminal)
• -p 80:80 → map host port 80 to container port 80
• -it is a common combined shortcut

The container takes over your terminal — Ctrl+C stops it.

Create and run a container in the background (detached)

docker container run -d -p 80:80 imageName

# Example with nginx:
docker container run -d -p 80:80 nginx

The -d flag means detached mode — the container runs in the background and your terminal returns immediately. This is how 99% of production containers are started.

Give a container a custom name

docker container run -d -p 80:80 --name myAppName nginx

# Example:
docker container run -d -p 80:80 --name nginx_local nginx

Without --name, Docker auto-generates a random name like nostalgic_einstein. Naming containers makes them much easier to manage — you can use the name instead of the container ID in any command.

Stop a running container

docker container stop containerIdOrName

# Examples:
docker container stop nginx_local
docker container stop abc123def456

Sends SIGTERM first (giving the container 10 seconds to shut down gracefully), then SIGKILL if it doesn’t comply.

Stop ALL running containers in one command

docker stop $(docker ps -aq)

The inner command docker ps -aq returns just the IDs of all containers, which the outer docker stop then stops. Lifesaver when you want a clean slate.

Start a stopped container

docker container start containerIdOrName

Brings a previously stopped container back to life with all its data intact.

Restart a container

docker container restart containerIdOrName

Stops and starts in one command. Useful after config changes.

Remove a container

# Remove a single container (must be stopped first)
docker container rm containerIdHere

# Force remove (even if running — Docker stops then removes)
docker container rm containerIdHere -f

# Remove multiple containers at once
docker container rm containerId1 containerId2 containerId3

Remove ALL containers

docker rm $(docker ps -aq)

# Force version (also stops running ones):
docker rm $(docker ps -aq) -f

View container logs

# All logs from a container
docker container logs containerName

# Follow logs in real time (like tail -f)
docker container logs -f containerName

# Show last 100 lines
docker container logs --tail 100 containerName

# Logs with timestamps
docker container logs -t containerName

The -f flag (follow) is what you’ll use most — it shows new log lines as they appear.

Inspect a container (full details)

docker container inspect containerName

Returns a massive JSON object with everything about the container — network settings, volumes, environment variables, mount points, IP address, you name it. Great for debugging.

Get a container’s IP address quickly

docker inspect -f '{{.NetworkSettings.IPAddress}}' containerName

A more focused version of inspect using Go template formatting.

See container resource usage (live)

docker stats

Shows real-time CPU, memory, network, and disk I/O for every running container. Like top but for Docker.

Execute a command inside a running container

# Open a shell inside a running container
docker exec -it containerId sh

# Or use bash if the image has it
docker exec -it containerId bash

# Run a one-off command without entering the container
docker exec containerId ls /etc

Run a new container and immediately enter it

docker container run -it imageName bash

Combines run and exec — creates a fresh container and drops you into a shell. The container exits when you leave the shell.

Working With Docker Images

List all local images

docker images

# Modern syntax:
docker image ls

Shows every image cached on your machine with size and tag info.

Pull an image from Docker Hub

docker pull imageNameHere

# Examples:
docker pull nginx
docker pull mysql:8.0           # specific version
docker pull node:20-alpine      # specific tag (smaller alpine variant)

Downloads an image without running it. Useful for pre-fetching images before going offline.

Search Docker Hub for images

docker search keyword

# Example:
docker search redis

Returns matching images from the Docker Hub registry, sorted by popularity (stars).

Remove an image

docker image rm imageIdHere

# Older syntax (still works):
docker rmi imageIdHere

You can’t remove an image that’s being used by a container — stop and remove the container first, or use -f to force.

Remove ALL images

docker rmi $(docker images -a -q)

# Force version:
docker rmi $(docker images -a -q) -f

Useful for completely resetting your Docker environment.

Remove only dangling images

docker image prune

“Dangling” images are unnamed image layers left over from rebuilds. This frees up space without touching images you actively use.

Tag an image

docker tag sourceImage:tag targetImage:tag

# Example: tag a local image for pushing to your registry
docker tag myapp:latest myregistry.com/myapp:v1.0

Tags don’t copy the image — they just create an additional name pointing to the same image data.

Push an image to a registry

docker push myregistry.com/myapp:v1.0

Uploads your image to Docker Hub or a private registry. Requires docker login first.

Docker Networks

Docker networks let containers talk to each other (or stay isolated). Every container is on a network — by default it’s the bridge network.

List all available networks

docker network ls

You’ll always see at least three default networks: bridge, host, and none.

Inspect a network

docker network inspect networkNameHere

Shows the network’s configuration plus all containers connected to it (with their IPs).

Create a new network

docker network create networkName

# With a specific driver:
docker network create --driver bridge my_bridge

Custom networks are usually bridge type (default). Use them to group related containers — they can find each other by container name instead of IP.

Run a container on a specific network

docker container run -d --network networkNameHere nginx

Connect an existing container to a network

docker network connect networkNameHere containerNameHere

A container can be on multiple networks simultaneously.

Disconnect a container from a network

docker network disconnect networkNameHere containerNameHere

Remove a network

docker network rm networkName

You can’t remove a network if any containers are still connected to it.

Working With Dockerfiles

A Dockerfile is a text file with instructions for building a custom image. Most real projects use one.

Build an image from a Dockerfile

# Build with a custom name, from current directory
docker image build -t customImageName .

# Older syntax (still works):
docker build -t customImageName .

# Build with a specific Dockerfile path
docker build -t myimage -f path/to/Dockerfile .

# Build with no cache (force fresh build)
docker build -t myimage --no-cache .

The . at the end is the build context — the folder Docker uses for the build. Don’t forget it.

Run your custom image

docker container run -p 80:80 --rm customImageName

The --rm flag automatically removes the container when it stops, so you don’t accumulate dead containers during development.

View build history of an image

docker history imageName

Shows each layer of the image and what command created it. Useful for understanding image size and optimization.

Volumes and Bind Mounts (Persistent Data)

Containers are ephemeral — when you delete them, all data inside is gone. To persist data, you need volumes or bind mounts.

Setting up a bind mount

docker container run -p 80:80 -v $(pwd):/usr/share/nginx/html nginx

This mounts your current directory ($(pwd)) into the container at /usr/share/nginx/html. Any file changes on your host are instantly visible inside the container. Perfect for development.

List all named volumes

docker volume ls

Create a named volume

docker volume create myvolume

Use a named volume with a container

docker container run -d -v myvolume:/var/lib/mysql mysql

Named volumes are managed by Docker and stored in a special directory (/var/lib/docker/volumes/ on Linux). They survive container deletion.

Inspect a volume

docker volume inspect myvolume

Shows the volume’s actual location on disk (the Mountpoint).

Remove a volume

docker volume rm myvolume

# Remove all unused volumes:
docker volume prune

Bind mount vs named volume — which to use?

Docker Compose Bonus

For multi-container apps (e.g. app + database + cache), use Docker Compose:

# Start all services defined in docker-compose.yml
docker compose up -d

# Stop all services
docker compose down

# View logs for all services
docker compose logs -f

# Restart a specific service
docker compose restart app

# Run a one-off command in a service
docker compose exec app bash

# Rebuild images and restart
docker compose up -d --build

Note: Modern Docker uses docker compose (with a space) instead of the older docker-compose (with a hyphen). Both work, but docker compose is the current standard built into Docker Desktop.

Common Errors and Fixes

Docker Commands Quick Reference (Cheat Sheet)

Containers

Images

Networks & Volumes

System

Docker Compose

Wrapping Up

These are the Docker commands you’ll actually use day-to-day — everything from basic container management to network configuration and cleanup. Bookmark this page; the quick reference at the bottom is everything you need for 95% of Docker work.

The two commands every Docker user should run regularly:

1. docker ps -a — see exactly what containers exist (running or not)
2. docker system prune -a — reclaim disk space (Docker quietly eats gigabytes)

For multi-container projects, learn Docker Compose — it replaces dozens of long docker run commands with a single docker-compose.yml file. And for production deployments, look into Docker Swarm or Kubernetes once your needs grow beyond a single machine.