WEBVTT

0:00:02.940000 --> 0:00:05.080000
 Hello and welcome to this video.

0:00:05.080000 --> 0:00:08.840000
 In this video I'd like to talk about network
 management automation protocols

0:00:08.840000 --> 0:00:15.160000
 and impact. In other words, as our topic
 says, what are some common languages

0:00:15.160000 --> 0:00:19.520000
 and protocols that are used in network
 automation tools for those tools

0:00:19.520000 --> 0:00:23.420000
 to talk to and control
 our network?

0:00:23.420000 --> 0:00:26.840000
 And what is the impact of automation
 on network management?

0:00:26.840000 --> 0:00:27.660000
 Why would you use it?

0:00:27.660000 --> 0:00:30.320000
 What are the benefits of it?

0:00:30.320000 --> 0:00:35.900000
 So let's start by looking at some common
 languages for network automation.

0:00:35.900000 --> 0:00:37.880000
 Starting with network monitoring.

0:00:37.880000 --> 0:00:42.620000
 So network automation can also include
 monitoring, which means monitoring

0:00:42.620000 --> 0:00:46.560000
 or automating the monitoring of several
 devices instead of doing it one

0:00:46.560000 --> 0:00:52.880000
 at a time. So typically we can use SNMP
 managers for that and our automation

0:00:52.880000 --> 0:00:56.480000
 tools can automate
 the SNMP process.

0:00:56.480000 --> 0:00:58.580000
 And also we can use
 NetFlow controllers.

0:00:58.580000 --> 0:01:02.460000
 So as far as the monitoring is concerned,
 it's typically done via SNMP

0:01:02.460000 --> 0:01:08.460000
 or NetFlow. Now what about common
 languages and protocols?

0:01:08.460000 --> 0:01:14.800000
 So what we're looking at here is how
 does the controller or the network

0:01:14.800000 --> 0:01:18.520000
 automation device talk
 to our network?

0:01:18.520000 --> 0:01:22.620000
 How does it actually communicate
 to the router or the switch?

0:01:22.620000 --> 0:01:25.540000
 Is it IP? Is it IPB6?

0:01:25.540000 --> 0:01:27.220000
 Is it something else?

0:01:27.220000 --> 0:01:29.860000
 And if it is IP, what's
 inside of that IP?

0:01:29.860000 --> 0:01:32.560000
 What protocol is that
 packet carrying?

0:01:32.560000 --> 0:01:37.920000
 So believe it or not, a very common method
 is still the command line carried

0:01:37.920000 --> 0:01:40.180000
 over a secure connection.

0:01:40.180000 --> 0:01:45.160000
 For example, carried over
 SSH or carried over SSL.

0:01:45.160000 --> 0:01:49.520000
 This is really no different than when
 you open up a secure CRT session

0:01:49.520000 --> 0:01:56.860000
 or a putty session and SSH into a Cisco
 router or a Cisco switch and then

0:01:56.860000 --> 0:01:58.740000
 manually type in your commands.

0:01:58.740000 --> 0:02:02.700000
 The only difference is network automation
 is sending those exact same

0:02:02.700000 --> 0:02:04.040000
 commands that you type.

0:02:04.040000 --> 0:02:06.840000
 You already pre-type them out
 in like a script or something.

0:02:06.840000 --> 0:02:10.880000
 So they're already typed out and it's
 sending those commands to potentially

0:02:10.880000 --> 0:02:15.820000
 hundreds of devices, maybe all at
 once, maybe one after the other.

0:02:15.820000 --> 0:02:19.620000
 So it's doing it via SSH just like you
 would do manually, but it's automating

0:02:19.620000 --> 0:02:24.360000
 the process so you can hit multiple
 devices all at once, reducing your

0:02:24.360000 --> 0:02:28.420000
 repetition. There's also SNMP.

0:02:28.420000 --> 0:02:33.360000
 SNMP can still be used to carry our
 automation commands downstream to

0:02:33.360000 --> 0:02:40.500000
 our devices. There's also NetConf,
 Yang and RestConf, Yang.

0:02:40.500000 --> 0:02:43.120000
 This gives you a little bit of
 information about NetConf.

0:02:43.120000 --> 0:02:46.740000
 What NetConf stands for is the
 network configuration protocol.

0:02:46.740000 --> 0:02:48.820000
 Now this is actually
 a transport protocol.

0:02:48.820000 --> 0:02:54.720000
 For communicating with network devices
 such as, for example, TCP is a

0:02:54.720000 --> 0:02:55.780000
 transport protocol.

0:02:55.780000 --> 0:02:58.500000
 Now I'm not saying that NetConf
 resides at layer four.

0:02:58.500000 --> 0:03:04.780000
 What I'm saying is that just like TCP,
 it purely dictates how you're going

0:03:04.780000 --> 0:03:06.840000
 to communicate with the devices.

0:03:06.840000 --> 0:03:13.240000
 It doesn't address the what related
 to what data is sent, what data is

0:03:13.240000 --> 0:03:16.960000
 received, what that data should
 look like, the format of it.

0:03:16.960000 --> 0:03:18.780000
 NetConf doesn't have anything
 to do with that.

0:03:18.780000 --> 0:03:22.740000
 It's simply how am I going to
 communicate with the device.

0:03:22.740000 --> 0:03:27.360000
 Now both NetConf and RestConf rely
 on secure transport protocols.

0:03:27.360000 --> 0:03:31.900000
 So they can use a variety of things such
 as SSH, that's what NetConf uses.

0:03:31.900000 --> 0:03:35.740000
 RestConf can use HTTP or HTTPS.

0:03:35.740000 --> 0:03:39.360000
 We can use TLS, all
 sorts of things.

0:03:39.360000 --> 0:03:42.040000
 Now one other thing that NetConf defines
 is not only how I'm going to

0:03:42.040000 --> 0:03:48.680000
 talk, but also what format the data
 should be in as it sent to and from

0:03:48.680000 --> 0:03:51.820000
 the device. Now what
 do I mean by format?

0:03:51.820000 --> 0:03:56.000000
 Well, for example, when I'm issuing,
 when I open up putty or secure CRT

0:03:56.000000 --> 0:04:01.660000
 and I initiate a telnet session or
 an SSH session, what is the format

0:04:01.660000 --> 0:04:04.060000
 of my data as I'm typing
 in my characters?

0:04:04.060000 --> 0:04:06.160000
 It's pretty much just
 ASCII text, right?

0:04:06.160000 --> 0:04:09.860000
 It's just whatever I type in is being
 converted into ASCII and then sent

0:04:09.860000 --> 0:04:14.380000
 directly to the device which the command
 line is designed to parse ASCII

0:04:14.380000 --> 0:04:18.760000
 and to know what an A is, what the
 number one is, what the number two

0:04:18.760000 --> 0:04:19.960000
 is that I'm sending.

0:04:19.960000 --> 0:04:21.600000
 So that's the format of the data.

0:04:21.600000 --> 0:04:25.720000
 Well in this case, NetConf and RestConf
 do not rely on ASCII, they've

0:04:25.720000 --> 0:04:26.940000
 got something else.

0:04:26.940000 --> 0:04:31.640000
 NetConf actually says that the data has
 to go back and forth in XML format,

0:04:31.640000 --> 0:04:34.360000
 which stands for extensible
 markup language.

0:04:34.360000 --> 0:04:39.920000
 RestConf, very similar to NetConf,
 can also use XML if you're familiar

0:04:39.920000 --> 0:04:44.480000
 with that or can also use JSON formatted
 data if you prefer that.

0:04:44.480000 --> 0:04:48.420000
 And there are actually a lot of advantages
 of using JSON over XML, but

0:04:48.420000 --> 0:04:50.820000
 we're not going to get into that
 in this particular video.

0:04:50.820000 --> 0:04:54.700000
 Now both of these have a slash and then
 say Yang after that, what is Yang?

0:04:54.700000 --> 0:05:01.480000
 Well Yang is another acronym, it stands
 for yet another next generation.

0:05:01.480000 --> 0:05:03.880000
 That's Yang, yet another
 next generation.

0:05:03.880000 --> 0:05:11.760000
 And this is a data modeling language used
 for NetConf among other protocols.

0:05:11.760000 --> 0:05:18.980000
 So what Yang does is it defines a data
 model to describe networking concepts

0:05:18.980000 --> 0:05:21.880000
 in a way that's reliable
 and consistent.

0:05:21.880000 --> 0:05:26.280000
 For example, let's say you want a query
 router via NetConf Yang for the

0:05:26.280000 --> 0:05:29.360000
 status about one of
 its interfaces.

0:05:29.360000 --> 0:05:34.240000
 Well Yang is what defines
 what an interface is.

0:05:34.240000 --> 0:05:40.680000
 For example, would you send it across
 saying port or interface or int

0:05:40.680000 --> 0:05:46.020000
 or PT? Well Yang would say how do
 I describe what an interface is?

0:05:46.020000 --> 0:05:49.100000
 And what are the components
 of a standard interface?

0:05:49.100000 --> 0:05:50.520000
 Well Yang would define
 that as well.

0:05:50.520000 --> 0:05:53.700000
 Yang would say well, and interface
 is supposed to have status.

0:05:53.700000 --> 0:05:55.760000
 Is it up, is it down?

0:05:55.760000 --> 0:05:59.320000
 Is it supposed to have, and maybe an
 address, an interface should have

0:05:59.320000 --> 0:06:04.860000
 a speed? So Yang is a data model that
 describes generic things like what

0:06:04.860000 --> 0:06:06.240000
 is an interface?

0:06:06.240000 --> 0:06:09.920000
 What is a routing protocol,
 things of that nature?

0:06:09.920000 --> 0:06:12.800000
 And how those components are
 supposed to be represented?

0:06:12.800000 --> 0:06:18.620000
 For example, if I'm querying a router
 or a switch from information about

0:06:18.620000 --> 0:06:24.340000
 its interface, well, that query I'm
 sending, is it all going to be sent

0:06:24.340000 --> 0:06:28.840000
 as a string? Is it going to be
 sent as binary ones and zeros?

0:06:28.840000 --> 0:06:33.780000
 Is it going to be sent as maybe
 numbers like integers or floats?

0:06:33.780000 --> 0:06:35.960000
 Well Yang defines that.

0:06:35.960000 --> 0:06:40.420000
 Yang might say okay, the interface
 name, like FastEthernet or Gigabit,

0:06:40.420000 --> 0:06:43.780000
 that should go across as a string,
 which would make sense.

0:06:43.780000 --> 0:06:47.440000
 A string is characters like AGI.

0:06:47.440000 --> 0:06:53.320000
 It might say okay, well, as far as the
 interface number, that should go

0:06:53.320000 --> 0:06:55.240000
 across as an integer.

0:06:55.240000 --> 0:06:58.340000
 Wouldn't make sense to represent
 Gigabit 1 slash 2.

0:06:58.340000 --> 0:07:03.080000
 It wouldn't make sense to represent
 the 1 slash 2 as a string or binary,

0:07:03.080000 --> 0:07:05.780000
 we should represent that as
 a number, as an integer.

0:07:05.780000 --> 0:07:06.760000
 Yang would define that.

0:07:06.760000 --> 0:07:10.820000
 So Yang is a data modeling language that
 defines those things that NetConf

0:07:10.820000 --> 0:07:12.240000
 can take advantage of.

0:07:12.240000 --> 0:07:17.040000
 We also have OpenFlow
 and Cisco OpFlex.

0:07:17.040000 --> 0:07:23.220000
 Both of these are also languages used
 to communicate and automate routers

0:07:23.220000 --> 0:07:28.340000
 and switches. OpenFlow is
 an industry standard.

0:07:28.340000 --> 0:07:34.680000
 It was a way to actually programmatically
 influence the forwarding table

0:07:34.680000 --> 0:07:37.300000
 of a router or a switch.

0:07:37.300000 --> 0:07:42.160000
 In other words, usually we think, let's
 just take a router from moment.

0:07:42.160000 --> 0:07:44.360000
 Think of the forwarding table,
 what is the forwarding table?

0:07:44.360000 --> 0:07:46.600000
 We normally call that the
 route table, right?

0:07:46.600000 --> 0:07:50.480000
 Or maybe if you're talking about a forwarding
 information base, like Cisco

0:07:50.480000 --> 0:07:52.940000
 Express forwarding has a forwarding
 information base.

0:07:52.940000 --> 0:07:57.760000
 But when a packet comes into a router,
 there is some table somewhere in

0:07:57.760000 --> 0:08:02.760000
 memory that packet has to be compared
 against, and that table will say,

0:08:02.760000 --> 0:08:06.280000
 yes, here's a match, and here's
 what you do with that packet.

0:08:06.280000 --> 0:08:08.600000
 You send it out this interface.

0:08:08.600000 --> 0:08:10.080000
 So there's some table.

0:08:10.080000 --> 0:08:15.420000
 Well, how does that data get into
 that table in the first place?

0:08:15.420000 --> 0:08:18.460000
 Well, in the normal course of learning
 about routers and switches, normally

0:08:18.460000 --> 0:08:22.200000
 we have to program some feature like we
 have to program a routing protocol,

0:08:22.200000 --> 0:08:27.480000
 for example, like EIGR peer OSPF that
 will learn routes and put those

0:08:27.480000 --> 0:08:29.280000
 routes in the routing table.

0:08:29.280000 --> 0:08:33.860000
 Or maybe we statically configure route,
 but somehow the router has to

0:08:33.860000 --> 0:08:37.380000
 learn of information to put
 into that routing table.

0:08:37.380000 --> 0:08:42.400000
 Well, OpenFlow was designed to
 say, hey, why don't we do this?

0:08:42.400000 --> 0:08:47.820000
 Why don't we take that logic, that ability
 to learn where everything is?

0:08:47.820000 --> 0:08:52.160000
 Why don't we remove that logic from
 the actual device and put that logic

0:08:52.160000 --> 0:08:56.720000
 on a separate device called,
 you guessed it, a controller?

0:08:56.720000 --> 0:09:01.400000
 Let's let the controller know where
 everything is, the best path to get

0:09:01.400000 --> 0:09:04.480000
 to everything, and then once the controller
 figures that out, we will

0:09:04.480000 --> 0:09:09.320000
 use OpenFlow to send commands down to
 that router, say, hey, program your

0:09:09.320000 --> 0:09:11.320000
 routing table with this path.

0:09:11.320000 --> 0:09:13.360000
 Program your routing table
 with this other path.

0:09:13.360000 --> 0:09:17.240000
 Hey, switch, program your switching
 table with this entry.

0:09:17.240000 --> 0:09:21.520000
 So the router switch at this point can
 just be a dumb device with a table,

0:09:21.520000 --> 0:09:24.560000
 and it's just sitting back and saying,
 OK, controller, tell me, what do

0:09:24.560000 --> 0:09:25.660000
 you want in this table?

0:09:25.660000 --> 0:09:28.420000
 Instead of the router, switch
 learning it directly.

0:09:28.420000 --> 0:09:31.260000
 That is what OpenFlow
 was designed to do.

0:09:31.260000 --> 0:09:33.540000
 Now, Cisco took a little bit
 of a different approach.

0:09:33.540000 --> 0:09:36.860000
 They said, hey, we've got all these routers
 and switches out there already.

0:09:36.860000 --> 0:09:42.540000
 They have massive intelligence to be
 able to do EIGRP, OSPF, dynamic Mac

0:09:42.540000 --> 0:09:46.700000
 learning. We've got specialized ASIX,
 actually, that we've invested millions

0:09:46.700000 --> 0:09:51.100000
 of dollars in to do this kind of stuff,
 to learn this kind of information

0:09:51.100000 --> 0:09:54.780000
 super fast and put it in
 these memory tables.

0:09:54.780000 --> 0:09:59.780000
 So rather than scrapping all of that
 and going with OpenFlow, Cisco said

0:09:59.780000 --> 0:10:01.880000
 we're going to do a slightly
 different approach.

0:10:01.880000 --> 0:10:06.400000
 We're still going to use the router switch
 to as the brain to dynamically

0:10:06.400000 --> 0:10:08.840000
 learn where everything out is.

0:10:08.840000 --> 0:10:16.160000
 Cisco OSPFLEX is basically a way of sort
 of, it's a glorified way of sending

0:10:16.160000 --> 0:10:19.940000
 commands down to the router switch,
 not just an SSH or something, but

0:10:19.940000 --> 0:10:25.080000
 the intelligence of the learning process,
 of learning Mac addresses, learning

0:10:25.080000 --> 0:10:29.480000
 routes, still resides in the individual
 device in an OPFLEX environment,

0:10:29.480000 --> 0:10:35.060000
 but OPFLEX can be used to send a command
 down saying, hey, brain on router,

0:10:35.060000 --> 0:10:39.060000
 I want you to do EIGRP,
 I want you to do OSPF.

0:10:39.060000 --> 0:10:41.640000
 This is the filter I want
 you to implement.

0:10:41.640000 --> 0:10:44.040000
 Here's the access list
 I want you to do.

0:10:44.040000 --> 0:10:48.520000
 So the actual learning is still taking
 place on the router or the switch,

0:10:48.520000 --> 0:10:55.480000
 but OPFLEX can be used to implement that
 learning or enhance that learning

0:10:55.480000 --> 0:10:59.960000
 of how it learns things, as opposed
 to OpenFlow which directly impacts

0:10:59.960000 --> 0:11:06.700000
 the forwarding table itself.

0:11:06.700000 --> 0:11:09.440000
 And then we also have REST APIs.

0:11:09.440000 --> 0:11:14.300000
 REST APIs are not typically used from
 a controller downstream to a network

0:11:14.300000 --> 0:11:19.040000
 device, although in some cases they
 can be, REST APIs in the terms of

0:11:19.040000 --> 0:11:24.920000
 network automation is for an external
 application to communicate with

0:11:24.920000 --> 0:11:29.980000
 the controller. For example, let's say
 that I have two different controllers

0:11:29.980000 --> 0:11:31.840000
 here from two different vendors.

0:11:31.840000 --> 0:11:36.900000
 Let's say that controller number one
 right here has network automation

0:11:36.900000 --> 0:11:39.300000
 functionality built right into it.


0:11:39.300000 --> 0:11:42.940000
 So I can go into that controller and
 I can create a bunch of stuff, so

0:11:42.940000 --> 0:11:48.340000
 it will reach out dynamically to 50
 or 100 or 1000 routers and it will

0:11:48.340000 --> 0:11:53.000000
 automate them. It'll program them
 with configurations and whatnot.

0:11:53.000000 --> 0:11:55.640000
 So that can all be done from
 this controller right here.

0:11:55.640000 --> 0:12:00.600000
 Let's say I have another controller that
 it can do a whole bunch of stuff,

0:12:00.600000 --> 0:12:02.020000
 but it can't do that.

0:12:02.020000 --> 0:12:04.180000
 It can't do network automation.

0:12:04.180000 --> 0:12:07.840000
 Well, in that case, I could use an
 external tool, some other external

0:12:07.840000 --> 0:12:11.020000
 to another server, to do
 the automation piece.

0:12:11.020000 --> 0:12:15.440000
 I'll write my scripts and configuration
 files over here and then using

0:12:15.440000 --> 0:12:20.580000
 a REST API, that device can communicate
 with my controller.

0:12:20.580000 --> 0:12:25.040000
 It can say, hey, controller, I can't talk
 to the router or switch directly,

0:12:25.040000 --> 0:12:29.520000
 but you can. So can you push down this
 configuration file to these 50

0:12:29.520000 --> 0:12:32.200000
 routers on my behalf?

0:12:32.200000 --> 0:12:36.660000
 The REST API can be used
 in that situation.

0:12:36.660000 --> 0:12:39.220000
 So what is the impact
 of all of this?

0:12:39.220000 --> 0:12:40.960000
 What's the impact of
 network automation?

0:12:40.960000 --> 0:12:44.120000
 I think you're starting to get a feel
 here for just how valuable this

0:12:44.120000 --> 0:12:48.740000
 can be. Well, network
 management impacted.

0:12:48.740000 --> 0:12:52.300000
 Number one, cost reduction,
 big deal right here.

0:12:52.300000 --> 0:12:56.300000
 You know, this is actually a fear of
 a lot of network engineers is that

0:12:56.300000 --> 0:12:59.540000
 they're going to be scaled back that a
 company that used to have 50 network

0:12:59.540000 --> 0:13:04.880000
 engineers now might need only five or
 six because they implement network

0:13:04.880000 --> 0:13:09.300000
 automation. So that would certainly be
 a cost reduction, a saving standpoint

0:13:09.300000 --> 0:13:14.280000
 from the standpoint of the company,
 but that's not necessarily the case.

0:13:14.280000 --> 0:13:17.980000
 They might still keep those same 50 engineers,
 but maybe what's been happening

0:13:17.980000 --> 0:13:19.720000
 is up until now.

0:13:19.720000 --> 0:13:26.120000
 Those 50 engineers have been spending
 the vast majority of their time

0:13:26.120000 --> 0:13:31.000000
 troubleshooting the network, issuing
 repetitive commands to monitor and

0:13:31.000000 --> 0:13:34.060000
 troubleshooting the network, and only
 a tiny little slice of their time

0:13:34.060000 --> 0:13:38.240000
 has been actually used to enhance the
 network, to design the network,

0:13:38.240000 --> 0:13:40.560000
 to build on top of it,
 to make it better.

0:13:40.560000 --> 0:13:43.060000
 They don't have time for that because
 most of their time is spent doing

0:13:43.060000 --> 0:13:47.680000
 these repetitious tasks, these repetitive
 tasks of troubleshooting and

0:13:47.680000 --> 0:13:52.920000
 monitoring. Well, with network automation,
 we can now automate a lot of

0:13:52.920000 --> 0:13:56.260000
 that stuff to give consistency
 across the network.

0:13:56.260000 --> 0:14:00.240000
 So now hopefully there will be a lot
 less time troubleshooting and these

0:14:00.240000 --> 0:14:03.940000
 engineers can now devote their time
 to stuff that's more profitable for

0:14:03.940000 --> 0:14:07.920000
 the company like designing the network,
 making it better, enhancing it,

0:14:07.920000 --> 0:14:11.740000
 learning new features and protocols that
 they didn't have time to do before.

0:14:11.740000 --> 0:14:14.880000
 That's also a cost reduction.

0:14:14.880000 --> 0:14:18.100000
 A time savings and elimination of repetition,
 and I've been mentioning

0:14:18.100000 --> 0:14:21.760000
 this over and over and over again, I think
 that goes without saying, configuration

0:14:21.760000 --> 0:14:27.500000
 consistency, elastic scaling,
 what's that referring to?

0:14:27.500000 --> 0:14:33.540000
 This is typically more use in the context
 of network of automation being

0:14:33.540000 --> 0:14:37.740000
 applied to servers, where you've got
 like a physical server and you've

0:14:37.740000 --> 0:14:41.400000
 got virtual servers in there, and we
 can use automation to dynamically

0:14:41.400000 --> 0:14:46.140000
 create some more virtual servers on
 the fly as we need them, and then

0:14:46.140000 --> 0:14:50.520000
 take those virtual servers away
 when the need no longer exists.

0:14:50.520000 --> 0:14:54.140000
 Now network automation can also be
 used for scaling when it does come

0:14:54.140000 --> 0:14:57.960000
 to the network. For example, we could
 bring up a new WAN circuit that's

0:14:57.960000 --> 0:15:01.620000
 just being sort of held in a backup state
 and give ourselves more bandwidth

0:15:01.620000 --> 0:15:05.300000
 across the WAN temporarily, and then
 bring that circuit down and put it

0:15:05.300000 --> 0:15:07.720000
 back into a backup state
 when we don't need it.

0:15:07.720000 --> 0:15:10.940000
 Network automation could do that as
 well, so that makes the network more

0:15:10.940000 --> 0:15:13.980000
 elastic and scalable.

0:15:13.980000 --> 0:15:17.400000
 So here's the crux of it all.

0:15:17.400000 --> 0:15:21.860000
 Up until now, you may have been really
 good with the command line.

0:15:21.860000 --> 0:15:26.080000
 You may be really knowledgeable about
 doing software upgrades and downgrades

0:15:26.080000 --> 0:15:29.620000
 and patches. Maybe you're really good
 with network monitoring with an

0:15:29.620000 --> 0:15:35.260000
 SNMP solution, but as network automation
 becomes more and more prevalent,

0:15:35.260000 --> 0:15:39.360000
 you as a network admin will start to
 need to become more familiar with

0:15:39.360000 --> 0:15:41.880000
 the server side of things.

0:15:41.880000 --> 0:15:47.520000
 All of these automation tools, all these
 controller software resides on

0:15:47.520000 --> 0:15:52.100000
 a server. So maybe up until now, you
 haven't really cared about, let's

0:15:52.100000 --> 0:15:56.500000
 see, how much memory, how much CPU power,
 how many virtual CPUs, how many

0:15:56.500000 --> 0:16:00.160000
 cores do I need to have
 to run this software?

0:16:00.160000 --> 0:16:04.340000
 Do I need to learn Linux so I can dive
 into the kernel and troubleshoot

0:16:04.340000 --> 0:16:08.360000
 when the software package isn't installing
 properly, which running really

0:16:08.360000 --> 0:16:12.300000
 slow, those are the types of things
 you actually will start to need to

0:16:12.300000 --> 0:16:17.100000
 learn to implement automation
 into your tasks.

0:16:17.100000 --> 0:16:22.340000
 But once automation is in there, hopefully
 you will gain all of these

0:16:22.340000 --> 0:16:27.340000
 benefits. So that brings us
 to the end of this video.

0:16:27.340000 --> 0:16:29.580000
 Thank you for watching and I
 hope it was useful for you.

