TLDR reference

Docker commands

A searchable cheatsheet of everyday Docker tasks paired with the exact command. Type what you want to do, or filter by intent. Everything runs in your browser.

31 shown

Build an image from a Dockerfile
Images
```
docker build -t myapp:latest .
```
-t tags the image; the trailing dot is the build context.
List local images
Images
```
docker images
```
Shows every image with its tag, id, and size.
Pull an image
Images
```
docker pull postgres:16
```
Downloads an image (and tag) from a registry such as Docker Hub.
Push an image
Images
```
docker push user/myapp:latest
```
Uploads a tagged image to a registry. Log in first with docker login.
Tag an image
Images
```
docker tag myapp:latest user/myapp:1.0
```
Adds another name to an existing image, usually before pushing.
Remove an image
Images
```
docker rmi myapp:latest
```
Deletes a local image once no container uses it.
Run a container
Containers
```
docker run -d -p 8080:80 --name web nginx
```
-d detaches, -p maps host:container ports, --name labels it.
Run an interactive shell
Containers
```
docker run -it --rm ubuntu bash
```
-it gives an interactive terminal; --rm deletes the container on exit.
List running containers
Containers
```
docker ps
```
Shows live containers. Add -a to include stopped ones.
Stop a container
Containers
```
docker stop web
```
Sends a graceful shutdown, then kills it after a timeout.
Start a stopped container
Containers
```
docker start web
```
Restarts an existing container by name or id.
Remove a container
Containers
```
docker rm web
```
Deletes a stopped container. Add -f to force-remove a running one.
View container logs
Logs & exec
```
docker logs -f web
```
-f streams new log lines as they appear.
Open a shell in a running container
Logs & exec
```
docker exec -it web sh
```
Runs a command inside a live container; sh or bash gives a shell.
Inspect a container
Logs & exec
```
docker inspect web
```
Dumps the full JSON config: networks, mounts, environment, and more.
Copy files in or out
Logs & exec
```
docker cp web:/app/log.txt .
```
Copies between the host and a container, in either direction.
Show live resource use
Logs & exec
```
docker stats
```
A top-like view of CPU, memory, and network per container.
Start the stack
Compose
```
docker compose up -d
```
Builds if needed and starts every service in the background.
Stop and remove the stack
Compose
```
docker compose down
```
Stops and removes the containers and network. Add -v to drop volumes too.
Rebuild and restart
Compose
```
docker compose up -d --build
```
Forces a rebuild of the images before starting.
Tail compose logs
Compose
```
docker compose logs -f
```
Streams the combined logs of every service.
Run a one-off command
Compose
```
docker compose run --rm app php bin/console
```
Spins up a service just to run a command, then removes it.
List compose services
Compose
```
docker compose ps
```
Shows the status of the services defined in the compose file.
List volumes
Networks & volumes
```
docker volume ls
```
Shows named volumes used for persistent data.
Create a volume
Networks & volumes
```
docker volume create data
```
Makes a named volume you can mount into containers.
List networks
Networks & volumes
```
docker network ls
```
Shows the Docker networks containers can join.
Create a network
Networks & volumes
```
docker network create mynet
```
Creates a user-defined bridge so containers can reach each other by name.
Reclaim space
System & cleanup
```
docker system prune
```
Removes stopped containers, unused networks, and dangling images. Add -a for more.
Show disk usage
System & cleanup
```
docker system df
```
Summarises space used by images, containers, and volumes.
Remove all stopped containers
System & cleanup
```
docker container prune
```
Clears out every exited container in one go.
Remove dangling images
System & cleanup
```
docker image prune
```
Deletes untagged leftover image layers.

How it works

A searchable cheatsheet for everyday Docker, organised around what you are trying to do rather than around the commands themselves. Type a goal - "view logs", "rebuild the stack", "reclaim space" - and the matching task surfaces with the exact command. The chips group tasks by intent: images, containers, logs and exec, Docker Compose, networks and volumes, and system cleanup.

Each card pairs the task with the precise command and a short note on the key flags, covering the daily loop of building images, running and inspecting containers, tailing logs, and bringing a Compose stack up and down. Everything is static and runs in your browser, so the lookup is instant and works offline once the page has loaded.

Example. Searching "logs" surfaces docker logs -f to stream a container's output, while filtering by the Compose chip lines up docker compose up -d, down, and up -d --build so you can start, stop, and rebuild a multi-service stack from one place.

FAQ

What is the difference between an image and a container?

An image is a read-only template: a snapshot of a filesystem plus the metadata needed to run it, built from a Dockerfile. A container is a running (or stopped) instance of an image, with its own writable layer on top. The relationship is like a class and an object: you build an image once and can start many containers from it. docker images lists the templates; docker ps lists the running instances.

What does Docker Compose add over plain docker run?

Compose describes a whole multi-container application in one docker-compose.yml file - services, their images, ports, volumes, networks, and environment - so you can start everything with a single docker compose up instead of a long, error-prone docker run for each piece. It also creates a shared network so the services can reach each other by name. For anything beyond a single throwaway container, Compose is the friendlier way to work.

How do I get a shell inside a running container?

Use docker exec -it <name> sh (or bash if the image has it). The -it flags attach an interactive terminal, and sh starts a shell inside the container so you can poke around its filesystem, check environment variables, or run one-off commands. This runs in the existing container; docker run by contrast starts a brand-new one, which is what you want for a fresh, disposable shell with --rm.

How do I free up the disk space Docker uses?

Docker accumulates stopped containers, unused images, build cache, and orphaned volumes over time. docker system df shows what is taking space, and docker system prune removes stopped containers, unused networks, and dangling images in one go; add -a to also remove images with no running container, and --volumes to include unused volumes. Run it periodically on a development machine, but read what it lists first so you do not delete data you still need.

Docker commands

Build an image from a Dockerfile

List local images

Pull an image

Push an image

Tag an image

Remove an image

Run a container

Run an interactive shell

List running containers

Stop a container

Start a stopped container

Remove a container

View container logs

Open a shell in a running container

Inspect a container

Copy files in or out

Show live resource use

Start the stack

Stop and remove the stack

Rebuild and restart

Tail compose logs

Run a one-off command

List compose services

List volumes

Create a volume

List networks

Create a network

Reclaim space

Show disk usage

Remove all stopped containers

Remove dangling images

How it works

FAQ