Fix format issue

01_introduction/1.3_why.md

@@ -57,16 +57,17 @@ Docker 的出现为上述问题提供了完美的解决方案。它通过"一次
 
 具体内容如下：
 
-```
-开发环境        测试环境        生产环境
-    │               │               │
-    ▼               ▼               ▼
-┌─────────┐   ┌─────────┐   ┌─────────┐
-│ Docker  │ = │ Docker  │ = │ Docker  │
-│  镜像   │   │  镜像   │   │  镜像   │
-└─────────┘   └─────────┘   └─────────┘
-    ↓               ↓               ↓
- 完全一致       完全一致       完全一致
+```mermaid
+flowchart TD
+    dev["开发环境"] --> img1["Docker 镜像"]
+    test["测试环境"] --> img2["Docker 镜像"]
+    prod["生产环境"] --> img3["Docker 镜像"]
+    
+    img1 === img2 === img3
+    
+    img1 --> res1["完全一致"]
+    img2 --> res2["完全一致"]
+    img3 --> res3["完全一致"]
 ```
 
 ### Docker 的核心优势
@@ -112,40 +113,42 @@ $ docker compose up
 
 Docker 容器共享宿主机内核，无需为每个应用运行完整的操作系统。
 
-```
-传统虚拟机方案：
-┌────────────────────────────────────────────────┐
-│  物理服务器 (64GB 内存)                         │
-├──────────────┬───────────────┬─────────────────┤
-│   VM1        │    VM2        │     VM3         │
-│  8GB 内存     │   8GB 内存    │    8GB 内存     │
-│  (含 OS 2GB)  │  (含 OS 2GB)  │   (含 OS 2GB)   │
-│   应用 1      │    应用 2     │     应用 3      │
-└──────────────┴───────────────┴─────────────────┘
-实际可用于应用：3 × 6GB = 18GB ❌
+```mermaid
+flowchart TD
+    subgraph VM ["传统虚拟机方案 (实际可用于应用: 18GB) ❌"]
+        direction TB
+        Server1["物理服务器 (64GB 内存)"]
+        subgraph VMs [" "]
+            direction LR
+            VM1["VM1<br/>8GB 内存 (含 OS 2GB)<br/>应用 1"]
+            VM2["VM2<br/>8GB 内存 (含 OS 2GB)<br/>应用 2"]
+            VM3["VM3<br/>8GB 内存 (含 OS 2GB)<br/>应用 3"]
+        end
+        Server1 --- VMs
+    end
 
-Docker 方案：
-┌────────────────────────────────────────────────┐
-│  物理服务器 (64GB 内存)                         │
-│  宿主机 OS + Docker (约 4GB)                   │
-├──────────────┬───────────────┬─────────────────┤
-│  容器 1      │   容器 2      │    容器 3        │
-│  应用 1      │   应用 2      │    应用 3        │
-│  (按需分配)   │  (按需分配)   │   (按需分配)     │
-└──────────────┴───────────────┴─────────────────┘
-实际可用于应用：约 60GB ✅
+    subgraph Docker ["Docker 方案 (实际可用于应用: 约 60GB) ✅"]
+        direction TB
+        Server2["物理服务器 (64GB 内存)<br/>宿主机 OS + Docker (约 4GB)"]
+        subgraph Containers [" "]
+            direction LR
+            C1["容器 1<br/>应用 1<br/>(按需分配)"]
+            C2["容器 2<br/>应用 2<br/>(按需分配)"]
+            C3["容器 3<br/>应用 3<br/>(按需分配)"]
+        end
+        Server2 --- Containers
+    end
 ```
 
 #### 4. 持续交付和部署
 
 Docker 完美契合 DevOps 的工作流程：
 
-```
-代码提交 ──→ 自动构建镜像 ──→ 自动测试 ──→ 自动部署
-    │           │              │            │
-    ▼           ▼              ▼            ▼
-  Git        docker         容器内       容器滚动
-  push       build          运行测试      更新
+```mermaid
+flowchart LR
+    A["代码提交<br/>(Git push)"] --> B["自动构建镜像<br/>(docker build)"]
+    B --> C["自动测试<br/>(容器内运行测试)"]
+    C --> D["自动部署<br/>(容器滚动更新)"]
 ```
 
 使用 [Dockerfile](../04_image/4.5_build.md) 定义镜像构建过程，使得：
@@ -172,17 +175,25 @@ Docker 可以在几乎任何平台上运行：
 - **独立部署**：更新一个服务不影响其他服务
 - **技术多样**：不同服务可以用不同语言和框架
 
-```
-┌───────────────────────────────────────────────────┐
-│                  微服务架构示例                    │
-├─────────────┬─────────────┬───────────────────────┤
-│  前端容器    │  API 容器   │     Worker 容器       │
-│  (Node.js)  │  (Python)   │      (Go)             │
-├─────────────┴─────────────┴───────────────────────┤
-│                  Redis 容器                        │
-├───────────────────────────────────────────────────┤
-│               PostgreSQL 容器                      │
-└───────────────────────────────────────────────────┘
+```mermaid
+flowchart TD
+    subgraph Microservices ["微服务架构示例"]
+        direction TB
+        subgraph AppLayer ["应用层"]
+            direction LR
+            Frontend["前端容器<br/>(Node.js)"]
+            API["API 容器<br/>(Python)"]
+            Worker["Worker 容器<br/>(Go)"]
+        end
+        Redis["Redis 容器"]
+        DB["PostgreSQL 容器"]
+        
+        Frontend --> API
+        API --> Redis
+        API --> DB
+        Worker --> Redis
+        Worker --> DB
+    end
 ```
 
 ### Docker 不适合的场景