Docker in Action (Jeff Nickoloff, Stephen Kuenzli) (Z-Library)

# Docker in Action, Second Edition — Reading Guide 【One-Line Pitch】 A practical, hands-on guide for Linux developers who want to master Docker containers—from running your first container to building, securing, and orchestrating production-grade applications. If you're ready to move beyond "it works on my machine" and understand containers deeply, this is your book. 【Book Arc】 - **Opening (~0%–6%)**: Sets the stage for why Docker matters—solving the "junk drawer" problem of tangled dependencies, messy filesystems, and fragile deployments. The authors explain their scope choices: Linux/macOS focus, Swarm over Kubernetes for orchestration, and why they skip cloud-specific platforms. - **Early (~6%–19%)**: Introduces the core mental model—images as shipping containers, containers as isolated runtime environments. Walks through the anatomy of `docker run`, the image resolution process, and how containers organize dependencies that would otherwise sprawl across a host system. - **Early (~19%–28%)**: Dives into running software in containers: detached daemons, process isolation via PID namespaces, and the security benefits of namespace separation. Includes practical exercises using `docker exec` to inspect container internals. - **Early–Middle (~28%–38%)**: Covers container lifecycle management—states, starting/stopping, linking containers, and environment variable injection. Uses a WordPress + MySQL example to show real-world dependency handling and configuration patterns. - **Middle (~38%–47%)**: Explores durable containers and image management: building images, understanding repositories and tags, and the composite key system (repository name + tag) that identifies images. Includes a fun "scavenger hunt" exercise to reinforce image discovery skills. 【Key Takeaways】 - **Containers solve dependency chaos** (Early): By isolating applications with their dependencies into images, Docker eliminates the "junk drawer" problem of conflicting libraries and versions on a shared host. The storage overhead concern is addressed by Docker's layered packaging system. - **`docker run` is a multi-step pipeline** (Early): When you run a container, Docker checks locally, then pulls from a registry, installs image layers, and starts the program—all in one command. Understanding this flow demystifies what's happening under the hood. - **Namespaces are the security backbone** (Early): PID namespaces prevent processes in one container from seeing or controlling processes in others, limiting attack surface. You can opt out with `--pid` flags when you need host-level process visibility for admin tasks. - **Detached mode is for daemons** (Early): Use `--detach` or `-d` for background services like web servers that don't need a terminal. Attached mode is for interactive or foreground processes. - **Environment variables are the configuration interface** (Early–Middle): Inject settings like `WORDPRESS_DB_HOST` via `--env` flags rather than hardcoding. This pattern makes containers portable across environments—critical for production deployments. - **Container startup order matters** (Early–Middle): Docker enforces dependency chains—you can't link to a non-running container. Start dependencies first, then dependent containers, or use orchestration to manage this automatically. - **Tags are flexible aliases, not just versions** (Middle): A single image can have multiple tags (e.g., `11-stretch`, `11.0.4-jdk-stretch`), letting you choose between "always latest" and "pinned exact version" strategies. Tags also encode configuration variants like "behind a load balancer." 【Reading Tips】 - **Skim the opening chapters** (~0%–6%) if you're already convinced Docker is useful—the "why" material is well-written but not essential for hands-on work. - **Deep-read the namespace and isolation sections** (~19%–28%): These are the conceptual foundation for everything security-related later. The `docker exec` exercises are worth doing, not just reading. - **Follow along with the WordPress example** (~28%–38%): It's the first realistic multi-container scenario and teaches linking, environment injection, and dependency ordering in one coherent project. - **Do the scavenger hunt** (~44%–47%): It's a clever way to practice image discovery and removal commands (`docker run`, `docker rmi`) in a low-stakes, game-like format. - **Don't worry about Windows-specific issues**: The authors explicitly scope to Linux/macOS, so if you're on Windows, focus on the concepts and adapt commands as needed. 【Coverage Limits】 The excerpts cover roughly the first half of the book (through image management and tags). Later chapters on building custom images, securing containers, and orchestration with Swarm are not covered in this guide.