In the panel mentioned above, Matthew Liste, talks about a “common abstraction layer” that enables you to consistently execute services like creating a VLAN across different hardware types (it’s around the 14:10 mark in the video). JR actually counters and says, “you don’t need that normalization you are talking about” if you can load a consistent network operating system on your choice of hardware. While JR makes a valid point and it is, of course, true, remember he is the CEO of Cumulus, and is always selling :).
More importantly, we have to remember, Liste’s point is more than valid and will always be valid. There are industry transitions, company transitions, acquisitions, and changes that can happen in technology consumption. Even if you adopt Cumulus 100% today, having a common abstraction layer, still makes sense.
It’s not new to talk about common, or standard, APIs. With the latest industry buzz around SDN controllers though, most of the chatter is about standardizing controller northbound APIs (NB-APIs). Even as I talked about the importance of the controller, the industry has vendors like Arista and Cumulus who offer open platforms (no controllers from them directly) , don’t view their networks necessarily as a single unified system, but let the customers unify it if they wish.
In October, Cisco announced the Nexus 9000 that can operate in one of two operational models --- one that leverages a controller (APIC) that puts applications first and another that leverages the openness of the software itself, more like the Arista and Cumulus model. The operational models talked about by Cisco during the ACI launch should be looked at more broadly by the industry. Both models make sense.
There won’t always be a controller, but there very well could be.
This is why I believe, as an industry, we should look at exploring a common programmable abstraction layer for network devices. The same abstraction layer should be exposed and/or integrated with controllers.
In the next post, I’ll give an overview of some work I’ve been doing in this area that was motivated by Jeremy Schulman, who is aspiring to bring DevOps to networking. This will help convey what I’m referring to with a “common programmable abstraction layer” (CPAL). It also just so happens I was working on this project during OCP week, and hearing Matthew Liste mention the well needed common abstraction layer (not referencing a controller), helped motivate the actual write up. Thanks to them both.
Stay tuned for the dirty details.
And of course, let me know what you think. Do common APIs at the device make sense? Or should all the time and energy be spent on controller NB-APIs?
The Power of a Programmable Abstraction Layer:
Demo: Common Programmable Abstraction Layer: