Docker
A platform for building, shipping and running software in containers.
In more detail
It includes the docker command, a background engine that builds images and runs containers, and tooling for registries. It popularised the container image format that is now standardised by the Open Container Initiative.
Examples
GitHub-hosted runner images include Docker, so a step can call docker build and docker push directly.The Docker course in this series covers images, containers and orchestration; this course hands over to it at the artifact boundary.The Next.js and Fastify apps are packaged as small, non-root production images with multi-stage builds.docker build -t healthcheck:dev .Every lesson runs its broker, database and Python clients as containers.Some course lessons show collector output as a transcript because the stack needs Docker.In this course: Container-based integration tests need Docker or another compatible container runtime installed and running on the machine. The course's container examples are shown as transcripts marked as not run, because the recording machine has no container daemon.Related terms
- docker build — The command that builds an image from a Dockerfile and a build context.
- docker push — The command that uploads a local image to a registry.
- Dockerfile — A text file of instructions, such as FROM, COPY and RUN, that tells Docker how to build an image.
- anti-aliasing — Softening the jagged edges of text and shapes by drawing edge pixels in in-between shades.
- flaky test — A test that sometimes passes and sometimes fails on the same code, because it depends on something it does not control.
- continuous integration — Automatically building and testing every change as soon as it is pushed, so problems are caught early.
- Linux — A free, open-source operating system kernel, and the family of operating systems built around it.
- container — A running program that has been fenced off from the rest of the computer so it only sees its own files, network and processes.
- image — A read-only package containing a program and everything it needs to run, used as the template for containers.
- Docker Engine — The open-source server part of Docker, made of the Docker daemon and the tools it drives, that runs on Linux.
- Docker CLI — The docker command you type into a terminal; it sends requests to the Docker daemon and prints the answers.
- Docker daemon — The background program that owns images, containers, networks and volumes and does the work the docker command asks for.
- containerd — An industry-standard program that manages containers and images on a machine, used underneath Docker and most Kubernetes clusters.
- runc — The small program that actually creates a container by making the kernel calls for namespaces, control groups and the root filesystem.
- Open Container Initiative — The industry body that publishes the open standards for container images, runtimes and registries.
- multi-stage build — A Dockerfile with several FROM stages, where later stages copy only what they need from earlier ones.
- Docker network — A virtual network Docker creates so containers can talk to each other and, if allowed, to the outside world.
- Docker Compose — A Docker tool that starts several related containers together from one YAML file.
- Kubernetes — An open-source system that runs and manages containers across a cluster of machines.
- Testcontainers — A family of libraries that start real dependencies such as databases in throwaway containers for the length of a test.
Taught in
- Runners: Where Code Executes — Continuous Integration & Continuous Delivery Pipelines
- Building and Pushing Container Images — Continuous Integration & Continuous Delivery Pipelines
- Container Images The Exam Way — Certified Kubernetes Application Developer (CKAD) Exam Prep
- ConfigMaps And Secrets — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Visual Regression Testing: Playwright & Snapshot Differencing — Design Systems & Component Engineering
- What DevOps Actually Is — DevOps & Site Reliability Engineering
- Disposability, Dev Prod Parity And Logs — DevOps & Site Reliability Engineering
- Containers And Orchestration Context — DevOps & Site Reliability Engineering
- Observability Context — DevOps & Site Reliability Engineering
- Namespaces And Cgroups: Isolation And Limits — Docker Architecture & Production Containers
- Union Filesystems, Images And Writable Layers — Docker Architecture & Production Containers
- Docker, OCI, The Engine And The CLI — Docker Architecture & Production Containers
- Install Docker And Verify Your Environment — Docker Architecture & Production Containers
- Run, Stop, Restart And Remove A Container — Docker Architecture & Production Containers
- Commands, Logs, Exec And Exit Codes — Docker Architecture & Production Containers
- Build Context, Dockerignore And Your First Dockerfile — Docker Architecture & Production Containers
- FROM, WORKDIR, COPY And ADD — Docker Architecture & Production Containers
- ARG, ENV, LABEL, EXPOSE And VOLUME — Docker Architecture & Production Containers
- CMD, ENTRYPOINT, USER And Process Signals — Docker Architecture & Production Containers
- Multi Stage Builds, Targets And Build Secrets — Docker Architecture & Production Containers
- Tags, Digests And Reproducible Image References — Docker Architecture & Production Containers
- Authenticate, Tag, Push And Pull From A Registry — Docker Architecture & Production Containers
- Scan, Patch And Inspect The Software Supply Chain — Docker Architecture & Production Containers
- Ephemeral Filesystems And Named Volumes — Docker Architecture & Production Containers
- Bind Mounts, Permissions And Backups — Docker Architecture & Production Containers
- Bridge Networks, DNS And Container Communication — Docker Architecture & Production Containers
- Port Publishing, Localhost And Network Troubleshooting — Docker Architecture & Production Containers
- Environment, Secret Files And Runtime Restrictions — Docker Architecture & Production Containers
- Define The Service And Database With Compose — Docker Architecture & Production Containers
- Health Checks, Dependencies And Reliable Startup — Docker Architecture & Production Containers
- Development Overrides, Hot Reloading And Debuggers — Docker Architecture & Production Containers
- Diagnose Crashes, Resource Limits And Unhealthy Containers — Docker Architecture & Production Containers
- Build, Test And Promote The Same Image In CI — Docker Architecture & Production Containers
- Harden And Deliver The Complete Service Stack — Docker Architecture & Production Containers
- From Local Containers To Kubernetes — Docker Architecture & Production Containers
- Containerization Architecture: Multi-Stage Dockerfiles — Production Full-Stack Engineering
- What Go Is and Why It Matters — Concurrent Systems Programming with Go
- Shipping in Scratch and Distroless Images — Concurrent Systems Programming with Go
- Containerizing and Testing the Final Build — Concurrent Systems Programming with Go
- Why A Log And Not A Queue — Apache Kafka & Event Streaming
- A Producer In Python — Apache Kafka & Event Streaming
- From Docker To Desired State — Kubernetes: Production-Grade Container Orchestration
- Worker Nodes: kubelet, Runtime, CNI And kube-proxy — Kubernetes: Production-Grade Container Orchestration
- Bootstrap A Local Cluster And Check Your Context — Kubernetes: Production-Grade Container Orchestration
- Instrumentation: OpenTelemetry & Performance Spans — Next.js 15 & Modern App Router Architecture
- Containerized Deployment: Multi-Stage Docker Builds — Next.js 15 & Modern App Router Architecture
- Close Phase & Signal Dispatch: Sockets & Teardown — Node.js Internals & Backend Services
- Production Hardening: Graceful Shutdown & Docker — Node.js Internals & Backend Services
- Prometheus Scraping And The Pull Model — Full-Stack Observability: Metrics, Tracing & Logging
- The OpenTelemetry Collector — Full-Stack Observability: Metrics, Tracing & Logging
- Service Level Indicators — Full-Stack Observability: Metrics, Tracing & Logging
- Service Level Objectives — Full-Stack Observability: Metrics, Tracing & Logging
- Error Budgets And Burn Rate Alerts — Full-Stack Observability: Metrics, Tracing & Logging
- Timeouts, And Avoiding Cascaded Failure — Scalable System Design & Distributed Architecture
- Monolith Versus Services: The Honest Trade Offs — Scalable System Design & Distributed Architecture
- Capacity Planning As A Design Input — Scalable System Design & Distributed Architecture
- Integration Testing With Containers — Automated Testing, TDD & Quality Engineering
- Two Managers Down: The Night The Swarm Froze — Docker Certified Associate (DCA) Exam Prep
- One Option At A Time: How DOMC Changes The Exam — Docker Certified Associate (DCA) Exam Prep
- Five Nodes Before Lunch: Building A Swarm — Docker Certified Associate (DCA) Exam Prep
- From docker run To docker service: Replicas, Global Mode And Updates — Docker Certified Associate (DCA) Exam Prep
- One File, Five Services: Stacks From Compose Files — Docker Certified Associate (DCA) Exam Prep
- Where Do The Tasks Land? Labels, Constraints And Templates — Docker Certified Associate (DCA) Exam Prep
- Stuck In Pending: Troubleshooting Services And Reading docker inspect — Docker Certified Associate (DCA) Exam Prep
- The Same Shop On Kubernetes: Pods, Services And Storage For The DCA — Docker Certified Associate (DCA) Exam Prep
References
- Docker overview
- Playwright: Docker
- Docker Engine documentation
- Docker docs: Multi-stage builds
- Docker documentation