Designing RESTful Northbound Interface for SDN Controllers

Table of Contents

1. Introduction

Traditional network management methods lack the flexibility required for modern network requirements. With increasing device connectivity and network scale, configuration errors have become widespread and challenging to resolve. Software Defined Networking (SDN) addresses these challenges by enabling programmatic network design and control through centralized controllers.

The fundamental problem addressed in this research is the absence of standardized northbound interfaces (NBI) in SDN implementations. Currently, each SDN controller implements its own proprietary interface, forcing applications to be rewritten for different controllers. This creates significant portability issues and increases development costs.

2. Background Information

2.1 Software Defined Networking Architecture

SDN architecture separates the control plane from the data plane, enabling centralized network management. The architecture consists of three main layers:

• Application Layer: Network applications and services
• Control Layer: SDN controllers managing network intelligence
• Infrastructure Layer: Network forwarding devices

2.2 Northbound Interface Challenges

The absence of standardized NBIs creates several critical challenges:

• Vendor lock-in and reduced interoperability
• Increased application development and maintenance costs
• Limited innovation due to proprietary interfaces
• Complex integration processes for multi-vendor environments

3. RESTful NBI Design Principles

3.1 Core Requirements

Based on previous research, the RESTful NBI must satisfy several key requirements:

• Uniform Interface: Consistent API design across controllers
• Stateless Operations: Each request contains all necessary information
• Cacheable Responses: Improved performance through caching
• Layered System: Support for hierarchical architecture
• Code on Demand: Optional executable code transfer

3.2 Architectural Framework

The proposed architecture includes three main components:

• API Gateway: Unified entry point for all applications
• Controller Adapters: Translation layer for different SDN controllers
• Event Management: Real-time network event processing

4. Technical Implementation

4.1 Mathematical Foundation

The network state can be modeled using graph theory. Let $G = (V, E)$ represent the network topology where $V$ is the set of vertices (switches) and $E$ is the set of edges (links). The network state $S$ at time $t$ can be represented as:

$S_t = \{G, F, R, P\}$

Where:

• $F$: Flow table configurations
• $R$: Routing policies
• $P$: Performance metrics

The RESTful interface provides operations to query and modify $S_t$ through standardized HTTP methods:

$\text{GET}/\text{network}/\text{state} \rightarrow S_t$

$\text{PUT}/\text{network}/\text{flows} \rightarrow S_{t+1}$

4.2 Code Implementation

The following Python pseudocode demonstrates the core RESTful NBI implementation:

class SDNNorthboundInterface:
    def __init__(self, controller_adapters):
        self.adapters = controller_adapters
        self.app = Flask(__name__)
        self._setup_routes()
    
    def _setup_routes(self):
        @self.app.route('/network/topology', methods=['GET'])
        def get_topology():
            """Retrieve current network topology"""
            topology = self.adapters.get_topology()
            return jsonify(topology)
        
        @self.app.route('/network/flows', methods=['POST'])
        def add_flow():
            """Install new flow rules"""
            flow_data = request.json
            result = self.adapters.install_flow(flow_data)
            return jsonify({'status': 'success', 'flow_id': result})
        
        @self.app.route('/network/statistics', methods=['GET'])
        def get_statistics():
            """Retrieve network performance statistics"""
            stats = self.adapters.get_statistics()
            return jsonify(stats)

class ControllerAdapter:
    def __init__(self, controller_type):
        self.controller_type = controller_type
        
    def get_topology(self):
        # Controller-specific implementation
        pass
        
    def install_flow(self, flow_data):
        # Controller-specific flow installation
        pass

4.3 Experimental Results

Experimental evaluation compared the proposed RESTful NBI against proprietary interfaces across three SDN controllers: OpenDaylight, ONOS, and Floodlight. Key performance metrics included:

The results demonstrate that the RESTful NBI provides competitive performance while significantly reducing application porting effort. The unified interface reduced porting time by 85-90% compared to direct controller-specific implementations.

5. Critical Analysis

6. Future Applications

The standardized RESTful NBI enables several promising future applications:

6.1 Multi-Domain Network Orchestration

Enable seamless orchestration across multiple administrative domains and heterogeneous SDN controllers, supporting emerging 5G and edge computing scenarios.

6.2 Intent-Based Networking

Provide foundation for intent-based networking systems where applications can declare desired network state without specifying implementation details.

6.3 AI-Driven Network Optimization

Standardized interfaces facilitate machine learning applications for predictive network optimization and automated troubleshooting.

6.4 Network Function Virtualization

Enhanced integration with NFV platforms through standardized service chaining and resource allocation APIs.

7. References

1. Alghamdi, A., Paul, D., & Sadgrove, E. (2022). Designing a RESTful Northbound Interface for Incompatible Software Defined Network Controllers. SN Computer Science, 3:502.
2. Kreutz, D., Ramos, F. M., Verissimo, P. E., Rothenberg, C. E., Azodolmolky, S., & Uhlig, S. (2015). Software-defined networking: A comprehensive survey. Proceedings of the IEEE, 103(1), 14-76.
3. ONF. (2022). OpenFlow Switch Specification. Open Networking Foundation.
4. Xia, W., Wen, Y., Foh, C. H., Niyato, D., & Xie, H. (2015). A survey on software-defined networking. IEEE Communications Surveys & Tutorials, 17(1), 27-51.
5. Fielding, R. T. (2000). Architectural styles and the design of network-based software architectures. Doctoral dissertation, University of California, Irvine.
6. Kim, H., & Feamster, N. (2013). Improving network management with software defined networking. IEEE Communications Magazine, 51(2), 114-119.