从 Linux 基础实现 Docker Bridge 网路：一步步理解容器通讯 (6)

部落格好读版

在上一章中，我们认识了 Docker 对 iptables 的修改，成功让容器之间以及容器与外网的流量顺利传输。然而，还有一个重要的情境需要解决：外部网路如何存取容器。

经常使用 Docker 的朋友可能已经知道答案了 - Docker Container 可以透过 Port Forwarding 来实现此功能。虽然它看起来像是一项新技术，但本质上也是 Network Address Translation (NAT) 的一种实现方式。

深入研究 NAT：认识常见的 NAT 型态

在深入讨论之前，让我们先来了解 NAT 的类型。在 iptables 中，可以灵活地进行各种 Network Address Translation (NAT) 操作，主要分为两种：Source NAT (SNAT) 与 Destination NAT (DNAT)。

SNAT：Source Network Address Translation

SNAT 会改写封包的来源 IP 位址，让外部看到的「Source IP」已被替换。举个例子，当多台 PC 透过一台 ADSL Router 共享上网时，每台 PC 都配置了 Private IP。当这些 PC 连线至外部网路时，Router 会将 packet header 里的 Source IP 改成 Router 本身的 Public IP。如此一来，外部网站（例如 Web Server）所记录到的 Source IP 就是 Router 的 IP，而非 PC 的 Private IP。

SNAT 常用于以下场景：

Internet Sharing一个公司或家庭网路内的多台设备分享同一个 Public IP 上网时，Router 使用 SNAT 技术把内部 Source IP（如 192.168.x.x）改为 Public IP，以便外网 Server 能正确回应。

Container Network 和 Hairpin NAT如 Docker 中，当 Container 需要通过映射的 Port 访问自己或其他 Container 时，SNAT（或 MASQUERADE，它是一种特殊形式的 SNAT）用来改写 Source Address，使得回应路由可以正确返回。

DNAT：Destination Network Address Translation (目标网路地址转换)

DNAT（Destination Network Address Translation）则改写封包的目的地 IP 位址，典型的应用场景是把位于内网的 Web 伺服器透过防火墙的公网 IP 对外发布。例如，一台 Web 伺服器只拥有内网 IP，却希望让网际网路使用者能直接使用公网 IP 来存取。当外部客户端发送封包时，目的地为该防火墙的公网 IP，而防火墙会将封包的目的地址动态改写成 Web 伺服器的内网 IP，并把封包转发至内网。最终，外部访问就能穿透防火墙，抵达实际的内网伺服器，达成 DNAT 所谓的「目标地址」转换。

DNAT 常用于以下场景：

Port Forwarding（连接埠转发）在家庭或企业网路中，外部访问某个公共 IP 和埠号的流量可以经过 NAT 设备转发到内部网路的特定伺服器。例如：外部访问公网 IP 的 8080 埠流量会被转发到内部 192.168.1.100 的 80 埠上。这里就使用了 DNAT 改写封包的目的地址与埠号。

Load Balancing（负载平衡）DNAT 可用于将到达某个入口点的流量分配到多个后端伺服器，以平衡负载。

MASQUERADE：地址伪装

MASQUERADE 其实是 SNAT 的一种特例，能够自动完成 SNAT。虽然在 iptables 中可以使用与 SNAT 类似的方式来实现转换，但仍存在一些差异。最主要的不同点在于，使用 SNAT 时必须明确指定要转换成的 IP，这个 IP 可以是一个或多个范围。但如果系统採用 ADSL 这类动态拨号方式，每次拨号后出口 IP 都可能改变，便无法使用事先写死的 SNAT 规则，因为规则里的 IP 不会随着拨号取得的新 IP 自动变更，导致我们必须频繁手动修改 iptables，非常不方便。

正因如此，MASQUERADE 便应运而生。它会自动侦测网卡（例如 eth0）的当前动态 IP，无论 IP 变动多频繁，都能在出站时自动将封包的来源 IP 改为网卡的最新 IP，如此就能大幅简化维运工作。

SNAT 与 MASQUERADE 的用法范例

总结：

• SNAT 与 DNAT 分别针对封包的「Source」或「Destination」进行转换。在实际应用中，我们常需要同时处理内网 Server 对外以及外网 Client 对内的流量，因此 SNAT 与 DNAT 经常搭配使用。
• MASQUERADE 作为 SNAT 的一种特例，特别适合用于出口 IP 不固定、动态频繁变更的环境，能为管理者省去手动修改规则的麻烦，让网路地址转换更自动化、更轻鬆。

分析：建立 Docker Container 前后的 iptables 与 NAT 变化

掌握必要的知识后，让我们实际分析 iptables 和 NAT 的变化。首先，查看 Docker Network：

docker network ls
# output
NETWORK ID NAME DRIVER SCOPE
469fd7ab0fbd bridge bridge local
a2b456636301 host host local
e5238737e4cb none null local

这三个是 Docker 的预设网路。接着，使用以下指令建立一个 nginx container：

docker container run --name my-nginx-container -d -p 8080:80 nginx

让我们观察 iptables 和 nat 的变化。首先看 filter table：

iptables -t filter -nvL --line-number
# output
Chain INPUT (policy ACCEPT 0 packets, 0 bytes)
num pkts bytes target prot opt in out source destination

Chain FORWARD (policy DROP 0 packets, 0 bytes)
num pkts bytes target prot opt in out source destination
1 0 0 DOCKER-USER all -- * * 0.0.0.0/0 0.0.0.0/0
2 0 0 DOCKER-ISOLATION-STAGE-1 all -- * * 0.0.0.0/0 0.0.0.0/0
3 0 0 ACCEPT all -- * docker0 0.0.0.0/0 0.0.0.0/0 ctstate RELATED,ESTABLISHED
4 0 0 DOCKER all -- * docker0 0.0.0.0/0 0.0.0.0/0
5 0 0 ACCEPT all -- docker0 !docker0 0.0.0.0/0 0.0.0.0/0
6 0 0 ACCEPT all -- docker0 docker0 0.0.0.0/0 0.0.0.0/0

Chain OUTPUT (policy ACCEPT 0 packets, 0 bytes)
num pkts bytes target prot opt in out source destination

Chain DOCKER (1 references)
num pkts bytes target prot opt in out source destination
+1 0 0 ACCEPT tcp -- !docker0 docker0 0.0.0.0/0 172.17.0.2 tcp dpt:80

Chain DOCKER-ISOLATION-STAGE-1 (1 references)
num pkts bytes target prot opt in out source destination
1 0 0 DOCKER-ISOLATION-STAGE-2 all -- docker0 !docker0 0.0.0.0/0 0.0.0.0/0
2 0 0 RETURN all -- * * 0.0.0.0/0 0.0.0.0/0

Chain DOCKER-ISOLATION-STAGE-2 (1 references)
num pkts bytes target prot opt in out source destination
1 0 0 DROP all -- * docker0 0.0.0.0/0 0.0.0.0/0
2 0 0 RETURN all -- * * 0.0.0.0/0 0.0.0.0/0

Chain DOCKER-USER (1 references)
num pkts bytes target prot opt in out source destination
1 0 0 RETURN all -- * * 0.0.0.0/0 0.0.0.0/0

###

iptables -t nat -nvL --line-number
# output
Chain PREROUTING (policy ACCEPT 0 packets, 0 bytes)
num pkts bytes target prot opt in out source destination
1 0 0 DOCKER all -- * * 0.0.0.0/0 0.0.0.0/0 ADDRTYPE match dst-type LOCAL

Chain INPUT (policy ACCEPT 0 packets, 0 bytes)
num pkts bytes target prot opt in out source destination

Chain OUTPUT (policy ACCEPT 0 packets, 0 bytes)
num pkts bytes target prot opt in out source destination
-1 69 5003 DOCKER all -- * * 0.0.0.0/0 !127.0.0.0/8 ADDRTYPE match dst-type LOCAL
+1 218 16475 DOCKER all -- * * 0.0.0.0/0 !127.0.0.0/8 ADDRTYPE match dst-type LOCAL

Chain POSTROUTING (policy ACCEPT 0 packets, 0 bytes)
num pkts bytes target prot opt in out source destination
1 0 0 MASQUERADE all -- * !docker0 172.17.0.0/16 0.0.0.0/0
+2 0 0 MASQUERADE tcp -- * * 172.17.0.2 172.17.0.2 tcp dpt:80

Chain DOCKER (2 references)
num pkts bytes target prot opt in out source destination
1 0 0 RETURN all -- docker0 * 0.0.0.0/0 0.0.0.0/0
+2 0 0 DNAT tcp -- !docker0 * 0.0.0.0/0 0.0.0.0/0 tcp dpt:8080 to:172.17.0.2:80

整理一下，只留下新增的规则:

*filter
Chain DOCKER (1 references)
num pkts bytes target prot opt in out source destination
1 0 0 ACCEPT tcp -- !docker0 docker0 0.0.0.0/0 172.17.0.2 tcp dpt:80

*nat
Chain POSTROUTING (policy ACCEPT 0 packets, 0 bytes)
num pkts bytes target prot opt in out source destination
2 0 0 MASQUERADE tcp -- * * 172.17.0.2 172.17.0.2 tcp dpt:80

Chain DOCKER (2 references)
num pkts bytes target prot opt in out source destination
2 0 0 DNAT tcp -- !docker0 * 0.0.0.0/0 0.0.0.0/0 tcp dpt:8080 to:172.17.0.2:80

使用 iptables-save 找到对应的项目：

*filter
-A DOCKER -d 172.17.0.2/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 80 -j ACCEPT

*nat
-A POSTROUTING -s 172.17.0.2/32 -d 172.17.0.2/32 -p tcp -m tcp --dport 80 -j MASQUERADE

-A DOCKER ! -i docker0 -p tcp -m tcp --dport 8080 -j DNAT --to-destination 172.17.0.2:80

解释：filter 表的规则

-A DOCKER -d 172.17.0.2/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 80 -j ACCEPT

解读：

• -A DOCKER：在 filter 表的自订 Chain DOCKER 中新增一条规则。
• -d 172.17.0.2/32：目的 IP 为 172.17.0.2（容器在 docker0 bridge 上的虚拟网卡 IP）。
• ! -i docker0：封包的输入介面不是 docker0，表示该封包来自外部。
• -o docker0：封包的输出介面是 docker0，表示封包要传送到 docker0 介面。
• -p tcp -m tcp --dport 80：协定为 TCP，目的埠为 80。
• -j ACCEPT：允许符合条件的封包通过。

目的：此规则允许外部流量传送到容器的 80 埠。

验证步骤

开始之前，我们先备份 iptables:

sudo iptables-save > /tmp/iptables-backup.txt

接着使用 iptables -D 删除规则，此时该条规则暂时失效

# iptables -D <CHAIN> <行号>
sudo iptables -D DOCKER 1

测试从 Host 外连线到 nginx 容器对应的 HOST_IP:PORT。你应该会看到连线失败的讯息。

最后，记得恢复 iptables:

sudo iptables-restore < /tmp/iptables-backup.txt

解释: nat 表的规则

-A POSTROUTING -s 172.17.0.2/32 -d 172.17.0.2/32 -p tcp -m tcp --dport 80 -j MASQUERADE

解读：

• -A POSTROUTING：在 nat 表的 POSTROUTING Chain 中新增规则。
• -s 172.17.0.2/32 -d 172.17.0.2/32：来源 IP 和目的 IP 同样是 172.17.0.2，表示同一个容器自己连到自己（loopback/hairpin）的情境。
• -p tcp -m tcp --dport 80：协定为 TCP，目的埠为 80。
• -j MASQUERADE：对此流量进行 NAT 转换（MASQUERADE 会动态改写来源 IP/Port），使其能正常「环迴」回到同一个容器。

目的：
这是 Docker 用来处理「容器透过主机映射的 Port 存取自己」的情境（俗称 Hairpin NAT）。举例来说，当容器尝试连到 host_ip:8080 时，最终需要转回自己的 80 Port，此时就需要 MASQUERADE 来实现「自我存取」的连线。若没有这个机制，封包在传输过程中可能会出现路由或 ARP 的错乱。

-A DOCKER ! -i docker0 -p tcp -m tcp --dport 8080 -j DNAT --to-destination 172.17.0.2:80

解读：

• -A DOCKER：在 nat 表里的自订 Chain DOCKER 新增规则。
• ! -i docker0：封包的输入介面不是 docker0（意即从外部或主机进来）。
• -p tcp -m tcp --dport 8080：协定为 TCP，目的埠为 8080。
• -j DNAT --to-destination 172.17.0.2:80：进行目地位址转换 (Destination NAT)，将目的 IP/Port 改写成 172.17.0.2:80。

目的：
这正是 Port Mapping 的关键规则：

• 当外界或本机对「Host 的 8080 Port」发起 TCP 连线，iptables 会把流量 DNAT 到容器的 172.17.0.2:80。
• 也就是说，外部连到 host:8080，最后转到容器 IP:80（nginx）上，使你可以从外部直接以 http://HOST_IP:8080 连到容器里面的服务。

补充: 解释 DOCKER Chain 的来源

NAT 转跳到 DOCKER 的条件有以下两个：

-A PREROUTING -m addrtype --dst-type LOCAL -j DOCKER
-A OUTPUT ! -d 127.0.0.0/8 -m addrtype --dst-type LOCAL -j DOCKER

我们来看看简单版 iptables 流程图:

简单解释一下两个 Chain 的差别:

PREROUTING：

• 主要处理外部网络进入的封包（经过网卡的流量）。
• 本地主机生成的封包不经过 PREROUTING，因为它们从来没有经过网卡的输入路径。

OUTPUT：

• 处理所有本地主机生成的封包，包括发往本机的封包。
• 如果 Docker 中需要处理本地主机生成的流量（例如连接 localhost:9091），则必须在 OUTPUT Chain中设置

其中规则的 --dst-type LOCAL 中的 LOCAL 代表"本地主机"，是指运行 iptables 的那台机器（例如 EC2 实例）的网路接口地址。相同的 network namespace 都算是 LOCAL 的范畴。而使用 Docker Bridge 时，由于本质上是建立了另一个 network namespace，所以从容器 IP 对于 Host 的 iptables 来说属于外网，会走 PREROUTING chain。

小结

使用 Docker，使用 bridge network 建立容器，并且指定 port forwarding 从容器 80 port 到 host 主机 8080 port (-p 8080:80)。会对 iptables 建立以下规则:

至于"允许容器对外部发起连线" 的规则，在第五章时已经做过了，规则如下:

# 允许: 所有预设 bridge 网段对外部连线
-A FORWARD -i docker0 ! -o docker0 -j ACCEPT
# 所有预设 bridge 网段连线到外部，做 SNAT 转换
-A POSTROUTING -s 172.17.0.0/16 ! -o docker0 -j MASQUERADE
# 允许: 所有预设 bridge 网段，连线建立后返回的封包或与该连线相关的封包
-A FORWARD -o docker0 -m conntrack --ctstate RELATED,ESTABLISHED -j ACCEPT

大家可以用上面学习到的知识，试着解读这些规则。

实作：Docker Style Port Forwarding

接下来我们要实作自己的 Container port forwarding，目标如下：

制作 HTTP Server 执行档

首先建立 Golang 专案，添加以下程式码：

package main

import (
"fmt"
"net/http"
"os"
"strconv"

"github.com/go-chi/chi/v5"
"github.com/go-chi/cors"
)

type Config struct{}

func main() {
app := Config{}

port := ":8080" // Default port
if len(os.Args) > 1 {
p, err := strconv.Atoi(os.Args[1])
if err != nil {
fmt.Println("Invalid port number:", err)
return
}
port = fmt.Sprintf(":%d", p)
}
srv := http.Server{
Addr: port,
Handler: app.routes(),
}
fmt.Printf("Server is listening on %s\\n", port)
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
fmt.Println("Error starting server:", err)
}
}

func (app *Config) routes() http.Handler {
mux := chi.NewRouter()

mux.Use(cors.Handler(cors.Options{
AllowedOrigins: []string{"https://*", "http://*"},
AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
AllowedHeaders: []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
ExposedHeaders: []string{"Link"},
AllowCredentials: true,
MaxAge: 300,
}))

mux.Get("/", app.HelloWorld)

return mux
}

func (app *Config) HelloWorld(w http.ResponseWriter, r *http.Request) {
_, err := w.Write([]byte("Hello World!"))
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}

编译执行档：

$env:GOOS = "linux"
$env:GOARCH = "amd64"
go build -o simpleServer cmd/api/main.go

执行 simpleServer，指定 8081 port，就可以启动一个简单的 Server：

./simpleServer 8081
# output
Server is listening on :8081

EC2 设定

为了方便施作，在既有的 Security Group 允许 TCP inbound：

把 simpleServer 执行档上传到 Host1 EC2：

scp -i </path/to/your-key.pem> </path/to/local-file> ec2-user@<EC2_IP或DNS>:</path/to/remote/directory>

测试连线：

curl localhost:8081
# output
Hello World!

在 ns1 运行 HTTP Server

在 ns1 开一个新的 bash shell：

sudo ip netns exec ns1 bash

使用 simpleServer 启动 HTTP server：

# in ns1
./simpleServer 8081
# output
Server is listening on :8081

在 ns1 再开一个新的 bash shell，检查 8081 Port 有没有被佔用：

# in ns1
netstat -ano | grep 8081
# output
tcp 0 0 0.0.0.0:8081 0.0.0.0:* LISTEN off (0.00/0/0)

回到 root ns 的 bash shell，检查 8081 Port 有没有被佔用：

netstat -ano | grep 8081
# output
$

在 root ns 测试 HTTP server 连线：

curl 172.18.0.3:8081
# output
Hello World!

在 root ns 启动 ns1 的 lo：

ip netns exec net1 ip link set lo up

在 ns1 的 bash shell，重新启动 HTTP server，测试访问自己：

# in ns1
curl localhost:8081
# output
Hello World!

準备测试环境

首先，我们将 Terminal 视窗切分，并準备好四个 Session，对应如下：

接着，测试 root ns -> ns1 以及 host2 -> host1 的连线是否畅通：

确认连线正常后，我们就可以开始添加规则了。

让本地主机（Host1）可以访问容器的 HTTP Server 服务

OUTPUT DNAT 规则

将本地主机到达本地主机 9091 Port 的 TCP 流量转发到容器的 8081 Port。

完整的 DNAT 规则如下：

-A OUTPUT ! -d 127.0.0.0/8 -m addrtype --dst-type LOCAL -j DOCKER
-A DOCKER ! -i docker0 -p tcp -m tcp --dport 8080 -j DNAT --to-destination 172.17.0.2:80

不透过 Docker Chain 处理，我们可以进一步简化规则：

-A OUTPUT \\
! -d 127.0.0.0/8 -m addrtype --dst-type LOCAL \\
-p tcp --dport 8080 \\
-j DNAT --to-destination 172.17.0.2:80

再将规则中的 bridge, dport 和 dnat 修改成我们的案例：

sudo iptables -t nat -A OUTPUT ! -d 127.0.0.0/8 -m addrtype --dst-type LOCAL \\
-p tcp -m tcp --dport 9091 -j DNAT --to-destination 172.18.0.3:8081

操作结果如下：

让外网 (Host2) 可以访问 Host1 容器的 HTTP Server 服务

我们需要同时设置 SNAT, DNAT 才能形成完整的 Port Forwarding

PREROUTING DNAT 规则

将外部到达本地主机 9091 Port 的 TCP 流量转发到容器的 8081 Port。

完整的 DNAT 规则如下：

-A PREROUTING -m addrtype --dst-type LOCAL -j DOCKER
-A DOCKER ! -i docker0 -p tcp -m tcp --dport 8080 -j DNAT --to-destination 172.17.0.2:80

不透过 Docker Chain 处理，我们可以进一步简化规则：

-A PREROUTING \\
-m addrtype --dst-type LOCAL \\
! -i docker0 \\
-p tcp --dport 8080 \\
-j DNAT --to-destination 172.17.0.2:80

再将规则中的 bridge, dport 和 dnat 修改成我们的案例：

sudo iptables -t nat -A PREROUTING -m addrtype --dst-type LOCAL \\
! -i docker1 -p tcp -m tcp --dport 9091 -j DNAT --to-destination 172.18.0.3:8081

Filter 规则

允许外网封包转送到 HTTP Server

sudo iptables -t filter -A FORWARD -d 172.18.0.3/32 ! -i docker1 -o docker1 -p tcp -m tcp --dport 8081 -j ACCEPT

操作结果如下：

结论

在本章中，我们深入探讨了 Docker 容器的 Port Forwarding 机制，并实际动手实作。主要学习到以下几点：

NAT 的基本概念与应用

• 了解 SNAT、DNAT 和 MASQUERADE 的差异与使用场景
• 掌握 Docker 如何运用 NAT 实现容器网路的连通性

Docker Port Forwarding 的实现原理

• Docker 透过 iptables 的 DNAT 规则实现 Port Mapping
• 使用 MASQUERADE 处理 Hairpin NAT（容器自访问）的情况
• Filter 表的规则确保封包能顺利通过

到这篇为止，我们差不多了解了 Docker Bridge 网路的全貌。之后可能会出个补充篇，再写一篇这个系列的总整理篇做个结尾。