Containers & Orchestration
Docker creates portable containers for consistent deployments.
On this page
Use this page for fast recall. Use Full documentation when you want the complete end-to-end path.
A simple 5-step flow you can follow when using Docker in real work.
1) Setup
Install/run the tool and confirm version. Create a minimal config.
2) Small change
Do one small action end-to-end to prove the workflow.
3) Validate
Check output, logs, and status. Catch mistakes early.
4) Automate
Convert it into a repeatable script or pipeline step.
5) Productionize
Add safety: secrets, rollback, observability, and docs.
These are practical sequences you can copy into your own checklist or runbook.
Goal: Run your app the same way locally as it runs in production.
- Build the image with a dev tag.
- Run with `--rm` and required env vars/ports.
- Inspect logs and confirm the health endpoint works.
- Package dependencies inside the image (avoid host coupling).
- Move to Compose for multi-service local environments.
- Images
- Containers
- Networks
Learning path (high-level):
- Dockerfile basics
- Compose multi-service apps
- Image optimization
Build image
Command
docker build -t my-app .Run container
Command
docker run -p 3000:3000 my-appList containers
Command
docker psShort descriptions and practical intent. Search, filter, copy, and reuse.
Showing 31
docker versionShow client/server version.
docker infoShow runtime details (storage driver, cgroups).
docker build -t my-app:dev .Build an image from Dockerfile.
docker build --no-cache -t my-app:dev .Build without cache (debug build issues).
docker history my-app:devInspect image layers (size + commands).
docker run --rm -p 3000:3000 my-app:devRun container and remove it on exit.
docker run -it --rm my-app:dev shStart an interactive shell in the image.
docker psList running containers.
docker ps -aList all containers.
docker logs <container>Show container logs.
docker logs -f <container>Follow logs (tail).
docker exec -it <container> shOpen shell in a running container.
docker inspect <container>Inspect container details (env, mounts, network).
docker stop <container>Stop a running container.
docker rm <container>Remove a container.
docker rmi <image>Remove an image.
docker imagesList local images.
docker tag my-app:dev myrepo/my-app:1.0.0Tag image for pushing.
docker loginLogin to a registry.
docker push myrepo/my-app:1.0.0Push image to registry.
docker pull nginx:alpinePull an image from a registry.
docker network lsList networks.
docker network inspect <net>Inspect network config.
docker volume lsList volumes.
docker volume inspect <vol>Inspect a volume.
docker compose up -dStart services in background.
docker compose psShow Compose service status.
docker compose logs -fFollow Compose logs.
docker compose down -vStop services and remove volumes (dev reset).
docker system dfShow disk usage by Docker objects.
docker system pruneClean unused docker resources.
Small blocks you can drop into your terminal, config, or runbook.
Minimal health-check style curl
bash
curl -fsS http://localhost:3000/health || echo "unhealthy"Run a container with env + port
bash
docker run --rm -p 3000:3000 -e NODE_ENV=production my-app:1.0.0When things break, follow this order to stay calm and move fast.
- If build is slow: check `.dockerignore`, reduce context, and leverage layer caching.
- If container exits: read logs first, then run the image interactively to inspect config/env.
- If networking fails: verify published ports, container network, and DNS inside container.
- If disk usage is high: use `docker system df`, then prune safely in dev.
The common mistakes that slow people down when using Docker.
- Building huge images (no `.dockerignore`, no multi-stage builds).
- Running as root in containers in production.
- Not pinning image tags (use digests or version tags).
Do these tasks in order. You will feel the tool instead of just reading about it.
- Write a minimal Dockerfile, build the image, run it, then inspect logs and environment variables.
- Use Compose to run 2 services and confirm networking between them.
- Optimize an image size using multi-stage build or `.dockerignore`.
Use these to test if you truly understand the basics (and can explain them clearly).
- Explain the tool’s role in a real CI/CD pipeline from commit to production.
- Describe the most common failure you’ve seen with this tool and how you fixed it.
- What would you monitor/alert on for this tool in production?