Docker 网络模式完全指南：从底层原理到生产实战#

1
# 查看NAT表规则
2
sudo iptables -t nat -L -n -v
3

4
# 查看DOCKER链规则
5
sudo iptables -t filter -L DOCKER -n -v

1
# 创建一个名为my-bridge的自定义网桥
2
docker network create --driver bridge my-bridge

1
docker network create \
2
  --driver bridge \
3
  --subnet 192.168.100.0/24 \
4
  --gateway 192.168.100.1 \
5
  --ip-range 192.168.100.128/25 \
6
  --opt com.docker.network.bridge.name=br-custom \
7
  --opt com.docker.network.driver.mtu=1450 \
8
  my-custom-bridge

1
# 添加网络标签便于管理
2
docker network create \
3
  --driver bridge \
4
  --label env=production \
5
  --label project=myapp \
6
  prod-network

1
# 启动容器并连接到自定义网络
2
docker run -d --name custom-demo1 \
3
  --network my-bridge \
4
  nginx:alpine
5

6
docker run -d --name custom-demo2 \
7
  --network my-bridge \
8
  alpine sleep 3600
9

10
# 指定静态IP地址
11
docker run -d --name static-ip-demo \
12
  --network my-bridge \
13
  --ip 192.168.100.100 \
14
  nginx:alpine

1
# 创建两个独立网络
2
docker network create net1
3
docker network create net2
4

5
# 在不同网络上启动容器
6
docker run -d --name c1 --network net1 alpine sleep 3600
7
docker run -d --name c2 --network net2 alpine sleep 3600
8

9
# c1无法访问c2（网络隔离生效）
10
docker exec c1 ping c2  # 失败

1
# 通过容器名访问（自动DNS解析）
2
docker exec custom-demo2 ping custom-demo1
3

4
# 通过容器名访问HTTP服务
5
docker exec custom-demo2 wget -O- http://custom-demo1

1
# 前端网络（对外暴露）
2
docker network create frontend
3

4
# 后端网络（内部通信）
5
docker network create backend
6

7
# 数据库网络（高度隔离）
8
docker network create database
9

10
# Web服务器连接前端和后端
11
docker run -d --name web \
12
  --network frontend \
13
  nginx:alpine
14
docker network connect backend web
15

16
# 应用服务器只连接后端
17
docker run -d --name app \
18
  --network backend \
19
  myapp:latest
20

21
# 数据库只连接数据库网络
22
docker run -d --name db \
23
  --network database \
24
  postgres:13
25
docker network connect backend db

1
# 启动容器时指定别名
2
docker run -d --name web \
3
  --network my-bridge \
4
  --network-alias nginx-server \
5
  --network-alias web-server \
6
  nginx:alpine
7

8
# 其他容器可以通过别名访问
9
docker run --rm --network my-bridge alpine \
10
  wget -O- http://nginx-server
11

12
docker run --rm --network my-bridge alpine \
13
  wget -O- http://web-server

1
# 将运行中的容器连接到新网络
2
docker network connect my-bridge bridge-demo
3

4
# 指定IP地址连接
5
docker network connect --ip 192.168.100.50 my-bridge bridge-demo
6

7
# 指定别名连接
8
docker network connect --alias db-server my-bridge bridge-demo
9

10
# 从网络中断开容器
11
docker network disconnect my-bridge bridge-demo

1
# 获取容器IP
2
IP=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' custom-demo1)
3

4
# 通过IP访问
5
docker exec custom-demo2 ping $IP

1
# 直接使用容器名
2
docker exec custom-demo2 ping custom-demo1
3

4
# HTTP服务访问
5
docker exec custom-demo2 curl http://custom-demo1
6

7
# 应用配置示例
8
docker run -d --name app \
9
  --network my-bridge \
10
  -e DATABASE_HOST=db \
11
  -e REDIS_HOST=cache \
12
  myapp:latest

1
# 创建服务（自动负载均衡）
2
docker service create \
3
  --name api \
4
  --network my-overlay \
5
  --replicas 3 \
6
  myapi:latest
7

8
# 其他服务通过服务名访问（自动负载均衡到3个副本）
9
docker service create \
10
  --name frontend \
11
  --network my-overlay \
12
  -e API_ENDPOINT=http://api:8080 \
13
  myfrontend:latest

1
# 启动数据库容器
2
docker run -d --name postgres \
3
  --network my-bridge \
4
  -e POSTGRES_PASSWORD=secret \
5
  postgres:13
6

7
# 应用容器通过环境变量获取数据库信息
8
docker run -d --name app \
9
  --network my-bridge \
10
  -e DB_HOST=postgres \
11
  -e DB_PORT=5432 \
12
  -e DB_USER=postgres \
13
  -e DB_PASS=secret \
14
  myapp:latest

1
# 使用nicolaka/netshoot工具箱容器
2
docker run -it --rm --network host nicolaka/netshoot
3

4
# 或者进入现有容器的网络命名空间
5
docker run -it --rm --network container:myapp nicolaka/netshoot

1
# ping测试（ICMP）
2
ping -c 3 google.com
3

4
# 端口连通性测试（TCP）
5
telnet myapp 8080
6
nc -zv myapp 8080
7

8
# DNS解析测试
9
nslookup myapp
10
dig myapp
11

12
# 路由追踪
13
traceroute myapp
14
mtr --report myapp

1
# 带宽测试（需要两端都运行）
2
# 服务端
3
iperf3 -s
4

5
# 客户端
6
iperf3 -c <server-ip> -t 30 -P 5
7

8
# HTTP性能测试
9
ab -n 10000 -c 100 http://myapp/
10

11
# 延迟测试
12
ping -c 100 myapp | tail -1

1
# 查看容器的网络接口
2
docker exec myapp ip addr show
3

4
# 查看容器的路由表
5
docker exec myapp ip route
6

7
# 查看容器的监听端口
8
docker exec myapp netstat -tlnp
9

10
# 查看容器的网络连接
11
docker exec myapp ss -tunap
12

13
# 抓包分析
14
docker exec myapp tcpdump -i eth0 -n

1
# 查看所有网络
2
docker network ls
3

4
# 查看网络详细信息
5
docker network inspect my-bridge
6

7
# 查看连接到网络的容器
8
docker network inspect my-bridge --format '{{range .Containers}}{{.Name}} {{end}}'
9

10
# 查看Docker网桥状态
11
ip addr show docker0
12
brctl show docker0

1
# 查看NAT表规则
2
sudo iptables -t nat -L -n -v --line-numbers
3

4
# 查看DOCKER链规则
5
sudo iptables -t filter -L DOCKER -n -v
6

7
# 查看端口转发规则
8
sudo iptables -t nat -L DOCKER -n | grep <port>
9

10
# 实时监控iptables流量
11
sudo iptables -t nat -L DOCKER -n -v -Z  # 清零计数器
12
sudo watch -n 1 'iptables -t nat -L DOCKER -n -v'

1
# 监控容器网络流量
2
docker stats --format "table {{.Container}}\t{{.NetIO}}"
3

4
# 使用ctop监控（需要安装）
5
ctop
6

7
# 宿主机网络监控
8
iftop -i docker0
9
nethogs docker0
10

11
# 网络连接监控
12
sudo watch -n 1 'netstat -antp | grep ESTABLISHED | wc -l'

1
# 创建隔离的生产网络
2
docker network create \
3
  --driver bridge \
4
  --subnet 10.1.0.0/24 \
5
  --opt com.docker.network.bridge.enable_icc=false \
6
  prod-isolated
7

8
# 禁用容器间直接通信（仅通过宿主机转发）
9
docker network create \
10
  --driver bridge \
11
  --internal \
12
  internal-only

1
# 限制容器只能访问特定外部IP
2
sudo iptables -I DOCKER-USER -s 172.17.0.0/16 \
3
  -d 10.0.0.0/8 -j DROP
4

5
# 允许容器访问特定服务
6
sudo iptables -I DOCKER-USER -s 172.17.0.0/16 \
7
  -d 8.8.8.8 -p udp --dport 53 -j ACCEPT
8

9
# 限制容器出站连接速率
10
sudo iptables -I DOCKER-USER -s 172.17.0.0/16 \
11
  -m limit --limit 100/s -j ACCEPT

1
# 创建加密overlay网络
2
docker network create \
3
  --driver overlay \
4
  --opt encrypted=true \
5
  --attachable \
6
  secure-net
7

8
# 验证加密状态
9
docker network inspect secure-net | grep Encrypted

1
# 禁用容器的网络特权
2
docker run -d --name restricted \
3
  --cap-drop NET_RAW \
4
  --cap-drop NET_ADMIN \
5
  nginx:alpine
6

7
# 使用只读根文件系统
8
docker run -d --name readonly \
9
  --read-only \
10
  --tmpfs /tmp \
11
  --tmpfs /run \
12
  nginx:alpine

1
# 1. 检查IP转发是否开启
2
sysctl net.ipv4.ip_forward
3
# 如果为0，需要开启
4
sudo sysctl -w net.ipv4.ip_forward=1
5

6
# 2. 检查iptables NAT规则
7
sudo iptables -t nat -L POSTROUTING -n -v
8

9
# 3. 检查DNS配置
10
docker exec myapp cat /etc/resolv.conf
11

12
# 4. 测试DNS解析
13
docker exec myapp nslookup google.com
14

15
# 5. 测试网络连通性
16
docker exec myapp ping 8.8.8.8
17
docker exec myapp curl -I https://www.google.com

1
# 方案1：重启Docker服务
2
sudo systemctl restart docker
3

4
# 方案2：手动添加NAT规则
5
sudo iptables -t nat -A POSTROUTING -s 172.17.0.0/16 ! -o docker0 -j MASQUERADE
6

7
# 方案3：配置正确的DNS
8
docker run -d --name app \
9
  --dns 8.8.8.8 \
10
  --dns 114.114.114.114 \
11
  myapp:latest

1
# 1. 检查端口映射配置
2
docker port myapp
3

4
# 2. 检查宿主机端口占用
5
sudo netstat -tulpn | grep 8080
6

7
# 3. 检查容器内服务状态
8
docker exec myapp netstat -tlnp
9

10
# 4. 检查iptables规则
11
sudo iptables -t nat -L DOCKER -n | grep 8080
12

13
# 5. 测试本地访问
14
curl -v http://localhost:8080

1
# 方案1：更换端口
2
docker run -d --name app -p 8081:80 nginx:alpine
3

4
# 方案2：绑定所有网络接口
5
docker run -d --name app -p 0.0.0.0:8080:80 nginx:alpine
6

7
# 方案3：检查防火墙
8
sudo ufw allow 8080/tcp
9
sudo firewall-cmd --add-port=8080/tcp --permanent

1
# 1. 检查容器是否在同一网络
2
docker inspect c1 --format '{{range $k,$v := .NetworkSettings.Networks}}{{$k}} {{end}}'
3
docker inspect c2 --format '{{range $k,$v := .NetworkSettings.Networks}}{{$k}} {{end}}'
4

5
# 2. 检查网络配置
6
docker network inspect my-bridge
7

8
# 3. 测试网络连通性
9
docker exec c1 ping c2
10

11
# 4. 检查防火墙规则
12
docker exec c1 iptables -L -n
13

14
# 5. 检查DNS解析
15
docker exec c1 nslookup c2

1
# 方案1：确保容器在同一网络
2
docker network connect my-bridge c1
3
docker network connect my-bridge c2
4

5
# 方案2：使用自定义网络（支持DNS）
6
docker network create my-net
7
docker run -d --name c1 --network my-net nginx:alpine
8
docker run -d --name c2 --network my-net alpine sleep 3600
9

10
# 方案3：检查ICC（Inter-Container Communication）
11
docker network inspect my-bridge | grep icc
12
# 如果为false，需要启用
13
docker network rm my-bridge
14
docker network create --opt com.docker.network.bridge.enable_icc=true my-bridge

1
# 1. 测试网络吞吐量
2
docker run --rm --network host nicolaka/netshoot \
3
  iperf3 -c <target-ip> -t 30
4

5
# 2. 测试延迟
6
docker exec myapp ping -c 100 target-host | tail -1
7

8
# 3. 检查MTU设置
9
docker network inspect my-bridge | grep mtu
10

11
# 4. 监控网络流量
12
docker stats --no-stream --format "table {{.Container}}\t{{.NetIO}}"
13

14
# 5. 检查CPU使用率（NAT转换开销）
15
docker stats --no-stream --format "table {{.Container}}\t{{.CPUPerc}}"

1
# 方案1：调整MTU（减少分片）
2
docker network create \
3
  --opt com.docker.network.driver.mtu=9000 \
4
  jumbo-net
5

6
# 方案2：使用host网络（最高性能）
7
docker run -d --name app --network host myapp:latest
8

9
# 方案3：启用TCP优化
10
docker run -d --name app \
11
  --sysctl net.ipv4.tcp_tw_reuse=1 \
12
  --sysctl net.core.somaxconn=4096 \
13
  myapp:latest
14

15
# 方案4：增加网络缓冲区
16
docker run -d --name app \
17
  --sysctl net.core.rmem_max=16777216 \
18
  --sysctl net.core.wmem_max=16777216 \
19
  myapp:latest

1
# 1. 创建隔离的生产网络
2
docker network create \
3
  --driver bridge \
4
  --subnet 10.100.0.0/24 \
5
  --gateway 10.100.0.1 \
6
  --opt com.docker.network.bridge.name=br-prod \
7
  --opt com.docker.network.driver.mtu=1450 \
8
  --opt com.docker.network.bridge.enable_icc=true \
9
  --opt com.docker.network.bridge.enable_ip_masquerade=true \
10
  --label env=production \
11
  prod-network
12

13
# 2. 启动容器时使用固定IP（关键服务）
14
docker run -d --name db \
15
  --network prod-network \
16
  --ip 10.100.0.10 \
17
  --restart unless-stopped \
18
  postgres:13
19

20
# 3. 配置健康检查
21
docker run -d --name api \
22
  --network prod-network \
23
  --health-cmd="curl -f http://localhost/health || exit 1" \
24
  --health-interval=30s \
25
  --health-retries=3 \
26
  myapi:latest
27

28
# 4. 限制资源和网络权限
29
docker run -d --name app \
30
  --network prod-network \
31
  --memory 2g \
32
  --cpus 1.5 \
33
  --cap-drop ALL \
34
  --cap-add NET_BIND_SERVICE \
35
  --read-only \
36
  --tmpfs /tmp \
37
  myapp:latest

1
#!/bin/bash
2
# docker-network-setup.sh
3

4
set -e
5

6
# 颜色定义
7
RED='\033[0;31m'
8
GREEN='\033[0;32m'
9
YELLOW='\033[1;33m'
10
NC='\033[0m'
11

12
echo -e "${GREEN}[INFO] 开始配置Docker网络...${NC}"
13

14
# 1. 检查IP转发
15
if [ $(sysctl -n net.ipv4.ip_forward) -eq 0 ]; then
16
    echo -e "${YELLOW}[WARN] 启用IP转发${NC}"
17
    sudo sysctl -w net.ipv4.ip_forward=1
18
    echo "net.ipv4.ip_forward=1" | sudo tee -a /etc/sysctl.conf
19
fi
20

21
# 2. 创建网络
22
NETWORKS=("frontend" "backend" "database")
23
for net in "${NETWORKS[@]}"; do
24
    if ! docker network ls | grep -q $net; then
25
        echo -e "${GREEN}[INFO] 创建网络: $net${NC}"
26
        docker network create \
27
          --driver bridge \
28
          --label env=production \
29
          $net
30
    else
31
        echo -e "${YELLOW}[WARN] 网络已存在: $net${NC}"
32
    fi
33
done
34

35
# 3. 配置防火墙规则
36
echo -e "${GREEN}[INFO] 配置防火墙规则${NC}"
37
sudo iptables -I DOCKER-USER -i docker0 -o eth0 -j ACCEPT
38
sudo iptables -I DOCKER-USER -m state --state RELATED,ESTABLISHED -j ACCEPT
39

40
echo -e "${GREEN}[INFO] Docker网络配置完成${NC}"