第36周：阶段项目——云网络简易 SDN 控制器

2026-05-27

字数统计: 3.7k字 | 阅读时长≈ 19分

第36周：阶段项目——云网络简易 SDN 控制器

目标：综合运用前 5 周知识，基于 OVS 和 OpenFlow 实现一个简易 SDN 控制器，自动化构建和管理多租户虚拟网络。

1. 项目架构

1.1 整体架构

                       ┌──────────────────┐
                       │   SDN 控制器     │
                       │   (Python)       │
                       │                  │
                       │  - 拓扑管理      │
                       │  - 租户管理      │
                       │  - 流表生成      │
                       │  - ARP 代答      │
                       │  - L2/L3 转发    │
                       └────────┬─────────┘
                                │ OpenFlow
                                │
     ┌──────────────────────────┼──────────────────────────┐
     │                          │                          │
┌────▼─────┐              ┌─────▼─────┐               ┌─────▼─────┐
│   OVS    │              │   OVS     │               │   OVS     │
│   Host A │              │  Host B   │               │  Host C   │
│          │              │           │               │           │
│  ┌────┐  │              │ ┌────┐    │               │ ┌────┐    │
│  │vx-1│  │              │ │vx-2│    │               │ │vx-3│    │
│  └─┬──┘  │              │ └─┬──┘    │               │ └─┬──┘    │
│  ┌─┴──┐  │              │ ┌─┴──┐    │               │ ┌─┴──┐    │
│  │VM-1│  │              │ │VM-2│    │               │ │VM-3│    │
│  └────┘  │              │ └────┘    │               │ └────┘    │
└──────────┘              └───────────┘               └───────────┘

租户 1: 10.0.1.0/24 (vxlan id 100)
租户 2: 10.0.2.0/24 (vxlan id 200)

1.2 关键功能

控制器功能：

1. 拓扑管理
   - 记录所有 OVS 节点
   - 维护网络拓扑
   - 自动发现链路

2. 租户网络管理
   - 创建/删除租户网络
   - 分配 VXLAN VNI
   - 分配子网

3. 流表自动生成
   - L2 转发（基于 MAC）
   - ARP 代答（避免广播）
   - L3 转发（基于目的 IP）
   - 隔离（不同租户不互通）

4. API 接口
   - RESTful API（控制平面）
   - Web UI（可选）
   - CLI（开发调试）

2. 项目结构

sdn_controller/
├── README.md
├── controller/
│   ├── sdn_controller.py    # 主控制器
│   ├── topology.py          # 拓扑管理
│   ├── tenant.py            # 租户管理
│   ├── flow_table.py        # 流表生成
│   ├── arp_handler.py       # ARP 代答
│   ├── api.py                # REST API
│   └── config.py            # 配置
├── topology/
│   ├── setup_topo.sh         # 拓扑搭建脚本
│   ├── create_tenant.sh     # 创建租户
│   └── teardown.sh          # 清理
├── docs/
│   ├── design.md
│   └── demo.md
└── requirements.txt

3. 拓扑搭建

3.1 setup_topo.sh

#!/bin/bash
# setup_topo.sh — 设置多主机 OVS + VXLAN 拓扑

set -e

# === 网络规划 ===
# Host A: 192.168.1.101, 网卡 eth0
# Host B: 192.168.1.102, 网卡 eth0
# Host C: 192.168.1.103, 网卡 eth0
# Underlay: 192.168.1.0/24

# 租户 1: 10.0.1.0/24, VNI=100
# 租户 2: 10.0.2.0/24, VNI=200

# === 在每台主机上运行 ===

# Host A 的 OVS 配置
HOST_IP="192.168.1.101"
PEERS=("192.168.1.102" "192.168.1.103")

# 1. 创建租户 1 bridge
sudo ovs-vsctl add-br br-tenant-1

# 添加本地 veth 给 VM
sudo ip link add veth-1 type veth peer name veth-1-ns
sudo ip netns add tenant-1
sudo ip link set veth-1-ns netns tenant-1
sudo ovs-vsctl add-port br-tenant-1 veth-1
sudo ip link set veth-1 up

# 配置 netns 内
sudo ip netns exec tenant-1 bash -c "
    ip addr add 10.0.1.10/24 dev veth-1-ns
    ip link set veth-1-ns up
    ip link set lo up
"

# 2. 添加 VXLAN 到所有对端
for peer in "${PEERS[@]}"; do
    sudo ovs-vsctl add-port br-tenant-1 "vxlan-1-$(echo $peer | tr . -)" \
        -- set interface "vxlan-1-$(echo $peer | tr . -)" \
        type=vxlan \
        options:remote_ip=$peer \
        options:key=100 \
        options:dstport=4789
done

# 3. 同样创建租户 2
sudo ovs-vsctl add-br br-tenant-2
sudo ip link add veth-2 type veth peer name veth-2-ns
sudo ip netns add tenant-2
sudo ip link set veth-2-ns netns tenant-2
sudo ovs-vsctl add-port br-tenant-2 veth-2
sudo ip link set veth-2 up

sudo ip netns exec tenant-2 bash -c "
    ip addr add 10.0.2.10/24 dev veth-2-ns
    ip link set veth-2-ns up
    ip link set lo up
"

for peer in "${PEERS[@]}"; do
    sudo ovs-vsctl add-port br-tenant-2 "vxlan-2-$(echo $peer | tr . -)" \
        -- set interface "vxlan-2-$(echo $peer | tr . -)" \
        type=vxlan \
        options:remote_ip=$peer \
        options:key=200 \
        options:dstport=4789
done

echo "Host A 配置完成"
ovs-vsctl show

3.2 在每台主机上运行

# 在 Host A 上：
HOST_IP="192.168.1.101" PEERS=("192.168.1.102" "192.168.1.103") ./setup_topo.sh

# 在 Host B 上：
HOST_IP="192.168.1.102" PEERS=("192.168.1.101" "192.168.1.103") ./setup_topo.sh

# 在 Host C 上：
HOST_IP="192.168.1.103" PEERS=("192.168.1.101" "192.168.1.102") ./setup_topo.sh

4. SDN 控制器

4.1 sdn_controller.py

#!/usr/bin/env python3
# sdn_controller.py — 基于 Ryu 的简易 SDN 控制器

import logging
import json
import threading
import time
from collections import defaultdict
from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_3
from ryu.lib.packet import packet, ethernet, arp, ipv4, icmp
from ryu.lib import hub

logger = logging.getLogger(__name__)


class SDNTenantNetwork:
    """租户网络"""
    def __init__(self, vni, subnet, gateway):
        self.vni = vni
        self.subnet = subnet
        self.gateway = gateway
        # MAC 学习表: (dpid, port) -> mac
        self.mac_table = defaultdict(dict)
        # ARP 表
        self.arp_table = {}  # IP -> MAC
        # 流表条目
        self.flow_entries = []


class SDNController(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

    def __init__(self, *args, **kwargs):
        super(SDNController, self).__init__(*args, **kwargs)

        # 租户网络
        self.tenant_networks = {}

        # 交换机连接：dpid -> datapath
        self.datapaths = {}

        # 主机拓扑
        self.hosts = {}  # (ip, mac) -> (dpid, port)

        # 链路
        self.links = {}  # (src_dpid, dst_dpid) -> src_port

        # 定期清理线程
        self.cleanup_thread = hub.spawn(self._cleanup_loop)

        # 注册默认租户
        self._register_default_tenants()

    def _register_default_tenants(self):
        """注册默认租户网络"""
        self.add_tenant_network(100, "10.0.1.0/24", "10.0.1.1")
        self.add_tenant_network(200, "10.0.2.0/24", "10.0.2.1")

    def add_tenant_network(self, vni, subnet, gateway):
        """添加租户网络"""
        tenant = SDNTenantNetwork(vni, subnet, gateway)
        self.tenant_networks[vni] = tenant
        logger.info(f"添加租户网络: VNI={vni}, subnet={subnet}")

    # === 交换机事件处理 ===

    @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
    def switch_features_handler(self, ev):
        """交换机连接"""
        datapath = ev.msg.datapath
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser
        dpid = datapath.id

        logger.info(f"交换机连接: dpid={dpid:016x}")
        self.datapaths[dpid] = datapath

        # 1. Table-miss 流：所有包转给控制器
        match = parser.OFPMatch()
        actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
                                          ofproto.OFPCML_NO_BUFFER)]
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
                                              actions)]
        mod = parser.OFPFlowMod(datapath=datapath, priority=0,
                                 match=match, instructions=inst)
        datapath.send_msg(mod)

        # 2. ARP 流：ARP 包转给控制器
        match = parser.OFPMatch(eth_type=0x0806)
        self.add_flow(datapath, 100, match, actions)

        # 3. 未知 IPv4 流：转给控制器
        match = parser.OFPMatch(eth_type=0x0800)
        self.add_flow(datapath, 50, match, actions)

    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        """包入事件处理"""
        msg = ev.msg
        datapath = msg.datapath
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser
        in_port = msg.match['in_port']

        pkt = packet.Packet(msg.data)
        eth = pkt.get_protocols(ethernet.ethernet)[0]

        # 根据包类型分发处理
        if eth.ethertype == 0x0806:  # ARP
            self._handle_arp(datapath, in_port, pkt)
        elif eth.ethertype == 0x0800:  # IPv4
            self._handle_ipv4(datapath, in_port, pkt, msg)
        else:
            # 未知类型泛洪
            self._flood(datapath, in_port, msg)

    def _handle_arp(self, datapath, in_port, pkt):
        """处理 ARP（实现 ARP 代答）"""
        arp_pkt = pkt.get_protocols(arp.arp)[0]
        parser = datapath.ofproto_parser
        ofproto = datapath.ofproto

        # ARP 请求：构造响应
        if arp_pkt.opcode == arp.ARP_REQUEST:
            src_ip = arp_pkt.src_ip
            dst_ip = arp_pkt.dst_ip
            src_mac = arp_pkt.src_mac

            logger.info(f"ARP 请求: {src_ip} -> {dst_ip}")

            # 学习源 IP/MAC
            self.hosts[(src_ip, src_mac)] = (datapath.id, in_port)

            # 如果是网关的 ARP（外部请求）
            for vni, tenant in self.tenant_networks.items():
                if dst_ip == tenant.gateway:
                    # 用网关的 MAC 响应
                    gateway_mac = self._get_gateway_mac(tenant)
                    if gateway_mac:
                        self._send_arp_reply(datapath, in_port,
                                              src_mac, src_ip,
                                              gateway_mac, dst_ip)

            # 主机询问其他主机的 ARP：泛洪
            self._flood(datapath, in_port, None)

    def _send_arp_reply(self, datapath, in_port, dst_mac, dst_ip,
                        src_mac, src_ip):
        """发送 ARP 应答"""
        pkt = packet.Packet()
        pkt.add_protocol(ethernet.ethernet(
            dst=dst_mac, src=src_mac, ethertype=0x0806))
        pkt.add_protocol(arp.arp(
            opcode=arp.ARP_REPLY,
            src_mac=src_mac, src_ip=src_ip,
            dst_mac=dst_mac, dst_ip=dst_ip))
        pkt.serialize()

        actions = [datapath.ofproto_parser.OFPActionOutput(in_port)]
        ofproto = datapath.ofproto

        out = datapath.ofproto_parser.OFPPacketOut(
            datapath=datapath, buffer_id=ofproto.OFP_NO_BUFFER,
            in_port=ofproto.OFPP_CONTROLLER, actions=actions, data=pkt.data)
        datapath.send_msg(out)

    def _handle_ipv4(self, datapath, in_port, pkt, msg):
        """处理 IPv4 数据包"""
        ipv4_pkt = pkt.get_protocols(ipv4.ipv4)[0]
        src_ip = ipv4_pkt.src
        dst_ip = ipv4_pkt.dst
        eth = pkt.get_protocols(ethernet.ethernet)[0]
        src_mac = eth.src

        # 学习主机位置
        self.hosts[(src_ip, src_mac)] = (datapath.id, in_port)

        # 查找目标主机的位置
        target = self._find_host_by_ip(dst_ip)
        if not target:
            # 未知目标，泛洪
            self._flood(datapath, in_port, msg)
            return

        target_dpid, target_port = target
        target_mac = self._find_mac_by_ip(dst_ip)

        # 下发流表（缓存转发）
        parser = datapath.ofproto_parser

        match = parser.OFPMatch(
            in_port=in_port,
            eth_type=0x0800,
            ipv4_src=src_ip,
            ipv4_dst=dst_ip
        )
        actions = [
            parser.OFPActionSetEthDst(target_mac),
            parser.OFPActionOutput(target_port)
        ]
        inst = [parser.OFPInstructionActions(parser.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(
            datapath=datapath, priority=200,
            match=match, instructions=inst, idle_timeout=60)
        datapath.send_msg(mod)

        # 立即发送当前包
        data = msg.data
        actions = [parser.OFPActionOutput(target_port)]
        out = parser.OFPPacketOut(
            datapath=datapath, buffer_id=msg.buffer_id,
            in_port=in_port, actions=actions, data=data)
        datapath.send_msg(out)

    def _flood(self, datapath, in_port, msg):
        """泛洪"""
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        actions = [parser.OFPActionOutput(ofproto.OFPP_FLOOD)]
        data = msg.data if msg and msg.buffer_id == ofproto.OFP_NO_BUFFER else None

        out = parser.OFPPacketOut(
            datapath=datapath, buffer_id=msg.buffer_id if msg else ofproto.OFP_NO_BUFFER,
            in_port=in_port, actions=actions, data=data)
        datapath.send_msg(out)

    def add_flow(self, datapath, priority, match, actions, idle_timeout=0):
        """下发流表"""
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = parser.OFPFlowMod(
            datapath=datapath, priority=priority,
            match=match, instructions=inst, idle_timeout=idle_timeout)
        datapath.send_msg(mod)

    def _find_host_by_ip(self, ip):
        """根据 IP 查找主机位置"""
        for (host_ip, mac), loc in self.hosts.items():
            if host_ip == ip:
                return loc
        return None

    def _find_mac_by_ip(self, ip):
        """根据 IP 查找 MAC"""
        for (host_ip, mac) in self.hosts.keys():
            if host_ip == ip:
                return mac
        return None

    def _get_gateway_mac(self, tenant):
        """获取租户网关的 MAC"""
        # 简化为固定 MAC
        return "00:00:00:00:00:01"

    def _cleanup_loop(self):
        """定期清理过期的流表"""
        while True:
            hub.sleep(60)
            # 流表超时由 OpenFlow 自身处理（idle_timeout）
            self.hosts.clear()  # 简化清理


# === REST API ===
from ryu.app.wsgi import ControllerBase, WSGIApplication
from webob import Response


class SDNControllerREST(ControllerBase):
    def __init__(self, req, link, data, **config):
        super(SDNControllerREST, self).__init__(req, link, data, **config)
        self.sdn = data['sdn']

    @staticmethod
    def add_router(app, sdn_instance):
        # 实际路由注册（省略）
        pass


# === CLI 接口 ===
class SDNControllerCLI:
    def __init__(self, controller):
        self.controller = controller

    def list_tenants(self):
        """列出所有租户"""
        return [{
            'vni': vni,
            'subnet': t.subnet,
            'gateway': t.gateway,
            'hosts': len(self.controller.hosts)
        } for vni, t in self.controller.tenant_networks.items()]

    def add_tenant(self, vni, subnet, gateway):
        self.controller.add_tenant_network(vni, subnet, gateway)
        return {'status': 'ok'}

    def list_hosts(self):
        return [{
            'ip': h[0], 'mac': h[1], 'dpid': dpid, 'port': port
        } for h, (dpid, port) in self.controller.hosts.items()]


if __name__ == '__main__':
    print("通过 ryu-manager 启动此控制器")
    print("ryu-manager sdn_controller.py --verbose")

4.2 requirements.txt

1
2
3

ryu==4.34
eventlet==0.33.0
webob==1.8.7

5. 启动与运行

5.1 启动控制器

# 安装依赖
pip install -r requirements.txt

# 启动控制器
ryu-manager sdn_controller.py --verbose

# 指定 OpenFlow 版本
ryu-manager --ofp-listen-host 0.0.0.0 --ofp-tcp-listen-port 6653 \
    sdn_controller.py --verbose

5.2 配置 OVS 连接控制器

# 在每台 OVS 主机上
sudo ovs-vsctl set-controller br-tenant-1 tcp:<controller_ip>:6653
sudo ovs-vsctl set-controller br-tenant-2 tcp:<controller_ip>:6653

# 验证连接
sudo ovs-vsctl show
# 应能看到 controller 配置

# 查看控制器状态
sudo ovs-vsctl list controller

5.3 测试

# === 测试 1：同租户互通 ===

# 在 Host A 的租户 1 VM 中
ip netns exec tenant-1 ping 10.0.1.20

# 在 Host B 的租户 1 VM 中
ip netns exec tenant-1 ping 10.0.1.10

# === 测试 2：不同租户隔离 ===

# 租户 1 VM ping 租户 2 VM（应该失败）
ip netns exec tenant-1 ping 10.0.2.20

# === 测试 3：ARP 代答 ===

# 观察控制器日志
ryu-manager sdn_controller.py --verbose | grep -E "ARP|host"

6. API 扩展

6.1 REST API

# api.py — 简易 REST API
from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route('/api/tenants', methods=['GET'])
def list_tenants():
    """列出所有租户"""
    return jsonify(controller.list_tenants())

@app.route('/api/tenants', methods=['POST'])
def add_tenant():
    """添加租户"""
    data = request.json
    vni = data['vni']
    subnet = data['subnet']
    gateway = data['gateway']
    return jsonify(controller.add_tenant(vni, subnet, gateway))

@app.route('/api/hosts', methods=['GET'])
def list_hosts():
    """列出所有学习到的主机"""
    return jsonify(controller.list_hosts())

@app.route('/api/topology', methods=['GET'])
def get_topology():
    """获取网络拓扑"""
    return jsonify({
        'switches': list(controller.datapaths.keys()),
        'hosts': list(controller.hosts.keys()),
        'links': list(controller.links.keys())
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

6.2 CLI 工具

# cli.py — 简单的 CLI 工具
import cmd
import json
import requests

class SDNCLI(cmd.Cmd):
    intro = 'SDN 控制器 CLI. 输入 help 或 ? 查看命令.\n'
    prompt = '(sdn) '

    def __init__(self, api_url='http://localhost:8080/api'):
        super().__init__()
        self.api_url = api_url

    def do_tenants(self, line):
        """列出所有租户：tenants"""
        r = requests.get(f'{self.api_url}/tenants')
        print(json.dumps(r.json(), indent=2))

    def do_add_tenant(self, line):
        """添加租户：add_tenant <vni> <subnet> <gateway>"""
        args = line.split()
        if len(args) != 3:
            print("用法: add_tenant <vni> <subnet> <gateway>")
            return
        data = {
            'vni': int(args[0]),
            'subnet': args[1],
            'gateway': args[2]
        }
        r = requests.post(f'{self.api_url}/tenants', json=data)
        print(r.json())

    def do_hosts(self, line):
        """列出学习到的主机：hosts"""
        r = requests.get(f'{self.api_url}/hosts')
        print(json.dumps(r.json(), indent=2))

    def do_topology(self, line):
        """查看网络拓扑：topology"""
        r = requests.get(f'{self.api_url}/topology')
        print(json.dumps(r.json(), indent=2))


if __name__ == '__main__':
    SDNCLI().cmdloop()

7. 高级特性

7.1 拓扑自动发现（LLDP）

# topology.py — LLDP 发现
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def lldp_packet_in(self, ev):
    """处理 LLDP 包"""
    pkt = packet.Packet(ev.msg.data)
    if pkt.get_protocols(lldp.lldp):
        # 处理 LLDP 帧
        # 记录链路信息
        pass

7.2 OpenFlow QoS

# QoS：限速
@set_ev_cls(...)
def install_qos(self, ev):
    """限速到 1Mbps"""
    ofproto = ev.msg.datapath.ofproto
    parser = ev.msg.datapath.ofproto_parser

    # 创建 meter
    meter_mod = parser.OFPMeterMod(
        datapath=ev.msg.datapath,
        command=ofproto.OFPMC_ADD,
        meters=[
            parser.OFPMeterBandRate(
                rate=1000,  # 1 Mbps
                burst_size=100
            )
        ],
        meter_id=1
    )
    ev.msg.datapath.send_msg(meter_mod)

7.3 监控与遥测

# 端口统计
@set_ev_cls(ofp_event.EventOFPPortStatsReply, MAIN_DISPATCHER)
def port_stats_reply_handler(self, ev):
    """端口统计"""
    for stat in ev.msg.body:
        logger.info(f"port={stat.port_no} "
                    f"rx_packets={stat.rx_packets} "
                    f"tx_packets={stat.tx_packets} "
                    f"rx_bytes={stat.rx_bytes}")

8. 主流 SDN 控制器

Ryu（推荐入门）：
  - Python 编写
  - 简单易学
  - REST API 友好
  - OpenFlow 1.0-1.5 支持

ONOS：
  - 运营商级 SDN 控制器
  - Java
  - 高可用

OpenDaylight：
  - 企业级
  - Java/Scala
  - 功能丰富

Faucet：
  - Python（基于 Ryu）
  - 简单、模块化
  - 数据中心 L2/L3

Tungsten Fabric：
  - 完整 SDN 平台
  - 支持 BGP/EVPN/VXLAN
  - 适合云网络

9. 测试用例

#!/bin/bash
# test_sdn.sh — SDN 控制器测试

set -e

echo "=== Test 1: 控制器连接 ==="
sudo ovs-vsctl set-controller br-tenant-1 tcp:127.0.0.1:6653
sleep 2
ovs-vsctl list controller

echo "=== Test 2: 同租户互通 ==="
ip netns exec tenant-1 ping -c 2 10.0.1.20

echo "=== Test 3: 不同租户隔离 ==="
# 应该失败
ip netns exec tenant-1 ping -c 2 10.0.2.20

echo "=== Test 4: ARP 代答 ==="
# 抓包观察 ARP
tcpdump -i veth-1 -nn arp &
ARPDUMP_PID=$!
sleep 1
ip netns exec tenant-1 arping -c 1 10.0.1.1
sleep 1
kill $ARPDUMP_PID

echo "=== Test 5: 流表查看 ==="
sudo ovs-ofctl dump-flows br-tenant-1

10. 性能优化

# === 优化 1：批量流表下发 ===

# 一次下发多个流表
def add_flows_batch(self, datapath, flows):
    for flow in flows:
        self.add_flow(datapath, **flow)

# === 优化 2：使用 GotoTable 减少控制器负担 ===

# 主表：基础匹配
# 二级表：详细处理

# === 优化 3：Meter 限速 ===

# 限制每个 VM 的带宽
meter_id = 1
mod = parser.OFPMeterMod(
    datapath=dp,
    command=ofproto.OFPMC_ADD,
    meters=[
        parser.OFPMeterBandRate(rate=1000, burst_size=100)
    ],
    meter_id=meter_id
)
dp.send_msg(mod)

# 应用到流
mod = parser.OFPFlowMod(
    ...,
    instructions=[
        parser.OFPInstructionActions(
            parser.OFPIT_APPLY_ACTIONS,
            [parser.OFPActionOutput(ofproto.OFPP_NORMAL)]
        ),
        parser.OFPInstructionMeter(meter_id)
    ]
)

11. 项目交付物

完整的项目结构：

sdn_controller/
├── README.md
├── controller/
│   ├── sdn_controller.py      # 主控制器
│   ├── topology.py            # 拓扑管理
│   ├── flow_manager.py        # 流表管理
│   ├── arp_handler.py         # ARP 代答
│   └── api.py                 # REST API
├── topology/
│   ├── setup_topo.sh          # 拓扑搭建
│   ├── cleanup.sh             # 清理
│   └── teardown.sh
├── tests/
│   ├── test_connectivity.sh   # 互通测试
│   ├── test_isolation.sh      # 隔离测试
│   └── test_perf.sh           # 性能测试
├── docs/
│   ├── design.md              # 设计文档
│   ├── demo.md                # 演示文档
│   └── perf_report.md         # 性能报告
├── config/
│   ├── sdn.yaml                # 配置文件
│   └── tenants.yaml            # 租户定义
├── cli/
│   └── sdn_cli.py              # CLI 工具
└── requirements.txt

演示流程：
  1. 启动控制器
  2. 搭建拓扑（3 主机 + 2 租户）
  3. OVS 连接控制器
  4. 启动 VM/容器
  5. 演示同租户互通
  6. 演示不同租户隔离
  7. 查看控制器学习的主机表
  8. 演示动态添加租户

12. 学习路径总结

通过整个阶段（第 31-36 周），你已掌握：

✅ Linux 网络虚拟化（netns、veth、bridge、macvlan）
✅ 隧道协议（VXLAN、GENEVE、GRE）
✅ Open vSwitch（OVS）和 OpenFlow
✅ P4 可编程数据平面
✅ SmartNIC、SR-IOV、Virtio
✅ RDMA/RoCE 基础

接下来可以：
  - 学习 Kubernetes CNI 实现（Cilium、Calico）
  - 深入研究 5G 网络与电信云
  - 探索 SD-WAN 技术
  - 研究 eBPF/XDP 在云网络的应用
  - 实际部署 Tungsten Fabric / OVN

本文作者： CoderSong
本文链接： https://jack-song-gif.github.io/2026/05/27/第36周：阶段项目——云网络简易 SDN 控制器/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！