Docker
Docker is a platform and ecosystem 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 a Streamlit app for consistent local execution and deployment beyond Streamlit Community Cloud.
- How deep it goes
- Works through Dockerfiles, images, containers, ports, and deployment architecture, but defers multi-container database management.
- Examples
- Uses a Streamlit app, a Python 3.12 Dockerfile, host-to-container port forwarding, and an Elastic Beanstalk deployment.
- What you can do after
- Build it from scratch: package an existing Streamlit app as a Docker image, run its container, and prepare it for cloud deployment.
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
- Packages dashboard services into isolated containers and manages their shared environment with Docker Compose.
- How deep it goes
- Defines containers and Compose, then works through configuration, deployment, health checks, security, and maintenance without aiming for Docker expertise.
- Examples
- Uses an ACH dashboard with UI, API, database, WireMock, docker-compose.yml, and a Next.js Dockerfile.
- What you can do after
- Operate/configure it to build, start, connect, secure, and maintain a multicontainer dashboard environment.
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 while helping align development and production environments.
- How deep it goes
- Teaches installation, verification, and a minimum single-service publishing workflow; defers broader Docker study.
- Examples
- Uses `docker --version` to verify installation and a single microservice as the starting point for packaging.
- What you can do after
- Apply it via Docker to package, publish, and locally test a microservice before deployment.
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.
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.
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 →
Related concepts
- containeruses · A software container is an isolated execution environment that packages an application and its dependencies while 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, relationships, or rules without prescribing the step-by-step operations that produce them.
- container imageproduces · A container image is a packaged filesystem and configuration artifact from which a container can be created and run.
- Dockerfileconfigured by · A Dockerfile is a text file containing declarative instructions for building a container image and specifying its contents and runtime metadata.
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.