Docker技术入门与实战（第2版） (容器技术系列) (杨保华,戴王剑,曹亚仑)（Z-Library）

# Docker技术入门与实战（第2版）— Reading Guide ## 【One-Line Pitch】 A practical, hands-on guide to Docker containers—covering core concepts, everyday commands, and real-world deployment scenarios—ideal for developers, DevOps engineers, and IT operators who want to move from "what is Docker" to "how do I use it effectively in production." ## 【Book Arc】 - **Opening (~0%–10%)**: Introduces Docker's origins (Go-based, born 2013, from dotCloud), its relationship to Linux containers (LXC), and the three core concepts—Image, Container, Repository—plus installation on major OS platforms. Sets the foundation for everything that follows. - **Early (~10%–23%)**: Dives into essential image and container operations: pulling, searching, creating (via commit, import, and Dockerfile), entering running containers (attach vs. exec), and setting up private registries for image distribution. This is the "daily driver" skill set. - **Early (~23%–32%)**: Covers data persistence (data volumes and data volume containers) and network access (port mapping with -P/-p). Also begins the application-focused section, starting with running common OS environments like Debian/Ubuntu and BusyBox/Alpine as containers. - **Middle (~32%–48%)**: Walks through typical use cases: adding SSH to images, running web servers (Apache, Nginx, Tomcat, Jetty, LAMP), and deploying databases (MySQL, MongoDB, Redis, Memcached, Cassandra). Emphasizes practical image building via Dockerfile and commit methods. - **Middle (~48%–52%+)**: Continues with more advanced database setups (e.g., MongoDB with authentication scripts) and distributed/big-data platforms (Cassandra, Hadoop, Spark, Storm, Elasticsearch). Shows how to connect containers and manage multi-container architectures. - **Late (~52%–end, partially covered)**: The book's third part addresses advanced topics and production considerations—cloud services, container platforms, and lessons from real-world practice. The excerpts provide only a glimpse; the full text includes deeper engineering discussions and an appendix of common issues. ## 【Key Takeaways】 - **Docker is a lightweight alternative to VMs** (Opening): It packages applications into isolated containers that share the host OS kernel, enabling "Build, Ship, and Run Any App, Anywhere." This is the core value proposition—efficiency and portability without the overhead of full virtualization. - **Master the three core concepts—Image, Container, Repository** (Opening): Images are read-only templates, containers are running instances, and repositories store/distribute images. Understanding this triad is essential before any practical work. - **Creating images is a three-path skill** (Early): Use `docker commit` for quick snapshots of modified containers, `docker import` for OS templates, and Dockerfile for reproducible builds. The latter is the professional choice for maintainability. - **Entering containers requires the right tool** (Early): `docker attach` shares the terminal with all attached sessions (can be blocking), while `docker exec -it` spawns a new process—more flexible and non-intrusive. Prefer `exec` for interactive debugging. - **Private registries enable internal image sharing** (Early): Run a registry container, tag images with the registry address, and push/pull over HTTP. For newer Docker versions, configure `--insecure-registry` or set up SSL/TLS certificates to bypass security checks. - **Data persistence is a deliberate design choice** (Early): Use data volumes (`-v`) and data volume containers (`--volumes-from`) to share and survive container lifecycles. Note that volumes are not automatically deleted—use `docker rm -v` explicitly. - **Port mapping is the gateway to container services** (Early): Without `-P` or `-p`, external clients cannot reach containerized apps. Use `-P` for random high ports or `-p` for explicit host:container mappings—critical for web and database deployments. - **Middleware and databases are ideal Docker use cases** (Middle): Web servers (Jetty, Nginx) and databases (MongoDB, Cassandra) deploy quickly via official images, but always map data directories (`-v`) to host paths to avoid data loss and performance degradation. ## 【Reading Tips】 - **Skim the first two chapters** if you already know what containers are; focus on the command syntax and the "why" behind each operation. The historical context (LXC, chroot) is interesting but not essential for daily use. - **Deep-read the image and container chapters (Ch. 3–4)**—they are the foundation. Practice `docker commit`, `docker import`, and `docker exec` in a sandbox environment until they feel natural. - **Use the application chapters (Ch. 9–14) as a recipe book**: You don't need to read them linearly. Jump to the specific service you need (e.g., MongoDB or Nginx) and follow the steps. Pay attention to the "notes" about security and persistence. - **Watch for version-specific commands**: The book references Docker 1.x-era syntax (e.g., `docker search -s`). Modern Docker may deprecate or rename flags—check `docker --help` or the official docs when a command fails. - **Take away the design principles, not just commands**: The book's real value is in showing *patterns*—how to structure images, manage data, and connect containers. These patterns transfer to newer tools like Docker Compose and Kubernetes. ## 【Coverage Limits】 This guide is based on excerpts covering roughly the first half of the book (through ~52%). The advanced topics in Part 3 (cloud platforms, production practices, and engineering aesthetics) are only partially represented; readers seeking deep coverage of those areas should consult the full text. ##