Ryu

What's Ryu?

Ryu is a component-based software defined networking framework. Ryu provides software components with well defined API that make it easy for developers to create new network management and control applications. Ryu supports various protocols for managing network devices, such as OpenFlow, Netconf, OF-config, etc. About OpenFlow, Ryu supports fully 1.0, 1.2, 1.3, 1.4, 1.5 and Nicira Extensions. All of the code is freely available under the Apache 2.0 license.

Ryu means "flow" in Japanese. Ryu is pronounced "ree-yooh".

___________________________________________________

 

实战录 | 绝对干货！SDN controller Ryu答

目录 技术文章2016年7月8日

《实战录》导语

云端卫士的新栏目《实战录》将会定期分享一些我们的工程师伙伴们在产品研发的过程中总结的实践经验，希望对于热爱技术且关注安全领域的受众有所裨益。本期分享人为云端卫士安全能力工程师刘小龙，将带来SDN controller Ryu的分享。

 

什么是SDN

随着云计算、大数据等业务的兴起，对网络的改造需求越来越迫切，底层网络资源如何能更好的为上层业务及应用服务，做到资源的灵活调度和按需交付至关重要。那么，SDN这样新型的网络架构就应运而生。

SDN（Software Defined Networking，软件定义网络）是一种新型的基于软件的网络架构及技术，其最大的特点在于松耦合的控制平面和数据平面，支持集中化的网络状态控制，实现底层网络设施对上层应用的透明。它具有灵活的软件编程能力，使得网络的自动化管理和控制能力获得了空前的提升，能够有效的解决当前网络系统所面临的资源规模扩展有限、组网灵活性差、难以快速满足业务需求等问题。

SDN具有三大特性：集中控制、开放接口、网络虚拟化。在SDN架构中包含应用层、控制层、转发层。其中控制层尤为重要，SDN控制器由于人的大脑一样，进行总体管控。

什么是Ryu

在当今市场，SDN控制器五花八门，各种各样。不同的控制器有不同的优点和特性。其中Open daylight、ONOS、Floodlight、ryu等控制器比较典型，被业界广泛应用。

尤其是Ryu因其架构简单，部署方便，便于扩展得以广泛应用，尤其适用于中小型网络架构的流量调度和控制。

Ryu是日本NTT公司主导开发的开源项目，其字面意思是日语中“Flow”的意思。Ryu调度目标是提供一个拥有逻辑上集中控制能力的SDN操作系统，该系统具有设计完备的API接口，使网络应用者能够便捷的创建新的管理和控制应用。Ryu用python语言编写，完全遵守Apache许可证，能够支持v1.0、v1.2、v1.3等多个版本的openflow协议。

Ryu控制器中包含了大量的库函数和组件供SDN的应用的开发。其中库函数是Ryu针对SDN控制器需求抽取的一些共性功能。这些库函数可以在组件中被直接调用，而组件之间的关系是相互独立的。Ryu提供的库函数和组件如下图：

Netconf、OF-conf、Sflow等库函数主要实现对Openflow 交换机的控制功能。在几个重要的组件中，OF-wire主要实现对openflow不同协议版本的支持，Topology主要实现对拓扑图构建，已经链路状态的跟踪，OF REST主要提供REST API 共用户配置openflow 交换机。VRRP组件用于在openflow交换机上添加VRRP能力，有效的改善网络的可靠性。另外可以和openstack云计算平台整合，使用户可以按需调度和使用控制其网络。

Ryu架构

1 总体框架

Ryu SDN framework主要提供控制能力，通过北向接口的Rest API为SDN apps提供服务，供SDN apps调度和控制流量和网络。通过南向接口的Openflow等协议控制openflow交换机，完成流量交互。其中Ryu SDN framework起到了承上启下的作用，是那北向接口的控制和交换中枢。

下图是对上图的每层结构包含内容的细化。

2 框架细化

• SDN apps

该层大致分为三类，第一类是oprator，通过RESTful management进行对SDN frame work进行控制和管理。第二类是OpenStack cloud or chestration，通过REST API for Quantum进行和openstack结合，进行网络的管理和控制。第三类是User apps，通过User-defined API via REST or RPC进行对SDN framework的控制和管理。

• Ryu SDN framework

这一层是Ryu框架层，主要包含OF REST,topology, discovery,filewall等组件。主要用于SDN控制器的核心功能实现，包含流表下发，拓扑发现等功能。

• OpenFlow switch

这一层主要包含支持openflow协议的交换机，包含软件交换机和物理交换机，软件交换机包括ovs等。硬件交换机包括盛科SDN交换机等。

3 工作流程

上图是对Ryu工作过程的详细描述：

• RYU APPS 是上层APP应用，通过SERVICE_BRICK（python中字典结构）进行事件的分发和传递。

• SERVICE_BRICK是通过RYU APPS注册到其中的响应事件的回调函数进行事件的路由，分发任务。

• OFPHandler 是RyuAPP一个最基础的子类，该类主要完成hello handler，switch features handler，port state handler，echo handler等openflow协议的协商工作。

• OFPHandler会实例化一个OpenflowController一个对象，该对象有几个交换机相连就实例化几个Datapath对象，一个Datapath对应于一个Openflow switch。

• Datapath通过python高并发框架eventlet中的stream sever创建socket于openflow交换机进行通信。

环境搭建

1 环境拓扑

Ryu做为控制器，OVS做为交换机，Ryu控制器控制两个OVS交换机。

Ryu通过6653端口和OVS进行连接。

每个OVS连接了2个HOST。

2 OVS 部署

2.1 源码下载

Openvswitch包下载地址：http://openvswitch.org/download/

命令：wget http://openvswitch.org/releases/openvswitch-2.5.0.tar.gz

主要用来解压缩包，为安装提供先天条件。

命令行：tar -xvf openvswitch-2.5.0.tar.gz

2.2 解压安装

命令行：

cd openvswitch-2.5.0/

./configure –with-linux=/lib/modules/`uname -r`/build

make && make install

Insmod datapath/linux/openvswitch.ko

说明：

在insmod 内核模块的时候，可以提示insmod内核模块失败，失败的原因如下：

通过查看modinfo信息，可以知道openvswitch.ko

依赖nf_conntrack,nf_defrag_ipv6,libcrc32c,gre,nf_defrag_ipv4，需要把这些模块insmod后，才能insmod openvswitch.ko模块。

2.3 配置文件

OVS安装成功，如果要使用ovs，必须配置ovs的数据库文件。

命令：

mkdir -p /usr/local/etc/openvswitch

ovsdb-tool create

/usr/local/etc/openvswitch/conf.db

/usr/local/share/openvswitch/vswitch.ovsschema

2.4 启动数据库

命令行：

# ovsdb-server

–remote=punix:/usr/local/var/run/openvswitch/db.sock

–remote=db:Open_vSwitch,Open_vSwitch,manager_options

–private-key=db:Open_vSwitch,SSL,private_key

–certificate=db:Open_vSwitch,SSL,certificate

–bootstrap-ca-cert=db:Open_vSwitch,SSL,ca_cert –pidfile –detach

说明：

— remote=punix:/usr/local/var/run/openvswitch/db.sock

表示指定一个锁文件

— remote=db:Open_vSwitch,Open_vSwitch,manager_options

表示指定数据库类型和表

— private-key=db:Open_vSwitch,SSL,private_key

表示使用ssl进行安全连接

— certificate=db:Open_vSwitch,SSL,certificate

表示指定openssl的证书

— bootstrap-ca-cert=db:Open_vSwitch,SSL,ca_cert

表示指定ca证书

— pidfile

表示创建pid 文件

— detach

表示后台运行

通过ps命令查看是否启动成功：

2.5 数据库初始化

命令行：# ovs-vsctl –no-wait init

说明：

初始化一次就行

2.6 OVS deamon启动

命令行： # ovs-vswitchd –pidfile –detach

通过ps命令查看是否成功启动：

2.7 OVS创建网桥

OVS安装运行后，需要创建网桥，才能进行工作。

命令行：ovs-vsctl add-br br0

查看网桥信息：

3 docker 部署

3.1 安装docker

命令行：yum install docker

执行上述命令后，发现报如下错误：

然后执行如下命令：yum remove lvm2-7:2.02.105-14.el7.x86_64

接着再次执行：yum install docker

3.2 启动docker服务

命令行：

systemctl start docker.service

systemctl enable docker.service

3.3 下载镜像到本地

命令行： docker pull centos

3.4 创建docker

命令行： docker run -i -t centos /bin/bash

由于进入创建的docker下载的官方centos7镜像不包含ifconfig、netstat等工具，需要进行下载：

命令行：yum install net-tools.x86_64（在docker中执行）

可以通过保存这个镜像到本地。

3.5 修改本地镜像

命令行：docker commit -m “centos 添加net工具” c2beb728796d centos/net

3.6 网络设置

创建无网络类型的docker 0

命令行：docker run –net=none –privileged=true -i -t centos/net

为容器添加网卡eth0

命令行：ovs-docker add-port br0 eth0 851ea099e0c0

为eth0网卡配置IP

命令行： ifconfig eth0 172.16.1.1/24

创建无网络类型的docker 1

命令行：docker run –net=none –privileged=true -i -t centos/net

为容器添加网卡eth1

命令行：ovs-docker add-port br0 eth1 0c6ef7091e77

为eth1网卡配置IP

命令行： ifconfig eth1 172.16.1.2/24

测试docker 0和docker 1的连通性

查看ovs网桥的端口情况

命令行：ovs-vsctl show

Ens3网口加入网桥

命令行： ovs-vsctl add-port br0 ens3

配置网桥的IP和路由

命令行：

ifconfig ens3 0.0.0.0

ifconfig br0 192.168.6.240/24

route add -net 0.0.0.0/0 gw 192.168.6.1 dev br0

连接控制器Ryu

命令行： ovs-vsctl set-controller br0 tcp:192.168.6.246:6653

4 Ryu部署

4.1 源码下载

‍

命令行： git clone git://github.com/osrg/ryu.git

4.2 安装依赖包

命令行：

pip install python-eventlet

pip install python-routes

pip install python-webob

pip install python-paramiko

cd ryu

sudo pip install -r tools/pip-requires

4.3 安装Ryu

命令行：python setup.py install

运行app

通过运行app目录下的simple_switch.py，主要用于二层交换， 实现二层交换功能。

命令行：ryu-manager simple_switch.py –verbose

运行后，通过docker host1 可以ping通docker host2

原因是因为运行了二层交换功能的app，实现二层交换。

如果ryu运行不加载二层交换app，运行后，通过docker host1 不能ping同docker host2。

总结

Ryu的结构简洁，层次分明。由于时间问题，还没有进行更多场景的app测试和性能测试，有机会后面会有更详尽的补充。

通过上面的描述，可见可以通过Ryu搭建自己的SDN 控制器，通过编写自己的app来满足自己特定的需求。但是Ryu也有自己的缺点，主要表现在对集群不支持，没有支持多级流表等方面。

___________________________________________________

 

最近一直在进行RYU控制器的研究，其实也就是学习吧，从初学者慢慢做起，希望可以将基于RYU控制器将SDN/OpenFlow相关的开源控制器进行深入的研究，并且和大家分享一些有帮助的信息。

在ryu的安装一直遇到问题，ryu的安装分为Python的安装、RYU所需相关依赖包的安装、安装工具pip和Git的安装、RYU的安装

一、Python的安装

我的安装环境是Linux Ubuntu 12.04的版本上进行安装的，在Linux安装的时候已经安装了Python，我们需要进行Python版本的查看：python -V（此处V要大写），显示的版本信息如下：

RYU对Python的版本要求是2.7+，因此如果自己的版本不够的话，就需要进行升级了，安装后如果还是2.6版本的话，那么就需要手动修改了vim ~/.bashrc ：

注：此处借鉴文刀分享

然后就可以成功安装python了

二、RYU所需相关的依赖包的安装

所需的依赖包有python-eventlet、python-routes、python-webob以及python-paramiko，在ubuntu上的安装就可以用apt-get install命令：

apt-get install python-eventlet

apt-get install python-routes

apt-get install python-webob

apt-get install python-paramiko

然后就可以将相应的依赖包安装成功了。

三、pip、git的安装

apt-get install python-pip

apt-get install python-dev

apt-get install python-essential

安装完后，一定要对pip进行更新，因为我在没有更新pip之前，进行安装的RYU总是报错如下：

这个问题困扰好长时间，后来将pip进行更新，然后，重新启动系统，再进行安装，后来就成功了

更新的命令：pip install --upgrade pip或者pip install -U pip更新后，就可以进行下面的RYU的安装

四、RYU的安装

pip安装（推荐）：pip install ryu

apt-get安装（可选，我用这个安装一直没有成功）：

apt-get install git

git clone https：//github.com/osrg/ryu.git

cd ryu

python ./setup.py install

安装完后运行ryu-manager验证

这样就成功了。

运行命令：pip list会显示已经安装的软件以及相应的版本号。例如：

                 

_______________________________________________

RYU入门教程

李呈 • 14-10-13 •27262 人围观

 

1 前言

辗转了POX, NOX, OpenDaylight等多个控制器之后，我终于意识到我只喜欢python语言的控制器。但是我依然记得OpenDaylight的Nullpointer的Exception，还记得YANG文件的深奥，但是OpenDaylight让我对控制器开发的兴趣减少了，这不是我想要的事情。最后，我下决定转向RYU。我突然发现，生活突然变得很美好。我用着我熟悉的，喜欢的，优美的python，写着充满美感的语句，犹如写诗一般的惬意。

本篇主要介绍如何安装RYU，和如何在RYU上开发APP。

2 RYU的安装

安装RYU，需要安装一些python的套件：

• python-eventlet
• python-routes
• python-webob
• python-paramiko

安装RYU主要有两种方式：

• pip安装

Shell

pip install ryu

1	pip install ryu

• 下载源文件安装

Shell

git clone git://github.com/osrg/ryu.git cd ryu sudo pip install -r tools/pip-requires sudo python setup.py install

1 2 3 4

git clone git://github.com/osrg/ryu.git cd ryu sudo pip install -r tools/pip-requires sudo python setup.py install

若还有更多问题，可参考@linton小伙伴的博客

3 RYU使用

安装RYU之后，进入ryu目录，输入：

Shell

ryu-manager yourapp.py

1	ryu-manager yourapp.py

运行对应的APP，如

Shell

ryu-manager simple_switch.py

1	ryu-manager simple_switch.py

4 RYU源码分析

当我安装好了RYU之后，第一件事就是迫不及待地去看它的源码，其可读性之高，超出我的想象。
下面介绍ryu/ryu目录下的主要目录内容。

• base

base中有一个非常重要的文件：app_manager.py，其作用是RYU应用的管理中心。用于加载RYU应用程序，接受从APP发送过来的信息，同时也完成消息的路由。

其主要的函数有app注册、注销、查找、并定义了RYUAPP基类，定义了RYUAPP的基本属性。包含name, threads, events, event_handlers和observers等成员，以及对应的许多基本函数。如：start(), stop()等。

这个文件中还定义了AppManager基类，用于管理APP。定义了加载APP等函数。不过如果仅仅是开发APP的话，这个类可以不必关心。

• controller

controller文件夹中许多非常重要的文件，如events.py, ofp_handler.py, controller.py等。其中controller.py中定义了OpenFlowController基类。用于定义OpenFlow的控制器， 用于处理交换机和控制器的连接等事件，同时还可以产生事件和路由事件。其事件系统的定义，可以查看events.py和ofp_events.py。

在ofp_handler.py中定义了基本的handler（应该怎么称呼呢？句柄？处理函数？），完成了基本的如：握手，错误信息处理和keep alive 等功能。更多的如packet_in_handler应该在app中定义。

在dpset.py文件中，定义了交换机端的一些消息，如端口状态信息等，用于描述和操作交换机。如添加端口，删除端口等操作。

其他的文件不再赘述。

• lib

lib中定义了我们需要使用到的基本的数据结构，如dpid, mac和ip等数据结构。在lib/packet目录下，还定义了许多网络协议，如ICMP, DHCP, MPLS和IGMP等协议内容。而每一个数据包的类中都有parser和serialize两个函数。用于解析和序列化数据包。

lib目录下，还有ovs, netconf目录，对应的目录下有一些定义好的数据类型，不再赘述。

• ofproto

在这个目录下，基本分为两类文件，一类是协议的数据结构定义，另一类是协议解析，也即数据包处理函数文件。如ofproto_v1_0.py是 1.0版本的OpenFlow协议数据结构的定义，而ofproto_v1_0_parser.py则定义了1.0版本的协议编码和解码。具体内容不赘 述，实现功能与协议相同。

• topology

包含了switches.py等文件，基本定义了一套交换机的数据结构。event.py定义了交换上的事件。dumper.py定义了获取网络拓扑的内容。最后api.py向上提供了一套调用topology目录中定义函数的接口。

• contrib

这个文件夹主要存放的是开源社区贡献者的代码。我没看过。

• cmd

定义了RYU的命令系统，具体不赘述。

• services

完成了BGP和vrrp的实现。具体我还没有使用这个模块。

• tests

tests目录下存放了单元测试以及整合测试的代码，有兴趣的读者可以自行研究。

5 开发你自己的RYU应用程序

大概浏览了一下RYU的源代码，相信看过OpenDaylight的同学会发现，太轻松了！哈哈，我想我真的不喜欢maven, osgi, xml, yang以及java，但是不能不承认OpenDaylight还是很牛逼的，在学习的读者要坚持啊！

开发RYU的APP，真的再简单不过了。先来最简单的：

Python

from ryu.base import app_manager class L2Switch(app_manager.RyuApp): def __init__(self, *args, **kwargs): super(L2Switch, self).__init__(*args, **kwargs)

1 2 3 4 5

from ryu.base import app_manager   class L2Switch(app_manager.RyuApp):     def __init__(self, *args, **kwargs):         super(L2Switch, self).__init__(*args, **kwargs)

如果你觉得非常熟悉，不要怀疑，我确实是在拿官网的例子再讲。

首先，我们从ryu.base import app_manager，在前面我们也提到过这个文件中定义了RyuApp基类。我们在开发APP的时候只需要继承这个基类，就获得你想要的一个APP的一切了。于是，我们就不用去注册了？！是的，不需要了！

保存文件，可以取一个名字为L2Switch.py。

现在你可以运行你的APP了。快得有点不敢相信吧！但是目前什么都没有，运行之后，马上就会结束，但起码我们的代码没有报错。

运行:

Shell

ryu-manager L2Switch.py

1	ryu-manager L2Switch.py

继续往里面添加内容：

Python

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 class L2Switch(app_manager.RyuApp): 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 datapath = msg.datapath ofp = datapath.ofproto ofp_parser = datapath.ofproto_parser actions = [ofp_parser.OFPActionOutput(ofp.OFPP_FLOOD)] out = ofp_parser.OFPPacketOut( datapath=datapath, buffer_id=msg.buffer_id, in_port=msg.in_port, actions=actions) datapath.send_msg(out)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

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   class L2Switch(app_manager.RyuApp):     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         datapath = msg.datapath         ofp = datapath.ofproto         ofp_parser = datapath.ofproto_parser           actions = [ofp_parser.OFPActionOutput(ofp.OFPP_FLOOD)]         out = ofp_parser.OFPPacketOut(             datapath=datapath, buffer_id=msg.buffer_id, in_port=msg.in_port,             actions=actions)         datapath.send_msg(out)

其中ofp_event完成了事件的定义，从而我们可以在函数中注册handler，监听事件，并作出回应。

packet_in_handler方法用于处理packet_in事件。@set_ev_cls修饰符用于告知RYU，被修饰的函数应该被调用。（翻译得有点烂这句）

set_ev_cls第一个参数表示事件发生时应该调用的函数，第二个参数告诉交换机只有在交换机握手完成之后，才可以被调用。

下面分析具体的数据操作：

• ev.msg：每一个事件类ev中都有msg成员，用于携带触发事件的数据包。
• msg.datapath：已经格式化的msg其实就是一个packet_in报文，msg.datapath直接可以获得packet_in报文的datapath结构。datapath用于描述一个交换网桥。也是和控制器通信的实体单元。datapath.send_msg()函数用于发送数据到指定datapath。通过datapath.id可获得dpid数据，在后续的教程中会有使用。
• datapath.ofproto对象是一个OpenFlow协议数据结构的对象，成员包含OpenFlow协议的数据结构，如动作类型OFPP_FLOOD。
• datapath.ofp_parser则是一个按照OpenFlow解析的数据结构。
• actions是一个列表，用于存放action list，可在其中添加动作。
• 通过ofp_parser类，可以构造构造packet_out数据结构。括弧中填写对应字段的赋值即可。

如果datapath.send_msg()函数发送的是一个OpenFlow的数据结构，RYU将把这个数据发送到对应的datapath。

至此，一个简单的HUB已经完成。

6 RYU进阶——二层交换机

在以上的基础之上，继续修改就可以完成二层交换机的功能。具体代码如下：

Python

import struct import logging from ryu.base import app_manager from ryu.controller import mac_to_port 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 from ryu.lib.mac import haddr_to_bin from ryu.lib.packet import packet from ryu.lib.packet import ethernet class L2Switch(app_manager.RyuApp): OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION]#define the version of OpenFlow def __init__(self, *args, **kwargs): super(L2Switch, self).__init__(*args, **kwargs) self.mac_to_port = {} def add_flow(self, datapath, in_port, dst, actions): ofproto = datapath.ofproto match = datapath.ofproto_parser.OFPMatch( in_port = in_port, dl_dst = haddr_to_bin(dst)) mod = datapath.ofproto_parser.OFPFlowMod( datapath = datapath, match = match, cookie = 0, command = ofproto.OFPFC_ADD, idle_timeout = 10,hard_timeout = 30, priority = ofproto.OFP_DEFAULT_PRIORITY, flags =ofproto.OFPFF_SEND_FLOW_REM, actions = actions) 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 pkt = packet.Packet(msg.data) eth = pkt.get_protocol(ethernet.ethernet) dst = eth.dst src = eth.src dpid = datapath.id #get the dpid self.mac_to_port.setdefault(dpid, {}) self.logger.info("packet in %s %s %s %s", dpid, src, dst , msg.in_port) #To learn a mac address to avoid FLOOD next time. self.mac_to_port[dpid][src] = msg.in_port out_port = ofproto.OFPP_FLOOD #Look up the out_port if dst in self.mac_to_port[dpid]: out_port = self.mac_to_port[dpid][dst] ofp_parser = datapath.ofproto_parser actions = [ofp_parser.OFPActionOutput(out_port)] if out_port != ofproto.OFPP_FLOOD: self.add_flow(datapath, msg.in_port, dst, actions) #We always send the packet_out to handle the first packet. packet_out = ofp_parser.OFPPacketOut(datapath = datapath, buffer_id = msg.buffer_id, in_port = msg.in_port, actions = actions) datapath.send_msg(packet_out) #To show the message of ports' status. @set_ev_cls(ofp_event.EventOFPPortStatus, MAIN_DISPATCHER) def _port_status_handler(self, ev): msg = ev.msg reason = msg.reason port_no = msg.desc.port_no ofproto = msg.datapath.ofproto if reason == ofproto.OFPPR_ADD: self.logger.info("port added %s", port_no) elif reason == ofproto.OFPPR_DELETE: self.logger.info("port deleted %s", port_no) elif reason == ofproto.OFPPR_MODIFY: self.logger.info("port modified %s", port_no) else: self.logger.info("Illeagal port state %s %s", port_no, reason)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

import struct import logging   from ryu.base import app_manager from ryu.controller import mac_to_port 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 from ryu.lib.mac import haddr_to_bin from ryu.lib.packet import packet from ryu.lib.packet import ethernet   class L2Switch(app_manager.RyuApp):       OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION]#define the version of OpenFlow       def __init__(self, *args, **kwargs):         super(L2Switch, self).__init__(*args, **kwargs)         self.mac_to_port = {}       def add_flow(self, datapath, in_port, dst, actions):         ofproto = datapath.ofproto           match = datapath.ofproto_parser.OFPMatch(             in_port = in_port, dl_dst = haddr_to_bin(dst))           mod = datapath.ofproto_parser.OFPFlowMod(             datapath = datapath, match = match, cookie = 0,             command = ofproto.OFPFC_ADD, idle_timeout = 10,hard_timeout = 30,             priority = ofproto.OFP_DEFAULT_PRIORITY,             flags =ofproto.OFPFF_SEND_FLOW_REM, actions = actions)           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           pkt = packet.Packet(msg.data)         eth = pkt.get_protocol(ethernet.ethernet)           dst = eth.dst         src = eth.src           dpid = datapath.id    #get the dpid         self.mac_to_port.setdefault(dpid, {})           self.logger.info("packet in %s %s %s %s", dpid, src, dst , msg.in_port)         #To learn a mac address to avoid FLOOD next time.           self.mac_to_port[dpid][src] = msg.in_port             out_port = ofproto.OFPP_FLOOD           #Look up the out_port         if dst in self.mac_to_port[dpid]:             out_port = self.mac_to_port[dpid][dst]           ofp_parser = datapath.ofproto_parser           actions = [ofp_parser.OFPActionOutput(out_port)]           if out_port != ofproto.OFPP_FLOOD:             self.add_flow(datapath, msg.in_port, dst, actions)             #We always send the packet_out to handle the first packet.         packet_out = ofp_parser.OFPPacketOut(datapath = datapath, buffer_id = msg.buffer_id,             in_port = msg.in_port, actions = actions)         datapath.send_msg(packet_out)     #To show the message of ports' status.     @set_ev_cls(ofp_event.EventOFPPortStatus, MAIN_DISPATCHER)     def _port_status_handler(self, ev):         msg = ev.msg         reason = msg.reason         port_no = msg.desc.port_no           ofproto = msg.datapath.ofproto           if reason == ofproto.OFPPR_ADD:             self.logger.info("port added %s", port_no)         elif reason == ofproto.OFPPR_DELETE:             self.logger.info("port deleted %s", port_no)         elif reason == ofproto.OFPPR_MODIFY:             self.logger.info("port modified %s", port_no)         else:             self.logger.info("Illeagal port state %s %s", port_no, reason)

相信代码中的注释已经足以让读者理解这个程序。完成之后，运行:

Shell

ryu-manager L2Switch.py

1	ryu-manager L2Switch.py

然后可以使用Mininet进行pingall测试，成功！

7 后语

习惯性还是写一写总结。RYU的方便简洁大大超出我的预料，比我使用过的任何一个控制器都要易于使用和开发。这些是我学RYU一两天的收获，希望在后续的学习中还能有所收获，写出更好的博文。如果你有什么意见或建议可以评论，相互学习，共同进步。

最后提供一些有用的链接：
（1）http://osrg.github.io/ryu/resources.html
我比较喜欢里里面的 http://ryu.readthedocs.org/en/latest/
当然里面的电子书也是相当好的：http://osrg.github.io/ryu-book/en/html/
（2）推荐一个小伙伴的博客：linton.tw
他在RYU上有更多的学习和研究。欢迎访问！

 
 
 
转载自：李呈博客@李呈，http://www.muzixing.com/pages/2014/09/20/ryuru-men-jiao-cheng.html

 

• 本站声明：本站原创文章仅代表作者观点，不代表SDNLAB立场。转载须注明来自 SDNLAB并附上本文链接。
• 本文链接：http://www.sdnlab.com/1785.html
• 本文标签：技术/tech

 

 

 

________