WEBVTT

0:00:03.240000 --> 0:00:06.840000
 Hello and welcome to this video titled
 Introduction to Network Management

0:00:06.840000 --> 0:00:11.420000
 Automation. So this video starts out
 a series of videos that are going

0:00:11.420000 --> 0:00:16.580000
 to cover a refresher and review of network
 automation and programmability

0:00:16.580000 --> 0:00:23.060000
 to the extent that you need to know
 it for the CCNA 200-301 exam.

0:00:23.060000 --> 0:00:26.720000
 So this is one of those things where
 at the CCNA level they purely want

0:00:26.720000 --> 0:00:31.860000
 you to really just understand conceptual
 topics, recognize terms, understand

0:00:31.860000 --> 0:00:35.120000
 at a high level how things work together
 and what problems were solved

0:00:35.120000 --> 0:00:36.940000
 by these topics.

0:00:36.940000 --> 0:00:40.600000
 There's no requirement to actually know
 how to implement or troubleshoot

0:00:40.600000 --> 0:00:42.420000
 or configure any of this stuff.

0:00:42.420000 --> 0:00:50.240000
 So let's start out with the concept
 of SDN software defined networking.

0:00:50.240000 --> 0:00:54.940000
 So what this is all about is that for
 most of the life of computer networks

0:00:54.940000 --> 0:00:58.920000
 for the last several decades the way
 networking devices have been set

0:00:58.920000 --> 0:01:02.880000
 up is that each device was
 an individual entity.

0:01:02.880000 --> 0:01:07.480000
 You had to log into a switch and configure
 your VLANs and your spanning

0:01:07.480000 --> 0:01:09.320000
 tree and all that stuff
 on that switch.

0:01:09.320000 --> 0:01:12.640000
 Then you would log out and you go on
 to switch number two and configure

0:01:12.640000 --> 0:01:15.980000
 that and switch number three and you're
 logged onto your routers one by

0:01:15.980000 --> 0:01:22.640000
 one. And so the idea was that typically
 you configured your networking

0:01:22.640000 --> 0:01:27.160000
 devices with certain parameters, certain
 features, certain protocols and

0:01:27.160000 --> 0:01:32.000000
 then you would see how that affected
 traffic flowing through your network.

0:01:32.000000 --> 0:01:34.180000
 It would have how it affected
 your applications.

0:01:34.180000 --> 0:01:37.460000
 And you might have to tweak your features
 or tweak your protocols a little

0:01:37.460000 --> 0:01:40.460000
 bit to make your applications run a
 little bit more smoothly, a little

0:01:40.460000 --> 0:01:44.160000
 bit faster but it was done
 on a hop by hop basis.

0:01:44.160000 --> 0:01:46.780000
 Each individual thing had to
 be programmed one at a time.

0:01:46.780000 --> 0:01:51.560000
 And there wasn't really any good method
 that existed to centralize all

0:01:51.560000 --> 0:01:55.860000
 that. It was the dream of many people
 for many years that man it'd be

0:01:55.860000 --> 0:01:59.740000
 so nice if I could have some central
 point like a server and I could log

0:01:59.740000 --> 0:02:04.700000
 into a GUI or something and that GUI
 could reach out and touch all my

0:02:04.700000 --> 0:02:06.100000
 networking devices.

0:02:06.100000 --> 0:02:10.940000
 So from one central point I could
 configure them and monitor them.

0:02:10.940000 --> 0:02:14.160000
 Now yes SNMP has been around
 for a long time.

0:02:14.160000 --> 0:02:17.680000
 There's been a lot of SNMP managers
 with really nice GUIs.

0:02:17.680000 --> 0:02:23.160000
 But SNMP even though technically it's
 supposed to have like a read or

0:02:23.160000 --> 0:02:26.360000
 not a read, a write option where
 you can write to devices.

0:02:26.360000 --> 0:02:28.180000
 It was never very robust.

0:02:28.180000 --> 0:02:30.740000
 It's very limited
 in what it can do.

0:02:30.740000 --> 0:02:35.160000
 And so SNMP has really just always been
 used to read the current information

0:02:35.160000 --> 0:02:40.180000
 about your networking devices, how they're
 doing, gather statistics but

0:02:40.180000 --> 0:02:43.980000
 was never very a good option
 for programming your devices.

0:02:43.980000 --> 0:02:48.480000
 And especially if you want to apply
 the same set of structure like the

0:02:48.480000 --> 0:02:52.740000
 same commands, the same features across
 a mass quantity of devices.

0:02:52.740000 --> 0:02:54.840000
 SNMP just wasn't really
 good for that.

0:02:54.840000 --> 0:02:59.600000
 Then somebody came around and they said
 well software defined networking.

0:02:59.600000 --> 0:03:01.480000
 What if we actually
 make this a reality?

0:03:01.480000 --> 0:03:05.540000
 What if we actually create some central
 device that can reach out, discover

0:03:05.540000 --> 0:03:09.380000
 all of our routers and switches
 and firewalls and whatnot.

0:03:09.380000 --> 0:03:11.920000
 And then that central device
 can actually program them.

0:03:11.920000 --> 0:03:16.200000
 It can configure them as well as reading
 their current state and getting

0:03:16.200000 --> 0:03:19.900000
 information so my monitoring and
 troubleshooting is easier.

0:03:19.900000 --> 0:03:21.440000
 So that's what SDN is all about.

0:03:21.440000 --> 0:03:26.960000
 And the central integral part
 of SDN is the controller.

0:03:26.960000 --> 0:03:31.280000
 So that is that central thing that's
 able to reach out and touch all of

0:03:31.280000 --> 0:03:35.560000
 your routers and switches and access points
 and firewalls and other things.

0:03:35.560000 --> 0:03:39.720000
 Now so if you want to do SDN, you've
 got to have a controller.

0:03:39.720000 --> 0:03:45.500000
 Now the controllers, just like wireless
 LAN controllers, come in two form

0:03:45.500000 --> 0:03:50.560000
 factors. You've got those that are software
 pre-installed on an appliance,

0:03:50.560000 --> 0:03:53.300000
 right? Just like with a wireless LAN
 controller, you could have a box

0:03:53.300000 --> 0:03:56.960000
 that you could buy that you could rack
 mount that was purpose built to

0:03:56.960000 --> 0:03:58.400000
 be a wireless LAN controller.

0:03:58.400000 --> 0:04:00.780000
 Well now we have an
 SDN controller.

0:04:00.780000 --> 0:04:03.940000
 And what's actually interesting is this
 is sort of like a cascading thing.

0:04:03.940000 --> 0:04:07.920000
 When it comes to wireless, if you get
 one of these controllers here, these

0:04:07.920000 --> 0:04:12.660000
 SDN controllers can actually control
 the wireless LAN controllers, which

0:04:12.660000 --> 0:04:15.780000
 in turn control the access points.


0:04:15.780000 --> 0:04:19.280000
 So it's sort of interesting there, especially
 in really large environments,

0:04:19.280000 --> 0:04:22.880000
 you might have several wireless
 LAN controllers.

0:04:22.880000 --> 0:04:25.960000
 And you might want to consolidate management
 of all your wireless LAN

0:04:25.960000 --> 0:04:28.800000
 controllers. And this is one of
 the devices that could do that.

0:04:28.800000 --> 0:04:31.940000
 And just like wireless LAN controllers
 come in physical appliances you

0:04:31.940000 --> 0:04:35.920000
 can hold in your hand, they also
 come in cloud-based versions.

0:04:35.920000 --> 0:04:40.520000
 Well, SDN controllers also offer
 you that option as well.

0:04:40.520000 --> 0:04:46.960000
 So some examples of SDN controllers,
 we have Cisco's ACI and their APIC,

0:04:46.960000 --> 0:04:49.080000
 and we also have their APIC EM.

0:04:49.080000 --> 0:04:53.260000
 Two different controllers built for two
 very different purposes, but ultimately

0:04:53.260000 --> 0:04:54.280000
 that's what they do.

0:04:54.280000 --> 0:05:02.740000
 They reach out and configure and manage
 router switches and other devices.

0:05:02.740000 --> 0:05:08.420000
 Okay, now along with these controllers,
 these controllers might have built

0:05:08.420000 --> 0:05:13.820000
 into them, or they might reach out to
 other software, which are network

0:05:13.820000 --> 0:05:17.700000
 automation software tools or
 network configuration tools.

0:05:17.700000 --> 0:05:22.600000
 These tools are software applications
 that you'd load on typically a Linux

0:05:22.600000 --> 0:05:25.800000
 server, although I think some of them
 you can also load on a Windows server

0:05:25.800000 --> 0:05:27.040000
 or something as well.

0:05:27.040000 --> 0:05:31.140000
 But basically when you load this in,
 these software automation tools,

0:05:31.140000 --> 0:05:34.980000
 these are the actual tools that reach
 out via various different protocols

0:05:34.980000 --> 0:05:38.440000
 to your routers and switches and program
 them, and reach out and send

0:05:38.440000 --> 0:05:41.540000
 commands to see what their current operational
 state is, and they're running

0:05:41.540000 --> 0:05:43.400000
 configs and things like that.

0:05:43.400000 --> 0:05:47.360000
 So some examples of these, some just
 terms you should know are Ansible,

0:05:47.360000 --> 0:05:51.540000
 Chef, Puppet, Saltstack,
 there are others.

0:05:51.540000 --> 0:05:57.260000
 So here's a picture of Ansible Tower,
 which is a GUI version of Ansible.

0:05:57.260000 --> 0:06:01.640000
 Ansible comes in both a command line
 version and a GUI version, and this

0:06:01.640000 --> 0:06:07.200000
 is a purpose-built application that can
 configure your routers and switches

0:06:07.200000 --> 0:06:15.140000
 and firewalls. So a lot of times your
 SDN controller will be paired with

0:06:15.140000 --> 0:06:19.460000
 one of these. This software might be
 running in the same physical box

0:06:19.460000 --> 0:06:21.520000
 as your SDN controller.

0:06:21.520000 --> 0:06:25.280000
 If you get an SDN controller that's software
-based that you download onto,

0:06:25.280000 --> 0:06:28.880000
 for example, your Linux server, you
 could also download Ansible Tower

0:06:28.880000 --> 0:06:32.140000
 onto that exact same Linux
 box and run them both.

0:06:32.140000 --> 0:06:36.560000
 But my point is the SDN controllers,
 just like they can have hooks into

0:06:36.560000 --> 0:06:39.560000
 your routers and switches so they can
 read information, they have hooks

0:06:39.560000 --> 0:06:40.880000
 into this as well.

0:06:40.880000 --> 0:06:46.560000
 So a lot of times there are some SDN
 controllers that have the ability

0:06:46.560000 --> 0:06:51.600000
 all by themselves, without any extra software,
 to reach out to your routers

0:06:51.600000 --> 0:06:56.360000
 and switches and basically apply a configuration
 file to configure them.

0:06:56.360000 --> 0:06:59.820000
 Other SDN controllers rely
 on something like this.

0:06:59.820000 --> 0:07:04.800000
 They rely on a connection to an Ansible
 software or a Puppet software,

0:07:04.800000 --> 0:07:08.420000
 and the two are integrated
 and they work together.

0:07:08.420000 --> 0:07:16.200000
 Okay, so those network automation tools
 I just talked about, Ansible,

0:07:16.200000 --> 0:07:18.940000
 Chef, Puppet, you're probably thinking,
 okay, the first thing I want to

0:07:18.940000 --> 0:07:24.620000
 do with this once I install it is I
 want to apply a configuration file.

0:07:24.620000 --> 0:07:29.080000
 So you have to stop and think about,
 okay, what sort of common things

0:07:29.080000 --> 0:07:31.220000
 do I want to apply to?

0:07:31.220000 --> 0:07:33.560000
 Let's start with my
 switches, okay?

0:07:33.560000 --> 0:07:36.940000
 So yeah, there's going to be some uniqueness
 among your switches, like

0:07:36.940000 --> 0:07:40.480000
 maybe your host names might vary, maybe
 their management IP addresses

0:07:40.480000 --> 0:07:43.060000
 vary, but there's also going to be
 some common things you're going to

0:07:43.060000 --> 0:07:47.040000
 apply. Like maybe you want to apply
 the same common set of VLANs across

0:07:47.040000 --> 0:07:48.480000
 all of your switches.

0:07:48.480000 --> 0:07:51.480000
 Maybe you want to apply the same common
 set of security features like

0:07:51.480000 --> 0:07:56.820000
 DHCP snooping or dynamic ARP inspection
 across all of your switches.

0:07:56.820000 --> 0:08:00.800000
 So that type of common stuff that you
 can push down to a mass quantity

0:08:00.800000 --> 0:08:06.600000
 of devices is what's perfectly aligned
 for these things like Chef, Puppet,

0:08:06.600000 --> 0:08:08.280000
 Ansible, and so forth.

0:08:08.280000 --> 0:08:11.740000
 So the next thing you have to think about
 is, how do I create that configuration

0:08:11.740000 --> 0:08:16.980000
 file? Most of the time it's not as simple
 as just opening up a text editor

0:08:16.980000 --> 0:08:23.240000
 and writing interface VLAN
 1 or VLAN 2 name payroll.

0:08:23.240000 --> 0:08:27.140000
 So most of these devices use some,
 most of these software applications

0:08:27.140000 --> 0:08:32.420000
 like Ansible, Chef, and Puppet use some
 kind of a scripting language in

0:08:32.420000 --> 0:08:36.440000
 order to create these configuration
 files that you're going to push down

0:08:36.440000 --> 0:08:42.020000
 to your routers and switches.

0:08:42.020000 --> 0:08:46.240000
 So let's take a step back here from
 Ansible and Chef and stuff for just

0:08:46.240000 --> 0:08:51.140000
 a moment. And what this slide is talking
 about is we can use scripting,

0:08:51.140000 --> 0:08:56.520000
 some sort of scripting language, to
 automate the process of configuring

0:08:56.520000 --> 0:09:03.300000
 a device. Now, when you run a script,
 you have to be on something, right?

0:09:03.300000 --> 0:09:06.620000
 You have to be on some sort of device
 and type in a command to say, run

0:09:06.620000 --> 0:09:10.960000
 this script. So now what we're looking
 at is what is that device?

0:09:10.960000 --> 0:09:14.820000
 Where can that script actually
 be located to be run from?

0:09:14.820000 --> 0:09:18.980000
 Well, the scripts can be initiated on
 a remote device and commands sent

0:09:18.980000 --> 0:09:20.320000
 over an IP connection.

0:09:20.320000 --> 0:09:23.920000
 For example, those things we just talked
 about, Ansible, Chef, Puppet,

0:09:23.920000 --> 0:09:25.060000
 that's a perfect example.

0:09:25.060000 --> 0:09:28.620000
 All of those are like this, where the
 script is on those servers, and

0:09:28.620000 --> 0:09:33.120000
 then when you run the script on those Ansible
 or Chef or Puppet applications,

0:09:33.120000 --> 0:09:39.400000
 they generate IP packets and they send
 the script down to the device.

0:09:39.400000 --> 0:09:41.540000
 Some software has script
 built into it.

0:09:41.540000 --> 0:09:45.660000
 For example, you're probably familiar
 with that Cisco has different flavors

0:09:45.660000 --> 0:09:53.180000
 of iOS. There's iOS Mainline, there's
 iOS XE, iOS XR, all kinds of stuff.

0:09:53.180000 --> 0:09:57.320000
 Well, one of the benefits of using
 iOS XE, and I'm sure there's other

0:09:57.320000 --> 0:10:01.260000
 ones as well, is that if you have a
 device that has iOS XE, it actually

0:10:01.260000 --> 0:10:06.460000
 gives you the ability to implement
 scripts right in Cisco iOS.

0:10:06.460000 --> 0:10:10.800000
 You can actually write like Python scripts
 right there on the iOS device

0:10:10.800000 --> 0:10:14.080000
 itself. You don't have to go to an external
 server or something like that.

0:10:14.080000 --> 0:10:15.660000
 So that's what that's talking to.

0:10:15.660000 --> 0:10:17.660000
 That's what that's talking about.

0:10:17.660000 --> 0:10:24.040000
 And two of the most popular scripting
 languages are tickle and Python

0:10:24.040000 --> 0:10:28.760000
 scripts. Now, at the CCA level, you
 don't have to know anything about

0:10:28.760000 --> 0:10:32.400000
 really what those are or what makes
 them different from each other, just

0:10:32.400000 --> 0:10:37.280000
 to be able to recognize those
 as common scripting languages.

0:10:37.280000 --> 0:10:42.620000
 So that concludes this first video
 in our Network Programmability and

0:10:42.620000 --> 0:10:44.560000
 Automation series.

0:10:44.560000 --> 0:10:45.180000
 Thank you for watching.