Docker Deep Dive Zero to Docker in a Single Book (Nigel Poulton)（Z-Library）

# Docker Deep Dive: Zero to Docker in a Single Book — Reading Guide ## 【One-Line Pitch】 The definitive, hands-on guide to mastering Docker from absolute zero—covering everything from container fundamentals to cutting-edge Wasm and local AI model deployment—for developers and IT professionals who want production-ready container skills in 2025. ## 【Book Arc】 - **Opening (~0%–9%)**: Sets the stage with "big picture" concepts—what Docker is, why containers beat VMs, and essential jargon like cloud-native, microservices, and orchestration. Establishes the book's two-part structure: conceptual foundation first, then technical deep-dives. - **Early (~9%–25%)**: Covers Docker's origin story (born from dotCloud's internal tool), the ecosystem of standards and projects (CNCF, Moby), and practical installation paths—Docker Desktop for Mac/Windows, Multipass for Linux-style VMs. Includes first verification steps with `docker version`. - **Early (~25%–34%)**: Explains the Docker Engine architecture—how containerd (high-level runtime) and runc (low-level runtime) work together, with shims enabling alternative runtimes. Introduces the first container runs and the fundamentals of images as layered, build-time constructs. - **Middle (~34%–47%)**: Deep-dives into images—layer stacking, manifests, tags vs. digests, multi-architecture support via manifest lists, and the content-addressable storage model. Transitions into container operations: starting, inspecting, and managing running containers, plus the VM tax comparison. - **Late (~47%–end)**: Covers advanced and emerging topics—Docker Model Runner for local LLMs, WebAssembly containers, Docker Swarm orchestration, plus modern tooling like Docker Init, Docker Debug, and Docker Scout for professional development workflows. ## 【Key Takeaways】 - **Containers share the host OS, unlike VMs** (Early): Every container uses the host's kernel, eliminating the "VM tax" of dedicated OSes that consume CPU, RAM, and boot time. This is why a single host can run 3x more containers than VMs—the core efficiency argument for containerization. - **Docker's architecture is modular and layered** (Early): The Docker Engine splits responsibilities—containerd manages container lifecycle (start, stop, delete) while runc does the actual low-level work. Shims allow swapping runtimes, which later enables Wasm support. Understanding this separation clarifies how Docker evolved beyond its LXC origins. - **Images are build-time constructs; containers are run-time constructs** (Early): An image is like a stopped container or a class in programming—a template containing OS filesystem, app code, and dependencies. You can start multiple containers from one image, and images cannot be deleted while containers using them run. - **Image tags are mutable; digests are immutable** (Middle): Pulling `alpine:latest` today won't give you the same image as a year from now. Docker's content-addressable storage assigns every image a cryptographic digest, guaranteeing you always pull the intended image—critical for production reproducibility and security auditing. - **Multi-architecture support is built into Docker** (Middle): Manifest lists let a single image name serve multiple OS/architecture combinations (linux/amd64, linux/arm64, windows/amd64, etc.). Docker automatically selects the right variant, making cross-platform deployment seamless. - **Docker has expanded beyond traditional containers** (Late): The 2025 edition covers Docker Model Runner for running local LLMs, WebAssembly containers for fast portable workloads, and Swarm for orchestration—positioning Docker as a platform for AI and next-gen computing, not just microservices. - **Modern Docker tooling addresses the full development lifecycle** (Late): Docker Init scaffolds new projects, Docker Debug simplifies container debugging, and Docker Scout provides vulnerability scanning—moving Docker from a deployment tool to a complete development environment solution. ## 【Reading Tips】 - **Skim the "big picture" chapters (0–9%)** if you already know container basics—they're essential for true beginners but review material for experienced developers. Focus instead on the technical chapters that follow. - **Deep-read the images chapter (~34–47%)**: Tags vs. digests, layer mechanics, and multi-arch support are the most exam-worthy and production-critical concepts. Practice `docker inspect`, `docker history`, and `docker manifest` commands alongside the text. - **Pay special attention to the Docker Engine chapter (~25%)**: The containerd/runc/shim architecture is the foundation for understanding advanced topics like Wasm. If this clicks, the later chapters will feel natural. - **For the 2025 additions (Model Runner, Wasm, Scout)**, treat them as practical tutorials—follow along with your own Docker installation rather than just reading. These chapters assume you've mastered the earlier fundamentals. - **Use the command examples as your lab manual**: The book is built around real CLI output. Reproduce the `docker run`, `docker ps`, and `docker pull` examples yourself—muscle memory beats passive reading for Docker skills. ## 【Coverage Limits】 This guide synthesizes the first ~47% of the book in depth (fundamentals through containers). The late-book chapters on Docker Model Runner, Wasm, and Swarm are covered at a high level from table-of-contents and summary material; detailed command walkthroughs for those sections are not fully represented in the source excerpts. ##