Docker
Docker is a platform and toolset for building, distributing, and running applications in containers.
Learn Docker in a Month of Lunches, Second Edition
Docker is a platform for building, distributing, and running applications in isolated software containers.
- How it is used
- Provides a common build, share, and run workflow across development, testing, and production.
- How deep it goes
- Works through container commands and explains Engine, API, and CLI roles, while deferring containerd and operating-system internals.
- Examples
- Runs a Hello World image, verifies Docker and Compose versions, and challenges readers to change a containerized website.
- What you can do after
- Operate/configure it to run and package applications locally, share images, and prepare container-based deployment workflows.
Read how Learn Docker in a Month of Lunches, Second Edition explains Docker →
Kubernetes in Action, Second Edition
Docker is a platform and toolset for building, distributing, and running software containers.
- How it is used
- Packages and runs applications locally as container images that can later be distributed or run with Kubernetes.
- How deep it goes
- Explains images, registries, and containers, then works through a Dockerfile and build command rather than Docker implementation internals.
- Examples
- Runs BusyBox to print a greeting and builds a Node.js application image from a minimal Dockerfile.
- What you can do after
- Apply it via the Docker CLI to run an existing image, build an application image, and view container logs.
Read how Kubernetes in Action, Second Edition explains Docker →
Road to Kubernetes
Docker is a software platform and command-line tool for building, distributing, and running applications in containers.
- How it is used
- Supports a deployment journey from locally running images to hosting containerized applications on virtual machines.
- How deep it goes
- Works through installation, image retrieval, container commands, VM deployment, and automated setup; defers hosting a private registry.
- Examples
- Uses a Python 3.10 Dockerfile and NGINX commands for local runs and Ubuntu VM deployment.
- What you can do after
- Operate/configure it to run and inspect containers locally or on an Ubuntu VM, then automate VM setup with GitHub Actions.
Build Python Web Apps with Streamlit
Docker is a platform and toolset for packaging applications with their dependencies into portable images and running them in isolated containers.
- How it is used
- Packages Streamlit apps and their dependencies for consistent local and cloud deployment.
- How deep it goes
- Explains images, layers, containers, port forwarding, and volumes through a Dockerfile; leaves self-managed PostgreSQL multi-container setups uncovered.
- Examples
- Uses a trivia app’s requirements.txt and Dockerfile, a port-forwarding diagram, and an Elastic Beanstalk deployment.
- What you can do after
- Apply Docker to package a Streamlit app, run a container locally, and deploy the app through Elastic Beanstalk.
Read how Build Python Web Apps with Streamlit explains Docker →
Build Financial Software with Generative AI (From Scratch)
Docker is a platform for packaging, distributing, and running applications in isolated containers.
- How it is used
- Uses containers to assemble and independently expand components of an ACH dashboard.
- How deep it goes
- Walks through Compose setup, deployment, security, maintenance, and health checks, while stopping short of Docker expertise.
- Examples
- Uses an ACH dashboard with Next.js, FastAPI, and PostgreSQL, plus a dashboard deployment connected to WireMock.
- What you can do after
- Operate and configure a multicontainer environment with Docker Compose, then build and run the dashboard container.
Read how Build Financial Software with Generative AI (From Scratch) explains Docker →
Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more
Docker is a container platform that provides a daemon-based engine, client, and ecosystem for building and running containers.
- How it is used
- Runs, builds, and manages containerized applications on a single node through a client-server engine.
- How deep it goes
- Explains the daemon chain and process ancestry, then stops short of detailed OCI-runtime or kernel implementation.
- Examples
- Uses registry image pulls, Docker client-server diagrams, and privileged host-mount commands as concrete examples.
- What you can do after
- Operate/configure Docker to pull and run images, while recognizing daemon dependencies and docker.sock privilege risks.
Machine Learning Platform Engineering
Docker is a platform and toolset for building, packaging, distributing, and running containerized applications.
- How it is used
- Packages ML and web applications consistently for local development, cloud deployment, Kubernetes operation, and automated delivery.
- How deep it goes
- Explains containerization from first principles and demonstrates application setup, while deferring detailed image-building configuration.
- Examples
- Demonstrates object detection dependencies, a FastAPI joke service, Kubernetes runtimes, and a Docker Compose Langfuse deployment.
- What you can do after
- Build it from scratch by packaging a dependency-bearing application and connecting its image to deployment automation.
Read how Machine Learning Platform Engineering explains Docker →
Kubernetes for Developers
Docker is a platform and toolset for building, packaging, and running containers.
- How it is used
- Packages applications for isolated local development and prepares their images for Kubernetes deployment.
- How deep it goes
- Works through local container commands and a compiling Dockerfile, but does not detail Docker’s internal implementation.
- Examples
- Uses an interactive Ubuntu shell, Python commands, and a Java application compiled in a Dockerfile.
- What you can do after
- Build it from scratch with a Dockerfile, then run and inspect containers using Docker commands.
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A Docker container is an isolated runtime instance of a container image with its own filesystem, processes, and resource context.
- How it is used
- Packages and publishes microservices, with local container testing supporting development and troubleshooting.
- How deep it goes
- Introduces installation, verification, and single-service packaging and publishing, while deferring broader Docker expertise.
- Examples
- Uses a Node.js microservice, a Docker version check, and the FlixTube application to practice the workflow.
- What you can do after
- Apply it via Docker to package and publish a microservice and test it locally.
AI-Powered Developer: Build software with ChatGPT and Copilot
A Docker container is a running, isolated instance of an application created from a Docker image.
- How it is used
- Packages a Python application and a PostgreSQL database for local running and deployment preparation.
- How deep it goes
- Defines images and containers, explains kernel-sharing isolation, and works through Dockerfile, build, and run commands without deeper runtime internals.
- Examples
- Demonstrates a PostgreSQL itam_db container and a Python 3.10 application image named itam:latest.
- What you can do after
- Operate/configure it to build images and run locally published application or database containers.
Read how AI-Powered Developer: Build software with ChatGPT and Copilot explains Docker →
Build and Orchestrator in Go (From Scratch)
A Docker container is an isolated runtime environment created and managed by Docker for executing software and its dependencies.
- How it is used
- Runs orchestration tasks as Docker containers so workers can start and stop the system’s smallest units of work.
- How deep it goes
- Explains command-line lifecycle, inspection state, configuration categories, and corresponding Docker API methods without detailing Docker internals.
- Examples
- Demonstrates running, connecting to, inspecting, and stopping a PostgreSQL container with port mappings and environment variables.
- What you can do after
- Apply it via the Docker CLI and Go SDK to create, start, inspect, and stop containers for task execution.
Read how Build and Orchestrator in Go (From Scratch) explains Docker →
.NET in Action, Second Edition
Docker is a platform and command-line tool for building, distributing, and running containerized applications.
- How it is used
- Hosts .NET containers locally during development and builds images when a custom Dockerfile is needed.
- How deep it goes
- Works through Dockerfile instructions, ignored files, tagging, and multi-stage builds without detailing Docker’s container internals.
- Examples
- Uses a .NET 6 service Dockerfile, a `.dockerignore` file, build-and-tag commands, and a named-stage publishing Dockerfile.
- What you can do after
- Apply it via the Docker CLI to build and tag a .NET service image from a Dockerfile.
Spring Microservices in Action
Docker is a platform for developing, shipping, and running applications in containers.
- How it is used
- Packages microservices and their supporting infrastructure for deployment in an IaaS cloud.
- How deep it goes
- Explains container deployment and build-pipeline roles, while deferring Docker, Maven, and plugin configuration.
- Examples
- Uses a microservice stack with database, messaging, and search containers to illustrate lightweight local deployment.
- What you can do after
- Apply Docker through Spotify’s Maven plugin to build images in a microservice deployment pipeline.
ScyllaDB in Action
Docker is a platform for building, packaging, and running applications in isolated containers.
- How it is used
- Runs ScyllaDB locally in containers so distributed-cluster behavior can be practiced on a personal computer.
- How deep it goes
- Explains networks, container names, hostnames, detached mode, port forwarding, logs, inspection, and shutdown, but not Docker internals.
- Examples
- Uses a three-node ScyllaDB cluster, docker network create, docker run, docker logs, docker ps, and docker stop.
- What you can do after
- Operate/configure a local ScyllaDB cluster, inspect its containers, and stop a node to observe failure behavior.
Fight Fraud with Machine Learning
Docker is a platform for packaging, distributing, and running applications in isolated environments called containers.
- How it is used
- Packages a Flask-based fraud-prediction service for repeatable deployment across payment processors.
- How deep it goes
- Explains Dockerfiles, image construction, image inspection, port mapping, and container launch through concrete commands.
- Examples
- Uses a random forest service, model_server.py, requirements.txt, model.joblib, and port 8890 as deployment artifacts.
- What you can do after
- Operate/configure a containerized Flask service that serves real-time fraud predictions through a mapped network port.
Read how Fight Fraud with Machine Learning explains Docker →
Spring in Action, Sixth Edition
The Docker runtime is the installed Docker software environment that builds and runs Docker images and containers.
- How it is used
- Deploys Spring Boot applications as portable container images for cloud environments.
- How deep it goes
- Explains Dockerfile instructions and build/run commands, while stopping short of deeper runtime internals.
- Examples
- Uses a Spring Boot JAR, an OpenJDK 11 Dockerfile, docker build, docker run, and port 8080 mapping.
- What you can do after
- Operate Docker by building, running, tagging, and pushing a Spring Boot container image.
AI Agents in Action, Second Edition
Docker is a platform for building, packaging, distributing, and running applications in containers.
- How it is used
- Deploys focused agent services locally or as coordinated container stacks.
- How deep it goes
- Explains container boundaries, local operation, and Compose orchestration, but defers Kubernetes and broader cloud deployment.
- Examples
- Uses an image-generator API, Dockerfile, Docker build and run commands, Docker Desktop logs, and a Compose stack.
- What you can do after
- Operate/configure agent containers, inspect logs, and launch coordinated services with Docker Compose.
Read how AI Agents in Action, Second Edition explains Docker →
Server-Side WebAssembly
Docker is a platform and command-line toolset for building, packaging, and running applications in containers.
- How it is used
- Runs Wasm guest modules in temporary, mounted host environments through familiar Docker tooling.
- How deep it goes
- Traces Docker Engine through runC, containerd-shim, and containerd, then contrasts the Wasm runtime path.
- Examples
- Demonstrates copying a compiled module, mounting it, invoking a published image, and producing Hello, Dan.
- What you can do after
- Operate/configure Docker to run a Wasm module through a mounted directory and temporary container.
Just Use Postgres!
Docker is a platform for building, distributing, and running software in containers.
- How it is used
- Deploys Postgres as a disposable, cross-platform development environment without OS-specific installers or permanent laptop installation.
- How deep it goes
- Explains container startup, persistence, port mapping, and readiness checks, but defers comprehensive deployment and administration guidance.
- Examples
- Uses Postgres 17.2 startup commands, container listings, and logs showing readiness to accept connections.
- What you can do after
- Operate/configure a local Postgres container with persistent storage, mapped connectivity, credentials, and basic readiness verification.
Rust Servers, Services, and Apps
Docker is a platform and toolset for building, packaging, and running applications in containers.
- How it is used
- Deploys Rust web services as portable containers and manages grouped application components.
- How deep it goes
- Builds and runs a basic image, then extends the treatment to multistage builds, static binaries, Compose, networks, and volumes.
- Examples
- Uses an Actix Web service with root and /hello endpoints, a Dockerfile-basic image, Docker CLI commands, and browser tests.
- What you can do after
- Operate/configure Docker to build images, run Rust services, test published endpoints, and coordinate containers with Compose.
Shipping Go: Develop, deliver, discuss, design, and go again
Docker is a software platform and toolset for building, distributing, and running containerized applications.
- How it is used
- Deploys portable applications while reducing local setup and dependency-management work across development and production.
- How deep it goes
- Explains images, runtimes, host-kernel sharing, Buildpacks, local execution, and publishing through a worked deployment workflow.
- Examples
- Uses a Go application, pack build hello-api, docker run hello-api, and alternative Docker-compatible tooling such as Podman.
- What you can do after
- Build it via Docker and Cloud Native Buildpacks, run it locally, test its endpoint, and publish the resulting container.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains Docker →
Acing the Certified Kubernetes Administrator Exam, Second Edition
Docker is a container platform for building, running, and managing container images and containers.
- How it is used
- Connects Docker images and container runtimes to the Kubernetes worker-node execution path.
- How deep it goes
- Explains runtime placement, image identifiers, pod states, and CRI integration, but stops short of Docker command usage or image construction.
- Examples
- Uses an nginx pod inspection showing a docker.io image reference and a containerd container identifier.
- What you can do after
- Diagnose pod execution by reading image, runtime, status, and event information with kubectl describe.
Read how Acing the Certified Kubernetes Administrator Exam, Second Edition explains Docker →
MongoDB 8.0 in Action, Third Edition
A Docker container is an isolated runtime instance created from a Docker image.
- How it is used
- Supports repeatable local MongoDB Atlas development by isolating dependencies and simplifying deployment management.
- How deep it goes
- Defines containerization and walks through installation, verification, and Atlas deployment management, without detailing Docker internals.
- Examples
- Uses docker info and atlas deployments setup --type local to verify Docker and create a local Atlas cluster.
- What you can do after
- Operate a Docker-backed local Atlas deployment, including setup, connection, lifecycle management, logging, and search configuration.
Read how MongoDB 8.0 in Action, Third Edition explains Docker →
Pro ASP.NET Core 7, Tenth Edition
A Docker container is an isolated process environment created and run by Docker with its application and dependencies.
- How it is used
- Prepares an ASP.NET Core application for deployment as a Docker container.
- How deep it goes
- Builds and runs an application image with Dockerfile and Compose steps, but stops short of a complete deployment guide.
- Examples
- Uses SportsStore, a .NET 7 Dockerfile, Docker Compose services, SQL Server, and the localhost:5000 endpoint.
- What you can do after
- Operate/configure Docker Desktop, build the SportsStore image, start its database and application containers, and verify the running endpoint.
Read how Pro ASP.NET Core 7, Tenth Edition explains Docker →
Essential TypeScript 5, Third Edition
Docker is a platform and toolset for building, distributing, and running applications in software containers.
- How it is used
- Deploys standalone web applications as portable containers for local testing and production hosting.
- How deep it goes
- Explains image construction and container lifecycle through Dockerfiles and commands, but does not detail Docker internals.
- Examples
- Uses standalone, Angular, and React web applications with Dockerfiles, port mappings, localhost tests, and container stop commands.
- What you can do after
- Operate/configure Docker to build images, run mapped-port containers, test applications locally, inspect running containers, and stop them.
Read how Essential TypeScript 5, Third Edition explains Docker →
Build AI-Enhanced Web Apps
A software platform for building, packaging, distributing, and running applications in containers.
- How it is used
- Supports advanced deployment of AI web applications by packaging applications consistently across environments.
- How deep it goes
- Defines dependency and configuration packaging, but stops short of implementation commands or container internals.
- Examples
- Uses AI models, web applications, dependencies, configurations, and self-hosted environments as deployment examples.
- What you can do after
- Operate/configure consistent application deployments across environments and prepare containers for orchestration at scale.
Data Pipelines with Apache Airflow, Second Edition
Docker is a platform for building, distributing, and running applications in containers.
- How it is used
- Runs reproducible Airflow environments and containerized tasks while organizing multicontainer deployments.
- How deep it goes
- Explains isolation, host-kernel virtualization, Compose configuration, and startup commands, but stops short of detailed container internals.
- Examples
- Uses Airflow Compose files, docker compose up, docker ps, and a multi-service stack with PostgreSQL and Redis.
- What you can do after
- Operate a local Airflow deployment with Docker Compose and inspect its running containers.
Read how Data Pipelines with Apache Airflow, Second Edition explains Docker →
Building Distributed Applications that Work
Docker is a platform for building, packaging, and running applications in containers.
- How it is used
- Packages applications and dependencies into portable containers for consistent execution across development, test, and production.
- How deep it goes
- Outlines container packaging, isolation, kernel sharing, and image contents as an overview.
- Examples
- Uses local development, test, and production environments to illustrate portability, and contrasts containers with virtual machines.
- What you can do after
- Understand how containers package and isolate applications while sharing the host operating system’s kernel.
Read how Building Distributed Applications that Work explains Docker →
Also covered in
- Developer Experience on KubernetesIn early access (MEAP)
- Acing the CCNA Exam: Volume 2 Advanced Networking and Security
- Logs and Telemetry
- Enterprise RAGIn early access (MEAP)
- Build Applications with Local AI Models on a Mac
- Cloud Observability in Action
- Pro Angular 16
- BDD in Action, Second Edition
- Lead Developer Career Guide
- Grokking Web Application Security
- Contract Testing in Action
- AI Agents in Action
What to know first
- containerA software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- PythonPython is a high-level, general-purpose, dynamically typed programming language with readable syntax and support for multiple programming paradigms.
- load balancingLoad balancing is the distribution or adjustment of work across multiple resources to manage demand and reduce overload or imbalance.
- microservice architectureMicroservice architecture is a software architectural style that structures an application as independently deployable services, typically organized around focused capabilities and communicating through defined interfaces.
Related concepts
- containeruses · A software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- Podmanincludes · Podman is a daemonless, open-source container engine for building, running, and managing containers and container images.
- docker inspectused by · docker inspect is a Docker command-line tool that displays detailed metadata, configuration, and state information for Docker objects.
- declarative programmingkind of · Declarative programming is a programming paradigm that specifies desired results, states, or relationships without prescribing the step-by-step procedure to achieve them.
- container imageproduces · A container image is a packaged filesystem and metadata artifact from which a container can be created and run.
- Docker Composeused by · Docker Compose is a tool for defining and running applications composed of multiple containers through declarative configuration.
Questions about Docker
What is Docker?
Docker is a platform and toolset for building, distributing, and running applications in containers.
Which Manning books explain Docker?
Learn Docker in a Month of Lunches, Second Edition, Kubernetes in Action, Second Edition, Road to Kubernetes, Build Python Web Apps with Streamlit, Build Financial Software with Generative AI (From Scratch), Podman in Action: Secure, rootless containers for Kubernetes, microservices, and more, Machine Learning Platform Engineering, Kubernetes for Developers and 20 more.
What should I know before learning Docker?
Manning books that teach Docker usually introduce container, Python, load balancing and microservice architecture first.
What kinds of Docker are there?
Kinds of Docker include Podman.
What is Docker a kind of?
Docker is a kind of declarative programming. Declarative programming is a programming paradigm that specifies desired results, states, or relationships without prescribing the step-by-step procedure to achieve them.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.



























