Docker实践 ( etc.)（Z-Library）

【One-Line Pitch】 A hands-on, recipe-driven guide for mid-to-senior DevOps and operations engineers who want to move Docker beyond experiments and into real development, CI/CD, and production workflows—packed with 101 practical techniques for solving concrete problems. 【Book Arc】 - **Opening (~0%–9%)**: Introduces Docker's core value proposition—why containers beat VMs and configuration management sprawl—and sets up the book's structure: four parts covering basics, development, DevOps pipelines, and production. The preface and foreword frame the authors' early-adopter experience at OpenBet. - **Early (~9%–25%)**: Covers Docker fundamentals: the key concepts of images, containers, and layers, plus the main CLI commands (`build`, `run`, `commit`, `tag`). A walkthrough builds a simple to-do app with a Dockerfile, demonstrating how to create, run, and inspect containers. - **Early (~25%–34%)**: Deepens the hands-on foundation by explaining the four ways to create images (manual, Dockerfile, config management tools, and importing files), then details the build process, port mapping, container lifecycle management, and the copy-on-write layering mechanism that makes containers fast and disk-efficient. - **Middle (~34%–47%)**: Shifts to architecture and operational techniques. Covers the Docker daemon, client, registry, and Hub, with tips on exposing the daemon over TCP, running containers as daemons with restart policies, and moving Docker data to different partitions. Emphasizes debugging and non-standard configurations. - **Middle (~47%–end of sample)**: Continues with practical daily-use techniques: managing volumes for persistence, running containers in the background, cleaning up resources, and using tools like DockerUI and dependency graphs. The book then moves into configuration management, DevOps integration, networking, orchestration, security, and production troubleshooting (per the roadmap). 【Key Takeaways】 - **Images are classes; containers are objects** (Early): This analogy clarifies the core distinction—containers are isolated, runnable instances of a static image, and changes inside a container don't affect the image. Understanding this is foundational for everything else. - **Dockerfile is a simple, ordered command sequence** (Early): It mixes filesystem changes (`RUN`) with metadata (`EXPOSE`, `CMD`, `WORKDIR`). Building a to-do app from a `node` base image shows how a few lines can replace complex installation instructions. - **Copy-on-write layering is what makes Docker fast and cheap** (Early): Containers share underlying layers, so starting hundreds of them doesn't duplicate disk usage. This is a critical operational advantage over VMs for scaling tests and environments. - **Four ways to create images, not just one** (Early): Manual `docker commit`, Dockerfile, config management tools, and importing a TAR of files each fit different scenarios—from quick proofs-of-concept to complex builds where Dockerfile alone is insufficient. - **Run containers as services with `-d` and restart policies** (Middle): The `--restart` flag (`no`, `always`, `on-failure`) lets you manage container lifecycle predictably, but beware: `always` with a quick-exiting command causes a restart loop, and container IDs persist across restarts. - **Exposing the Docker daemon is powerful but dangerous** (Middle): Opening it via TCP (`-H tcp://0.0.0.0:2375`) enables remote debugging and workflow integration, but it's a privilege-escalation risk—always restrict to specific IP ranges, never bind to all interfaces. - **Volumes and data containers solve persistence** (Middle): The book addresses the "where does my data go?" problem with techniques like data containers, SSHFS, NFS, and distributed volumes, which are essential for real development workflows. 【Reading Tips】 - **Skim the first two chapters if you're already comfortable with Docker basics**—the to-do app walkthrough and core concepts are well-trodden ground; the real value starts with the architecture and debugging tips in Chapter 2. - **Treat the book as a recipe book, not a cover-to-cover read**—each "problem/solution/discussion" technique is self-contained, so jump to the section that matches your current pain point (e.g., persistence, networking, security). - **Deep-read the sections on daemon security and restart policies**—these are easy to get wrong in production and have subtle failure modes (like the `--restart=always` loop) that the authors illustrate with concrete examples. - **Pay attention to the Docker version caveat**—the book targets Docker 1.9, so commands and behaviors may differ in modern versions; use the techniques as conceptual guides, not verbatim instructions. - **Take away the mental model of "container as a process"**—this framing helps you reason about lifecycle, logging, and debugging in ways that translate to any container runtime, not just Docker. 【Coverage Limits】 This guide covers the sampled excerpts (roughly the first half of the book), which focus on Docker fundamentals, development workflows, and early operational techniques. The later parts on DevOps pipelines, networking, orchestration, security, and production troubleshooting are only summarized from the roadmap and are not covered in detail here.