290  SDN Controller Comparison

290.1 Learning Objectives

By the end of this chapter, you will be able to:

  • Compare Major Controllers: Evaluate OpenDaylight, ONOS, Ryu, and Floodlight for different IoT deployment scenarios
  • Assess Performance Metrics: Understand throughput (flows/sec), scalability (devices), and latency characteristics
  • Match Controllers to Requirements: Select appropriate controllers based on scale, language preference, and feature needs
  • Plan Controller Deployment: Determine resource requirements and learning curve for each controller

290.2 Prerequisites

Before diving into this chapter, you should be familiar with:

Think of SDN controllers like car manufacturers - each optimizes for different priorities.

Just as Toyota focuses on reliability, Tesla on innovation, and Ferrari on performance, SDN controllers have different design philosophies:

Controller โ€œCarโ€ Equivalent Optimized For
OpenDaylight Swiss Army Knife Maximum features, enterprise complexity
ONOS Heavy-duty truck Carrier-scale, high availability
Ryu Go-kart Learning, prototyping, simplicity
Floodlight Sports car Raw performance, speed

Which one should you learn first?

  • Students/Researchers: Start with Ryu (Python, simple, great tutorials)
  • Enterprise IT: Learn OpenDaylight (comprehensive, industry standard)
  • Telecom/Smart City: Focus on ONOS (scales to 10K+ devices)
  • Performance-critical: Consider Floodlight (fast packet processing)

The good news: All controllers speak OpenFlow, so concepts transfer between them. Learning one makes the others easier to understand.

Deep Dives: - SDN Controller Basics (Overview) - Index of all SDN controller topics - SDN Controller Architecture - Internal components and message flow - SDN APIs and Clustering - Northbound/southbound APIs and high availability

Protocols: - SDN Fundamentals and OpenFlow - OpenFlow protocol basics - Software Defined Networking - SDN overview

Learning: - Simulations Hub - SDN simulation tools - Network Design and Simulation - SDN testing

290.3 Controller Comparison Overview

Time: ~18 min | Difficulty: Intermediate | Unit: P04.C27.U02

Different controllers excel in different scenarios. Here is a comprehensive comparison of the four major open-source SDN controllers.

%% fig-cap: "SDN Controller Comparison Matrix showing OpenDaylight, ONOS, Ryu, and Floodlight evaluated across six dimensions: Performance, Scalability, Features, Complexity, Language, and HA Support"
%% fig-alt: "Comparison matrix with four SDN controllers (OpenDaylight, ONOS, Ryu, Floodlight) shown as columns and six evaluation criteria as rows. Each cell contains ratings and key metrics. Performance: ONOS highest at 1M flows/sec, Ryu lowest at 50K. Scalability: ONOS best for 10K+ devices. Features: OpenDaylight most comprehensive. Complexity: Ryu simplest for learning. Languages: Java for ODL/ONOS/Floodlight, Python for Ryu. HA: ONOS has best clustering support."

%%{init: {'theme': 'base', 'themeVariables': { 'primaryColor': '#2C3E50', 'primaryTextColor': '#fff', 'primaryBorderColor': '#16A085', 'lineColor': '#16A085', 'secondaryColor': '#E67E22', 'tertiaryColor': '#7F8C8D'}}}%%

graph TB
    subgraph Controllers["SDN Controller Comparison"]
        ODL["OpenDaylight (ODL)"]
        ONOS["ONOS"]
        Ryu["Ryu"]
        Flood["Floodlight"]
    end

    subgraph Performance["Performance (flows/sec)"]
        ODL_P["ODL: 200K-500K"]
        ONOS_P["ONOS: 1M+"]
        Ryu_P["Ryu: 50K-100K"]
        Flood_P["Flood: 300K-600K"]
    end

    subgraph Scalability["Scalability (devices)"]
        ODL_S["ODL: 1K-5K optimal"]
        ONOS_S["ONOS: 10K+ devices"]
        Ryu_S["Ryu: <1K devices"]
        Flood_S["Flood: 1K-3K devices"]
    end

    subgraph Features["Feature Richness"]
        ODL_F["ODL: Comprehensive"]
        ONOS_F["ONOS: Carrier-grade"]
        Ryu_F["Ryu: Minimal"]
        Flood_F["Flood: Moderate"]
    end

    subgraph Language["Implementation"]
        ODL_L["ODL: Java/OSGi"]
        ONOS_L["ONOS: Java"]
        Ryu_L["Ryu: Python"]
        Flood_L["Flood: Java"]
    end

    subgraph HA["High Availability"]
        ODL_H["ODL: Clustering"]
        ONOS_H["ONOS: Built-in"]
        Ryu_H["Ryu: Manual"]
        Flood_H["Flood: Limited"]
    end

    subgraph UseCase["Best For"]
        ODL_U["ODL: Enterprise"]
        ONOS_U["ONOS: Telecom/IoT"]
        Ryu_U["Ryu: Education"]
        Flood_U["Flood: Performance"]
    end

    ODL --> ODL_P
    ODL --> ODL_S
    ODL --> ODL_F
    ODL --> ODL_L
    ODL --> ODL_H
    ODL --> ODL_U

    ONOS --> ONOS_P
    ONOS --> ONOS_S
    ONOS --> ONOS_F
    ONOS --> ONOS_L
    ONOS --> ONOS_H
    ONOS --> ONOS_U

    Ryu --> Ryu_P
    Ryu --> Ryu_S
    Ryu --> Ryu_F
    Ryu --> Ryu_L
    Ryu --> Ryu_H
    Ryu --> Ryu_U

    Flood --> Flood_P
    Flood --> Flood_S
    Flood --> Flood_F
    Flood --> Flood_L
    Flood --> Flood_H
    Flood --> Flood_U

    style ODL fill:#2C3E50,stroke:#16A085,stroke-width:2px,color:#fff
    style ONOS fill:#16A085,stroke:#2C3E50,stroke-width:2px,color:#fff
    style Ryu fill:#E67E22,stroke:#2C3E50,stroke-width:2px,color:#fff
    style Flood fill:#7F8C8D,stroke:#2C3E50,stroke-width:2px,color:#fff

Figure 290.1: Comparison matrix with four SDN controllers (OpenDaylight, ONOS, Ryu, Floodlight) shown as columns and six evaluation criteria as rows

290.3.1 Quick Comparison Table

Feature OpenDaylight ONOS Ryu Floodlight
Primary Focus Enterprise SDN Carrier-grade telecom Education/Research Performance
Language Java (OSGi) Java Python Java
Complexity High (steep learning) Medium Low (easiest) Medium
Performance 200K-500K flows/sec 1M+ flows/sec 50K-100K flows/sec 300K-600K flows/sec
Scalability 1K-5K devices 10K+ devices <1K devices 1K-3K devices
Clustering Yes (Akka) Yes (native) Manual Limited
Northbound API REST, RESTCONF REST, gRPC REST (custom) REST
GUI DLUX web UI ONOS web UI Basic Basic
Community Large (Linux Foundation) Large (ONF) Active Medium
Documentation Extensive Good Excellent tutorials Good
Learning Curve Months Weeks Days Weeks
Best IoT Use Complex enterprise Large-scale deployments Prototyping/PoC High-performance apps

290.4 OpenDaylight (ODL)

Overview: The most comprehensive open-source SDN controller with modular architecture.

290.4.1 Architecture

  • Model-Driven Service Abstraction Layer (MD-SAL) for plugin ecosystem
  • OSGi framework for dynamic module loading
  • 50+ projects covering everything from OpenFlow to BGP

290.4.2 Strengths

  • Feature-rich: Supports OpenFlow, NETCONF, BGP-LS, PCEP, and more
  • Mature ecosystem: 100+ companies contributing
  • Production-ready: Used by AT&T, China Mobile, Ericsson

290.4.3 Weaknesses

  • Complexity: Steep learning curve (weeks to months)
  • Resource-heavy: Requires 4GB+ RAM minimum
  • Slower iteration: Feature releases take months

290.4.4 IoT Use Case

Enterprise campus with mixed devices (IoT sensors + traditional network gear) needing multi-protocol support.

290.4.5 Getting Started

# Download and run OpenDaylight
wget https://nexus.opendaylight.org/content/repositories/releases/...
tar -xvf distribution-karaf-*.tar.gz
cd distribution-karaf-*/bin
./karaf
# Controller runs on http://localhost:8181
# Default credentials: admin/admin

290.4.6 Resource Requirements

Component Minimum Recommended
RAM 4 GB 8+ GB
CPU 2 cores 4+ cores
Disk 10 GB 50+ GB
Java OpenJDK 11+ OpenJDK 17

290.5 ONOS (Open Network Operating System)

Overview: Designed for carrier-grade scalability and high availability.

290.5.1 Architecture

  • Distributed core with intent-based northbound interface
  • Built-in clustering and state replication
  • Optimized for large-scale deployments

290.5.2 Strengths

  • Highest performance: 1M+ flow installations/second
  • Best clustering: Native distributed architecture, sub-5s failover
  • Intent-based: Applications express โ€œwhatโ€ not โ€œhowโ€ (controller figures out implementation)

290.5.3 Weaknesses

  • Less comprehensive: Focuses on core SDN (fewer protocols than ODL)
  • Fewer tutorials: Smaller community than ODL
  • Enterprise features: Some advanced features in proprietary extensions

290.5.4 IoT Use Case

Smart city with 10,000+ IoT devices requiring 99.99%+ uptime and dynamic traffic patterns.

290.5.5 Getting Started

# Download and run ONOS
wget https://repo1.maven.org/maven2/org/onosproject/onos-releases/...
tar -xzf onos-*.tar.gz
cd onos-*/bin
./onos-service start
# Access GUI at http://localhost:8181/onos/ui
# Default credentials: onos/rocks

290.5.6 Resource Requirements

Component Minimum Recommended
RAM 4 GB 16+ GB (cluster)
CPU 4 cores 8+ cores
Disk 10 GB 100+ GB
Java OpenJDK 11+ OpenJDK 17

290.6 Ryu

Overview: Python-based controller focused on simplicity and education.

290.6.1 Architecture

  • Component-based architecture with event-driven programming
  • Minimalist design (just core SDN functions)
  • Easy-to-understand codebase (~20K lines)

290.6.2 Strengths

  • Easiest to learn: Python + simple API = quick prototyping
  • Excellent docs: Best tutorials and examples among all controllers
  • Lightweight: Runs on 512MB RAM

290.6.3 Weaknesses

  • Single-threaded: Limited performance (50K flows/sec)
  • No built-in HA: Must implement clustering manually
  • Limited scalability: Best for <1000 devices

290.6.4 IoT Use Case

Research prototype or proof-of-concept for smart home (100-500 devices).

290.6.5 Getting Started

# Install Ryu
pip install ryu

# Run simple learning switch
ryu-manager ryu.app.simple_switch_13

# Write custom controller (just 20 lines!)
from ryu.base import app_manager
from ryu.controller import ofp_event

class SimpleController(app_manager.RyuApp):
    def __init__(self, *args, **kwargs):
        super(SimpleController, self).__init__(*args, **kwargs)

290.6.6 Resource Requirements

Component Minimum Recommended
RAM 512 MB 2 GB
CPU 1 core 2+ cores
Disk 1 GB 5 GB
Python 3.6+ 3.9+

290.7 Floodlight

Overview: High-performance controller with focus on throughput.

290.7.1 Architecture

  • Multi-threaded Java implementation
  • Optimized packet processing pipeline
  • RESTful API for integration

290.7.2 Strengths

  • High throughput: 300K-600K flows/second
  • Good performance/complexity ratio: Easier than ODL, faster than Ryu
  • Active development: Big Switch Networks backing

290.7.3 Weaknesses

  • Limited clustering: Not designed for large-scale distribution
  • Smaller ecosystem: Fewer third-party modules than ODL
  • Single-vendor focus: Less community diversity

290.7.4 IoT Use Case

Industrial IoT network requiring high packet processing rates (e.g., video surveillance with 500 cameras).

290.7.5 Getting Started

# Clone and build Floodlight
git clone https://github.com/floodlight/floodlight.git
cd floodlight
ant
java -jar target/floodlight.jar
# Access GUI at http://localhost:8080/ui/index.html

290.7.6 Resource Requirements

Component Minimum Recommended
RAM 2 GB 4+ GB
CPU 2 cores 4+ cores
Disk 5 GB 20 GB
Java OpenJDK 8+ OpenJDK 11

290.8 Controller Selection Guide

290.8.1 Decision Matrix

Requirement Recommended Controller Rationale
Learning/Education Ryu Python, simplest API, best tutorials
Prototype/PoC Ryu or Floodlight Quick setup, good performance
Enterprise deployment OpenDaylight Comprehensive features, multi-protocol
High availability critical ONOS Best clustering, carrier-grade reliability
High performance ONOS or Floodlight 1M+ and 600K flows/sec respectively
Large scale (10K+ devices) ONOS Designed for scalability
Mixed network (IoT + legacy) OpenDaylight Supports most protocols
Cloud-native deployment ONOS Microservices architecture
On-premises/embedded Ryu or Floodlight Lightweight, lower resource usage

290.8.2 Example Selection Scenarios

1. Smart Home Startup (500 devices)

  • Controller: Ryu
  • Reason: Fast prototyping, Python integrates with IoT platforms (Home Assistant, OpenHAB)

2. Smart City (10,000 devices, 99.99% uptime)

  • Controller: ONOS with 3-node cluster
  • Reason: Scalability + high availability

3. Industrial Factory (2,000 devices, mixed protocols)

  • Controller: OpenDaylight
  • Reason: Needs OpenFlow + NETCONF + Modbus integration

4. Research Lab (100 devices, custom algorithms)

  • Controller: Ryu
  • Reason: Easy to modify, implement custom routing

290.9 Knowledge Check

Test your understanding of SDN controller characteristics.

Question 1: A smart city deployment is evaluating SDN controllers for 15,000 IoT devices across 500 switches. They need 99.99% uptime and the development team is proficient in Python. Which controller is the BEST choice?

Explanation: ONOS is the best choice for this scenario because: (1) Scalability: Designed for 10K+ devices, handles 15,000 easily; (2) High Availability: Native clustering with sub-5s failover achieves 99.99% uptime; (3) Performance: 1M+ flows/sec throughput. While Ryu is Python-based, it only scales to <1K devices and lacks built-in HA. Floodlight has limited clustering. OpenDaylight is more complex with longer learning curve.

Question 2: A university research lab wants to experiment with novel SDN routing algorithms. The team has Python expertise and needs to modify controller internals. Budget is limited. Which controller should they choose?

Explanation: Ryu is ideal for research because: (1) Python: Matches team expertise; (2) Simple codebase: Only ~20K lines makes it easy to understand and modify; (3) Low resource requirements: Runs on minimal hardware (512MB RAM); (4) Excellent documentation: Best tutorials among all controllers. OpenDaylight and ONOS are overkill for research and have steep learning curves. Floodlight requires Java expertise.

Question 3: An enterprise IT team manages a campus network with 2,000 IoT sensors, 500 traditional switches, and legacy SNMP devices. They need to integrate all these into a unified SDN solution. Which controller fits best?

Explanation: OpenDaylight is the right choice because: (1) Multi-protocol: Supports OpenFlow, NETCONF, BGP-LS, SNMP, and more in a single controller; (2) Enterprise-ready: Designed for complex campus networks with diverse device types; (3) Scale: Handles 1K-5K devices comfortably; (4) Mature ecosystem: 100+ companies contributing plugins for various protocols. Other controllers focus on OpenFlow and would require custom integration for legacy SNMP devices.

290.10 Summary

Key Takeaways:

  1. Four major controllers serve different needs: OpenDaylight (enterprise complexity), ONOS (carrier-grade scale), Ryu (education/prototyping), Floodlight (performance)
  2. Performance varies significantly: From Ryuโ€™s 50K flows/sec to ONOSโ€™s 1M+ flows/sec
  3. Scalability matters for IoT: ONOS handles 10K+ devices; Ryu limited to <1K
  4. Language impacts adoption: Python (Ryu) for rapid prototyping; Java (others) for production
  5. Learning curve investment: Days (Ryu) to months (OpenDaylight) depending on controller complexity

Controller Selection Cheat Sheet:

Need Choose Why
Learning SDN Ryu Simple, Python, great tutorials
Production IoT ONOS Scale, HA, performance
Multi-protocol OpenDaylight Most comprehensive
Fast prototyping Ryu/Floodlight Quick setup, good docs

290.11 Whatโ€™s Next

Now that you understand controller options:

Hands-on Practice:

  • Install Ryu and run simple learning switch
  • Deploy Mininet to simulate SDN network with 100 IoT devices
  • Compare OpenDaylight and ONOS performance in your environment