Back in the springtime of this year, I saw that Coursera was going to be offering a free six-week SDN MOOC taught by Dr. Nick Feamster, an Associate Professor at Georgia Tech’s School of Computer Science. As I had already been learning about and investigating this new SDN world in my free time, I thought I’d sign up and give it a go. The prerequisites were listed as:
- Have taken at least an undergraduate-level networking course.
- Have programming experience in Python.
- Be able to write a simple client-server program in Python.
- Proficiency with basic networking concepts and facility with configuring networking in Linux environments.
- Experience with virtual machines and other virtual networking environments may also be useful.
I was good on all the pre-req’s excepting the Python ones. However, I had done a smattering of Python programming in my past, and wanted to sharpen my skills in this area; so before the class started, I worked my way through the beginning 40 exercises of Learn Python the Hard Way (which was recommended by many Internet sources as a good way to learn Python.) This was not quite sufficient, as I found out 🙂
The course started out in week one with a history lesson on the underpinning research and production systems that led up to SDN as it now stands. This was fascinating to me as I love history, and always want to know what the origins of things are. There was a bit of grumbling on the course’s discussion boards about this, mostly from the programmers who wanted to dive right in to SDN coding, but I think most students were pleased about learning the history of SDN from one of the long-time researchers in the field.
Week two got us up to speed with the tools we’d be using in the class to do exercises, namely:
- Oracle’s VirtualBox virtualization environment (used to run the custom Mininet VM with the tools listed below)
- Mininet, a network emulator which creates a network of virtual hosts, switches, controllers, and links.
- OpenFlow, the “instruction set” protocol that is used to actually program the forwarding tables in the network devices.
As well, Professor Nick delved into the core of what SDN is – namely, the separation of the control plane from the forwarding (or data) plane in network devices. He also discussed the motivations for doing this, and the challenges around doing so.
Week three was all about Network Virtualization, which has been described as the “killer app” for SDN, at least to date. Mininet was held out as an example of network virtualization, and the Python API for Mininet was discussed. This allows network experiments (from topology creation to testing) to be shared and run in a repeatable way. The first programming assignment was in this week as well, which namely was to use the Mininet Python API to create a custom three-layer core/agg/edge switch tree topology with a configurable fanout value (k) of child devices. For example, if k = 2, the topology would look like:
The assignment also specified setting at bandwidth and delay parameters for each link, which is supported in Mininet via its integration of the Linux tc command’s “netem” module. This programming assignment let me know that I was indeed a Python newb, for it took me quite a few hours to get the node and link creation logic right… But, in the end I got it working, and it felt good to get the “Test Succeeded!” message when I submitted the code to the Coursera server.
In week four, the rubber finally met the road as far as getting hands dirty with SDN programming goes. There were two units this week, one on the Control Plane, and the other (of course) on the Data Plane. In the Control Plane unit, we finally got exposure to programming an experiment in Mininet using POX, which is a OpenFlow controller written in Python. The assignment was to create a network application that implements a Layer-2 firewall that disables inbound and outbound traffic between two systems based on their MAC address. As it turns out, this is done by writing an object-oriented Python module that is invoked as a command-line POX parameter, as in:
$ pox.py log.level --DEBUG my-firewall-app
Hmmm… never wrote object-oriented Python before. And I paid for it… It was a hard slog, but with some assistance from fellow students in the course discussion boards, I finally got it to work (many tracebacks later.) But, when I realized that I had actually programmed my first SDN app, I felt it was all worth it. (And once I get this Python stuff down, there’ll be no stopping me 🙂
The Data Plane portion was on Programmable Software Data Planes, and presented topics on how to scale (increase forwarding speed) of software-based data planes, such as what Intel is doing with their DPDK initiative, as well as how to make hardware-based data planes more programmable (like what the NetFPGA project is working on.)
Week five brought us to the subject of “Northbound APIs”, and the work being done to create a higher-level programming interface to be able to ease programming SDNs. The examples held out in this area were Frenetic (SDN programming language work being done at Cornell and Princeton Universities), Pyretic (which is a Python-based project built on top of Frenetic) and Resonance (a project to make a OpenFlow controller that permits event-driven network control, which Dr. Feamster is a part of.) The programming assignment for the week was to re-implement the Layer-2 firewall as encoded in POX the prior week using the higher-level constructs offered by Pyretic. Indeed, this was easier than programming OpenFlow commands via POX, but the Pyretic syntax was a bit tricky to get right (the documentation is sparse at present, but rapidly improving.)
Finally, week six was a wrap-up which discussed the open problems in the SDN field (which are many at this early stage!) and where SDN may best find other opportunities than the current data-center focus to make networking better (such as in the areas of Internet Exchange Points, Wide-Area networking, and home networking.) There was another programming assignment using PyResonance, which I opted to skip, as I think the programming level frankly was way beyond my limited abilities (judging on all the cries for help on the course discussion boards), and the fact that it wouldn’t affect my final grade (see below.)
I should mention that besides the programming assignments, there was a weekly quiz, and the final grading (which was amended as few times by Dr. Feamster as the general student experience level became known) was finally settled on as being:
- For a normal certificate of accomplishment you are required to achieve a minimum of 70% on each quiz to successfully complete the course.
- For a certificate of accomplishment with a distinction, you are required to get a minimum of 70% on each quiz, and complete at least three out of the four programming assignments successfully.
A very valuable part of the course to me (besides the video lectures and the programming work) was the many research and white-paper references that were provided each week, as well as at least one pre-recorded Google Hangout with a SDN luminary (in the last weeks, more than one) which can now be seen on Dr. Feamster’s YouTube channel.
It looks like the course was a big success – from one of Dr. Feamster’s posts on the discussion board, something like over 50,000 people signed up to take the course, and more than 1,000 were actively completing all the quizzes and programming assignments. He also mentioned that it was the plan to keep the course site on Coursera open (not sure if one can still sign up at this point and get access to all of the materials or not?), and that he’s planning a re-run in Spring 2014 (most likely late February or early March.) If you’ve never taken a MOOC course, do think about it – and I’d highly recommend this one.