深入理解 Kube-OVN 网络：从组件到实践

1
2
3
4
5
6
7

Logical_Switch        # 逻辑交换机（二层网络）
Logical_Router        # 逻辑路由器（三层网络）
Logical_Switch_Port   # 逻辑交换机端口
Logical_Router_Port   # 逻辑路由器端口
ACL                   # 访问控制列表
Load_Balancer         # 负载均衡器
DHCP_Options          # DHCP 配置

1
2
3
4
5
6

type DatapathBinding struct {
    UUID          string            `ovsdb:"_uuid"`
    ExternalIDs   map[string]string `ovsdb:"external_ids"`
    LoadBalancers []string          `ovsdb:"load_balancers"`
    TunnelKey     int               `ovsdb:"tunnel_key" validate:"min=1,max=16777215"`
}

1
2
3
4
5
6
7
8
9

type PortBinding struct {
    UUID          string  `ovsdb:"_uuid"`
    Datapath      string  `ovsdb:"datapath"`      // 指向 Datapath_Binding
    LogicalPort   string  `ovsdb:"logical_port"`   // 逻辑端口名称
    Chassis       *string `ovsdb:"chassis"`        // 绑定的物理节点
    TunnelKey     int     `ovsdb:"tunnel_key"`     // 端口级 TunnelKey
    MAC           []string `ovsdb:"mac"`           // MAC 地址
    Type          string  `ovsdb:"type"`           // 端口类型
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 查看 Datapath_Binding 表
ovn-sbctl list Datapath_Binding

# 输出示例
_uuid               : a1b2c3d4-e5f6-7890-abcd-ef1234567890
external_ids        : {logical-router="vpc-a", name="lr-vpc-a"}
tunnel_key          : 1

_uuid               : b2c3d4e5-f6a7-8901-bcde-f12345678901
external_ids        : {logical-switch="subnet-a", name="ls-subnet-a"}
tunnel_key          : 2

_uuid               : c3d4e5f6-a7b8-9012-cdef-123456789012
external_ids        : {logical-router="vpc-b", name="lr-vpc-b"}
tunnel_key          : 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

+--------------------------------------------------+
| Geneve Header                                    |
| - Version: 0                                     |
| - Opt Len: 变长                                  |
| - OAM/Critical: 标志位                          |
| - Proto: 0x6558 (Ethernet)                      |
| - VNI: tunnel_key (例如：1)                      |
+--------------------------------------------------+
| Outer UDP Header                                 |
| - Src Port: Random                               |
| - Dst Port: 6081 (Geneve)                       |
+--------------------------------------------------+
| Outer IP Header                                  |
| - Src IP: Node1_IP (例如：192.168.1.1)          |
| - Dst IP: Node2_IP (例如：192.168.1.2)          |
+--------------------------------------------------+
| Inner Ethernet Frame                             |
| - Src MAC: Pod-A MAC                             |
| - Dst MAC: Pod-B MAC                             |
| - Type: IPv4 (0x0800)                           |
+--------------------------------------------------+
| Inner IP Packet                                  |
| - Src IP: Pod-A IP                               |
| - Dst IP: Pod-B IP                              |
+--------------------------------------------------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 查看 OVS 流表
ovs-ofctl dump-flows br-int

# 示例流表（简化）
# table=0: 匹配 tunnel_id，设置 metadata
cookie=0x0, table=0, priority=100, tun_id=0x1 actions=load:0x1->NXM_NX_TUN_ID[0..31],load:0x2->NXM_NX_METADATA,in_port=1,output:2

# table=0: 匹配 tunnel_id=0x1 (VPC-A)
# actions=设置 metadata，转发到正确的端口

# table=0: 匹配 tunnel_id=0x3 (VPC-B)
cookie=0x0, table=0, priority=100, tun_id=0x3 actions=load:0x3->NXM_NX_TUN_ID[0..31],load:0x4->NXM_NX_METADATA,in_port=1,output:3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 1. Pod-A 发送数据包
#    src_ip=10.0.1.2, dst_ip=10.0.1.3
#    src_mac=pod-a-mac, dst_mac=gateway-mac（或直接是 pod-b-mac）

# 2. OVS br-int table=0 处理
#    匹配 in_port="pod-a"
#    设置 tunnel_id 和 metadata

# 3. OVS br-int table=1 MAC 学习
#    查找 MAC_Binding 表，发现 10.0.1.3 在 Node2

# 4. OVS br-int table=2 路由
#    确定输出端口为隧道接口

# 5. 封装 Geneve
#    VNI = 1 (VPC-A 的 datapath tunnel_key)
#    外层 IP: src=Node1_IP, dst=Node2_IP
#    外层 UDP: dst_port=6081

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 1. OVS br-int 从 genev_sys_6081 接收数据包
#    匹配 tun_id=1

# 2. 设置 metadata
#    load:0x1->NXM_NX_TUN_ID
#    load:datapath_metadata->NXM_NX_METADATA

# 3. 解封装
#    移除 Geneve 头部

# 4. table=1: 查找目标 MAC
#    匹配 eth_dst=pod-b-mac

# 5. 输出到 pod-b 端口
#    output:"pod-b"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

Node1:
  Pod-A1 (VPC-A) ---+
                    |
  Pod-A2 (VPC-A) ---+--> OVS br-int --> 不同 datapath (tunnel_key=1)
                    |
                    |    完全隔离（通过 metadata 匹配）
                    |
  Pod-B1 (VPC-B) ---+--> OVS br-int --> 不同 datapath (tunnel_key=3)
                    |
  Pod-B2 (VPC-B) ---+

OVS 流表逻辑：
- Pod-A1 的数据包：metadata=0x1（VPC-A）
- Pod-B1 的数据包：metadata=0x3（VPC-B）
- 流表匹配时，必须同时匹配 metadata，确保不会混淆

1
2
3
4
5
6
7
8
9

type PortBinding struct {
    UUID          string   // 唯一标识
    Chassis       *string  // Pod 所在节点的 UUID（关键！）
    Datapath      string   // 所属的逻辑网络（VPC）
    LogicalPort   string   // 逻辑端口名称（Pod 名称）
    MAC           []string // MAC 地址
    TunnelKey     int      // 端口级 TunnelKey
    Encap         *string  // 隧道封装类型（geneve）
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 查看 Port_Binding 表
ovn-sbctl list Port_Binding

# 查看特定 Pod 的位置
ovn-sbctl find Port_Binding logical_port=pod-default-my-pod

# 输出示例
_uuid               : a1b2c3d4-e5f6-7890-abcd-ef1234567890
chassis             : node1-uuid    # Pod 在 Node1
datapath            : vpc-a-dp      # 属于 VPC-A
logical_port        : pod-a         # 端口名称
mac                 : ["00:00:00:00:00:01"]
tunnel_key          : 1             # 端口 TunnelKey
encap               : geneve        # 使用 Geneve 封装

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# 进入 kube-ovn-controller Pod
kubectl exec -it -n kube-ovn deploy/kube-ovn-controller -- bash

# 查看 OVN NB 数据库
# 列出所有 Logical Switch
ovn-nbctl list Logical_Switch

# 列出所有 Logical Router
ovn-nbctl list Logical_Router

# 查看 VPC 对应的 Logical Router
ovn-nbctl lr-list | grep <vpc-name>

# 查看子网对应的 Logical Switch
ovn-nbctl ls-list | grep <subnet-name>

# 查看端口信息
ovn-nbctl list Logical_Switch_Port | grep <port-name>

# 查看路由策略
ovn-nbctl lr-route-list <vpc-name>

# 查看 ACL 规则
ovn-nbctl acl-list <logical-switch>

# 查看 Load Balancer
ovn-nbctl list Load_Balancer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 进入 kube-ovn-daemon Pod（在目标节点上）
kubectl exec -it -n kube-ovn -l app=kube-ovn-daemon --node <node-name> -- bash

# 查看 OVS 网桥
ovs-vsctl show

# 查看端口信息
ovs-vsctl list Interface | grep <port-name>

# 查看端口统计
ovs-vsctl get Interface <port-name> statistics

# 查看 OpenFlow 流表
ovs-ofctl dump-flows br-int

# 查看流表（带详细信息）
ovs-ofctl dump-flows br-int --names

# 查看端口状态
ovs-ofctl show br-int

# 查看端口映射
ovs-vsctl get Interface <port-name> external_ids

# 抓包分析
tcpdump -i <interface> -nn -vvv

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 查看 Datapath_Binding（VNI 分配）
ovn-sbctl list Datapath_Binding

# 查看端口绑定状态
ovn-sbctl list Port_Binding | grep <port-name>

# 查看端口在哪个节点上
ovn-sbctl list Port_Binding | grep -A 5 <port-name> | grep chassis

# 查看 Chassis 信息（节点注册）
ovn-sbctl list Chassis

# 查看逻辑流表
ovn-sbctl lflow-list

# 查看特定 datapath 的流表
ovn-sbctl lflow-list <datapath-uuid>

# 查看 MAC 绑定
ovn-sbctl list MAC_Binding

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# 进入 Pod 网络命名空间
kubectl exec -it <pod-name> -- sh

# 查看 Pod 网络接口
ip addr
ip link

# 查看 Pod 路由表
ip route

# 查看 Pod ARP 表
ip neigh

# Ping 测试
ping <target-ip>

# 查看网络连通性
# 从 Pod 内部
kubectl exec -it <pod-name> -- ping <target-ip>

# 从节点
kubectl exec -it -n kube-ovn -l app=kube-ovn-daemon -- ping <pod-ip>

# 抓包分析（在节点上）
# 找到 Pod 的 veth pair 名称
kubectl get pod <pod-name> -o jsonpath='{.metadata.name}'

# 在节点上查找对应的接口
ip link | grep <pod-name>

# 抓包
tcpdump -i <interface> -nn -vvv

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 查看 VPC CRD
kubectl get vpc

# 查看 VPC 详情
kubectl describe vpc <vpc-name>

# 查看 Subnet CRD
kubectl get subnet

# 查看 Subnet 详情
kubectl describe subnet <subnet-name>

# 查看 Pod annotation（IP/MAC）
kubectl get pod <pod-name> -o jsonpath='{.metadata.annotations}'

# 查看特定 annotation
kubectl get pod <pod-name> -o jsonpath='{.metadata.annotations.ovn\.kubernetes\.io/ip_address}'
kubectl get pod <pod-name> -o jsonpath='{.metadata.annotations.ovn\.kubernetes\.io/mac_address}'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 查看 kube-ovn-controller 日志
kubectl logs -n kube-ovn deploy/kube-ovn-controller --tail=100 -f

# 查看 kube-ovn-daemon 日志
kubectl logs -n kube-ovn -l app=kube-ovn-daemon --tail=100 -f

# 查看特定节点的 daemon 日志
kubectl logs -n kube-ovn -l app=kube-ovn-daemon --field-selector spec.nodeName=<node-name>

# 搜索错误日志
kubectl logs -n kube-ovn deploy/kube-ovn-controller | grep -i error
kubectl logs -n kube-ovn deploy/kube-ovn-controller | grep -i "failed to"

# 查看事件
kubectl get events --sort-by='.lastTimestamp'
kubectl get events -n kube-ovn --sort-by='.lastTimestamp'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 1. 检查子网状态
kubectl get subnet
kubectl describe subnet <subnet-name>

# 2. 检查子网是否有可用 IP
kubectl get subnet <subnet-name> -o jsonpath='{.status.availableIPs}'

# 3. 查看 controller 日志
kubectl logs -n kube-ovn deploy/kube-ovn-controller | grep -i "allocate"

# 4. 检查 webhook 是否正常
kubectl get pods -n kube-ovn -l app=kube-ovn-webhook
kubectl logs -n kube-ovn -l app=kube-ovn-webhook

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 1. 检查 Pod IP/MAC annotation
kubectl get pod <pod-name> -o jsonpath='{.metadata.annotations}'

# 2. 检查 OVN NB 端口是否创建
ovn-nbctl list Logical_Switch_Port | grep <pod-name>

# 3. 检查 OVN SB 端口绑定状态
ovn-sbctl list Port_Binding | grep <pod-name>

# 4. 检查端口是否绑定到正确节点
ovn-sbctl list Port_Binding | grep -A 10 <pod-name> | grep chassis

# 5. 检查 OVS 端口是否创建
ovs-vsctl show | grep <pod-name>

# 6. 检查流表是否正确下发
ovs-ofctl dump-flows br-int | grep <port-number>

# 7. 抓包分析
# 在源 Pod 所在节点
tcpdump -i genev_sys_6081 -nn -vvv
# 在目标 Pod 所在节点
tcpdump -i <pod-interface> -nn -vvv

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 1. 检查 VPC Peering 配置
kubectl get vpc <vpc-name> -o yaml | grep -A 20 staticRoutes

# 2. 检查 Peer Router Port
ovn-nbctl list Logical_Router_Port | grep <vpc-name>

# 3. 检查路由是否正确
ovn-nbctl lr-route-list <vpc-a-name>
ovn-nbctl lr-route-list <vpc-b-name>

# 4. 检查 ACL 是否阻止
ovn-nbctl acl-list <logical-switch>

# 5. 测试连通性
kubectl exec -it <pod-a> -- ping <pod-b-ip>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 1. 检查节点网关配置
kubectl get node <node-name> -o jsonpath='{.metadata.annotations}'

# 2. 检查 ovn0 接口
ip addr show ovn0
ip link show ovn0

# 3. 检查路由表
ip route | grep <pod-cidr>

# 4. 检查 OVS 端口
ovs-vsctl show | grep node-

# 5. 检查流表
ovs-ofctl dump-flows br-int | grep node

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 1. Pod 发送原始数据包
# Ethernet Header:
#   src_mac: 00:00:00:00:00:01 (Pod-A MAC)
#   dst_mac: 00:00:00:00:00:03 (Pod-B MAC, 通过 ARP 获取)
# IP Header:
#   src_ip: 10.0.1.2
#   dst_ip: 10.0.1.3

# 2. OVS br-int 处理
# table=0: 匹配 in_port="ovn-pod-a"
ovs-ofctl dump-flows br-int | grep "in_port=\"ovn-pod-a\""

# 示例流表
cookie=0x0, table=0, priority=100, in_port="ovn-pod-a"
  actions=load:0x1->NXM_NX_TUN_ID[],load:0x2->NXM_NX_METADATA[],output:2

# table=1: MAC 地址查找
# 查找 MAC_Binding 表，发现 00:00:00:00:00:03 在 Node2

# table=2: 封装 Geneve
# VNI = 1 (VPC-A 的 datapath tunnel_key)
# 外层 IP: src=Node1_IP, dst=Node2_IP
# 外层 UDP: dst_port=6081

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 1. 从隧道接口接收数据包
# 外层 IP: dst=Node2_IP
# 外层 UDP: dst_port=6081 (Geneve)
# Geneve Header: VNI=1

# 2. OVS br-int 处理
# table=0: 匹配 tun_id=1
ovs-ofctl dump-flows br-int | grep "tun_id=0x1"

# 示例流表
cookie=0x0, table=0, priority=100, tun_id=0x1
  actions=load:0x1->NXM_NX_TUN_ID[],load:0x3->NXM_NX_METADATA[],output:"ovn-pod-b"

# 3. 解封装并转发
# 移除 Geneve 头部
# 匹配 dst_mac=00:00:00:00:00:03
# 输出到 ovn-pod-b 端口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

# 1. Provider Network 配置
# 创建 ProviderNetwork CRD
apiVersion: kubeovn.io/v1
kind: ProviderNetwork
metadata:
  name: net1
spec:
  defaultInterface: eth0
  excludedNodes: []
  customInterfaces: []

# 2. 节点上创建 OVS bridge
# kube-ovn-daemon 会自动配置
ovs-vsctl add-br br-phys
ovs-vsctl add-port br-phys eth0

# 3. 创建 VLAN
apiVersion: kubeovn.io/v1
kind: Vlan
metadata:
  name: vlan100
spec:
  provider: net1
  vlanId: 100
  id: 100

# 4. 创建 Subnet 使用 VLAN
apiVersion: kubeovn.io/v1
kind: Subnet
metadata:
  name: subnet-underlay
spec:
  provider: net1
  vlan: vlan100
  cidrBlock: 192.168.1.0/24
  gateway: 192.168.1.1

# 5. Pod 发送数据包（无隧道封装）
# Ethernet Header:
#   src_mac: Pod-A MAC
#   dst_mac: Pod-B MAC（通过 ARP 获取，物理网络学习）
# VLAN Header: tag=100
# IP Header:
#   src_ip: 192.168.1.2
#   dst_ip: 192.168.1.3

# 6. OVS br-phys 处理
# 直接转发到物理网卡
# 添加 VLAN tag=100

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 1. 物理网卡接收数据包
# 已经带有 VLAN tag=100

# 2. OVS br-phys 处理
# 匹配 VLAN tag
ovs-ofctl dump-flows br-phys | grep "dl_vlan=100"

# 示例流表
cookie=0x0, table=0, priority=100, dl_vlan=100
  actions=strip_vlan,output:"ovn-pod-b"

# 3. 移除 VLAN tag，转发到 Pod

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# 1. 启用 Subnet 的 BGP 发布
apiVersion: kubeovn.io/v1
kind: Subnet
metadata:
  name: subnet-bgp
  annotations:
    ovn.kubernetes.io/bgp: "true"  # 发布整个子网 CIDR
spec:
  cidrBlock: 10.16.0.0/16
  
# 2. 启用 Pod 的 BGP 发布
apiVersion: v1
kind: Pod
metadata:
  name: pod-bgp
  annotations:
    ovn.kubernetes.io/bgp: "local"  # 只从本节点发布 Pod IP
spec:
  containers:
  - name: nginx
    image: nginx

# 3. 启用 Service ClusterIP 的 BGP 发布
apiVersion: v1
kind: Service
metadata:
  name: svc-bgp
  annotations:
    ovn.kubernetes.io/bgp: "true"
spec:
  type: ClusterIP
  clusterIPs:
  - 10.96.0.100

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 1. kube-ovn-speaker 配置
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: kube-ovn-speaker
spec:
  template:
    spec:
      containers:
      - name: kube-ovn-speaker
        args:
        - --neighbor-address=192.168.1.1  # BGP 邻居（物理路由器）
        - --neighbor-as=65000            # 邻居 AS 号
        - --cluster-as=65001              # 集群 AS 号
        - --router-id=$(POD_IP)

# 2. 查看发布的路由
# 在 kube-ovn-speaker Pod 中
kubectl exec -it -n kube-ovn kube-ovn-speaker-xxx -- gobgp global rib

# 输出示例
Network          Next Hop        AS_PATH    Age        Attrs
10.16.0.0/16     192.168.1.10    65001      00:01:23   origin: i-incomplete
10.16.0.2/32     192.168.1.10    65001      00:00:45   origin: i-incomplete

# 3. 在物理路由器上查看路由
# Cisco 示例
show ip route bgp
# 输出
     10.16.0.0/16 [20/0] via 192.168.1.10, 00:01:23
     10.16.0.2/32  [20/0] via 192.168.1.10, 00:00:45

# Juniper 示例
show route protocol bgp
# 输出
10.16.0.0/16    *[BGP/20] 00:01:23, localpref 100
                  > to 192.168.1.10 via eth0
10.16.0.2/32     *[BGP/20] 00:00:45, localpref 100
                  > to 192.168.1.10 via eth0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 1. Underlay Subnet
apiVersion: kubeovn.io/v1
kind: Subnet
metadata:
  name: subnet-underlay
spec:
  provider: net1
  vlan: vlan100
  cidrBlock: 192.168.1.0/24
  gateway: 192.168.1.1
  u2oInterconnection: true  # 启用 U2O 互联

# 2. Overlay Subnet
apiVersion: kubeovn.io/v1
kind: Subnet
metadata:
  name: subnet-overlay
spec:
  cidrBlock: 10.0.1.0/24
  gateway: 10.0.1.1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 1. Underlay Pod 发送数据包
# src_ip: 192.168.1.2 (Underlay Pod)
# dst_ip: 10.0.1.2 (Overlay Pod)

# 2. Underlay Subnet 的路由表
# 默认网关: 192.168.1.254 (U2O Gateway IP)
ip route
# default via 192.168.1.254

# 3. U2O Gateway 处理
# 接收数据包，查找路由表
# 目标 10.0.1.2 在 Overlay 网络
# 封装 Geneve 包，VNI=Overlay Datapath ID

# 4. 发送到 Overlay 网络
# 外层 IP: src=Node_IP, dst=Overlay_Node_IP
# Geneve: VNI=Overlay_VNI
# 内层 IP: src=192.168.1.2, dst=10.0.1.2

# 5. Overlay Node 接收
# 匹配 VNI，解封装
# 转发到 Pod-Overlay

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

Node1:
  1. Pod-A1 发送数据包
     - src_ip: 10.0.1.2
     - dst_ip: 10.0.1.3
     - src_mac: 00:00:00:00:00:01
     - dst_mac: 00:00:00:00:00:03 (通过 ARP 或 L3 获取)

  2. veth pair: eth0 (Pod) ↔ ovn-pod-a1 (Node)
     - 数据包进入 OVS br-int

  3. OVS table=0: 入口处理
     - 匹配 in_port="ovn-pod-a1"
     - 设置 tunnel_id 和 metadata
     - metadata = VPC-A 的 datapath identifier

  4. OVS table=1: MAC 查找
     - 查找 eth_dst=00:00:00:00:00:03
     - 发现目标在远程节点 Node2

  5. OVS table=2: 封装准备
     - 查找输出端口: tunnel interface (genev_sys_6081)
     - 准备 Geneve 封装

  6. Geneve 封装
     - VNI = tunnel_key = 1 (VPC-A 的 Datapath_Binding.tunnel_key)
     - 外层 IP: src=Node1_IP, dst=Node2_IP
     - 外层 UDP: dst_port=6081

物理网络:
  7. 数据包通过物理网络传输

Node2:
  8. OVS br-int 从 genev_sys_6081 接收
     - 匹配 tun_id=0x1 (VNI=1)
     - 设置 metadata（标识 VPC-A）

  9. OVS table=0: 解封装
     - 移除 Geneve 头部
     - 恢复原始以太网帧

  10. OVS table=1: MAC 匹配
      - 匹配 eth_dst=00:00:00:00:00:03
      - 确定输出端口为 ovn-pod-a2

  11. OVS table=2: 输出
      - 输出到 ovn-pod-a2 端口

  12. veth pair: ovn-pod-a2 (Node) ↔ eth0 (Pod)
      - 数据包到达 Pod-A2

  13. Pod-A2 接收数据包

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

VPC-A (Node1):
  1. Pod-A1 发送数据包
     - src_ip: 10.0.1.2
     - dst_ip: 10.1.1.2 (不同 VPC 的 IP)

  2. OVS table=0: 匹配 in_port="ovn-pod-a1"
     - 设置 metadata = VPC-A identifier

  3. OVS table=1: L2/L3 查找
     - 发现目标 IP 不在本 VPC 子网内
     - 需要路由到 VPC Router

  4. OVS table=2: 路由处理
     - 发送到 VPC-A 的 Logical Router
     - 匹配静态路由: dst=10.1.0.0/16, next_hop=10.0.255.2

  5. Logical Router: 路由转发
     - 查找路由表
     - 输出到 Peer Router Port: vpc-a-vpc-b

  6. OVS table=3: 发送到 Peer Port
     - 数据包进入 VPC-A ↔ VPC-B 的连接

VPC-B (同一节点或不同节点):
  7. 数据包从 Peer Port 接收
     - Peer Port: vpc-b-vpc-a

  8. OVS table=0: 匹配 in_port="vpc-b-vpc-a"
     - 设置 metadata = VPC-B identifier

  9. OVS table=1: L2 查找
     - 查找 MAC: 00:00:00:00:00:04 (Pod-B1)
     - 发现目标在远程节点 Node2

  10. OVS table=2: 封装 Geneve
      - VNI = tunnel_key = 3 (VPC-B 的 Datapath_Binding.tunnel_key)
      - 外层 IP: src=Node_IP, dst=Node2_IP

  11. Geneve 封装发送

Node2 (VPC-B):
  12. OVS br-int 接收
      - 匹配 tun_id=0x3 (VNI=3, VPC-B)
      - 设置 metadata = VPC-B identifier

  13. OVS table=1: MAC 匹配
      - 匹配 eth_dst=00:00:00:00:00:04

  14. 输出到 Pod-B1
      - 输出端口: ovn-pod-b1