通信网系列实验（一）——基于DFS算法的Ryu+Mininet应用

最新推荐文章于 2025-03-12 18:56:14 发布
最新推荐文章于 2025-03-12 18:56:14 发布
阅读量5.1k 收藏 66
点赞数 19
分类专栏： SDN 文章标签： Ryu Mininet SDN DFS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43734019/article/details/103480199
版权
本文介绍了如何在Mininet上使用Ryu控制器，通过DFS算法寻找并配置20节点网络的最短和最长路径。详细步骤包括网络搭建、Ryu与Mininet的连接、拓扑可视化、DFS算法实现以及路径配置和网络验证。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

利用DFS算法，实现Ryu应用，并在Mininet上完成相关验证

Ryu与Mininet相关安装与配置详见：

https://blog.csdn.net/haimianxiaojie/article/details/50705288

关于本文内所有完整代码详见：

https://github.com/PPPerry/Ryu_projects中的DFS部分

实现内容如下：

  1. 在Mininet上搭建一个20个节点网络（拓扑给定），每个网络节点下挂一个主机；
    在这里插入图片描述
    按照如图所示的拓扑，编写mininet的拓扑代码，各个交换机与主机的序号均相同。
    完整的拓扑代码如下：

    #!/usr/bin/python

from mininet.net import Mininet
from mininet.node import Controller, RemoteController, OVSController
from mininet.node import CPULimitedHost, Host, Node
from mininet.node import OVSKernelSwitch, UserSwitch
from mininet.node import IVSSwitch
from mininet.cli import CLI
from mininet.log import setLogLevel, info
from mininet.link import TCLink, Intf
from subprocess import call

def myNetwork():

    net = Mininet( topo=None,
                   controller=None,
                   ipBase='10.0.0.0/8')
    
    ## specify clearly to use a remote controller instead of the default one 
    c=RemoteController('c','0.0.0.0',6633)
    net.addController(c)

    info( '*** Add switches\n')
    s2 = net.addSwitch('s2', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s11 = net.addSwitch('s11', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s3 = net.addSwitch('s3', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s8 = net.addSwitch('s8', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s4 = net.addSwitch('s4', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s6 = net.addSwitch('s6', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s7 = net.addSwitch('s7', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s5 = net.addSwitch('s5', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s10 = net.addSwitch('s10', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s9 = net.addSwitch('s9', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s1 = net.addSwitch('s1', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s12 = net.addSwitch('s12', cls=OVSKernelSwitch,protocols=['OpenFlow13'])
    s13 = net.addSwitch('s13', cls=OVSKernelSwitch,protocols=['OpenFlow13'])

    info( '*** Add hosts\n')
    h3 = net.addHost('h3', cls=Host, ip='10.0.0.3', defaultRoute=None,mac='00:00:00:00:00:03')
    h10 = net.addHost('h10', cls=Host, ip='10.0.0.10', defaultRoute=None,mac='00:00:00:00:00:10')
    h2 = net.addHost('h2', cls=Host, ip='10.0.0.2', defaultRoute=None,mac='00:00:00:00:00:02')
    h5 = net.addHost('h5', cls=Host, ip='10.0.0.5', defaultRoute=None,mac='00:00:00:00:00:05')
    h1 = net.addHost('h1', cls=Host, ip='10.0.0.1', defaultRoute=None,mac='00:00:00:00:00:01')
    h11 = net.addHost('h11', cls=Host, ip='10.0.0.11', defaultRoute=None,mac='00:00:00:00:00:11')
    h6 = net.addHost('h6', cls=Host, ip='10.0.0.6', defaultRoute=None,mac='00:00:00:00:00:06')
    h4 = net.addHost('h4', cls=Host, ip='10.0.0.4', defaultRoute=None,mac='00:00:00:00:00:04')
    h7 = net.addHost('h7', cls=Host, ip='10.0.0.7', defaultRoute=None,mac='00:00:00:00:00:07')
    h13 = net.addHost('h13', cls=Host, ip='10.0.0.13', defaultRoute=None,mac='00:00:00:00:00:13')
    h9 = net.addHost('h9', cls=Host, ip='10.0.0.9', defaultRoute=None,mac='00:00:00:00:00:09')
    h12 = net.addHost('h12', cls=Host, ip='10.0.0.12', defaultRoute=None,mac='00:00:00:00:00:12')
    h8 = net.addHost('h8', cls=Host, ip='10.0.0.8', defaultRoute=None,mac='00:00:00:00:00:08')

    info( '*** Add links\n')
    net.addLink(h1, s1)
    net.addLink(h2, s2)
    net.addLink(h3, s3)
    net.addLink(h4, s4)
    net.addLink(h5, s5)
    net.addLink(h6, s6)
    net.addLink(h7, s7)
    net.addLink(h8, s8)
    net.addLink(h9, s9)
    net.addLink(h10, s10)
    net.addLink(h11, s11)
    net.addLink(h12, s12)
    net.addLink(h13, s13)
    net.addLink(s2, s1)
    net.addLink(s2, s3)
    net.addLink(s3, s4)
    net.addLink(s2, s5)
    net.addLink(s5, s7)
    net.addLink(s5, s6)
    net.addLink(s5, s8)
    net.addLink(s5, s9)
    net.addLink(s8, s9)
    net.addLink(s9, s11)
    net.addLink(s9, s10)
    net.addLink(s10, s11)
    net.addLink(s3, s10)
    net.addLink(s3, s13)
    net.addLink(s10, s13)
    net.addLink(s11, s12)
    net.addLink(s12, s13)

    ## start switch
    for i in range(1,7):
        net.get("s{}".format(i)).start([])

    info( '*** Starting network\n')
    net.start()

    #into the interactive mode
    CLI(net)
    net.stop()

if __name__ == '__main__':
    setLogLevel( 'info' )
    myNetwork()

    其中，控制器c被设置为RemoteController，方便下一步与Ryu进行连接。
    在这里插入图片描述

  2. 使用Ryu连接Mininet中的交换机；
    使用Ryu连接mininet后，结果如下：
    在这里插入图片描述

    Ryu读出了所有的交换机，并发现了34个连接。

  3. 并将拓扑读出来进行可视化展示；
    利用mininet自带的miniedit.py，我们可以直观的实现mininet的静态可视化，如图所示：
    在这里插入图片描述

  4. 在Ryu上实现深度优先遍历算法，并找出任意两个主机间的最短路和最长路；
    使用DFS可以找到任意两个交换机之间的所有路径，从而通过遍历，很容易找到任意两个主机（交换机）之间的最短路和最长路。
    实现DFS的递归算法如下：

    	def findpath(self,src_sw,dst_sw,sign,onepath,allpaths):
	       if src_sw==dst_sw:
	           #print(onepath)
	           allpaths.append(onepath.copy())
	           #print(allpaths)
	       else:
	           for u in self.switches:
	               if (self.get_adjacent(src_sw,u) is not None)and(sign[u]!=1):
	                       sign[u]=1
	                       onepath.append(u)
	                       
	                       self.findpath(u,dst_sw,sign,onepath,allpaths)
	                           
	                       onepath.remove(u)
	                       sign[u]=0

    返回值为一个二维列表，里面存储了从源交换机到目的交换机的所有路径（用队列存储）

  5. 使用最长路来配置任意两个主机间的通信连接
    再得到所有路径之后，通过遍历找到最长路和最短路并打印，再将最长路的路径存储到record中，进行下一步的路径配置

    	def shortest_path(self,src_sw,dst_sw,first_port,last_port):
	        self.logger.info("topo calculate the shortest path from ---{}-{}-------{}-{}".format(first_port,src_sw,dst_sw,last_port))
	        self.logger.debug("there is {} swithes".format(len(self.switches)))
	        
	        sign={}
	        for s in self.switches:
	            sign[s]=0
	        sign[src_sw]=1
	        
	        onepath=[]
	        onepath.append(src_sw)
	
	        allpaths=[]
	        self.findpath(src_sw,dst_sw,sign,onepath,allpaths)
	        #print(allpaths)
	        print("paths num is: {}".format(len(allpaths)))
	        print("all paths:")
	        sp=allpaths[0]
	        lp=allpaths[0]
	        for i in allpaths:
	            if(len(i)>len(lp)):
	                lp=i
	            if(len(i)<len(sp)):
	                sp=i
	            print(i)
	
	        print("the shortest path is: ")
	        print(sp)
	        print("the longest path is: ")
	        print(lp)
	
	
	        if src_sw==dst_sw:
	                path=[src_sw]
	        else:
	                path=lp
	            
	        record=[]
	        inport=first_port
	
	            # s1 s2; s2:s3, sn-1  sn
	        for s1,s2 in zip(path[:-1],path[1:]):
	                # s1--outport-->s2
	            outport,_=self.get_adjacent(s1,s2)
	                
	            record.append((s1,inport,outport))
	            inport,_=self.get_adjacent(s2,s1)
	            
	        record.append((dst_sw,inport,last_port))
	        
	        #we find a path
	        # (s1,inport,outport)->(s2,inport,outport)->...->(dest_switch,inport,outport)
	        return record

    返回值record为最长路（一维列表），传到路径配置中
    实现效果如图：
    以h1 ping -c 1 h9为例：（拓扑序号命名见前面的拓扑图）
    打印出h9到h1所有路径和最长路、最短路，并配置最长路：
    在这里插入图片描述

    以pingall为例：
    在这里插入图片描述
    在这里插入图片描述
    所有的交换机均ping通，无掉包，且均按最长路径配置
    输出所有的路径：
    在这里插入图片描述

  6. 将配置通的业务在可视化平台上进行展示
    利用networkx，将拓扑图与最长路径（配置的路径）进行可视化展示：
    以h1 ping -c 1 h9为例：（拓扑序号命名见前面的拓扑图）
    在这里插入图片描述
    图片样式是networkx随机生成的，但拓扑是不会变的，即从h1到h9的路径就如图中红色的路径所示。
    实现networkx的部分代码如下：

    #draw
def draw_graph(graph,path):

    # extract nodes from graph

    nodes = set([n1 for n1, n2 in graph] + [n2 for n1, n2 in graph])

    # create networkx graph

    G=nx.Graph()

    # add nodes

    for node in nodes:

        G.add_node(node)


    # add edges
    G.add_edges_from(graph,color='b')
    G.add_edges_from(path,color='r')

    #G.add_edges_from(new)


    # draw graph

    edges = G.edges()
    colors = [G[u][v]['color'] for u,v in edges]

    nx.draw(G,with_labels=True,edges=edges,edge_color=colors)

    # show graph

plt.show()
通信网系列实验（三）——基于Dijkstra算法的Ryu+Mininet应用
qq_43734019的博客
02-16 4589
在Ryu控制器中，使用Dijkstra算法（dial实现）计算任意两点间的最短路，并在Mininet上完成配通业务。 Ryu与Mininet相关安装与配置详见： https://blog.csdn.net/haimianxiaojie/article/details/50705288 关于本文内所有完整代码详见： https://github.com/PPPerry/Ryu_projects中的D...
RYU+mininet——mininet
qq_34415266的博客
05-08 4621
mininet基本操作 Mininet是一个网络仿真器，Mininet是一个网络仿真器，它在单个Linux内核上运行一组终端主机，交换机，路由器和链接。它使用轻量级虚拟化使单个系统看起来像一个完整的网络，运行相同的内核，系统和用户代码。 Mininet主机的行为就像真机一样;你可以ssh到它并运行任意程序。你运行的程序可以通过看似真正的以太网接口发送数据包，具有给定的链接速度和延迟。数据包会通过...
Mininet学习记录（常用命令+创建网络拓扑+OpenDaylight显示拓扑结构)
xiaosangtongxue的博客
12-02 9762
Mininet常用命令+创建拓扑的三种方式+OpenDaylight显示拓扑结构
RYU+mininet——RYU
qq_34415266的博客
06-18 1万+
1. 使用RYU做mininet的控制器 1.1 RYU介绍与安装 RYU是一款基于python的控制器，你可用Ryu实现各种想要实现的网络功能，它可以下发或接收流表进行各种路由运算。 建议使用高版本的Ubuntu系统安装ryu，否则会有各种错误，安装过程比较简单，如下： apt install gcc libffi-dev libssl-dev libxml2-dev libxslt1-...
Mininet 部署指南
最新发布
漫谈网络
03-12 1195
Mininet 是一个用于快速构建软件定义网络（SDN）实验环境的轻量级仿真工具。以下从 安装 和 卸载 两个方面提供完整操作说明，覆盖主流操作系统及常见问题解决方案。
控制器Ryu+Mininet完成集线器、自学习交换机、流量监控实例开发
weixin_42070473的博客
03-06 4804
一、Hub+Learning 1.案例分析 通过控制器来实现集线器算法（泛洪），然后指导数据平面实现集线器操作
通信网实验_最大流_Ryu_Mininet
weixin_45921043的博客
02-04 602
笔者的最大流实验指定使用Ford-Furkerson算法。（学院可能会改成使用P.R.算法，也有可能直接改题）该实验需要以https://www.bilibili.com/read/cv9546894为基础，在找增广路时可能需要用到https://www.bilibili.com/read/cv9606328 还是不贴代码了——把需要用到的算法塞进之前的project中，改一下SwitchEnter事件和PacketIn事件下的行为就vans了。 实验内容 1、利用网络中链路信息，使用F.F.算法求解两点间
【ryu+mininet】基于跳数和剩余带宽的最短路算法
诗鸩的博客
07-25 2160
利用mininet搭建网络拓扑，利用ryu控制器实现查找两点间跳数最少，在此条件下剩余带宽最大的路径，并将此路径通过流表规则下发到网络中的交换机上。
一篇文章搞懂 SDN中Minint和Ryu的安装及使用
if_Echo_else的博客
05-15 1673
SDN（Software Defined Network）软件定义网络。2006年，以斯坦福大学教授Nike Mckewn为首的团队提出了OpenFlow的概念，并基于OpenFlow技术实现网络的可编程能力（OpenFlow只是实现SDN的一个协议），是网络像软件一样灵活编程，SDN技术应运而生。SDN的定义SDN的定义是其字面意思，控制与转发分离，管理与控制分离只是满足SDN的一种手段，OpenFlow只是满足SDN的一种协议SDN的分类。
sdn mininet+ryu可视化配置教程及资源
03-29
通过Mininet，开发者可以便捷地部署、测试和实验SDN应用程序。 Ryu是Facebook贡献的一个开放源代码的SDN控制器，支持OpenFlow协议。它提供了丰富的API，使得开发者能够轻松地构建自己的SDN应用。Ryu的主要特点包括...
Mininet和Ryu实验.docx
12-18
4搭建SDN环境
SDN路由：在Mininet中使用Dijkstra算法在软件定义网络中进行链路状态路由的协议
02-05
软件定义网络中的链接状态路由 创建一个模拟软件定义的网络并运行成本最低的路径Dijkstra的算法。 内容 描述 该项目旨在在小型自助流量网络上使用OpenFlow模拟SDN LSRouting和数据传递。 TestNet-用于使用实现OpenFlow协议的交换机创建和测试软件定义的网络。 网络是使用自定义拓扑预设创建的，其中每个交换机到交换机的链路都分配有权重。 LSRouting-使用Dijkstra的成本最低的路径算法执行链路状态路由。 该算法的结果用于配置网络中每个交换机中的流表条目。 安装指南 克隆存储库，在VM上安装Python软件包，然后运行run.py脚本。 查看详细的。
Mininet实验 使用l2_multi模块寻找最短路径实验
weixin_34221775的博客
11-20 514
参考：使用l2_multi模块寻找最短路径实验 1. 实验目的 1、认识VND并且掌握其基本使用方法。 2、学会使用pox控制器的l2_multi模块寻找主机间的最短传输路径。 2. 实验原理 VND是一个基于web的图形用户界面，布局和用法有点类似于packet tracer，用户利用所提供的网络元件自主搭建拓扑，双击某个元件可以查看、编辑该元件的基本信息。拓扑搭建完成后，用户可以根据需要导出生...
【SDN Mininet Ryu 实验环境搭建】
m0_52710304的博客
08-18 801
SDN实验环境搭建
Mininet安装，简单实现一个网络拓扑结构
weixin_30514745的博客
04-03 260
安装mininet Mininet安装教程，可以按照这个来，然而这个虚拟机有时会很难装。可以考虑如下的做法：先 git clone，cd mininet 和 cat INSTALL之后，可以在提示信息中发现这样的安装方式，照做即可： 推荐学习：Mininet Walkthrough，这是官方文档，虽然是英文版，但非常得值的学习，可以慢慢地看，了解很多mininet的指令。 安装好mininet后...
SDN实验：使用mininet和RYU实现DDoS攻击与防御模拟
weixin_45236003的博客
09-01 5147
本文基于mininet平台模拟仿真SDN架构研究DDoS的攻击和防御，为真实网络监控提供一定的借鉴意义。利用sFlow来实时监控传输流量信息的变化，并在曲线图中绘制出来得到更加直观的结果。
通信网实验_DFS算法_Dijkstra算法_Mininet_Ryu
weixin_45921043的博客
02-02 1216
这两个project的实现需要广播，也就是需要以https://www.bilibili.com/read/cv9546894为基础。 为什么这两实验需要广播？因为要做链路层发现，洪泛的时候要用到MST。 https://zhidao.baidu.com/question/367633876776495564.html 之所以把DFS算法和Dijkstra算法放在一起讲，是因为这两个project实现起来都很简单 和找最x路有关，虽然很少用DFS算法来找最短路，但是project的内容就是这么强行让人搞。
Mininet创建网络拓扑
热门推荐
weixin_46490821的博客
10-14 1万+
一、Mininet创建网络拓扑常用参数 1). -c 释放之前创建拓扑时占用的未释放的资源 2). -h 产看帮助 3). --topo 在mininet启动时通过命令行定义拓扑 4). --custom 用于创建自定义拓扑 5). --switch 定义要使用的交换机，默认使用OVSK交换机 6). --controller 定义要使用的控制器，如果没有指定则使用mininet中默认的控制器 7). --mac 自动设置设备的MAC地址，从而使MAC地址更易读。 二、命令行创建网络拓扑 1、单一网络拓扑
RYU基于跳数的最短路径转发
qq_37041925的博客
12-05 4976
RYU控制器实现基于跳数的最短路径转发 from ryu.base import app_manager from ryu.ofproto import ofproto_v1_3, ofproto_v1_3_parser from ryu.controller.handler import set_ev_cls from ryu.controller.handler import CONFIG_D...
评论 25
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PPPerry_1

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值