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

Restruct

Browse Source
This commit is contained in:
Baohua Yang
2026-02-09 12:56:12 -08:00
parent 63377d0431
commit b44c9acd6c
228 changed files with 326 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
08_data_network/README.md Normal file
View File

@@ -0,0 +1,6 @@
# 第八章 数据与网络管理
本章将介绍 Docker 中的数据管理与网络配置。
* [数据管理](data/README.md)
* [网络配置](network/README.md)

10
08_data_network/data/README.md Normal file
View File

@@ -0,0 +1,10 @@
# 数据管理
数据管理 示意图如下：
![](../_images/types-of-mounts.png)
这一章介绍如何在 Docker 内部以及容器之间管理数据，在容器中管理数据主要有两种方式：
* 数据卷（Volumes）
* 挂载主机目录 (Bind mounts)

BIN
08_data_network/data/_images/types-of-mounts.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 23 KiB

332
08_data_network/data/bind-mounts.md Normal file
View File

@@ -0,0 +1,332 @@
## 挂载主机目录
### 什么是绑定挂载
Bind Mount（绑定挂载）将**宿主机的目录或文件**直接挂载到容器中。容器可以读写宿主机的文件系统。
```
宿主机 容器
┌─────────────────────┐ ┌─────────────────────┐
│ /home/user/code/ │ │ │
│ ├── index.html │◄───────►│ /usr/share/nginx/ │
│ ├── style.css │ Bind │ html/ │
│ └── app.js │ Mount │ (同一份文件) │
└─────────────────────┘ └─────────────────────┘
```
---
### Bind Mount vs Volume
| 特性 | Bind Mount | Volume |
|------|------------|--------|
| **数据位置** | 宿主机任意路径 | Docker 管理的目录 |
| **路径指定** | 必须是绝对路径 | 卷名 |
| **可移植性** | 依赖宿主机路径 | 更好（Docker 管理） |
| **性能** | 依赖宿主机文件系统 | 优化的存储驱动 |
| **适用场景** | 开发环境、配置文件 | 生产数据持久化 |
| **备份** | 直接访问文件 | 需要通过 Docker |
#### 选择建议
具体内容如下：
```
需求 推荐方案
─────────────────────────────────────────
开发时同步代码 → Bind Mount
持久化数据库数据 → Volume
共享配置文件 → Bind Mount
容器间共享数据 → Volume
备份方便 → Bind Mount（直接访问）
生产环境 → Volume
```
---
### 基本语法
#### 使用 --mount（推荐）
运行以下命令：
```bash
$ docker run -d \
--mount type=bind,source=/宿主机路径,target=/容器路径 \
nginx
```
#### 使用 -v（简写）
运行以下命令：
```bash
$ docker run -d \
-v /宿主机路径:/容器路径 \
nginx
```
#### 两种语法对比
| 特性 | --mount | -v |
|------|---------|-----|
| 语法 | 键值对，更清晰 | 冒号分隔，更简洁 |
| 路径不存在时 | 报错 | 自动创建目录 |
| 推荐程度 | ✅ 推荐 | 常用 |
---
### 使用场景
#### 场景一：开发环境代码同步
运行以下命令：
```bash
## 将本地代码目录挂载到容器
$ docker run -d \
-p 8080:80 \
--mount type=bind,source=$(pwd)/src,target=/usr/share/nginx/html \
nginx
## 修改本地文件，容器内立即生效（热更新）
$ echo "Hello" > src/index.html
## 浏览器刷新即可看到变化
具体内容如下：
```
#### 场景二：配置文件挂载
运行以下命令：
```bash
## 挂载自定义 nginx 配置
$ docker run -d \
--mount type=bind,source=/path/to/nginx.conf,target=/etc/nginx/nginx.conf,readonly \
nginx
```
#### 场景三：日志收集
运行以下命令：
```bash
## 将容器日志输出到宿主机目录
$ docker run -d \
--mount type=bind,source=/var/log/myapp,target=/app/logs \
myapp
```
#### 场景四：共享 SSH 密钥
运行以下命令：
```bash
## 挂载 SSH 密钥（只读）
$ docker run --rm -it \
--mount type=bind,source=$HOME/.ssh,target=/root/.ssh,readonly \
alpine ssh user@remote
```
---
### 只读挂载
防止容器修改宿主机文件：
```bash
## --mount 语法
$ docker run -d \
--mount type=bind,source=/config,target=/app/config,readonly \
myapp
## -v 语法
$ docker run -d \
-v /config:/app/config:ro \
myapp
```
容器内尝试写入会报错：
```bash
$ touch /app/config/new.txt
touch: /app/config/new.txt: Read-only file system
```
---
### 挂载单个文件
运行以下命令：
```bash
## 挂载 bash 历史记录
$ docker run --rm -it \
--mount type=bind,source=$HOME/.bash_history,target=/root/.bash_history \
ubuntu bash
## 挂载自定义配置文件
$ docker run -d \
--mount type=bind,source=/path/to/my.cnf,target=/etc/mysql/my.cnf \
mysql
```
> ⚠️ **注意**：挂载单个文件时，如果宿主机上的文件被编辑器替换（而非原地修改），容器内仍是旧文件的 inode。建议重启容器或挂载目录。
---
### 查看挂载信息
运行以下命令：
```bash
$ docker inspect mycontainer --format '{{json .Mounts}}' | jq
```
输出：
```json
[
{
"Type": "bind",
"Source": "/home/user/code",
"Destination": "/app",
"Mode": "",
"RW": true,
"Propagation": "rprivate"
}
]
```
| 字段 | 说明 |
|------|------|
| `Type` | 挂载类型（bind） |
| `Source` | 宿主机路径 |
| `Destination` | 容器内路径 |
| `RW` | 是否可读写 |
| `Propagation` | 挂载传播模式 |
---
### 常见问题
#### Q: 路径不存在报错
运行以下命令：
```bash
$ docker run --mount type=bind,source=/not/exist,target=/app nginx
docker: Error response from daemon: invalid mount config for type "bind":
bind source path does not exist: /not/exist
```
**解决**：确保源路径存在，或改用 `-v`（会自动创建）
#### Q: 权限问题
容器内用户可能无权访问挂载的文件：
```bash
## 方法1：确保宿主机文件权限允许容器用户访问
$ chmod -R 755 /path/to/data
## 方法2：以 root 运行容器
$ docker run -u root ...
## 方法3：使用相同的 UID
$ docker run -u $(id -u):$(id -g) ...
```
#### Q: macOS/Windows 性能问题
在 Docker Desktop 上，Bind Mount 性能较差（需要跨文件系统同步）：
```bash
## 使用 :cached 或 :delegated 提高性能（macOS）
$ docker run -v /host/path:/container/path:cached myapp
```
| 选项 | 说明 |
|------|------|
| `:cached` | 宿主机权威，容器读取可能延迟 |
| `:delegated` | 容器权威，宿主机读取可能延迟 |
| `:consistent` | 默认，完全一致（最慢） |
---
### 最佳实践
#### 1. 开发环境使用 Bind Mount
运行以下命令：
```bash
## 代码热更新
$ docker run -v $(pwd):/app -p 3000:3000 node npm run dev
```
#### 2. 生产环境使用 Volume
运行以下命令：
```bash
## 数据持久化
$ docker run -v mysql_data:/var/lib/mysql mysql
```
#### 3. 配置文件使用只读挂载
运行以下命令：
```bash
$ docker run -v /config/nginx.conf:/etc/nginx/nginx.conf:ro nginx
```
#### 4. 注意路径安全
运行以下命令：
```bash
## ❌ 危险：挂载根目录或敏感目录
$ docker run -v /:/host ...
## ✅ 只挂载必要的目录
$ docker run -v /app/data:/data ...
```
---
### 本章小结
| 要点 | 说明 |
|------|------|
| **作用** | 将宿主机目录挂载到容器 |
| **语法** | `-v /宿主机:/容器` 或 `--mount type=bind,...` |
| **只读** | 添加 `readonly` 或 `:ro` |
| **适用场景** | 开发环境、配置文件、日志 |
| **vs Volume** | Bind 更灵活，Volume 更适合生产 |
### 延伸阅读
- [数据卷](volume.md)：Docker 管理的持久化存储
- [tmpfs 挂载](tmpfs.md)：内存临时存储
- [Compose 数据管理](../compose/10.5_compose_file.md)：Compose 中的挂载配置

420
08_data_network/data/volume.md Normal file
View File

@@ -0,0 +1,420 @@
## 数据卷
### 为什么需要数据卷
容器的存储层有一个关键问题：**容器删除后，数据就没了**。
```mermaid
flowchart LR
Run[容器运行] --> Write[写入数据]
Write --> Delete[容器删除]
Delete -->|数据都在容器 writable 层| Lost[DATA LOST! ❌]
```
数据卷（Volume）解决了这个问题，它的生命周期独立于容器。
---
### 数据卷的特性
| 特性 | 说明 |
|------|------|
| **持久化** | 容器删除后数据仍然保留 |
| **共享** | 多个容器可以挂载同一个数据卷 |
| **即时生效** | 对数据卷的修改立即可见 |
| **不影响镜像** | 数据卷中的数据不会打包进镜像 |
| **性能更好** | 绕过 UnionFS，直接读写 |
---
### 数据卷 vs 容器存储层
#### 容器存储层（不推荐存储重要数据）
具体内容如下：
```mermaid
graph TD
subgraph Container [容器]
Writable[容器存储层<br>Writable]
Image[镜像层<br>ReadOnly]
Writable --- Image
end
Lifecycle[生命周期 = 容器生命周期] -.-> Container
Delete[容器删除] -->|导致| DataLost[数据丢失 ❌]
```
#### 数据卷（推荐）
具体内容如下：
```mermaid
graph TD
subgraph Container [容器]
AppDir["/app/data"]
end
subgraph Volume [数据卷 my-data]
Data[持久化数据]
end
AppDir == 挂载 ==> Volume
Delete[容器删除] -.->|不会影响| Volume
```
---
### 数据卷基本操作
#### 创建数据卷
运行以下命令：
```bash
$ docker volume create my-vol
```
#### 列出所有数据卷
运行以下命令：
```bash
$ docker volume ls
DRIVER VOLUME NAME
local my-vol
local postgres_data
local redis_data
```
#### 查看数据卷详情
运行以下命令：
```bash
$ docker volume inspect my-vol
[
{
"CreatedAt": "2026-01-15T10:00:00Z",
"Driver": "local",
"Labels": {},
"Mountpoint": "/var/lib/docker/volumes/my-vol/_data",
"Name": "my-vol",
"Options": {},
"Scope": "local"
}
]
```
**关键字段**：
- `Mountpoint`：数据卷在宿主机上的实际存储位置
- `Driver`：存储驱动（默认 local，也可以用第三方驱动）
---
### 挂载数据卷
#### 方式一：--mount（推荐）
运行以下命令：
```bash
$ docker run -d \
--name web \
--mount source=my-vol,target=/usr/share/nginx/html \
nginx
```
**参数说明**：
| 参数 | 说明 |
|------|------|
| `source` | 数据卷名称（不存在会自动创建） |
| `target` | 容器内挂载路径 |
| `readonly` | 可选，只读挂载 |
#### 方式二：-v（简写）
运行以下命令：
```bash
$ docker run -d \
--name web \
-v my-vol:/usr/share/nginx/html \
nginx
```
**格式**：`-v 数据卷名:容器路径[:选项]`
#### 两种方式对比
| 特性 | --mount | -v |
|------|---------|-----|
| 语法 | 键值对，更清晰 | 冒号分隔，更简洁 |
| 自动创建卷 | source 不存在会报错 | 自动创建 |
| 推荐程度 | ✅ 推荐（更明确） | 常用（更简洁） |
#### 只读挂载
运行以下命令：
```bash
## --mount 方式
$ docker run -d \
--mount source=my-vol,target=/data,readonly \
nginx
## -v 方式
$ docker run -d \
-v my-vol:/data:ro \
nginx
```
---
### 使用场景示例
#### 场景一：数据库持久化
运行以下命令：
```bash
## 创建数据卷
$ docker volume create postgres_data
## 启动 PostgreSQL，数据存储在数据卷中
$ docker run -d \
--name postgres \
-e POSTGRES_PASSWORD=secret \
-v postgres_data:/var/lib/postgresql/data \
postgres:16
## 即使删除容器，数据仍然保留
$ docker rm -f postgres
## 重新启动，数据还在
$ docker run -d \
--name postgres \
-e POSTGRES_PASSWORD=secret \
-v postgres_data:/var/lib/postgresql/data \
postgres:16
```
#### 场景二：多容器共享数据
运行以下命令：
```bash
## 创建共享数据卷
$ docker volume create shared-data
## 容器 A 写入数据
$ docker run -d --name writer \
-v shared-data:/data \
alpine sh -c "while true; do date >> /data/log.txt; sleep 5; done"
## 容器 B 读取数据
$ docker run --rm \
-v shared-data:/data \
alpine cat /data/log.txt
```
#### 场景三：配置文件持久化
运行以下命令：
```bash
## 将 nginx 配置存储在数据卷中
$ docker run -d \
-v nginx-config:/etc/nginx/conf.d \
-v nginx-logs:/var/log/nginx \
-p 80:80 \
nginx
```
---
### 数据卷管理
#### 删除数据卷
运行以下命令：
```bash
## 删除指定数据卷
$ docker volume rm my-vol
## 删除容器时同时删除数据卷
$ docker rm -v container_name
```
#### 清理未使用的数据卷
运行以下命令：
```bash
## 查看未被任何容器使用的数据卷
$ docker volume ls -f dangling=true
## 删除所有未使用的数据卷
$ docker volume prune
## 强制删除（不提示确认）
$ docker volume prune -f
```
> ⚠️ **注意**：数据卷不会自动垃圾回收。长期运行的系统应定期清理无用数据卷。
---
### 数据卷备份与恢复
#### 备份数据卷
运行以下命令：
```bash
## 使用临时容器挂载数据卷，打包备份
$ docker run --rm \
-v my-vol:/source:ro \
-v $(pwd):/backup \
alpine tar czf /backup/my-vol-backup.tar.gz -C /source .
```
**原理**：
1. 创建临时容器
2. 挂载要备份的数据卷到 `/source`
3. 挂载当前目录到 `/backup`
4. 使用 tar 打包
#### 恢复数据卷
运行以下命令：
```bash
## 创建新数据卷
$ docker volume create my-vol-restored
## 解压备份到新数据卷
$ docker run --rm \
-v my-vol-restored:/target \
-v $(pwd):/backup:ro \
alpine tar xzf /backup/my-vol-backup.tar.gz -C /target
```
#### 备份脚本示例
运行以下命令：
```bash
#!/bin/bash
## backup-volume.sh
VOLUME_NAME=$1
BACKUP_DIR=${2:-/backups}
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
docker run --rm \
-v ${VOLUME_NAME}:/source:ro \
-v ${BACKUP_DIR}:/backup \
alpine tar czf /backup/${VOLUME_NAME}_${TIMESTAMP}.tar.gz -C /source .
echo "Backed up ${VOLUME_NAME} to ${BACKUP_DIR}/${VOLUME_NAME}_${TIMESTAMP}.tar.gz"
```
---
### 数据卷 vs 绑定挂载
Docker 有两种主要的数据持久化方式：
| 特性 | 数据卷 (Volume) | 绑定挂载 (Bind Mount) |
|------|----------------|---------------------|
| **管理方式** | Docker 管理 | 用户管理 |
| **存储位置** | `/var/lib/docker/volumes/` | 任意宿主机路径 |
| **可移植性** | 更好 | 依赖宿主机路径 |
| **适用场景** | 生产数据持久化 | 开发时同步代码 |
| **备份** | 需要工具 | 直接访问文件 |
```bash
## 数据卷
$ docker run -v mydata:/app/data nginx
## 绑定挂载
$ docker run -v /host/path:/app/data nginx
```
详见 [绑定挂载](bind-mounts.md) 章节。
---
### 常见问题
#### Q: 如何知道容器使用了哪些数据卷？
运行以下命令：
```bash
$ docker inspect container_name --format '{{json .Mounts}}' | jq
```
#### Q: 数据卷的数据在哪里？
运行以下命令：
```bash
## 查看数据卷详情
$ docker volume inspect my-vol
## Mountpoint 字段显示实际路径
"Mountpoint": "/var/lib/docker/volumes/my-vol/_data"
```
> ⚠️ **注意**：不建议直接修改 Mountpoint 中的文件，应通过容器操作。
#### Q: 如何在不同机器间迁移数据卷？
1. 在源机器备份：`docker run --rm -v mydata:/data -v $(pwd):/backup alpine tar czf /backup/data.tar.gz -C /data .`
2. 传输 tar.gz 文件
3. 在目标机器恢复
---
### 本章小结
| 操作 | 命令 |
|------|------|
| 创建数据卷 | `docker volume create name` |
| 列出数据卷 | `docker volume ls` |
| 查看详情 | `docker volume inspect name` |
| 删除数据卷 | `docker volume rm name` |
| 清理未用 | `docker volume prune` |
| 挂载数据卷 | `-v name:/path` 或 `--mount source=name,target=/path` |
### 延伸阅读
- [绑定挂载](bind-mounts.md)：挂载宿主机目录
- [tmpfs 挂载](tmpfs.md)：内存中的临时存储
- [存储驱动](../14_implementation/14.4_ufs.md)：Docker 存储的底层原理

333
08_data_network/network/README.md Normal file
View File

@@ -0,0 +1,333 @@
# 网络配置
## Docker 网络概述
Docker 容器需要网络来：
- 与外部世界通信（访问互联网、被外部访问）
- 容器之间相互通信
- 与宿主机通信
Docker 在安装时会自动配置网络基础设施，大多数情况下开箱即用。
## 默认网络架构
Docker 启动时自动创建以下网络组件：
```mermaid
graph TD
subgraph Host [宿主机]
eth0[物理网卡 eth0<br>192.168.1.100]
docker0[docker0 网桥<br>172.17.0.1]
subgraph Containers
subgraph ContainerA [容器 A]
eth0_A[eth0<br>172.17.0.2]
end
subgraph ContainerB [容器 B]
eth0_B[eth0<br>172.17.0.3]
end
end
eth0 <--> docker0
docker0 <--> eth0_A
docker0 <--> eth0_B
end
Internet((互联网)) <--> eth0
```
### 核心组件
| 组件 | 说明 |
|------|------|
| **docker0** | 虚拟网桥，充当交换机角色 |
| **veth pair** | 虚拟网卡对，一端在容器内，一端连接网桥 |
| **容器 eth0** | 容器内的网卡 |
| **IP 地址** | 自动从 172.17.0.0/16 网段分配 |
### 数据流向
具体内容如下：
```
容器 A (172.17.0.2) → docker0 → 容器 B (172.17.0.3) (容器间通信)
容器 A (172.17.0.2) → docker0 → eth0 → 互联网 (访问外网)
外部请求 → eth0 → docker0 → 容器 A (被外部访问，需端口映射)
```
---
## Docker 网络类型
查看默认网络：
```bash
$ docker network ls
NETWORK ID NAME DRIVER SCOPE
abc123... bridge bridge local
def456... host host local
ghi789... none null local
```
| 网络类型 | 说明 | 适用场景 |
|---------|------|---------|
| **bridge** | 默认类型，容器连接到虚拟网桥 | 大多数单机场景 |
| **host** | 容器直接使用宿主机网络栈 | 需要最高网络性能时 |
| **none** | 禁用网络 | 完全隔离的容器 |
| **overlay** | 跨主机网络 | Docker Swarm 集群 |
| **macvlan** | 容器拥有独立 MAC 地址 | 需要直接接入物理网络 |
---
## 用户自定义网络（推荐）
### 为什么要用自定义网络
默认 bridge 网络的局限：
| 问题 | 自定义网络的优势 |
|------|-----------------|
| 只能用 IP 通信 | 支持容器名 DNS 解析 |
| 所有容器在同一网络 | 更好的隔离性 |
| 需要 --link（已废弃） | 原生支持服务发现 |
### 创建自定义网络
运行以下命令：
```bash
## 创建网络
$ docker network create mynet
## 查看网络详情
$ docker network inspect mynet
```
### 使用自定义网络
运行以下命令：
```bash
## 启动容器并连接到自定义网络
$ docker run -d --name web --network mynet nginx
$ docker run -d --name db --network mynet postgres
## 在 web 容器中可以直接用容器名访问 db
$ docker exec web ping db
PING db (172.18.0.3): 56 data bytes
64 bytes from 172.18.0.3: seq=0 ttl=64 time=0.083 ms
```
### 容器名 DNS 解析
自定义网络自动提供 DNS 服务：
```
┌─────────────────────────────────────────────────────────┐
│ mynet 网络 │
│ │
│ ┌─────────┐ DNS ┌─────────┐ │
│ │ web │ ──── "db" → 172.18.0.3 ───► │ db │ │
│ │172.18.0.2│ │172.18.0.3│ │
│ └─────────┘ └─────────┘ │
│ │
│ web 容器可以用 "db" 作为主机名访问 db 容器 │
└─────────────────────────────────────────────────────────┘
```
---
## 容器互联
### 同一网络内的容器
同一自定义网络内的容器可以直接通信：
```bash
## 创建网络
$ docker network create app-net
## 启动应用和数据库
$ docker run -d --name redis --network app-net redis
$ docker run -d --name app --network app-net myapp
## app 容器中可以用 redis:6379 连接 Redis
具体内容如下：
```
### 连接到多个网络
一个容器可以连接到多个网络：
```bash
## 启动容器
$ docker run -d --name multi-net-container --network frontend nginx
## 再连接到另一个网络
$ docker network connect backend multi-net-container
## 查看容器的网络
$ docker inspect multi-net-container --format '{{json .NetworkSettings.Networks}}'
```
### ⚠️ --link 已废弃
运行以下命令：
```bash
## 旧方式（不推荐）
$ docker run --link db:database myapp
## 新方式（推荐）
$ docker network create mynet
$ docker run --network mynet --name db postgres
$ docker run --network mynet --name app myapp
```
---
## 端口映射
容器默认只能在 Docker 网络内访问。要从外部访问容器，需要端口映射：
### 基本语法
运行以下命令：
```bash
## -p 宿主机端口:容器端口
$ docker run -d -p 8080:80 nginx
```
### 映射方式
| 参数 | 说明 | 示例 |
|------|------|------|
| `-p 8080:80` | 指定端口映射 | 宿主机 8080 → 容器 80 |
| `-p 80` | 随机宿主机端口 | 随机端口 → 容器 80 |
| `-P` | 自动映射所有暴露端口 | 随机端口 → 所有 EXPOSE 端口 |
| `-p 127.0.0.1:8080:80` | 只绑定本地 | 仅本机可访问 |
| `-p 8080:80/udp` | UDP 端口 | UDP 协议 |
### 查看端口映射
运行以下命令：
```bash
$ docker port mycontainer
80/tcp -> 0.0.0.0:8080
```
### 端口映射示意图
具体内容如下：
```
外部请求 http://宿主机IP:8080
│
▼
┌─────────────┐
│ 宿主机:8080 │ ─── iptables NAT ───┐
└─────────────┘ │
▼
┌───────────────┐
│ 容器 nginx:80 │
└───────────────┘
```
---
## 网络隔离
不同网络之间默认隔离：
```bash
## 创建两个网络
$ docker network create frontend
$ docker network create backend
## 容器 A 在 frontend
$ docker run -d --name web --network frontend nginx
## 容器 B 在 backend
$ docker run -d --name db --network backend postgres
## web 无法直接访问 db（不同网络）
$ docker exec web ping db
ping: db: Name or service not known
```
这种隔离有助于安全：前端容器无法直接访问数据库网络。
---
## 常用命令
运行以下命令：
```bash
## 列出网络
$ docker network ls
## 创建网络
$ docker network create mynet
## 查看网络详情
$ docker network inspect mynet
## 连接容器到网络
$ docker network connect mynet mycontainer
## 断开网络连接
$ docker network disconnect mynet mycontainer
## 删除网络
$ docker network rm mynet
## 清理未使用的网络
$ docker network prune
```
---
## 本章小结
| 概念 | 要点 |
|------|------|
| **默认网络** | docker0 网桥，172.17.0.0/16 网段 |
| **自定义网络** | 推荐使用，支持容器名 DNS 解析 |
| **端口映射** | `-p 宿主机端口:容器端口` 暴露服务 |
| **网络隔离** | 不同网络默认隔离，增强安全性 |
| **--link** | 已废弃，使用自定义网络替代 |
## 延伸阅读
- [高级网络配置](linking.md)：容器互联详解
- [配置 DNS](dns.md)：自定义 DNS 设置
- [端口映射](port_mapping.md)：高级端口配置
- [Compose 网络](../compose/10.5_compose_file.md)：Compose 中的网络配置

117
08_data_network/network/dns.md Normal file
View File

@@ -0,0 +1,117 @@
## 配置 DNS
### 容器的 DNS 机制
Docker 容器的 DNS 配置有两种情况：
1. **默认 Bridge 网络**：继承宿主机的 DNS 配置（`/etc/resolv.conf`）。
2. **自定义网络**（推荐）：使用 Docker 嵌入式 DNS 服务器 (Embedded DNS)，支持通过**容器名**进行服务发现。
---
### 嵌入式 DNS
这是 Docker 网络最强大的功能之一。在自定义网络中，容器可以通过"名字"找到彼此，而不需要知道对方的 IP（因为 IP 可能会变）。
```bash
## 1. 创建自定义网络
$ docker network create mynet
## 2. 启动容器 web 并加入网络
$ docker run -d --name web --network mynet nginx
## 3. 启动容器 client 并尝试 ping web
$ docker run -it --rm --network mynet alpine ping web
PING web (172.18.0.2): 56 data bytes
64 bytes from 172.18.0.2: seq=0 ttl=64 time=0.074 ms
```
**原理**：
Docker 守护进程在 `127.0.0.11` 运行了一个 DNS 服务器。容器内的 DNS 请求会被转发到这里。如果是容器名，解析为容器 IP；如果是外部域名（如 google.com），转发给上游 DNS。
---
### 配置 DNS 参数
如果你需要手动配置容器的 DNS（例如使用内网 DNS 服务器），可以在 `docker run` 中使用以下参数：
#### 1. --dns
指定 DNS 服务器 IP。
```bash
$ docker run -it --dns=114.114.114.114 ubuntu cat /etc/resolv.conf
nameserver 114.114.114.114
```
#### 2. --dns-search
指定 DNS 搜索域。例如设置为 `example.com`，则 `ping host` 会尝试解析 `host.example.com`。
```bash
$ docker run --dns-search=example.com myapp
```
#### 3. --hostname（-h）
设置容器的主机名。
```bash
$ docker run -h myweb nginx
```
---
### 全局 DNS 配置
如果希望所有容器都使用特定的 DNS 服务器（而不是继承宿主机），可以修改 `/etc/docker/daemon.json`：
```json
{
"dns": [
"114.114.114.114",
"8.8.8.8"
]
}
```
修改后需要重启 Docker 服务：`systemctl restart docker`。
---
### 常见问题
#### Q: 容器无法解析域名
**现象**：`ping www.baidu.com` 失败，但 `ping 8.8.8.8` 成功。
**解决**：
1. 宿主机的 `/etc/resolv.conf` 可能有问题（例如使用了本地回环地址 127.0.0.53，特别是 Ubuntu 系统）。Docker 可能会尝试修复，但有时会失败。
2. 尝试手动指定 DNS：`docker run --dns 8.8.8.8 ...`
3. 检查防火墙是否拦截了 UDP 53 端口。
#### Q: 无法通过容器名通信
**现象**：`ping db` 提示 `bad address 'db'`。
**原因**：
- 你可能在使用**默认的 bridge 网络**。默认 bridge 网络**不支持**通过容器名进行 DNS 解析（这是一个历史遗留设计）。
- **解决**：使用自定义网络 (`docker network create ...`)。
---
### 本章小结
| 场景 | DNS 行为 | 备注 |
|------|----------|------|
| **默认网络** | 继承宿主机 | 不支持容器名解析 |
| **自定义网络** | Docker 嵌入式 DNS | ✅ 支持容器名解析 |
| **手动指定** | 使用 `--dns` | 覆盖默认配置 |
### 延伸阅读
- [网络模式](README.md)：Docker 网络概览
- [端口映射](port_mapping.md)：外部访问

168
08_data_network/network/port_mapping.md Normal file
View File

@@ -0,0 +1,168 @@
## 外部访问容器
### 为什么要映射端口
容器运行在自己的隔离网络环境中（通常是 Bridge 模式）。这意味着：
- **容器之间**：可以通过 IP 或容器名（自定义网络）互通。
- **宿主机访问容器**：可以通过容器 IP 访问。
- **外部网络访问容器**：❌ 默认无法直接访问。
为了让外部（如你的浏览器、其他局域网机器）访问容器内的服务，我们需要将容器的端口**映射**到宿主机的端口。
```
外部用户 (Browser)
│
▼
宿主机 (localhost:8080)
│
┌────┴────┐ 端口映射
│ Docker │ (8080 -> 80)
│ Proxy │
└────┬────┘
│
▼
容器 (Class B: 80)
```
---
### 端口映射方式
#### 1. 指定映射
Docker 提供了多种方式来指定端口映射，最常用的是 `-p` 参数。
使用 `-p <宿主机端口>:<容器端口>` 格式。
```bash
## 将宿主机的 8080 端口映射到容器的 80 端口
$ docker run -d -p 8080:80 nginx
```
此时访问 `http://localhost:8080` 即可看到 Nginx 页面。
**多种格式**：
| 格式 | 含义 | 示例 |
|------|------|------|
| `ip:hostPort:containerPort` | 绑定指定 IP 的特定端口 | `-p 127.0.0.1:8080:80` (仅本机访问) |
| `ip::containerPort` | 绑定指定 IP 的随机端口 | `-p 127.0.0.1::80` |
| `hostPort:containerPort` | 绑定所有 IP (0.0.0.0) 的特定端口 | `-p 8080:80` (默认) |
| `containerPort` | 绑定所有 IP 的随机端口 | `-p 80` |
#### 2. 随机映射
如果您不关心宿主机使用哪个端口，可以使用随机映射功能。
使用 `-P` (大写) 参数，Docker 会随机映射 Dockerfile 中 `EXPOSE` 指令暴露的所有端口到宿主机的高端口（49000-49900）。
```bash
$ docker run -d -P nginx
```
查看映射结果：
```bash
$ docker ps
CONTAINER ID PORTS
abc123456 0.0.0.0:49153->80/tcp
```
此时 Nginx 被映射到了宿主机的 49153 端口。
---
### 查看端口映射
#### docker port
我们可以使用 `docker port` 命令来查看当前容器的端口映射规则。
运行以下命令：
```bash
$ docker port mycontainer
80/tcp -> 0.0.0.0:8080
80/tcp -> [::]:8080
```
#### docker ps
运行以下命令：
```bash
$ docker ps
CONTAINER ID IMAGE PORTS NAMES
abc123456 nginx 0.0.0.0:8080->80/tcp web
```
---
### 最佳实践与安全
#### 1. 限制监听 IP
为了保证服务的安全性，我们应该谨慎选择绑定的 IP 地址。
默认情况下，`-p 8080:80` 会监听 `0.0.0.0:8080`，这意味着任何人只要能连接你的宿主机 IP，就能访问该服务。
如果不希望对外暴露（例如数据库服务），应绑定到 `127.0.0.1`：
```bash
## 仅允许本机访问
$ docker run -d -p 127.0.0.1:3306:3306 mysql
```
#### 2. 避免端口冲突
如果宿主机 8080 已经被占用了，容器将无法启动。
**解决**：
- 更换宿主机端口：`-p 8081:80`
- 让 Docker 自动分配：`-p 80`
#### 3. UDP 映射
默认是 TCP 协议。如果要映射 UDP 服务（如 DNS, Syslog）：
```bash
$ docker run -d -p 53:53/udp dns-server
```
---
### 实现原理
Docker 使用 `docker-proxy` 进程（用户态）或 `iptables` DNAT 规则（内核态）来实现端口转发。
当流量到达宿主机端口时，iptables 规则将其目标地址修改为容器 IP 并转发：
```bash
## 简化的 iptables 逻辑
iptables -t nat -A DOCKER -p tcp --dport 8080 -j DNAT --to-destination 172.17.0.2:80
```
这也是为什么你在容器内部看到的访问来源 IP 通常是网关 IP（如 172.17.0.1），而不是真实的外部 Client IP（除非使用 host 网络模式）。
---
### 本章小结
| 要点 | 说明 |
|------|------|
| **-p** | 指定端口映射（常用），如 `8080:80` |
| **-P** | 随机映射所有 EXPOSE 的端口 |
| **安全性** | 默认监听所有 IP，敏感服务应绑定 `127.0.0.1` |
| **查看** | 使用 `docker port` 或 `docker ps` |
### 延伸阅读
- [EXPOSE 指令](../07_dockerfile/7.9_expose.md)：在 Dockerfile 中声明端口
- [网络模式](README.md)：Host 模式不需要端口映射