实验6:开源控制器实践——RYU

实验6:开源控制器实践——RYU


一、基本要求

1. 搭建下图所示SDN拓扑,协议使用Open Flow 1.0,并连接Ryu控制器,通过Ryu的图形界面查看网络拓扑。

  • 建立拓扑并连接Ryu控制器,浏览器输入127.0.0.1:8080在Ryu的图形界面查看网络拓扑

2. 阅读Ryu文档的The First Application一节,运行当中的L2Switch,h1 ping h2或h3,在目标主机使用 tcpdump 验证L2Switch,分析L2Switch和POX的Hub模块有何不同。

  • L2Switch.py
from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import MAIN_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_0

class L2Switch(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION]

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

    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        msg = ev.msg
        dp = msg.datapath
        ofp = dp.ofproto
        ofp_parser = dp.ofproto_parser

        actions = [ofp_parser.OFPActionOutput(ofp.OFPP_FLOOD)]

        data = None
        if msg.buffer_id == ofp.OFP_NO_BUFFER:
             data = msg.data

        out = ofp_parser.OFPPacketOut(
            datapath=dp, buffer_id=msg.buffer_id, in_port=msg.in_port,
            actions=actions, data = data)
        dp.send_msg(out)
  • 运行L2Switch,h1 ping h2、h3, 在h2、h3分别使用tcpdump -nn -i h2-ethotcpdump -nn -i h3-etho验证L2Switch

  • 分析L2Switch和POX的Hub模块有何不同
    Hub和L2Switch模块都是洪泛转发,但L2Switch模块下发的流表无法查看,而Hub模块下发的流表可以查看


3. 编程修改L2Switch.py,另存为L2032002530.py,使之和POX的Hub模块的变得一致

  • L2032002530.py
from ryu.base import app_manager
from ryu.ofproto import ofproto_v1_3
from ryu.controller import ofp_event
from ryu.controller.handler import MAIN_DISPATCHER, CONFIG_DISPATCHER
from ryu.controller.handler import set_ev_cls


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

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

    @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
    def switch_feathers_handler(self, ev):
        datapath = ev.msg.datapath
        ofproto = datapath.ofproto
        ofp_parser = datapath.ofproto_parser

        # install flow table-miss flow entry
        match = ofp_parser.OFPMatch()
        actions = [ofp_parser.OFPActionOutput(ofproto.OFPP_CONTROLLER, ofproto.OFPCML_NO_BUFFER)]
        # 1\OUTPUT PORT, 2\BUFF IN SWITCH?
        self.add_flow(datapath, 0, match, actions)

    def add_flow(self, datapath, priority, match, actions):
        # 1\ datapath for the switch, 2\priority for flow entry, 3\match field, 4\action for packet
        ofproto = datapath.ofproto
        ofp_parser = datapath.ofproto_parser
        # install flow
        inst = [ofp_parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = ofp_parser.OFPFlowMod(datapath=datapath, priority=priority, match=match, instructions=inst)
        datapath.send_msg(mod)

    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        msg = ev.msg
        datapath = msg.datapath
        ofproto = datapath.ofproto
        ofp_parser = datapath.ofproto_parser
        in_port = msg.match['in_port']  # get in port of the packet

        # add a flow entry for the packet
        match = ofp_parser.OFPMatch()
        actions = [ofp_parser.OFPActionOutput(ofproto.OFPP_FLOOD)]
        self.add_flow(datapath, 1, match, actions)

        # to output the current packet. for install rules only output later packets
        out = ofp_parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id, in_port=in_port, actions=actions)
        # buffer id: locate the buffered packet
        datapath.send_msg(out)
  • 查看流表

二、进阶要求

1. 阅读Ryu关于simple_switch.py和simple_switch_1x.py的实现,以simple_switch_13.py为例,完成其代码的注释工作,并回答问题

  • simple_switch_13.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 packet
from ryu.lib.packet import ethernet
from ryu.lib.packet import ether_types


class SimpleSwitch13(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]	 # OpenFlow1.3版本

    def __init__(self, *args, **kwargs):
        super(SimpleSwitch13, self).__init__(*args, **kwargs)
        self.mac_to_port = {}	# 保存(交换机id, mac地址)到转发端口的字典

	# 处理SwitchFeatures事件
    @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

        # 安装 table-miss 流条目
        match = parser.OFPMatch()	# match指流表项匹配,OFPMatch()指不匹配任何信息
        actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER, ofproto.OFPCML_NO_BUFFER)]	# actions为相应动作,若匹配成功则不缓存数据包,同时将数据包发送给控制器
        self.add_flow(datapath, 0, match, actions)	# 通过add_flow添加流表项,add_flow调用了send_msg(mod)下发流表。

	# 增加流表项
    def add_flow(self, datapath, priority, match, actions, buffer_id=None):
        # 获取交换机信息
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser
        # 对action进行封装
        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        # 判断是否存在buffer_id,并生成mod对象
        if buffer_id:
            mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id, priority=priority, match=match, instructions=inst)
        else:
            mod = parser.OFPFlowMod(datapath=datapath, priority=priority, match=match, instructions=inst)
        # 下发流表
        datapath.send_msg(mod)
        
        
	# 控制器在MAIN_DISPATCHER状态并且触发Packet_In事件,调用_packet_in_handler函数
    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def _packet_in_handler(self, ev):
        # If you hit this you might want to increase
        # the "miss_send_length" of your switch
        if ev.msg.msg_len < ev.msg.total_len:		# 传输出错,打印debug信息
            self.logger.debug("packet truncated: only %s of %s bytes", ev.msg.msg_len, ev.msg.total_len)
        # 解析数据结构
        msg = ev.msg    # ev.msg指packet_in data structure对象
        datapath = msg.datapath
        # dp. ofproto 和 dp.ofproto_parser 为代表 Ryu 和交换机进行谈判的 OpenFlow 协议对象
        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 == ether_types.ETH_TYPE_LLDP:
            # 忽略LLDP类型的数据包
            return
        dst = eth.dst	# 目的端口
        src = eth.src	# 源端口

        dpid = format(datapath.id, "d").zfill(16)
        self.mac_to_port.setdefault(dpid, {})

        self.logger.info("packet in %s %s %s %s", dpid, src, dst, in_port)

        # 学习一个mac地址,下次避免FLOOD。
        self.mac_to_port[dpid][src] = in_port   # 交换机自学习,取来往数据包的交换机id、源mac和入端口绑定来构造表。

	# 查看是否已经学习过该目的mac地址
        if dst in self.mac_to_port[dpid]:	# 若在表中找到出端口信息,指示出端口
            out_port = self.mac_to_port[dpid][dst]
        # 否则,洪泛    
        else:
            out_port = ofproto.OFPP_FLOOD

        actions = [parser.OFPActionOutput(out_port)]

        # 安装一个流以避免下次packet_in
        if out_port != ofproto.OFPP_FLOOD:
            match = parser.OFPMatch(in_port=in_port, eth_dst=dst, eth_src=src)
            # 验证我们是否有一个有效的 buffer_id
            # 如果是,则避免同时发送 flow_mod 和 packet_out
            if msg.buffer_id != ofproto.OFP_NO_BUFFER:	# 如果有buffer_id,则带上buffer_id,然后只发送Flow_mod报文,因为交换机已经有缓存数据包,就不需要发送packet_out报文
                self.add_flow(datapath, 1, match, actions, msg.buffer_id)
                return
            else:
                self.add_flow(datapath, 1, match, actions)	# 若没有buffer_id,则发送的Flow_Mod报文就无需要带上buffer_id,但是下一步要再发送一个packet_out报文带上原数据包信息。
        data = None
        if msg.buffer_id == ofproto.OFP_NO_BUFFER:
            data = msg.data

	# 发送Packet_out数据包 带上交换机发来的数据包的信息
        out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id, in_port=in_port, actions=actions, data=data)
                                  
        # 发送流表                          
        datapath.send_msg(out)

a) 代码当中的mac_to_port的作用是什么?

保存 mac地址交换机端口 的映射

b) simple_switch和simple_switch_13在dpid的输出上有何不同?

simple_switch_13.py 中为 dpid = format(datapath.id,"d").zfill(16)
simple_switch.py 中为 dpid = datapath.id
可以看到simple_switch_13dpid的输出格式为:用0dpid前填充至总长度为16,而simple_switch直接输出dpid

c) 相比simple_switch,simple_switch_13增加的switch_feature_handler实现了什么功能?

switch_feature_handler实现了交换机以特性应答消息来响应特性请求的功能

d) simple_switch_13是如何实现流规则下发的?

在触发PacketIn事件后,首先解析相关数据结构,获取协议信息、获取源端口包学习交换机信息以太网信息等。如果以太网类型是LLDP类型,则忽略。如果不是LLDP类型,则获取目的端口源端口还有交换机id,然后进行交换机自学习,先学习源地址对应的交换机的入端口,再查看是否已经学习目的mac地址,如果没有就洪泛转发。如果学习过,则查看是否有buffer_id,如果有则在添加流时加上buffer_id,向交换机发送数据包和流表。

e) switch_features_handler和_packet_in_handler两个事件在发送流规则的优先级上有何不同?

switch_features_handler下发流表的优先级_packet_in_handler

2.编程实现和ODL实验的一样的硬超时功能

  • TimeOut.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 packet
from ryu.lib.packet import ethernet
from ryu.lib.packet import ether_types


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

    def __init__(self, *args, **kwargs):
        super(SimpleSwitch13, self).__init__(*args, **kwargs)
        self.mac_to_port = {}

    @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

        match = parser.OFPMatch()
        actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER, ofproto.OFPCML_NO_BUFFER)]
        self.add_flow(datapath, 0, match, actions)

    def add_flow(self, datapath, priority, match, actions, buffer_id=None, hard_timeout=0):
        ofproto = datapath.ofproto
        parser = datapath.ofproto_parser

        inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        if buffer_id:
            mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id, priority=priority, match=match, instructions=inst, hard_timeout=hard_timeout)
        else:
            mod = parser.OFPFlowMod(datapath=datapath, priority=priority, match=match, instructions=inst, hard_timeout=hard_timeout)
        datapath.send_msg(mod)

    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def _packet_in_handler(self, ev):
        if ev.msg.msg_len < ev.msg.total_len:
            self.logger.debug("packet truncated: only %s of %s bytes", ev.msg.msg_len, ev.msg.total_len)
        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 == ether_types.ETH_TYPE_LLDP:
            return
        dst = eth.dst
        src = eth.src

        dpid = format(datapath.id, "d").zfill(16)
        self.mac_to_port.setdefault(dpid, {})

        self.logger.info("packet in %s %s %s %s", dpid, src, dst, in_port)

        self.mac_to_port[dpid][src] = in_port

        if dst in self.mac_to_port[dpid]:
            out_port = self.mac_to_port[dpid][dst]
        else:
            out_port = ofproto.OFPP_FLOOD

        actions = [parser.OFPActionOutput(out_port)]\

        actions_timeout=[]

        if out_port != ofproto.OFPP_FLOOD:
            match = parser.OFPMatch(in_port=in_port, eth_dst=dst, eth_src=src)
            hard_timeout=10
            if msg.buffer_id != ofproto.OFP_NO_BUFFER:
                self.add_flow(datapath, 2, match,actions_timeout, msg.buffer_id,hard_timeout=10)
                self.add_flow(datapath, 1, match, actions, msg.buffer_id)
                return
            else:
                self.add_flow(datapath, 2, match, actions_timeout, hard_timeout=10)
                self.add_flow(datapath, 1, match, actions)
        data = None
        if msg.buffer_id == ofproto.OFP_NO_BUFFER:
            data = msg.data

        out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
                                  in_port=in_port, actions=actions, data=data)
        datapath.send_msg(out)
  • 实现硬超时

三、个人总结

1. 实验难度

本次的实验难度适中,跟着实验指导书一步一步做,基本上都能够较顺利的完成。

2. 实验过程遇到的困难及解决办法

一开始不知道如何利用Ryu的图形界面查看拓扑,在阅读Ryu相关文件后,才知道在本地浏览器输入"127.0.0.1:8080"即可访问Ryu的图形界面

3. 个人感想

本次实验的难度集中在了对代码的理解和编写上,只有真正理解了Ryu里面定义的数据结构以及一系列函数体后,才能够顺利的进行代码的修改与编写。通过本次实验,深入理解了RYU控制器实现软件定义的集线器原理以及RYU控制器实现软件定义的交换机原理。

Ryu的数据平面是由若干网元(Network Element)组成,每个网元包含一个或多个SDN数据路径(SDN Datapath)。SDN Datapath是逻辑上的网络设备,负责转发和处理数据无控制能力,一个SDN DataPath包含控制数据平面接口(Control Data Plane Interface,CDPI)、代理、转发引擎(Forwarding Engine)表和处理功能(Processing Function)SDN数据面(转发面)的关键技术:对数据面进行抽象建模。

OpenFlow交换器会接受来自于controller的指令并达到下列功能:

  • 对于接收到的封包进行修改或针对指定的端口进行转发。
  • 对于接收到的封包进行转发到Controller的动作(Packet-In)。
  • 对于接收到的来自Controller的封包转送到指定端口(Packet-out)。

利用Packet-in功能达到Mac地址的学习。Controller使用Packet-In接受来自交换机的封包后进行分析,得到连接端口相关的资料和所连接的host的Mac地址。学习之后,将封包的目的地址,在已经学习的host资料中进行检索,根据检索结果进行以下处理:

  • 如果是已经存在在记录中的host:使用packet-out功能转发到所对应的连接端口。
  • 如果是尚未存在记录的host:使用packet-out功能来达到Flooding。

在本次实验当中,也认识并验证了Ryu的L2Switch模块与POX的Hub模块之间的异同

posted @ 2022-10-17 23:01  Jf_Pan  阅读(172)  评论(0编辑  收藏  举报