WEBVTT

0:00:02.880000 --> 0:00:08.080000
 Hello and welcome to this video titled
 introducing Northbound and Southbound

0:00:08.080000 --> 0:00:13.220000
 APIs. In this video I'm going to introduce
 the concept of what is an API

0:00:13.220000 --> 0:00:16.320000
 in case you've never heard
 of an API before.

0:00:16.320000 --> 0:00:21.200000
 And then we'll talk about what is meant
 by Southbound and Northbound APIs

0:00:21.200000 --> 0:00:25.740000
 and where do they fit in the world
 of software defined networking.

0:00:25.740000 --> 0:00:31.540000
 So let's start with this overall
 concept of what is an API.

0:00:31.540000 --> 0:00:36.980000
 Now I'm taking this from the standpoint
 of I am not me personally a software

0:00:36.980000 --> 0:00:41.060000
 developer. I've never written
 a line of code in my life.

0:00:41.060000 --> 0:00:46.920000
 So as a network engineer I need to understand,
 divorced from this programming

0:00:46.920000 --> 0:00:54.140000
 stuff, what an API is, me as a network
 engineer and dealing with software

0:00:54.140000 --> 0:00:56.080000
 defined networking.

0:00:56.080000 --> 0:00:58.420000
 So from that perspective
 what is an API?

0:00:58.420000 --> 0:00:59.860000
 Well let's start with the acronym.


0:00:59.860000 --> 0:01:01.360000
 What's API stand for?

0:01:01.360000 --> 0:01:05.540000
 It stands for application
 programming interface.

0:01:05.540000 --> 0:01:07.280000
 Let's break that down.

0:01:07.280000 --> 0:01:10.220000
 So we have an application.

0:01:10.220000 --> 0:01:15.140000
 We need to program that application
 and something needs to give us an

0:01:15.140000 --> 0:01:17.520000
 interface into that application.

0:01:17.520000 --> 0:01:20.880000
 And something needs to allow us to
 interface the application so we can

0:01:20.880000 --> 0:01:27.540000
 program it. That piece of code that
 does that thing is called an API.

0:01:27.540000 --> 0:01:31.600000
 So it's simply a piece of code to allow
 different applications to talk

0:01:31.600000 --> 0:01:35.260000
 to each other. There's two
 different kinds of APIs.

0:01:35.260000 --> 0:01:39.060000
 There are those that allow internal applications
 in your own local system

0:01:39.060000 --> 0:01:40.360000
 to exchange data.

0:01:40.360000 --> 0:01:48.120000
 For example, if you were looking at
 a website and you copy the data so

0:01:48.120000 --> 0:01:52.400000
 you highlight the data and you right
 click and click copy and then you

0:01:52.400000 --> 0:01:56.360000
 open up a text editor like notepad or
 wordpad and then you paste the data

0:01:56.360000 --> 0:02:02.340000
 in there, you are actually invoking
 probably one or more APIs in order

0:02:02.340000 --> 0:02:07.060000
 to do that. You're invoking some API
 to take the data out of one format

0:02:07.060000 --> 0:02:11.540000
 which is your web browser and put it
 in a different application which

0:02:11.540000 --> 0:02:13.200000
 is notepad in this example.

0:02:13.200000 --> 0:02:17.720000
 That's an example of an API that
 allows that functionality.

0:02:17.720000 --> 0:02:21.560000
 Now that particular API has
 no networking component.

0:02:21.560000 --> 0:02:23.960000
 There's nothing dealing with
 networking going on there.

0:02:23.960000 --> 0:02:26.480000
 It's all locally within
 your own system.

0:02:26.480000 --> 0:02:30.440000
 There are other types of APIs which is
 more applicable in a software defined

0:02:30.440000 --> 0:02:35.240000
 networking environment that actually
 use IP networking to exchange data

0:02:35.240000 --> 0:02:38.620000
 between remote applications.

0:02:38.620000 --> 0:02:43.040000
 So how are APIs utilized in
 software defined networking?

0:02:43.040000 --> 0:02:46.680000
 Well, there's two primary uses.

0:02:46.680000 --> 0:02:49.660000
 Applications connecting
 to controllers.

0:02:49.660000 --> 0:02:53.040000
 So an application that's running on some
 server wants to talk to a controller

0:02:53.040000 --> 0:02:57.700000
 and either say, hey controller, give me
 some information about the network,

0:02:57.700000 --> 0:03:03.200000
 show me what the network looked like,
 say push this information down to

0:03:03.200000 --> 0:03:06.820000
 your network, make the
 network look like this.

0:03:06.820000 --> 0:03:09.880000
 So there's some APIs that communicate
 that way between the controller

0:03:09.880000 --> 0:03:12.080000
 and application.

0:03:12.080000 --> 0:03:15.740000
 And there's other APIs that are used
 for the controller to talk down to

0:03:15.740000 --> 0:03:20.040000
 the networking device, to either extract
 data, show me what your CPU looks

0:03:20.040000 --> 0:03:24.760000
 like, give me your interface statistics,
 give me your configuration, or

0:03:24.760000 --> 0:03:27.760000
 an API might be used to program
 a networking device.

0:03:27.760000 --> 0:03:29.540000
 Here's a security policy for you.

0:03:29.540000 --> 0:03:33.020000
 Here's a new route
 that you can use.

0:03:33.020000 --> 0:03:36.980000
 So both of these types of connections
 are talking about APIs that are

0:03:36.980000 --> 0:03:42.400000
 using IP connectivity to talk from one
 application to another application,

0:03:42.400000 --> 0:03:46.780000
 applications that do not reside
 on the exact same box.

0:03:46.780000 --> 0:03:53.640000
 And it frequently uses HTTP or HTTPS
 for this type of communication.

0:03:53.640000 --> 0:03:56.340000
 And APIs use a client
 server model.

0:03:56.340000 --> 0:04:01.720000
 The API that's doing the requesting
 is considered the client where the

0:04:01.720000 --> 0:04:06.560000
 data resides that you're trying to extract
 or the data you're trying to

0:04:06.560000 --> 0:04:11.780000
 change, that is considered the server
 from the API's perspective.

0:04:11.780000 --> 0:04:17.000000
 So if we look here, when an application
 is communicating with a controller,

0:04:17.000000 --> 0:04:20.040000
 the application would be considered
 the API client.

0:04:20.040000 --> 0:04:23.740000
 The controller that is trying to control
 or manipulate would be considered

0:04:23.740000 --> 0:04:29.580000
 the API server. Now when that same controller
 is trying to use a different

0:04:29.580000 --> 0:04:34.340000
 API to talk to a networking device like
 a router switch, now the controller

0:04:34.340000 --> 0:04:38.980000
 would be considered the client and the
 router switch would be considered

0:04:38.980000 --> 0:04:45.200000
 the server. So that's just some high
-level information there about APIs.

0:04:45.200000 --> 0:04:48.940000
 Now in the world of software-defined networking
 and network programmability,

0:04:48.940000 --> 0:04:53.760000
 you'll hear this term southbound
 and northbound APIs.

0:04:53.760000 --> 0:04:55.540000
 What's that referring to?

0:04:55.540000 --> 0:05:00.840000
 Well, this is all in reference to communications
 with a controller, and

0:05:00.840000 --> 0:05:03.320000
 who's talking to the controller.

0:05:03.320000 --> 0:05:08.500000
 So in a lot of networking environments,
 you'll see a picture looking something

0:05:08.500000 --> 0:05:12.820000
 like this, where the controller will
 be in the center of the image, your

0:05:12.820000 --> 0:05:17.860000
 network will be at the bottom, what
 we call our fabric is at the bottom,

0:05:17.860000 --> 0:05:22.140000
 that's your routers and switches and firewalls,
 your hosts, all that stuff.

0:05:22.140000 --> 0:05:27.060000
 And then above the controller will be some
 generic representation of applications.

0:05:27.060000 --> 0:05:31.160000
 Applications that can actually talk to
 the controller and use the controller

0:05:31.160000 --> 0:05:36.260000
 to program the network, or maybe at
 minimum get information about the

0:05:36.260000 --> 0:05:43.140000
 network. So the API that runs between
 the application and the controller,

0:05:43.140000 --> 0:05:47.940000
 we call that a northbound API, because
 it's north, it's on top of the

0:05:47.940000 --> 0:05:51.100000
 controller, conceptually
 in this framework here.

0:05:51.100000 --> 0:05:55.720000
 And the APIs are used for the controller
 to talk downstream to the network,

0:05:55.720000 --> 0:06:00.320000
 you guessed it, those are
 called southbound APIs.

0:06:00.320000 --> 0:06:04.920000
 And what I'd like to wrap up this section
 with is just some brief examples

0:06:04.920000 --> 0:06:10.180000
 of what northbound and
 southbound APIs are.

0:06:10.180000 --> 0:06:14.080000
 So when it comes to northbound APIs,
 you might hear of Cisco's intent

0:06:14.080000 --> 0:06:21.200000
 API, this is a type of API that runs on Cisco
 controllers to talk to applications.

0:06:21.200000 --> 0:06:24.820000
 Juniper also has one, they
 call that the contrail API.

0:06:24.820000 --> 0:06:28.180000
 Both of these are examples of
 what are called REST APIs.

0:06:28.180000 --> 0:06:32.000000
 Not going to get into the details of
 REST APIs in this video, but a REST

0:06:32.000000 --> 0:06:37.680000
 API has certain characteristics about
 how it talks between applications

0:06:37.680000 --> 0:06:41.200000
 and what the format of the
 data needs to look like.

0:06:41.200000 --> 0:06:45.600000
 So both of the intent and the contrail
 applications are northbound REST

0:06:45.600000 --> 0:06:50.280000
 APIs. Now what about talking southbound
 between the controller and the

0:06:50.280000 --> 0:06:52.060000
 network devices?

0:06:52.060000 --> 0:06:59.580000
 Well, we've got these various options
 here, open flow, Cisco Optflex,

0:06:59.580000 --> 0:07:05.180000
 simply having a command line over SSH,
 could be an example of a southbound

0:07:05.180000 --> 0:07:11.620000
 API interaction, using SNMP commands,
 that would be an example, or NetConf

0:07:11.620000 --> 0:07:19.200000
 Yang or RESTConf Yang would be
 an example of southbound APIs.

0:07:19.200000 --> 0:07:22.580000
 So that concludes this video.

0:07:22.580000 --> 0:07:23.560000
 I hope you found it useful.

