The SDN control plane
In Software-Defined Networking (SDN), forwarding decisions can use many packet header fields (from the link, network, and transport layers).
Because forwarding decisions can be based on arbitrary packet-header fields rather than only destination addresses, these forwarding devices are often referred to as SDN switches or packet switches rather than routers.
Characteristics of an SDN architecture
| Characteristic | Description |
|---|---|
Flow-based forwarding |
|
Separation of data plane and control plane |
|
Software-based network control |
|
Programmable network |
|
SDN control plane
Components of the SDN control plane:
| Component | Description | Image |
|---|---|---|
Network-control applications |
|
|
SDN controller (or network operating system) |
|
The SDN control plane is responsible for "the network's intelligence":
- computing flow-table entries
- updating flow tables when network conditions change (e.g., a link goes down)
- coordinating flow table entries at multiple switches to ensure consistent network-wide functionality
The switches execute the forwarding and packet-processing actions specified by those rules.
SDN controller
The SDN controller can be organized into three layers:
| Layer | Details | Image |
|---|---|---|
|
Northbound interface (APIs ans abstractions for network control apps) |
|
|
|
Control plane core (network-wide distributed state management) |
|
|
|
Southbound interface (communication to/from controlled devices) |
|
SDN controllers such as OpenDaylight and ONOS are logically centralized on purpose. They look like one central controller but are actually distributed across several machines, which makes them more scalable and reliable for network devices and control applications.
SDN vs. traditional per-router control
In SDN:
- components such as switches, controllers, and network control applications can be developed and provided by different vendors
- this contrasts with traditional networking, where each router contains all functionality in a single integrated product from one vendor
SDN enables greater flexibility and vendor independence:
- with SDN, an ISP can easily switch from least-cost routing to custom routing strategies: the controller only needs a software update to change forwarding behavior
- in traditional networks, similar changes require updating software on all routers, which can be difficult when routers come from different vendors
OpenFlow
The OpenFlow protocol is a southbound interface in Software-Defined Networking (SDN):
- it is used for communication between an SDN controller and a network switch (or other OpenFlow-capable device)
- it runs over a reliable TCP connection (default port 6653)
Important messages used by the controller to configure and control the SDN-controlled switch:
- configuration messages (
OFPT_SET_CONFIG,OFPT_GET_CONFIG): read or modify switch configuration parameters - flow modification (
OFPT_FLOW_MOD): add, delete, or update flow table entries that define packet forwarding behavior - statistics requests (
OFPT_MULTIPART_REQUEST): retrieve flow, port, and switch statistics such as counters and state information - packet out (
OFPT_PACKET_OUT): instruct the switch to send a specific packet out of a selected port
Important messages used by the switch to report events or send packets to the controller:
- flow removed (
OFPT_FLOW_REMOVED): indicates that a flow entry has been removed, typically due to timeout or replacement - port-status (
OFPT_PORT_STATUS): reports changes in port state, such as being added, deleted, or modified - packet in (
OFPT_PACKET_IN): sends packets from the switch to the controller when:- no flow table entry matches the packet (table miss), so forwarding behavior is unknown
- a flow entry explicitly directs the switch to send matching packets to the controller (e.g., using the "send to controller" action)
Google has used SDN principles in its global infrastructure, including its private backbone network known as B4, which connects data centers worldwide. Early versions were influenced by OpenFlow concepts, although modern implementations extend beyond pure OpenFlow.