ehlxr/docker_practice
1
0
Fork 0
mirror of https://github.com/yeasy/docker_practice.git synced 2026-03-11 12:21:17 +00:00
Code Issues Projects Releases Wiki Activity

Fix ascii figures

Browse Source
This commit is contained in:
Baohua Yang
2026-02-21 10:59:17 -08:00
parent 5ae315c9dd
commit ad68b2d973
7 changed files with 89 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
02_basic_concept/2.3_repository.md
View File

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

19
04_image/4.1_pull.md
View File

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

39
04_image/4.3_rm.md
View File

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

22
04_image/4.7_internal.md
View File

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

14
05_container/5.2_daemon.md
View File

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

17
05_container/5.4_attach_exec.md
View File

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

9
SUMMARY.md
View File

@@ -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)
## 第四部分: 实战篇