WEBVTT

0:00:03.120000 --> 0:00:06.680000
 Hello and welcome this video in which
 we're going to do a refresher of

0:00:06.680000 --> 0:00:14.640000
 APIs and what this concept of northbound
 and southbound APIs are with

0:00:14.640000 --> 0:00:18.000000
 relationship to software
 defined networking.

0:00:18.000000 --> 0:00:21.100000
 So let's do a review.

0:00:21.100000 --> 0:00:26.140000
 What is an API? So an API stands for
 an application programming interface.

0:00:26.140000 --> 0:00:30.140000
 It's a piece of code, a piece of software
 that basically allows different

0:00:30.140000 --> 0:00:33.180000
 applications to talk
 to each other.

0:00:33.180000 --> 0:00:36.980000
 So two different kinds of APIs.

0:00:36.980000 --> 0:00:40.920000
 Those allow internal applications in
 your local system to exchange data.

0:00:40.920000 --> 0:00:52.160000
 For example, if I am in a web browser,
 I have the ability to highlight

0:00:52.160000 --> 0:00:57.740000
 something in that browser like a line
 of text in that browser, right click

0:00:57.740000 --> 0:01:03.280000
 copy, and then go to a completely different
 application like notepad or

0:01:03.280000 --> 0:01:08.260000
 my text editor, right click paste, and
 paste that information in there.

0:01:08.260000 --> 0:01:14.480000
 Well, my web browser wasn't built
 with any knowledge of notepad.

0:01:14.480000 --> 0:01:16.540000
 It doesn't know what notepad is.

0:01:16.540000 --> 0:01:17.900000
 It doesn't know how notepad
 is structured.

0:01:17.900000 --> 0:01:22.660000
 And similarly, notepad has no
 idea of what a web browser is.

0:01:22.660000 --> 0:01:27.060000
 So how was it that I was able to take
 the data out of this one application

0:01:27.060000 --> 0:01:30.580000
 and put it into this
 other application?

0:01:30.580000 --> 0:01:32.020000
 That was an API.

0:01:32.020000 --> 0:01:35.980000
 There's an API underneath the hood that
 you don't see that connects those

0:01:35.980000 --> 0:01:37.820000
 two that allows you to do that.

0:01:37.820000 --> 0:01:41.840000
 So that's an example of an API that
 has no networking component.

0:01:41.840000 --> 0:01:47.060000
 It's purely built to operate within your
 own local system to so that applications

0:01:47.060000 --> 0:01:51.320000
 can share data between each
 other in your own box.

0:01:51.320000 --> 0:01:55.540000
 And then there are also other APIs that
 actually use the Internet protocol

0:01:55.540000 --> 0:02:00.820000
 to exchange data between applications
 that are on separate devices that

0:02:00.820000 --> 0:02:05.100000
 require a network to go across.

0:02:05.100000 --> 0:02:10.120000
 Now, as far as SDN is concerned, it's
 really the second type of API that

0:02:10.120000 --> 0:02:11.840000
 we're really focusing in on here.

0:02:11.840000 --> 0:02:17.260000
 APIs that utilize IP to reach out and
 push information from one application

0:02:17.260000 --> 0:02:22.020000
 to another or retrieve information from
 one to another on separate disparate

0:02:22.020000 --> 0:02:26.300000
 systems like a controller and
 a router as an example.

0:02:26.300000 --> 0:02:31.560000
 So there's two primary use cases
 of APIs in the world of SDN.

0:02:31.560000 --> 0:02:33.900000
 Applications connecting
 to the controller.

0:02:33.900000 --> 0:02:39.160000
 I've used in the several other videos
 prior to this, this analogy of an

0:02:39.160000 --> 0:02:41.580000
 application's running
 on a server somewhere.

0:02:41.580000 --> 0:02:44.520000
 The application talks to the controller
 and says, hey, I'm about to send

0:02:44.520000 --> 0:02:46.640000
 some packets to this destination.

0:02:46.640000 --> 0:02:48.740000
 I need the network
 to look like this.

0:02:48.740000 --> 0:02:54.280000
 Well, that communication between the
 application and the controller, which

0:02:54.280000 --> 0:02:58.740000
 are probably on two separate boxes,
 actually separated by a network, is

0:02:58.740000 --> 0:03:00.120000
 facilitated by an API.

0:03:00.120000 --> 0:03:03.140000
 There's an API that does that.

0:03:03.140000 --> 0:03:07.120000
 And then, of course, for the controller
 to reach into the switch or router

0:03:07.120000 --> 0:03:11.500000
 or firewall and declare what needs to happen
 or maybe even actually configure

0:03:11.500000 --> 0:03:14.780000
 the device, there's an
 API for that as well.

0:03:14.780000 --> 0:03:19.080000
 So both of these utilize the Internet
 protocol, your standard IP headers,

0:03:19.080000 --> 0:03:24.820000
 and many times they utilize HTTP in the
 background as your actual transport

0:03:24.820000 --> 0:03:31.720000
 mechanism. So these APIs use
 a client server model.

0:03:31.720000 --> 0:03:37.060000
 Where the application in this case,
 so in the case where the application

0:03:37.060000 --> 0:03:41.400000
 is talking to the SDN controller, the
 application would be considered

0:03:41.400000 --> 0:03:45.720000
 the client of the API, the controller
 would be considered the server.

0:03:45.720000 --> 0:03:49.880000
 And then if we turn around where the
 SDN controller is talking to the

0:03:49.880000 --> 0:03:54.060000
 router, the switch, now the controller
 is the client and the router, the

0:03:54.060000 --> 0:04:00.800000
 switch, is the API
 for the controller.

0:04:00.800000 --> 0:04:02.040000
 So, let's talk about this
 in practical terminology.

0:04:02.040000 --> 0:04:06.660000
 Okay, so you might see this term
 northbound and southbound APIs.

0:04:06.660000 --> 0:04:11.280000
 So, like I said, this is all in relationship
 to the position of the controller

0:04:11.280000 --> 0:04:12.560000
 in the topology.

0:04:12.560000 --> 0:04:19.440000
 So when the application is talking to the
 SDN controller, it uses a northbound

0:04:19.440000 --> 0:04:24.560000
 API. So, let's talk about this
 in practical terminology.

0:04:24.560000 --> 0:04:28.080000
 Let's say that you are thinking of,
 let's say you've already got a bunch

0:04:28.080000 --> 0:04:31.680000
 of existing applications in your network,
 that you've already implemented,

0:04:31.680000 --> 0:04:33.780000
 they're doing their thing.

0:04:33.780000 --> 0:04:38.240000
 And you're thinking of purchasing an
 SDN controller, maybe one of Cisco's,

0:04:38.240000 --> 0:04:40.280000
 maybe somebody else's.

0:04:40.280000 --> 0:04:42.780000
 So you're starting reading up on the
 documentation of this controller

0:04:42.780000 --> 0:04:44.060000
 before you buy it.

0:04:44.060000 --> 0:04:49.840000
 And it tells you, oh, our northbound
 API is blah, blah, blah, you know,

0:04:49.840000 --> 0:04:51.160000
 they give it some name.

0:04:51.160000 --> 0:04:55.800000
 Okay, so now what you should do is look at
 the documentation of your applications

0:04:55.800000 --> 0:05:00.300000
 and see if your applications
 support that northbound API.

0:05:00.300000 --> 0:05:01.820000
 It's basically a language.

0:05:01.820000 --> 0:05:05.180000
 If they don't support that northbound
 API, they don't have any ability

0:05:05.180000 --> 0:05:07.520000
 to talk to the controller.

0:05:07.520000 --> 0:05:10.660000
 You need them to support that if they
 don't, is there a way you could

0:05:10.660000 --> 0:05:15.200000
 import, you could sort of download that API
 and import it into your applications.

0:05:15.200000 --> 0:05:17.620000
 So this is why the northbound
 API is important.

0:05:17.620000 --> 0:05:21.640000
 If you want your applications to actually
 be able to communicate to that

0:05:21.640000 --> 0:05:27.040000
 controller back and forth, you'll need
 a common northbound API to do that.

0:05:27.040000 --> 0:05:32.440000
 And then the southbound API is for the
 controller to talk to the networking

0:05:32.440000 --> 0:05:38.740000
 devices. For example, some controllers
 might say, hey, our southbound

0:05:38.740000 --> 0:05:45.200000
 API is SSH. All right, so that basically
 means that all that controller

0:05:45.200000 --> 0:05:50.460000
 can do is establish an SSH session
 with a router switch like you would

0:05:50.460000 --> 0:05:55.260000
 do and putty or secure CRT or hyper terminal
 and then issue CLI commands.

0:05:55.260000 --> 0:05:58.900000
 So it's basically doing the exact same
 thing you're doing, which probably

0:05:58.900000 --> 0:06:02.660000
 means in that controller, you'll have
 to create some sort of scripts with

0:06:02.660000 --> 0:06:07.060000
 the iOS commands you want or the Juniper
 commands or the HP commands so

0:06:07.060000 --> 0:06:09.100000
 that the controller can do that.

0:06:09.100000 --> 0:06:15.300000
 Other controllers might say our
 southbound API is using Netcom.

0:06:15.300000 --> 0:06:19.220000
 We use Netcom or maybe a
 combination of those two.

0:06:19.220000 --> 0:06:23.660000
 So once again, in a practical approach,
 once you find out what the southbound

0:06:23.660000 --> 0:06:28.580000
 API is on this controller, you have
 to ask yourself, do my networking

0:06:28.580000 --> 0:06:31.760000
 devices support that
 southbound API.

0:06:31.760000 --> 0:06:35.060000
 If a controller says, oh, our southbound
 API, the only one we have is

0:06:35.060000 --> 0:06:41.340000
 Netcom. Well, that's fine if you have
 the newer like Cisco iOS XE devices,

0:06:41.340000 --> 0:06:45.180000
 but if I have some older, you know, five,
 six, seven, eight year old routers

0:06:45.180000 --> 0:06:47.680000
 and switches, they're not
 going to support Netcom.

0:06:47.680000 --> 0:06:51.700000
 So they're not going to be able to be
 managed or even discovered probably

0:06:51.700000 --> 0:06:53.820000
 by that controller.

0:06:53.820000 --> 0:06:59.980000
 So some examples of these
 northbound APIs.

0:06:59.980000 --> 0:07:05.180000
 So Cisco has something called
 the intent northbound API.

0:07:05.180000 --> 0:07:09.260000
 So if you want an application to talk
 to, for example, DNA center or some

0:07:09.260000 --> 0:07:12.620000
 of their other controllers, your application
 will need to understand the

0:07:12.620000 --> 0:07:16.540000
 intent API. And if your application
 doesn't, I'm sure you can download

0:07:16.540000 --> 0:07:18.560000
 that from Cisco somewhere.

0:07:18.560000 --> 0:07:22.140000
 Juniper has something called
 the contrail northbound API.

0:07:22.140000 --> 0:07:25.600000
 Both of these are examples of REST
 APIs, which we'll get into in just

0:07:25.600000 --> 0:07:28.680000
 a moment what REST APIs
 are southbound.

0:07:28.680000 --> 0:07:33.160000
 Well, you've got your typical
 CLI, SNMP, Netcom.

0:07:33.160000 --> 0:07:36.380000
 We also have open
 flow and op flex.

0:07:36.380000 --> 0:07:43.120000
 So for the purposes of the CCNA, you
 don't really need to know the details

0:07:43.120000 --> 0:07:43.800000
 of how to use the CNA.

0:07:43.800000 --> 0:07:50.160000
 So open flow, op flex and Netcom work,
 but you should know that they are

0:07:50.160000 --> 0:07:55.940000
 southbound APIs, that their goal, their
 mission is to allow a controller

0:07:55.940000 --> 0:08:00.380000
 to speak southbound to the routers
 and switches and firewalls in your

0:08:00.380000 --> 0:08:04.040000
 network. So that concludes
 this video.

0:08:04.040000 --> 0:08:04.720000
 Thank you for watching.