Mininet ~ 负载平衡

Question

我必须使用 Mininet、Python、SDN，我的目标是完成一项简单的任务：创建一个网络，其中一些交换机随机连接（因此拓扑并不重要），每个交换机都连接一个主机。在网络中，我必须进行负载平衡，并且必须能够监视负载平衡是否正常工作。

这是一个项目，因此负载平衡必须很简单，并且必须是这样的：H1 想要 ping H2，并且从 H1 到 H2 正好有 2 条具有相同跳数的路径（例如 H1 连接，因此 S1 和H2 连接到 S2。然后 S1 连接到 S3 和 S4，它们也连接到 S2）。这两条路径是：H1-S1-S3-S2-H2和H1-S1-S4-S2-H2。我想以这样的方式进行负载平衡：如果 H1 发送 2 个 ping，则 1 会抛出第一个路径，第二个会抛出第二条路径。这样，当 H1 向 H2 发送一些流量时，流量的 50% 在第一条路径上传输，50% 在第二条路径上传输。

如何在一个非常简单的网络（如示例中的 4 个交换机）中实现类似的功能？我搜索了很多参考资料，但没有发现任何有用的东西。理论上我必须使用 NOX，但如果我必须使用 POX 来理解该主题，我会这样做;)

感谢所有愿意帮助我的人的建议:)

Answer 1

我知道您可以对交换机和控制器之间的连接进行负载平衡，但不确定交换机到交换机的路径。

显然，在openflow中，有一种组称为“选择组”。我认为根据分配给这些存储桶的重量，您可以分发数据包。存储桶在该组处理的流量中所占的份额由单个存储桶的权重除以该组中存储桶权重的总和来定义。不过我对此并不完全确定。

也有解决方法。您可以设置它，以便主机从其中一条路径接收数据包并从另一条路径发送数据包。

另一个技巧可能是根据数据包协议或其他因素分配负载。例如，您可以说从该路径发送所有 TCP 数据包，从不同路径发送所有 UDP 数据包。

Answer 2

这是一个简单的方法：

loadBalancingTopology.py:
from mininet.topo import Topo
from mininet.net import Mininet
from mininet.node import RemoteController
from mininet.link import TCLink

class LoadBalancingTopology(Topo):
    def build(self):
        s1 = self.addSwitch('s1')
        s2 = self.addSwitch('s2')

        h1 = self.addHost('h1')
        h2 = self.addHost('h2')
        h3 = self.addHost('h3')
        h4 = self.addHost('h4')

        self.addLink(h1, s1)
        self.addLink(h2, s1)
        self.addLink(h3, s2)
        self.addLink(h4,s2)

topo = LoadBalancingTopology()
net = Mininet(topo=topo, link=TCLink, controller=RemoteController)
net.start()

and the load_balancer_controller.py
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 ethernet

class LoadBalancerController(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
    
    def __init__(self, *args, **kwargs):
        super(LoadBalancerController, self).__init__(*args, **kwargs)
        self.datapaths = {}
        
    @set_ev_cls(ofp_event.EventOFPStateChange, [CONFIG_DISPATCHER, MAIN_DISPATCHER])
    def _state_change_handler(self, ev):
        datapath = ev.msg.datapath
        if ev.state == MAIN_DISPATCHER:
            self.datapaths[datapath.id] = datapath
            self.logger.info("Switch %s is connected", datapath.id)
            
    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):    
        msg = ev.msg
        datapath = msg.datapath
        ofproto = datapath.ofproto
        
        
        pkt = ethernet.ethernet(raw=msg.data)    
        eth_dst = pkt.dst
        eth_src = pkt.src
        
        if datapath.id == 1:
            out_port = ofproto.OFPP_PORT
        else:
            out_port = 1    
            
        actions = [datapath.ofproto_parser.OFPActionOutput(out_port)]
        data = None if msg.buffer_id ==  ofproto.OFP_NO_BUFFER else msg.data
        out = datapath.ofproto_parser.OFPPacketOut(
            datapath = datapath,
            buffer_id = msg.buffer_id,
            in_port=msg.match['in_port'],
            actions = actions,
            data = data
        )  
        datapath.senf_msg(out)