1
# Linux 内核 ECMP 配置示例
2
# 添加两条等价路由
3
ip route add 10.0.2.0/24 nexthop via 10.0.1.1 dev eth1 weight 1 \
4
                         nexthop via 10.0.1.2 dev eth2 weight 1
5

6
# 查看路由表中的多路径
7
ip route show 10.0.2.0/24
8
# 10.0.2.0/24
9
#   nexthop via 10.0.1.1 dev eth1 weight 1
10
#   nexthop via 10.0.1.2 dev eth2 weight 1

1
# Linux 创建 VXLAN 接口
2
ip link add vxlan0 type vxlan \
3
    id 10010 \                    # VNI = 10010
4
    dev eth0 \                    # underlay 接口
5
    dstport 4789 \                # UDP 目的端口
6
    local 10.0.1.1 \              # 本端 VTEP IP
7
    remote 10.0.2.1               # 对端 VTEP IP（点对点模式）
8

9
# 启动接口
10
ip link set vxlan0 up
11

12
# 将 VXLAN 接口加入网桥
13
ip link add br-vxlan type bridge
14
ip link set vxlan0 master br-vxlan
15
ip link set eth1 master br-vxlan   # eth1 连接虚拟机/容器
16
ip link set br-vxlan up

1
# FRR EVPN 配置示例
2
router bgp 65001
3
  bgp router-id 10.0.1.1
4
  neighbor fabric peer-group
5
  neighbor fabric remote-as 65001
6
  neighbor 10.0.0.2 peer-group fabric
7
  neighbor 10.0.0.3 peer-group fabric
8
  !
9
  address-family l2vpn evpn
10
    neighbor fabric activate
11
    advertise-all-vnis
12
    advertise-svi-ip
13
exit-address-family

1
# OpenFlow 流表规则示例
2
# 匹配条件          动作           优先级
3
table=0,ip,nw_dst=10.0.1.0/24,output:1    priority=100
4
table=0,ip,nw_dst=10.0.2.0/24,output:2    priority=100
5
table=0,arp,arp_tpa=10.0.1.0/24,output:1   priority=200
6
table=0,tcp,tp_dst=80,output:3             priority=50
7
table=0,*,controller                       priority=0    # 默认上送控制器

1
# 创建 OVS 网桥
2
ovs-vsctl add-br br-sdn
3

4
# 添加物理端口
5
ovs-vsctl add-port br-sdn eth1
6

7
# 添加 VXLAN 隧道端口
8
ovs-vsctl add-port br-sdn vxlan0 \
9
    -- set interface vxlan0 type=vxlan \
10
    options:remote_ip=10.0.2.1 \
11
    options:key=10010 \
12
    options:dst_port=4789
13

14
# 设置 OpenFlow 控制器
15
ovs-vsctl set-controller br-sdn tcp:127.0.0.1:6653
16

17
# 查看流表
18
ovs-ofctl dump-flows br-sdn
19

20
# 手动下发流表规则
21
ovs-ofctl add-flow br-sdn "ip,nw_dst=10.0.1.0/24,actions=output:1"
22
ovs-ofctl add-flow br-sdn "ip,nw_dst=10.0.2.0/24,actions=output:2"
23

24
# 查看端口统计
25
ovs-ofctl dump-ports br-sdn

1
# nginx 四层负载均衡配置（stream 模块）
2
stream {
3
    upstream backend_mysql {
4
        # 简单轮询
5
        server 10.0.1.10:3306;
6
        server 10.0.1.11:3306;
7
        server 10.0.1.12:3306;
8
    }
9

10
    server {
11
        listen 3306;
12
        proxy_pass backend_mysql;
13
        proxy_connect_timeout 1s;
14
    }
15
}

1
# nginx 七层负载均衡配置（http 模块）
2
http {
3
    upstream backend_api {
4
        # 加权轮询 + 健康检查
5
        server 10.0.1.10:8080 weight=3 max_fails=2 fail_timeout=10s;
6
        server 10.0.1.11:8080 weight=2 max_fails=2 fail_timeout=10s;
7
        server 10.0.1.12:8080 weight=1 max_fails=2 fail_timeout=10s;
8

9
        # 一致性哈希（基于客户端 IP）
10
        # hash $remote_addr consistent;
11
    }
12

13
    server {
14
        listen 80;
15

16
        location /api/ {
17
            proxy_pass http://backend_api;
18
            proxy_set_header X-Real-IP $remote_addr;
19
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
20
        }
21

22
        location /static/ {
23
            # 静态资源直接返回
24
            root /var/www/static;
25
        }
26
    }
27
}

1
# Istio VirtualService 配置示例：按版本路由
2
apiVersion: networking.istio.io/v1alpha3
3
kind: VirtualService
4
metadata:
5
  name: reviews
6
spec:
7
  hosts:
8
    - reviews
9
  http:
10
    - match:
11
        - headers:
12
            x-user-type:
13
              exact: premium
14
      route:
15
        - destination:
16
            host: reviews
17
            subset: v2
18
          weight: 100
19
    - route:
20
        - destination:
21
            host: reviews
22
            subset: v1
23
          weight: 90
24
        - destination:
25
            host: reviews
26
            subset: v2
27
          weight: 10

1
# 安装 Mininet
2
sudo apt install mininet
3

4
# 启动默认拓扑（1 交换机 + 2 主机）
5
sudo mn
6

7
# 启动自定义拓扑
8
sudo mn --topo tree,depth=2,fanout=3 --controller=remote,ip=127.0.0.1,port=6653
9

10
# Mininet 交互命令
11
# mininet> nodes          # 查看所有节点
12
# mininet> links          # 查看所有链路
13
# mininet> h1 ping h2     # 主机间 ping
14
# mininet> iperf h1 h2    # 测量带宽
15
# mininet> dump           # 导出节点信息

1
#!/usr/bin/env python3
2
"""Mininet CLOS 脊叶拓扑实验"""
3

4
from mininet.topo import Topo
5
from mininet.net import Mininet
6
from mininet.node import RemoteController
7
from mininet.cli import CLI
8

9

10
class CLOSTopo(Topo):
11
    """2 Spine + 4 Leaf 的 CLOS 拓扑"""
12

13
    def build(self):
14
        # 创建 Spine 交换机
15
        s1 = self.addSwitch('s1')  # Spine 1
16
        s2 = self.addSwitch('s2')  # Spine 2
17

18
        # 创建 Leaf 交换机和主机
19
        for i in range(1, 5):
20
            leaf = self.addSwitch(f'l{i}')
21
            # 每台 Leaf 下挂 2 台主机
22
            for j in range(1, 3):
23
                host = self.addHost(f'h{i}{j}',
24
                                    ip=f'10.0.{i}.{j}/24')
25
                self.addLink(host, leaf)
26
            # Leaf 与所有 Spine 全互联
27
            self.addLink(leaf, s1)
28
            self.addLink(leaf, s2)
29

30

31
if __name__ == '__main__':
32
    topo = CLOSTopo()
33
    net = Mininet(topo=topo,
34
                  controller=RemoteController('ryu', ip='127.0.0.1',
35
                                              port=6653))
36
    net.start()
37
    CLI(net)
38
    net.stop()

1
# 查看 OVS 网桥
2
ovs-vsctl show
3

4
# 查看交换机 s1 的流表（初始为空）
5
ovs-ofctl dump-flows s1
6

7
# 下发 L2 学习交换规则（将 s1 配置为学习交换机）
8
# 匹配所有包，泛洪到除入端口外的所有端口
9
ovs-ofctl add-flow s1 "priority=1,actions=flood"
10

11
# 更精细的规则：基于目的 MAC 转发
12
ovs-ofctl add-flow s1 "priority=10,dl_dst=00:00:00:00:00:01,actions=output:1"
13
ovs-ofctl add-flow s1 "priority=10,dl_dst=00:00:00:00:00:02,actions=output:2"
14

15
# 下发 L3 路由规则
16
ovs-ofctl add-flow l1 "priority=100,ip,nw_dst=10.0.1.0/24,actions=output:1"
17
ovs-ofctl add-flow l1 "priority=100,ip,nw_dst=10.0.2.0/24,actions=output:2"
18

19
# 查看流表统计（匹配计数）
20
ovs-ofctl dump-flows s1
21
# NXST_FLOW reply:
22
#  cookie=0x0, duration=10.5s, table=0, n_packets=42, n_bytes=3864,
23
#    priority=10,dl_dst=00:00:00:00:00:01 actions=output:1
24

25
# 删除流表规则
26
ovs-ofctl del-flows s1 "dl_dst=00:00:00:00:00:01"
27

28
# 清空所有流表
29
ovs-ofctl del-flows s1

1
#!/usr/bin/env python3
2
"""Ryu L2 学习交换机控制器"""
3

4
from ryu.base import app_manager
5
from ryu.controller import ofp_event
6
from ryu.controller.handler import MAIN_DISPATCHER, CONFIG_DISPATCHER
7
from ryu.controller.handler import set_ev_cls
8
from ryu.ofproto import ofproto_v1_3
9

10

11
class L2Switch(app_manager.RyuApp):
12
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
13

14
    def __init__(self, *args, **kwargs):
15
        super().__init__(*args, **kwargs)
16
        self.mac_to_port = {}  # {dpid: {mac: port}}
17

18
    @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
19
    def switch_features_handler(self, ev):
20
        """交换机连接时下发默认规则：未知包上送控制器"""
21
        datapath = ev.msg.datapath
22
        ofproto = datapath.ofproto
23
        parser = datapath.ofproto_parser
24

25
        match = parser.OFPMatch()
26
        actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
27
                                          ofproto.OFPCML_NO_BUFFER)]
28
        self.add_flow(datapath, 0, match, actions)
29

30
    def add_flow(self, datapath, priority, match, actions):
31
        """向交换机下发流表规则"""
32
        ofproto = datapath.ofproto
33
        parser = datapath.ofproto_parser
34
        inst = [parser.OFPInstructionActions(
35
            ofproto.OFPIT_APPLY_ACTIONS, actions)]
36
        mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
37
                                match=match, instructions=inst)
38
        datapath.send_msg(mod)
39

40
    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
41
    def packet_in_handler(self, ev):
42
        """处理上送的数据包：学习源 MAC，转发目的 MAC"""
43
        msg = ev.msg
44
        datapath = msg.datapath
45
        ofproto = datapath.ofproto
46
        parser = datapath.ofproto_parser
47
        dpid = datapath.id
48

49
        # 获取入端口
50
        in_port = msg.match['in_port']
51

52
        # 解析以太网头部
53
        pkt = msg.data
54
        dl_src = pkt[6:12].hex()   # 源 MAC
55
        dl_dst = pkt[0:6].hex()    # 目的 MAC
56

57
        # 学习源 MAC
58
        self.mac_to_port.setdefault(dpid, {})
59
        self.mac_to_port[dpid][dl_src] = in_port
60

61
        # 查找目的 MAC
62
        out_port = self.mac_to_port[dpid].get(dl_dst, ofproto.OFPP_FLOOD)
63

64
        # 下发精确匹配规则（后续同流量的包不再上送控制器）
65
        actions = [parser.OFPActionOutput(out_port)]
66
        if out_port != ofproto.OFPP_FLOOD:
67
            match = parser.OFPMatch(in_port=in_port, eth_dst=dl_dst)
68
            self.add_flow(datapath, 1, match, actions)
69

70
        # 发送当前数据包
71
        out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
72
                                  in_port=in_port, actions=actions)
73
        datapath.send_msg(out)

1
# 终端 1：启动 Ryu 控制器
2
ryu-manager l2_switch.py --ofp-tcp-listen-port 6653
3

4
# 终端 2：启动 Mininet 拓扑，连接 Ryu 控制器
5
sudo python3 clos_topo.py
6

7
# Mininet 终端内测试
8
# mininet> h11 ping h21
9
# mininet> h11 iperf -c h21
10

11
# 终端 3：观察流表变化
12
watch -n 1 'ovs-ofctl dump-flows s1 | tail -5'

1
# 查看交换机与控制器的连接状态
2
ovs-vsctl get-controller s1
3
# "tcp:127.0.0.1:6653"
4

5
# 查看流表匹配统计，定位流量是否按预期转发
6
ovs-ofctl dump-flows l1 --stats
7
# 注意 n_packets 和 n_bytes 字段
8

9
# 抓包分析 OpenFlow 消息
10
sudo tcpdump -i lo -w of.pcap tcp port 6653
11

12
# 查看交换机端口状态
13
ovs-ofctl show l1
14

15
# 模拟链路故障
16
ovs-ofctl mod-port l1 2 down    # 关闭端口
17
ovs-ofctl mod-port l1 2 up      # 恢复端口