Docker Command Helper

Search common Docker tasks — run, build, debug, clean up — and get the exact command with an explanation and a warning when it deletes data.

What do you want to do with Docker?

Popular:

58 commands

Download (pull) an image
Images
Image <image>
docker pull <image>
Downloads an image from a registry (Docker Hub by default). Pin a version tag such as nginx:1.27 rather than relying on latest.
List local images
Images
docker images
docker image ls --digests
Shows images stored locally with their tags, IDs and sizes. --digests adds the content digest used for reproducible pulls.
Tag an image with a new name
Images
Image <image>
New image <new-image>
docker tag <image> <new-image>
Adds another name to the same image — for example the registry path you are about to push to. It does not copy any layers.
Remove an image
Use with careImages
Careful: Removed images must be pulled or rebuilt again before they can be used.
Image <image>
docker image rm <image>
Removes the image tag and any layers no other image uses. Fails if a container still uses it — remove the container first, or add -f.
See how an image was built (layers)
Images
Image <image>
docker history --no-trunc <image>
Lists each layer with the instruction that created it and its size — handy for finding what makes an image large.
Export an image to a tar file
Images
File <file>
Image <image>
docker save -o <file> <image>
Writes the image (all layers and tags) to a tar archive you can copy to an air-gapped machine.
Import an image from a tar file
Images
File <file>
docker load -i <file>
Loads an image archive created by docker save, restoring its tags.
Build an image from a Dockerfile
Build
Image <image>
Build context <context>
docker build -t <image> <context>
Builds an image from the Dockerfile in the build context (usually .) and tags it. Keep a .dockerignore so the context stays small.
Build with a specific Dockerfile
Build
Dockerfile <dockerfile>
Image <image>
Build context <context>
docker build -f <dockerfile> -t <image> <context>
Uses a Dockerfile with a different name or location, e.g. Dockerfile.prod, while still sending the given context.
Rebuild without the cache
Build
Image <image>
Build context <context>
docker build --no-cache --pull -t <image> <context>
Ignores cached layers and pulls the newest base image — useful to pick up security updates in apt-get or base layers.
Build for multiple CPU architectures
Build
Platforms <platform>
Image <image>
Build context <context>
docker buildx build --platform <platform> -t <image> --push <context>
Builds one image for several architectures (e.g. Intel servers and ARM laptops) and pushes a multi-platform manifest. Requires a buildx builder.
Pass a build argument
Build
Variable <env>
Image <image>
Build context <context>
docker build --build-arg <env> -t <image> <context>
Sets an ARG declared in the Dockerfile, e.g. NODE_VERSION=20. Build args are visible in image history — never use them for secrets.
Run a container in the background
Run containers
Name <name>
Image <image>
docker run -d --name <name> <image>
Starts a new container from the image and returns immediately. --name gives it a stable name for later commands.
Run and publish a port
Run containers
Host port <host-port>
Container port <container-port>
Name <name>
Image <image>
docker run -d -p <host-port>:<container-port> --name <name> <image>
Maps a port on your machine to a port inside the container, e.g. 8080:80 serves the container's port 80 at localhost:8080.
Run an interactive shell in a new container
Run containers
Image <image>
Command <command>
docker run -it --rm <image> <command>
Starts a throwaway container with a terminal attached (-it) and deletes it on exit (--rm). Use sh for Alpine-based images, bash otherwise.
Run with environment variables
Run containers
Variable <env>
Name <name>
Image <image>
docker run -d -e <env> --name <name> <image>
docker run -d --env-file .env --name <name> <image>
Sets environment variables one at a time with -e, or loads a whole .env file with --env-file.
Mount a folder from your machine
Run containers
Host path <host-path>
Container path <container-path>
Name <name>
Image <image>
docker run -d -v "$(pwd)"/<host-path>:<container-path> --name <name> <image>
Makes a host directory visible inside the container. Changes are shared both ways — handy for live-reloading code during development.
Run with a named volume for persistent data
Run containers
Volume <volume>
Container path <container-path>
Name <name>
Image <image>
docker run -d -v <volume>:<container-path> --name <name> <image>
Stores data in a Docker-managed volume that survives container removal — the usual choice for databases.
Restart a container automatically
Run containers
Name <name>
Image <image>
docker run -d --restart unless-stopped --name <name> <image>
Restarts the container if it crashes and when Docker starts, unless you stopped it yourself.
Limit CPU and memory
Run containers
Name <name>
Image <image>
docker run -d --memory 512m --cpus 1.5 --name <name> <image>
Caps the container at 512 MB of RAM and 1.5 CPU cores so one service cannot starve the others.
List containers
Manage containers
docker ps
docker ps -a
docker ps shows running containers; -a includes stopped ones too.
Stop a running container
Manage containers
Container <container>
docker stop <container>
Sends SIGTERM, waits 10 seconds for a graceful shutdown, then SIGKILL. The container and its data remain until removed.
Start a stopped container
Manage containers
Container <container>
docker start <container>
docker restart <container>
start resumes a stopped container with its original settings; restart stops and starts a running one.
Remove a container
Use with careManage containers
Careful: Anything written inside the container (outside volumes) is lost when it is removed.
Container <container>
docker rm <container>
docker rm -f <container>
Deletes a stopped container. -f stops and removes a running one in one step.
Rename a container
Manage containers
Container <container>
Name <name>
docker rename <container> <name>
Changes the container's name without restarting it.
Copy files to or from a container
Manage containers
Container <container>
Container path <container-path>
Host path <host-path>
docker cp <container>:<container-path> <host-path>
docker cp <host-path> <container>:<container-path>
Copies files between your machine and a container, running or stopped.
Change a container's restart policy
Manage containers
Container <container>
docker update --restart unless-stopped <container>
Changes the restart policy (or CPU/memory limits) of an existing container without recreating it.
View container logs
Logs & debugging
Lines <n>
Container <container>
docker logs -f --tail <n> <container>
Shows the container's output and keeps following it (-f). --tail limits how many past lines are printed first.
Open a shell inside a running container
Logs & debugging
Container <container>
Command <command>
docker exec -it <container> <command>
Runs a command in an already-running container. Use sh when the image has no bash (e.g. Alpine).
Inspect a container's configuration
Logs & debugging
Container <container>
docker inspect <container>
docker inspect -f '{{.NetworkSettings.IPAddress}}' <container>
Prints full JSON details — mounts, environment, network settings. -f extracts a single field with a Go template.
Watch CPU and memory usage
Logs & debugging
Container <container>
docker stats
docker top <container>
stats streams live resource usage for all running containers; top lists the processes inside one container.
Show which ports a container publishes
Logs & debugging
Container <container>
docker port <container>
Lists the container-to-host port mappings, e.g. 80/tcp -> 0.0.0.0:8080.
Watch Docker events
Logs & debugging
docker events --filter type=container
Streams container lifecycle events (start, die, OOM kill) — useful to see why a container keeps restarting.
Create a volume
Volumes
Volume <volume>
docker volume create <volume>
Creates a named volume. Docker also creates one automatically the first time -v name:/path is used.
List and inspect volumes
Volumes
Volume <volume>
docker volume ls
docker volume inspect <volume>
Lists volumes, and shows where one is stored on the Docker host (Mountpoint).
Back up a volume to a tar file
Volumes
Volume <volume>
docker run --rm -v <volume>:/data -v "$(pwd)":/backup alpine tar czf /backup/<volume>.tgz -C /data .
Mounts the volume and your current directory into a temporary Alpine container and archives the volume's contents.
Remove a volume
Use with careVolumes
Careful: Volume data is deleted permanently — back it up first if you might need it.
Volume <volume>
docker volume rm <volume>
Deletes the volume and all data in it. Fails while a container still uses it.
Create a network
Networks
Network <network>
docker network create <network>
Creates a user-defined bridge network. Containers on it can reach each other by container name.
Run a container on a network
Networks
Network <network>
Name <name>
Image <image>
docker run -d --network <network> --name <name> <image>
Starts the container on the given network so other containers there can reach it as <name>.
Connect a running container to a network
Networks
Network <network>
Container <container>
docker network connect <network> <container>
docker network disconnect <network> <container>
Adds or removes a network from an existing container without restarting it.
List and inspect networks
Networks
Network <network>
docker network ls
docker network inspect <network>
Shows networks, and which containers and IP addresses are attached to one.
Start all services with Compose
Compose
docker compose up -d
Creates and starts every service in compose.yaml (or docker-compose.yml) in the background.
Rebuild and restart services
Compose
docker compose up -d --build
Rebuilds images for services with a build: section and recreates containers whose configuration changed.
Follow Compose logs
Compose
Service <service>
docker compose logs -f <service>
Streams logs from one service, or from every service if you leave the name out.
Run a command in a Compose service
Compose
Service <service>
Command <command>
docker compose exec <service> <command>
Opens a shell or runs a command in the running container of a service.
List Compose services
Compose
docker compose ps
Shows each service's container, state, health and published ports.
Stop and remove the Compose stack
Use with careCompose
Careful: down -v deletes the stack's volumes — including database data.
docker compose down
docker compose down -v
Stops and removes the stack's containers and networks. -v also removes its named volumes.
Log in to a registry
Registry
Registry <registry>
Username <user>
docker login <registry> -u <user>
Prompts for a password or token and stores credentials for pushes and private pulls. Prefer --password-stdin in scripts so the token never appears in shell history.
Push an image to a registry
Registry
Image <image>
New image <new-image>
docker tag <image> <new-image>
docker push <new-image>
Tags the image with the registry path, then uploads it. Only layers the registry does not already have are sent.
Log out of a registry
Registry
Registry <registry>
docker logout <registry>
Removes stored credentials for the registry from this machine.
Remove all stopped containers
Use with careCleanup
Careful: Deletes the listed resources permanently. Make sure nothing you need is stopped or unused right now.
docker container prune
Deletes every stopped container after asking for confirmation.
Remove unused images
Use with careCleanup
Careful: Deletes the listed resources permanently. Make sure nothing you need is stopped or unused right now.
docker image prune
docker image prune -a
Removes dangling (untagged) images; -a removes every image not used by a container.
Free disk space (system prune)
Use with careCleanup
Careful: --volumes deletes unused volumes and their data permanently.
docker system prune
docker system prune -a --volumes
Removes stopped containers, unused networks, dangling images and build cache. -a --volumes also removes unused images and volumes.
Clear the build cache
Cleanup
docker builder prune
Deletes cached build layers. Builds will be slower until the cache is rebuilt.
Stop all running containers
Use with careCleanup
Careful: Stops every running container on this host, including ones other projects rely on.
docker stop $(docker ps -q)
Passes every running container ID to docker stop.
See how much disk Docker uses
System
docker system df
docker system df -v
Summarises space used by images, containers, volumes and build cache; -v breaks it down per item.
Show Docker version and settings
System
docker version
docker info
version shows client and engine versions; info shows storage driver, number of containers and daemon settings.
Switch between Docker hosts (contexts)
System
Name <name>
docker context ls
docker context use <name>
Lists configured Docker endpoints and switches the CLI to another one, e.g. a remote host over SSH.

How to use this tool

Describe what you want to do in the search box — for example run with port, view logs or free disk space — or pick a category on the left.
Fill in the fields on a card (image, container name, ports…). The command updates as you type, and invalid values such as an uppercase image name are flagged.
Read the explanation under each command, and pay attention to cards marked Use with care — they delete containers, images or volume data.
Click Copy on a command line and paste it into your terminal.

Example

Run nginx and publish it on port 8080

Search + fields

run with port
Host port: 8080   Container port: 80
Name: web         Image: nginx:1.27-alpine

Command

docker run -d -p 8080:80 --name web nginx:1.27-alpine

Common use cases

Remembering the exact flags for publishing ports, mounting folders or setting environment variables.
Debugging a misbehaving container with logs, exec, inspect and stats.
Cleaning up disk space safely without deleting the wrong volume.
Preparing an image for a registry: tagging, logging in and pushing.
Teaching teammates the Docker commands they will use every day.

How the Docker command helper works

The helper is a curated catalogue of everyday Docker CLI tasks grouped into images, builds, running and managing containers, debugging, volumes, networks, Compose, registries, cleanup and system commands. Search matches your words against each task's title, keywords and the command itself, so both “delete stopped containers” and “container prune” find the same card.

Placeholders such as <image> or <host-port> become input fields. Values are checked against Docker's rules — image references must be lowercase, ports must be 1–65535, environment variables must look like KEY=value — and anything containing spaces or shell characters is quoted safely before it is inserted.

Commands that remove containers, images or volumes are marked Use with care with a short explanation of what is lost. docker system prune -a --volumes and docker compose down -v in particular delete data that cannot be recovered.

Everything runs in your browser; nothing is executed. Commands target the Docker Engine CLI and Compose v2 (docker compose, not the older docker-compose).

Limitations

Covers common Docker Engine and Compose v2 commands, not every flag. See docker <command> --help for the full reference.
Commands use POSIX shell syntax (e.g. "$(pwd)"); adjust paths and quoting for Windows PowerShell or cmd.

Frequently asked questions

What is the difference between `docker run` and `docker exec`?

docker run creates and starts a new container from an image. docker exec runs an extra command inside a container that is already running — for example to open a shell for debugging.

How do I free up disk space used by Docker?

Start with docker system df to see what uses space, then docker system prune to remove stopped containers, unused networks, dangling images and build cache. Add -a to remove all unused images, and --volumes only if you are sure no volume data is needed.

Does `docker compose down` delete my database?

Not by default — it removes containers and networks but keeps named volumes. docker compose down -v also removes the volumes, which deletes the data stored in them.

Why is my image name rejected?

Docker repository names must be lowercase and may contain digits, dots, dashes and underscores, optionally prefixed by a registry host and followed by a :tag. MyApp:Latest is invalid; myapp:latest is fine.

Download (pull) an image

List local images

Tag an image with a new name

Remove an image

See how an image was built (layers)

Export an image to a tar file

Import an image from a tar file

Build an image from a Dockerfile

Build with a specific Dockerfile

Rebuild without the cache

Build for multiple CPU architectures

Pass a build argument

Run a container in the background

Run and publish a port

Run an interactive shell in a new container

Run with environment variables

Mount a folder from your machine

Run with a named volume for persistent data

Restart a container automatically

Limit CPU and memory

List containers

Stop a running container

Start a stopped container

Remove a container

Rename a container

Copy files to or from a container

Change a container's restart policy

View container logs

Open a shell inside a running container

Inspect a container's configuration

Watch CPU and memory usage

Show which ports a container publishes

Watch Docker events

Create a volume

List and inspect volumes

Back up a volume to a tar file

Remove a volume

Create a network

Run a container on a network

Connect a running container to a network

List and inspect networks

Start all services with Compose

Rebuild and restart services

Follow Compose logs

Run a command in a Compose service

List Compose services

Stop and remove the Compose stack

Log in to a registry

Push an image to a registry

Log out of a registry

Remove all stopped containers

Remove unused images

Free disk space (system prune)

Clear the build cache

Stop all running containers

See how much disk Docker uses

Show Docker version and settings

Switch between Docker hosts (contexts)