If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/yeasy/docker_practice shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Missing license — unclear to depend on

• Last commit 1d ago
• 3 active contributors
• CI configured
• ⚠ Small team — 3 contributors active in recent commits
• ⚠ Single-maintainer risk — top contributor 98% of recent commits
• ⚠ No license — legally unclear to depend on
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live yeasy/docker_practice repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/yeasy/docker_practice.

What it runs against: a local clone of yeasy/docker_practice — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in yeasy/docker_practice | Confirms the artifact applies here, not a fork | | 2 | Default branch master exists | Catches branch renames | | 3 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 4 | Last commit ≤ 31 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of yeasy/docker_practice. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/yeasy/docker_practice.git
#   cd docker_practice
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of yeasy/docker_practice and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "yeasy/docker_practice(\\.git)?\\b" \\
  && ok "origin remote is yeasy/docker_practice" \\
  || miss "origin remote is not yeasy/docker_practice (artifact may be from a fork)"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f ".vuepress/config.js" \\
  && ok ".vuepress/config.js" \\
  || miss "missing critical file: .vuepress/config.js"
test -f "01_introduction/README.md" \\
  && ok "01_introduction/README.md" \\
  || miss "missing critical file: 01_introduction/README.md"
test -f "07_dockerfile/7.1_run.md" \\
  && ok "07_dockerfile/7.1_run.md" \\
  || miss "missing critical file: 07_dockerfile/7.1_run.md"
test -f ".github/workflows/ci.yaml" \\
  && ok ".github/workflows/ci.yaml" \\
  || miss "missing critical file: .github/workflows/ci.yaml"
test -f ".docker/docker-entrypoint.sh" \\
  && ok ".docker/docker-entrypoint.sh" \\
  || miss "missing critical file: .docker/docker-entrypoint.sh"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 31 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/yeasy/docker_practice"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

Docker 从入门到实践 is a comprehensive, open-source Chinese textbook teaching Docker container technology from fundamentals to advanced production patterns. It covers 21 chapters spanning Docker concepts (images, containers, registries), Dockerfile authoring, Compose, Buildx, orchestration (Kubernetes, Etcd), security, monitoring (Prometheus, ELK), and real DevOps case studies—all with executable examples and deep technical explanations. Monolithic chapter-based structure: 21 numbered content directories (01_introduction/ through implied 21_/) each containing markdown files (e.g., .1_.md for subsections) plus README.md and summary.md for navigation. Build system: Vuepress config (.vuepress/config.js) for online rendering, GitHub Actions workflows (.github/workflows/) for CI/CD, and webpack-based build (package.json scripts) for static generation into dist/.

Four distinct audiences: (1) Operations newcomers learning basic Docker operations (chapters 1-4), (2) Developers containerizing applications with Dockerfile and Compose (chapters 1-3, 5-8), (3) DevOps engineers implementing container orchestration and CI/CD automation (chapters 9-14, 18), and (4) Architects designing enterprise container infrastructure and security (chapters 15-21).

Highly mature and actively maintained. The repository shows 19.6.0 version numbering, GitHub Actions CI workflows (auto-release, link checking, PDF preview), Dependabot integration for dependency updates, and is documented as 'Based on Docker Engine v29.x'. The structured chapter organization and multi-format distribution (GitBook online, PDF downloads, Vuepress mirror site) indicate production-quality documentation.

Low technical risk for a documentation/learning repository. The main dependency is webpack for the build pipeline (see package.json: webpack and webpack-cli), which are stable. Single-maintainer risk exists (yeasy as sole owner based on CODEOWNERS), but the project has strong community signals (GitHub stars badge, active GitHub workflows). No code quality metrics are apparent since this is primarily Markdown content, not a software library.

Active maintenance with GitHub Actions automation: auto-release workflows, link validation (check-link.yml), preview PDF generation, and Dependabot auto-merging enabled. The devcontainer.json suggests VS Code Remote Containers support for collaborative development. Recent focus appears to be keeping content aligned with Docker Engine v29.x releases and maintaining multiple distribution channels (online GitBook, PDF, Vuepress mirror).

Clone the repository, install dependencies, and build the documentation: git clone https://github.com/yeasy/docker_practice.git && cd docker_practice && npm install && npm run build. This creates a dist/ directory with the compiled content. To read online immediately without local build, visit https://yeasy.gitbook.io/docker_practice or download the latest PDF from GitHub Releases.

Daily commands: Install Node.js dependencies: npm install. Build static output: npm run build (creates dist/ directory via mkdir -p $PWD/dist && cp -r src/* dist/). For live editing with Vuepress preview: npm run dev (inferred from Vuepress conventions, though explicit script not shown in snippet). Access online version at https://yeasy.gitbook.io/docker_practice without local setup.

• .vuepress/config.js — VuePress configuration that defines the entire documentation site structure, navigation, and build pipeline — essential for understanding how content is organized and deployed
• 01_introduction/README.md — Entry point to the tutorial series that frames Docker's purpose and value; every new contributor should understand the pedagogical approach
• 07_dockerfile/7.1_run.md — Core Dockerfile instruction documentation that teaches the most frequently-used and error-prone command; foundational for all image building examples
• .github/workflows/ci.yaml — CI/CD pipeline definition that validates all markdown, links, and build artifacts; critical for PR quality gates
• .docker/docker-entrypoint.sh — Docker container entrypoint for the documentation build system itself; shows how this repo demonstrates Docker practices through its own tooling
• 04_image/demo/multistage-builds/Dockerfile — Real-world multi-stage build example demonstrating best practices; serves as reference for contributors adding image-building tutorials
• 06_repository/demo/docker-compose.yml — Production-ready Docker Compose configuration for a private registry; demonstrates orchestration patterns taught in the repository section

Add a new Docker installation guide for a new OS

1. Create new markdown file following existing naming pattern (e.g., 3.11_custom_os.md) in the 03_install/ directory (03_install/3.11_custom_os.md)
2. Add comprehensive prerequisites, installation steps, and verification commands using Markdown code blocks (03_install/3.11_custom_os.md)
3. Update the navigation in .vuepress/config.js to include the new guide in the installation section sidebar (.vuepress/config.js)
4. Update 03_install/README.md with a link entry to the new guide in the table of contents (03_install/README.md)

Add a new Dockerfile instruction tutorial

1. Create numbered markdown file in 07_dockerfile/ (e.g., 7.19_instruction_name.md) following the sequential pattern (07_dockerfile/7.19_instruction_name.md)
2. Include description, syntax, example Dockerfile snippets, and common use cases with practical demonstrations (07_dockerfile/7.19_instruction_name.md)
3. Create a corresponding demo subdirectory under 04_image/demo/ if demonstrating complex scenarios (e.g., instruction-demo/Dockerfile) (04_image/demo/instruction-demo/Dockerfile)
4. Register the new tutorial in .vuepress/config.js sidebar configuration under the Dockerfile section (.vuepress/config.js)
5. Add reference link in 07_dockerfile/README.md and update 07_dockerfile/summary.md with the new content (07_dockerfile/README.md)

Add a new practical demo example with Docker Compose

1. Create demo directory under the relevant section (e.g., 06_repository/demo/my-registry-setup/) with docker-compose.yml (06_repository/demo/my-registry-setup/docker-compose.yml)
2. Add any required configuration files (nginx.conf, .env templates, SSL certificates, etc.) alongside docker-compose.yml (06_repository/demo/my-registry-setup/.env.example)
3. Create a corresponding markdown tutorial in the relevant section (e.g., 6.5_my_registry_setup.md) that explains the docker-compose.yml configuration (06_repository/6.5_my_registry_setup.md)
4. Update .vuepress/config.js to link the tutorial and register it in sidebar navigation (.vuepress/config.js)

Improve documentation and fix broken links detected by CI

1. Review the check-link.yml workflow output to identify broken internal or external links (.github/workflows/check-link.yml)
2. Update the broken markdown files with corrected links, ensuring all relative paths follow ../../section/file.md pattern (01_introduction/1.2_what.md)
3. Run local build verification using the .docker/docker-entrypoint.sh to validate VuePress output before submitting PR (.docker/docker-entrypoint.sh)
4. Submit PR which will trigger ci.yaml workflow to re-check all links and build artifacts (.github/workflows/ci.yaml)

• VuePress (Vue.js-based SSG) — Enables fast, responsive documentation site with client-side navigation; supports Markdown with Vue components for interactive tutorials; ideal for technical documentation with code examples
• GitHub Actions CI/CD — Provides free, integrated workflow automation for link validation, builds, and releases; automatic deployment to GitHub Pages requires no external infrastructure
• Markdown content format — Version-controllable, renders directly on GitHub, supports embedded code blocks; ideal for collaborative documentation with clear git history of changes
• Docker containerization (for docs build) — Demonstrates Docker best practices within the project itself; ensures reproducible builds across contributors' machines; serves as meta-example of concepts being taught

• Static site generation (VuePress) rather than dynamic content platform

  • Why: Simplifies maintenance, reduces hosting costs, improves page load performance, leverages Git for version control and collaboration
  • Consequence: Cannot support user comments, real-time search, or personalization; all content is read-only educational material

• Chinese-first language with English as secondary (inferred from repo name '中文')

  • Why: Serves the primary audience of Chinese-speaking Docker learners; demonstrates localization practices in documentation
  • Consequence: English content may lag behind Chinese versions; translation maintenance burden on contributors

• CC BY-NC-SA 4.0 non-commercial license

  • Why: Protects educational content from commercial exploitation while allowing free learning and distribution
  • Consequence: Cannot be used in paid courses or commercial products without modification; limits corporate training adoption

• Monolithic sequential tutorial structure (01→07) over module-based learning paths

  • Why: Provides clear progression from fundamentals to advanced topics; suitable for linear learning; easier to maintain dependencies between chapters
  • Consequence: Readers seeking specific topics must navigate through prerequisite material; less flexible for learners with existing Docker knowledge

• Does not provide interactive hands-on environments (no embedded Docker playground or browser-based terminal)
• Does not support real-time Docker cluster monitoring or live system diagnostics
• Does not serve as API reference documentation for Docker Engine (focuses on learning concepts, not exhaustive CLI reference)
• Does not provide certification or formal assessment mechanisms (educational resource, not a training platform)
• Does not cover Kubernetes or container orchestration beyond Docker Compose (Docker-specific scope)
• Does not include video tutorials or multimedia content (text and code examples only)

(1) Content is primarily in Chinese (Markdown files) with English translations in parallel—ensure translations stay in sync. (2) Chapter numbering is critical for Vuepress sidebar configuration; adding/reordering chapters requires .vuepress/config.js updates. (3) The 'dist/' directory is build output and should not be edited directly; always modify source markdown in chapter directories. (4) GitHub Actions workflows assume specific event triggers (push to main, pull requests); modifying them requires understanding GitHub Actions syntax. (5) The .zhlintignore file suggests automated Chinese text linting—new content may need linting validation before merge.

• Container Layering (Copy-on-Write) — Understanding how Docker images use layered filesystems with copy-on-write (taught in 02_basic_concept/2.1_image.md and 04_image/4.7_internal.md) is essential for optimizing image size, build performance, and storage efficiency in production
• Namespaces and Cgroups — These Linux kernel primitives (covered in chapter 12 on deeper principles) are the foundational isolation mechanism enabling containers; understanding them explains why containers are lightweight and secure compared to VMs
• Dockerfile Build Context — Chapter 07 (Dockerfile authoring) teaches that build context—the directory sent to the daemon—directly impacts build speed and security; misunderstanding it leads to accidentally including secrets or large files in images
• Multi-stage Builds — Chapter 07 (Dockerfile optimization) covers multi-stage builds as the pattern for reducing image size in production; critical for DevOps (chapters 9-14) to keep deployments fast and secure
• Volume Mounts vs Bind Mounts — Chapter 08 (data management) distinguishes between named volumes (managed by Docker) and bind mounts (host paths); this distinction affects data persistence strategy, portability, and cluster deployment (Kubernetes, chapters 15+)
• Registry Authentication and Image Signing — Chapters 06 (repositories) and 17+ (security) cover how registries authenticate pulls/pushes and how image signing (Notary, DCT) prevents tampering; critical knowledge for DevOps engineers managing private registries and CI/CD pipelines
• Container Orchestration Patterns (Scheduling, Service Discovery, Load Balancing) — Chapters 13-15 on Kubernetes and container orchestration teach declarative infrastructure patterns fundamentally different from Docker standalone; essential for architects (target audience per roadmap) designing scalable systems

• moby/moby — The official Docker Engine open-source repository; this learning guide teaches the concepts and patterns implemented in Moby's codebase
• docker/docs — Official Docker documentation; docker_practice complements with Chinese explanations, deeper educational content, and curated learning paths not in official docs
• kubernetes/kubernetes — Kubernetes is taught in chapters 15+ as the container orchestration layer beyond Docker; readers graduating from this course naturally transition to K8s
• compose-spec/compose-spec — Official Docker Compose specification; this repo covers Compose in chapters 9-11 with hands-on examples building on Compose spec
• prometheus/prometheus — Prometheus monitoring is covered in chapter 19 (implied, based on README mentioning Prometheus in monitoring discussion); provides concrete tools taught in the course

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add comprehensive Docker command examples for 05_container section

The file structure shows 04_image is well-populated with demos (multistage-builds, buildkit, multi-arch), but 05_container appears empty. This is a critical gap since container management is fundamental. Adding practical examples for docker run, container lifecycle, networking, volumes, and resource limits would significantly improve the learning progression.

• [ ] Create 05_container/5.1_run.md with docker run examples and flags explanation
• [ ] Create 05_container/5.2_lifecycle.md covering start, stop, restart, rm operations with real scenarios
• [ ] Create 05_container/5.3_inspect.md for docker inspect, logs, stats, ps commands
• [ ] Create 05_container/5.4_network.md with bridge, host, custom network examples
• [ ] Create 05_container/5.5_volume.md with bind mounts, named volumes, and data persistence patterns
• [ ] Add demo subdirectory with working Dockerfiles and docker-compose examples for each topic
• [ ] Create 05_container/README.md and summary.md following the pattern of other sections

Add automated link validation to check-link workflow for Chinese and English content

The repo has a check-link.yml workflow but the README indicates bilingual content (Chinese and English). Many markdown files may have broken internal cross-references or outdated external links. Adding a more robust link checker with exclusion rules and reporting would catch these issues early and improve content quality.

• [ ] Review .github/workflows/check-link.yml to identify current link validation scope
• [ ] Extend check-link.yml to validate both Chinese and English markdown files in all numbered sections (01_introduction through 05_container+)
• [ ] Add .zhlintignore patterns to exclude known-good external links and internal anchors
• [ ] Configure the workflow to generate a report of broken links and create issues automatically
• [ ] Test the workflow against sample broken links in a test branch

Create Docker Compose examples section with real-world multi-container scenarios

The repo covers Docker basics and images but lacks dedicated Docker Compose documentation with practical examples. Given the file structure shows demo folders for advanced image topics, a new section covering docker-compose orchestration (YAML syntax, service definition, networking, scaling) with 3-5 complete working examples would be highly valuable for intermediate learners.

• [ ] Create 06_compose directory with README.md following existing section structure
• [ ] Create 06_compose/6.1_compose_intro.md explaining docker-compose.yml syntax and key concepts
• [ ] Create 06_compose/6.2_networking.md for multi-container networking patterns
• [ ] Create 06_compose/demo directory with 3 working examples: (1) WordPress+MySQL, (2) Node.js+Redis+PostgreSQL, (3) Microservices architecture
• [ ] Each demo should include docker-compose.yml, .env.example, and README with run instructions
• [ ] Create 06_compose/summary.md linking all topics together

• Verify and update Docker command examples in chapters 04_image/ (4.1_pull.md, 4.2_list.md, 4.3_rm.md) against Docker Engine v29.x documentation; add version compatibility notes if outputs differ: README states 'Based on Docker Engine v29.x' but example screenshots/outputs may be outdated; validates accuracy of beginner-facing content
• Add missing Dockerfile best-practices checklist or linting guide to chapter 07_* (implied but not in file list); include examples of common anti-patterns and their fixes: Developers (target audience per learning roadmap) need practical guidance on production-ready Dockerfile patterns; currently no dedicated best-practices reference visible
• Create an English translation index or 'translations available' badge in 01_introduction/README.md pointing to official English versions if they exist, or document the translation workflow for contributors: Project shows CC BY-NC-SA 4.0 license encouraging derivatives; clarifying translation status reduces duplicate translation efforts and sets community expectations

Failed to generate security analysis.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.