Our Open Source Software Defined Networking (SDN) Controller comparison continues with Ryu. Ryu is a very different proposition to the other options being put forward. Although boasting a core set of programs that are run as a ‘platform’, Ryu is better thought of as a toolbox, with which SDN controller functionality can be built.
Ryu is a component-based software defined networking framework. It provides software components with well defined API that make it easy for developers to create new network management and control applications. Ryu means “flow” in Japanese and is pronounced “ree-yooh”.
A Ryu SDN controller composes of these components:
- Southbound interfaces allow communication of SDN switches and controllers
- Its core supports limited applications (e.g. Topology discovery, Learning switch) and libraries
- External applications can deploy network policies to data planes via well-defined northbound APIs such as REST
Modularity and Extensibility
Ryu is structured differently from other solutions in that it provides simple supporting infrastructure that users of the platform must write code to utilise as desired. While this requires development expertise, it also allows complete flexibility of the SDN solution.
Ryu does not have an inherent clustering ability and requires external tools to share the network state and allow failover between cluster members.
- External tools such as Zookeeper distribute a desired state. Extra instances of the controller can be started independently as long as the backing configuration remains identical.
- While Ryu supports high availability via a Zookeeper component, it does not yet support a co-operative cluster of controllers.
- Southbound: It supports multiple southbound protocols for managing devices, such as OpenFlow, NETCONF, OF-Config, and partial support of P4
- Northbound: Offer RESTful APIs only, which are limited compared to ONOS and ODL
Ryu doesn’t provide any telemetry functionality. This needs to be provided via external tools.
Resilience and Fault Tolerance
Ryu has no inbuilt clustering mechanism, instead relying on external tools to maintain availability. High availability is achieved by running multiple, identically configured instances, or a single instance controlled by an external framework that detects and restarts failed nodes.
Fault tolerance can be provided by Zookeeper for monitoring the controllers in order to detect controller’s failure and sharding state between cluster members.
Ryu is written in Python.
An active community developing the framework, it is a well supported and targeted controller.