Fix ascii figures

02_basic_concept/2.3_repository.md

@@ -16,25 +16,29 @@ Docker Registry 是镜像分发和管理的核心组件。本节将介绍 Regist
 
 Docker Registry 中可以包含多个 Repository，每个 Repository 可以包含多个 Tag。如图 2-2 所示，它们之间具有清晰的层级关系。
 
-```
+```mermaid
-┌─────────────────────────────────────────────────────────────────────┐
+flowchart TB
-│                         Docker Registry                             │
+    subgraph Registry ["Docker Registry（如 Docker Hub）"]
-│                      （如 Docker Hub）                               │
+        direction TB
-│  ┌─────────────────────────────────────────────────────────────┐   │
+        subgraph RepoNginx ["Repository（仓库）: nginx"]
-│  │  Repository（仓库）: nginx                                    │   │
+            direction LR
-│  │  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐         │   │
+            N1(":latest (tag)")
-│  │  │ :latest │  │ :1.25   │  │ :1.24   │  │ :alpine │   ...   │   │
+            N2(":1.25 (tag)")
-│  │  │  (tag)  │  │  (tag)  │  │  (tag)  │  │  (tag)  │         │   │
+            N3(":1.24 (tag)")
-│  │  └─────────┘  └─────────┘  └─────────┘  └─────────┘         │   │
+            N4(":alpine (tag)")
-│  └─────────────────────────────────────────────────────────────┘   │
+            N5("...")
-│                                                                     │
+            N1 ~~~ N2 ~~~ N3 ~~~ N4 ~~~ N5
-│  ┌─────────────────────────────────────────────────────────────┐   │
+        end
-│  │  Repository（仓库）: mysql                                    │   │
+        subgraph RepoMysql ["Repository（仓库）: mysql"]
-│  │  ┌─────────┐  ┌─────────┐  ┌─────────┐                      │   │
+            direction LR
-│  │  │ :latest │  │ :8.0    │  │ :5.7    │   ...                │   │
+            M1(":latest")
-│  │  └─────────┘  └─────────┘  └─────────┘                      │   │
+            M2(":8.0")
-│  └─────────────────────────────────────────────────────────────┘   │
+            M3(":5.7")
-└─────────────────────────────────────────────────────────────────────┘
+            M4("...")
+            M1 ~~~ M2 ~~~ M3 ~~~ M4
+        end
+        RepoNginx ~~~ RepoMysql
+    end
 ```
 
 图 2-2 Registry、Repository 与 Tag 的层级关系

04_image/4.1_pull.md

@@ -91,16 +91,15 @@ docker.io/library/ubuntu:24.04
 
 从输出可以看到，镜像是**分层下载**的：
 
-```
+```mermaid
-┌─────────────────────────────────────────────────────────────┐
+flowchart TD
-│                   ubuntu:24.04 镜像                          │
+    subgraph Image ["ubuntu:24.04 镜像"]
-├─────────────────────────────────────────────────────────────┤
+        direction TB
-│  第3层 c8299583700a  ───────► 已存在，跳过下载               │
+        L3["第3层 c8299583700a<br/>(已存在，跳过下载)"]
-├─────────────────────────────────────────────────────────────┤
+        L2["第2层 be13a9d27eb8<br/>(下载中... 完成)"]
-│  第2层 be13a9d27eb8  ───────► 下载中... 完成                 │
+        L1["第1层 92dc2a97ff99<br/>(下载中... 完成)"]
-├─────────────────────────────────────────────────────────────┤
+        L3 --- L2 --- L1
-│  第1层 92dc2a97ff99  ───────► 下载中... 完成                 │
+    end
-└─────────────────────────────────────────────────────────────┘
 ```
 
 如果本地已有相同的层，Docker 会跳过下载，节省带宽和时间。

04_image/4.3_rm.md

@@ -96,25 +96,26 @@ Deleted: sha256:32770d1dcf835f192cafd6b9263b7b597a1778a403a109e2cc2ee866f74adf23
 
 Docker 会检测镜像是否有容器依赖或其他标签指向，只有在确认为无用资源时才会真正删除存储层。
 
-```
+```mermaid
-docker rmi redis:alpine
+flowchart TD
-        │
+    Start(["docker rmi redis:alpine"]) --> Step1
-        ▼
+    
-┌───────────────────────────────────────────────────────────────┐
+    subgraph Process ["删除流程"]
-│  1. Untag：移除 redis:alpine 标签                              │
+        direction TB
-│       ↓                                                       │
+        Step1["1. Untag：移除 redis:alpine 标签"] --> Step2
-│  2. 检查是否还有其他标签指向这个镜像                             │
+        
-│       ├── 有 → 只 Untag，不删除                                │
+        Step2{"2. 检查是否还有其他标签指向此镜像"}
-│       └── 无 →                                                │
+        Step2 -- "有" --> Keep1["只 Untag，不删除"]
-│             ↓                                                 │
+        Step2 -- "无" --> Step3
-│  3. 检查是否有容器依赖                                          │
+        
-│       ├── 有 → 报错，无法删除                                  │
+        Step3{"3. 检查是否有容器依赖"}
-│       └── 无 →                                                │
+        Step3 -- "有" --> Error["报错，无法删除"]
-│             ↓                                                 │
+        Step3 -- "无" --> Step4
-│  4. 从上到下逐层删除，检查每层是否被其他镜像使用                   │
+        
-│       ├── 被使用 → 保留                                       │
+        Step4{"4. 从上到下逐层删除，检查每层是否被其他镜像使用"}
-│       └── 未使用 → Deleted                                    │
+        Step4 -- "被使用" --> Keep2["保留该层"]
-└───────────────────────────────────────────────────────────────┘
+        Step4 -- "未使用" --> Delete["Deleted (删除该层)"]
+    end
 ```
 
 ---

04_image/4.7_internal.md

@@ -25,16 +25,18 @@ Docker 镜像并不是一个单纯的文件，而是由一组文件系统叠加
 
 当容器启动时，Docker 会在镜像的最上层，添加一个新的**可写层（Writable Layer）**，通常被称为**容器层**。
 
-```
+```mermaid
-┌──────────────────────────────────────────────┐
+flowchart TD
-│  容器层 (可写, Writable Container Layer)      │  <-- 所有的写操作都在这里
+    subgraph Container ["运行中的容器"]
-├──────────────────────────────────────────────┤
+        direction TB
-│  镜像层 (只读, Read-only Image Layer)         │
+        L4["容器层 (可写, Writable Container Layer)"]
-├──────────────────────────────────────────────┤
+        L3["镜像层 (只读, Read-only Image Layer)"]
-│  镜像层 (只读, Read-only Image Layer)         │
+        L2["镜像层 (只读, Read-only Image Layer)"]
-├──────────────────────────────────────────────┤
+        L1["基础镜像层 (只读, Base Image Layer)"]
-│  基础镜像层 (只读, Base Image Layer)          │
+        
-└──────────────────────────────────────────────┘
+        L4 --- L3 --- L2 --- L1
+    end
+    Note["所有的写操作都在容器层这里"] -.-> L4
 ```
 
 *   **读取文件**：当容器需要读取文件时，Docker 会从最上层（容器层）开始向下层（镜像层）寻找，直到找到该文件为止。

05_container/5.2_daemon.md

@@ -59,13 +59,13 @@ $ docker run -d ubuntu:24.04
 
 #### 核心原理：容器的生命周期与主进程绑定
 
-```
+```mermaid
-┌─────────────────────────────────────────────────────────────────────┐
+flowchart TD
-│  Docker 容器的生命周期 = 容器内 PID 1 进程的生命周期                   │
+    subgraph Lifecycle ["Docker 容器的生命周期 = 容器内 PID 1 进程的生命周期"]
-│                                                                     │
+        direction LR
-│  主进程启动 → 容器运行                                                │
+        Start["主进程启动"] --> Run["容器运行"]
-│  主进程退出 → 容器停止                                                │
+        Exit["主进程退出"] --> Stop["容器停止"]
-└─────────────────────────────────────────────────────────────────────┘
+    end
 ```
 
 当你运行 `docker run -d ubuntu:24.04` 时：

05_container/5.4_attach_exec.md

@@ -129,14 +129,15 @@ $ docker attach 容器名
 
 `attach` 会附加到容器的**主进程**（PID 1）的标准输入输出：
 
-```
+```mermaid
-┌─────────────────────────────────────────┐
+flowchart LR
-│              容器                        │
+    subgraph Container ["容器"]
-│  ┌─────────────────────────────────┐    │
+        direction TB
-│  │  PID 1: /bin/bash (主进程)       │◄───┼─── docker attach 附加到这里
+        subgraph Process ["主进程"]
-│  │    └─ 你的输入直接发送到主进程    │    │
+            P1["PID 1: /bin/bash<br>(你的输入直接发送到主进程)"]
-│  └─────────────────────────────────┘    │
+        end
-└─────────────────────────────────────────┘
+    end
+    Attach["docker attach"] -->|"附加到这里"| P1
 ```
 
 #### docker attach 示例

SUMMARY.md

@@ -10,10 +10,12 @@
   * [快速上手](01_introduction/1.1_quickstart.md)
   * [什么是 Docker](01_introduction/1.2_what.md)
   * [为什么要用 Docker](01_introduction/1.3_why.md)
+  * [本章小结](01_introduction/summary.md)
 * [第二章 基本概念](02_basic_concept/README.md)
   * [镜像](02_basic_concept/2.1_image.md)
   * [容器](02_basic_concept/2.2_container.md)
   * [仓库](02_basic_concept/2.3_repository.md)
+  * [本章小结](02_basic_concept/summary.md)
 * [第三章 安装 Docker](03_install/README.md)
   * [Ubuntu](03_install/3.1_ubuntu.md)
   * [Debian](03_install/3.2_debian.md)
@@ -33,6 +35,7 @@
   * [使用 Dockerfile 定制镜像](04_image/4.5_build.md)
   * [其它制作镜像的方式](04_image/4.6_other.md)
   * [实现原理](04_image/4.7_internal.md)
+  * [本章小结](04_image/summary.md)
 * [第五章 操作容器](05_container/README.md)
   * [启动](05_container/5.1_run.md)
   * [守护态运行](05_container/5.2_daemon.md)
@@ -40,11 +43,13 @@
   * [进入容器](05_container/5.4_attach_exec.md)
   * [导出和导入](05_container/5.5_import_export.md)
   * [删除](05_container/5.6_rm.md)
+  * [本章小结](05_container/summary.md)
 * [第六章 访问仓库](06_repository/README.md)
   * [Docker Hub](06_repository/6.1_dockerhub.md)
   * [私有仓库](06_repository/6.2_registry.md)
   * [私有仓库高级配置](06_repository/6.3_registry_auth.md)
   * [Nexus 3](06_repository/6.4_nexus3_registry.md)
+  * [本章小结](06_repository/summary.md)
 
 ## 第二部分: 进阶篇
 
@@ -67,14 +72,17 @@
   * [参考文档](07_dockerfile/7.16_references.md)
   * [多阶段构建](07_dockerfile/7.17_multistage_builds.md)
   * [实战多阶段构建 Laravel 镜像](07_dockerfile/7.18_multistage_builds_laravel.md)
+  * [本章小结](07_dockerfile/summary.md)
 * [第八章 数据与网络管理](08_data_network/README.md)
   * [数据管理](08_data_network/data/README.md)
     * [数据卷](08_data_network/data/volume.md)
     * [挂载主机目录](08_data_network/data/bind-mounts.md)
     * [tmpfs 挂载](08_data_network/data/tmpfs.md)
+    * [本章小结](08_data_network/data/summary.md)
   * [网络配置](08_data_network/network/README.md)
     * [配置 DNS](08_data_network/network/dns.md)
     * [外部访问容器](08_data_network/network/port_mapping.md)
+    * [本章小结](08_data_network/network/summary.md)
 * [第九章 Docker Buildx](09_buildx/README.md)
   * [BuildKit](09_buildx/9.1_buildkit.md)
   * [使用 buildx 构建镜像](09_buildx/9.2_buildx.md)
@@ -144,6 +152,7 @@
   * [联合文件系统](14_implementation/14.4_ufs.md)
   * [容器格式](14_implementation/14.5_container_format.md)
   * [网络](14_implementation/14.6_network.md)
+  * [本章小结](14_implementation/summary.md)
 
 ## 第四部分: 实战篇