Controller-Based Networking and Network Automation

A switch or router does three kinds of work, called planes: the data plane forwards each message, the control plane builds the tables it uses, and the management plane lets people manage the device. Controller-based networking, first called SDN, puts a controller in charge of part of the control plane. It talks down to devices through southbound interfaces and up to programs through northbound ones.

In Daveth Pro (Network)13 min video

By , founder of Daveth · Updated

Opening frame of the video walkthrough of Controller-Based Networking and Network Automation

Watch this lesson

13 min · Video walkthrough

In Daveth Pro (Network)

The full 13 min walkthrough is in Daveth Pro (Network). See what the plan opens

What this page answers

What are the data, control and management planes?

The data plane is everything done to each message as it is forwarded; the control plane is the work that builds what the data plane uses, such as routing tables; the management plane is how people and tools manage the device. Read it in “Three kinds of work in one box”

What is a southbound interface?

The interface a controller uses to talk to the network devices, named for where they sit in the drawings: below. Options include OpenFlow, CLI over SSH, SNMP and NETCONF. Read it in “A controller: deciding in one place”

Three kinds of work in one box

Month ten, a week on. Head office's campus is HQD and a switch on each floor (09.2), and every change still means Ravi logging in to each one in turn. A supplier's pitch for a controller ends with a promise: one place to run the whole campus. Ravi has a question first.

No. To see why, split what a switch or router does into three kinds of work, called planes.

The data plane is everything done to each message as it passes through: receiving it, deciding where it goes, sending it on. Matching a frame's destination MAC in the MAC table, or a packet's destination in the routing table; adding or removing an 802.1Q tag; putting a packet in a new frame; encrypting it for a VPN; changing its addresses for NAT; discarding it because an ACL or port security says so. All of it is per message, which is why it's also called the forwarding plane.

The control plane is whatever controls the data plane, mostly by building the tables it reads: routing protocols such as OSPF, ARP and IPv6's Neighbor Discovery, a switch learning MAC addresses, STP choosing which ports may forward. Without it a router would have almost no routes, and a switch could only flood. When a router's data plane finds no route that matches, it discards the packet; the control plane decided what was in the table.

The management plane is how people and tools manage the device: SSH and Telnet, SNMP, syslog. It doesn't directly change forwarding. A router with SSH switched off routes exactly as before.

A traditional network spreads both the data plane and the control plane across every device: each router runs its own OSPF and builds its own table from what its neighbours tell it. Sort twelve things the company's devices do:

Interactive tool: HQ2 matches a frame's destination MAC in its MAC table and forwards it out one port Right: it is done to each message as it passes through: the data plane. HQ2 adds a new MAC address to its MAC table from a frame's source address R3 learns a route with OSPF and adds it to its routing table R3 matches a packet's destination in its routing table and forwards it HQD runs STP and blo

Each plane leaves its own evidence on HQ2. A real feature can involve more than one (the control plane builds the MAC table, and the data plane reads it), so the names describe the main job, not three separate boxes inside the switch:

CommandShowsPlaneDoesn't prove
show mac address-tablethe table HQ2 forwards frames bydata (its table; learning it is control)that a given frame was actually forwarded
show spanning-tree vlan 100which ports STP lets forward, and which it blockscontrolthat traffic is flowing on the forwarding ports
show loggingthe messages HQ2 has loggedmanagementanything about forwarding, unless a message reports it

Why forwarding is done in hardware

24 million. 1,000,000,000 bits a second, divided into 1000-bit frames, is a million frames a second per port, and with full duplex all 24 ports can receive at once. Even a small switch needs millions of frames a second, more than a general-purpose CPU can handle in software. So switches have always forwarded in hardware. An ASIC (application-specific integrated circuit), a chip built for the job, does the forwarding, and TCAM (ternary content-addressable memory) holds the table: the ASIC hands it a MAC address and gets the matching entry straight back, with no search to run. The switch still has a CPU and RAM, running its operating system and most of the control and management planes; MAC learning happens in the ASIC. Some routers forward in hardware too, for the same reasons.

The CPU does the thinking. The ASIC does the lifting, twenty-four million times a second, and never asks why.

A controller: deciding in one place

Controller-based networking, first called Software Defined Networking (SDN) and now also software-defined architecture or programmable networks, puts one piece of software in charge: a controller. Most approaches move part of the control plane into it. Most control plane protocols are distributed by design, and many have worked well that way for decades. But a program with all the network's information in one place is easier to write than one spread across every device. How much the controller takes over varies. It can do all the control plane work, leaving the devices only a data plane, or it can simply know what the devices' own planes are doing, without changing them. In each case on this page the devices keep the data plane, and the controller only needs IP reachability to them.

Network drawing: northbound (NBI), southbound (SBI): HQD shown, each device the same, frames stay down here, Ops app, CTRL1, R3, HQD, HQ2, Printer, HQ4, Gi0/5

A planned controller for head office: CTRL1 talks down to the devices (southbound) and up to programs (northbound); frames move only along the cables below.

The controller talks to the devices through its southbound interface (SBI), named for where the devices sit in the drawings: below. Here, interface means a software interface, not a port. An SBI is usually a protocol plus an API (application programming interface): a way for one program to exchange data with another. A protocol exists as a document, usually from a standards body; an API exists as usable code, functions, variables and data structures, that one program calls to reach another. The SBIs a controller supports say a lot about what it can do; some support one, others many. Southbound options include the open standard OpenFlow, CLI over SSH, SNMP, and NETCONF.

Above it, the northbound interface (NBI) opens the controller to other programs. The controller gathers what those programs need: the devices, their capabilities and interfaces, each port's state, the topology, the configuration. Through the NBI a program can read all of that, or ask the controller to change the network. A program on the controller's own server calls it directly; one elsewhere uses HTTP across the network, and gets back structured data, named values a program can use straight away, rather than a web page.

You can think of the controller as a railway's timetable office: it decides which train runs where and when, and the trains run the track without phoning in at every station. (Where it stops: when a train loses contact with the office it still runs, but what a switch does while it can't reach its controller, and whether a second controller takes over, depends on the product and the design.)