What is Netfloc?
NETwork FLOws for Clouds (Netfloc) is SDN-based SDK for datacenter network programming. It is comprised of set of tools and libraries packed as Java bundles that interoperate with the OpenDaylight controller. Netfloc exposes REST API abstractions and Java interfaces for network programmers to enable optimal integration in cloud datacenters and fully SDN-enabled end-to-end management of OpenFlow enabled switches.
A more extensive documentation can be found here:
Why OpenDaylight as SDN controller?
OpenDaylight is hosting one of the biggest growing community for network programability and NFV support that has gone beyond being just being SDN controller. It supports variety of networking projects, standards and protocols.
Work in progress
Currently Netfloc provides library support for OpenStack tenant-based network graph management and traversal. It is based on the following OpenDaylight features: mdsal, openflowplugin and ovsdb (see Architecture. It also provides a support for the northbound OpenStack Neutron ML2 plugin APIs. Check Netfloc status for the latest updates and the Roadmap section for upcoming milestones.
- Facilitate pluggable and chainable network functions as Java bundles
- End-to-end network control in datacenters
- Reduce the complexity and protocol overhead in cloud networks
- Increase tenant traffic efficiency
- Enable optimal data center network planing and design
- OpenStack Neutron ML2 plugin and northbound API support
- ODL Lithium support
- OpenFlow support
The SDK4SDN is implemented in Java programming language and comes with integrated OpenDaylight controller, version Lithium. It can be also used as standalone feature inside other OLD versions. It has been tested and supported using OpenStack Kilo and Juno releases.
To use SDK4SDN, the network needs to be fully SDN enabled through the OVS switches. The network interfaces of the switch should be connected with the interfaces of the OpenStack nodes and the ODL.
Installation of the following is required:
- JAVA 7 JDK
- Maven 3.1.1
- OpenFlow 1.3 enabled network devices
- Open Stack basic environment (ex. 3 nodes: compute, control, neutron)
Installation and Testing
Clone and install Netfloc in the sdn-control node:
$git clone https://github.com/icclab/netfloc.git $cd netfloc $mvn clean install
To make sure all the state is clear before running Netfloc, the following steps and checkups are required:
- OVS running in all of the nodes (run ovs-vsctl show and check the configuration of the OVSs)
- SDK not running: ./karaf/target/assembly/bin/status
- Cleanup OpenStack environment (delete all: VMs, router interfaces, routers, and networks)
- Source the admin file: source keystonerc_admin
- Make sure you delete the following directories in the SDN node:
rm -rf karaf/target/assembly/data rm -rf karaf/target/assembly/journal rm -rf karaf/target/assembly/snapshots
Configure the OVSs of each Open Stack node to connect to ODL on port 6633. Set up ODL as manager on port 6640:
ovs-vsctl set-manager tcp:[Controller_IP]:6640 ovs-vsctl set-contorller tcp:[Controller_IP]:6633
After the above steps, start the SDN controller (Netfloc):
To monitor Netfloc logs in the ODL run:
tail -f ./karaf/target/assembly/data/log/karaf.log
It displays the initialization process and the link discovery. Netfloc startup has completed when the log message shows: GraphListener.
The current version of Netfloc includes the Lithium version of the OpenDayligh controller. If you want to use Netfloc libraries in other ODL controllers generate SDK library from Netfloc:
$cd scripts $./compile_sdk4sdn.sh
The zip folder contains all the necesarry jar files to be copied and extracted in the deploy folder of any ODL controller. A successful installation can be confirmed inside the karaf console as shown below:
opendaylight-user@root>bundle:list | grep netfloc 105 | Installed | 80 | 1.0.0.SNAPSHOT | netfloc-api 106 | Installed | 80 | 1.0.0.SNAPSHOT | netfloc-impl 107 | Active | 80 | 1.0.0.SNAPSHOT | netfloc-karaf 108 | Active | 80 | 1.0.0.SNAPSHOT | netfloc-features
The Service Function Chain basic APIs are fully functional at the moment. Netfloc defines API Specification for the following network resources, for which development of Northbound APIs has been scheduled:
- Tenant filtered network graph
- All host ports
- End-to-end network path
- Flow patterns on network paths
- Chain patterns
For more detailed information: Netfloc APIs
Currently Netfloc implements libraries to support for the following applications:
- Isolation Application: Ensure end-to-end tenant segregation using novel non-GRE/VxLAN tunnelling mechanism for optimized packet header.
- Resilience Application: Provide direct SDN control on a physical level enabling fully SDN-managed infrastructure.
- Service Function Chaining: Traffic classification and steering support for NFVs. There is a test-case application based on this library.
Next milestone for Netfloc is to provide application examples based on the supported libraries. New libraries to be implemented:
- Service Function Chain resilience
- Inter-datacenter SFC support
- Advanced testing and monitoring features
- QoS support
- Expose all libraries via API and Java bundles
Netfloc is licensed under the Apache License version 2.0. See the file LICENSE.