WEBVTT

0:00:05.040000 --> 0:00:09.140000
 So let's contrast those same things
 against routing protocols that fall

0:00:09.140000 --> 0:00:13.540000
 into another category, which are called
 link state routing protocols.

0:00:13.540000 --> 0:00:18.780000
 Maybe you don't like the way distance
 vector sends its updates as full

0:00:18.780000 --> 0:00:21.080000
 updates periodically.

0:00:21.080000 --> 0:00:22.440000
 Maybe you think that's overkill.

0:00:22.440000 --> 0:00:23.780000
 Maybe you don't like that.

0:00:23.780000 --> 0:00:25.860000
 Okay, what other alternative
 do you have?

0:00:25.860000 --> 0:00:28.280000
 This might be a suitable
 alternative.

0:00:28.280000 --> 0:00:32.520000
 Link state. Neighbor relationships
 are required.

0:00:32.520000 --> 0:00:36.240000
 In other words, a router has to learn
 of directly connected neighbors

0:00:36.240000 --> 0:00:38.840000
 and establish some
 ground rules first.

0:00:38.840000 --> 0:00:41.300000
 Certain things have to match.

0:00:41.300000 --> 0:00:45.260000
 On the one hand, that might sound good
 to you because you might say, okay,

0:00:45.260000 --> 0:00:48.780000
 good because, you know, I don't want
 it just speaking to any old router

0:00:48.780000 --> 0:00:53.880000
 out there. I want to make sure I'm talking
 to trusted neighbors that they're

0:00:53.880000 --> 0:00:56.940000
 not rogue routers that have been
 inserted into my organization.

0:00:56.940000 --> 0:01:00.860000
 So yeah, I like the idea of a neighbor
 relationship, of certain things

0:01:00.860000 --> 0:01:02.620000
 being established beforehand.

0:01:02.620000 --> 0:01:07.760000
 Sounds good. The downside to this is
 that's additional stuff that could

0:01:07.760000 --> 0:01:11.640000
 fail, right? It's sort of
 like your car, right?

0:01:11.640000 --> 0:01:14.340000
 The more bells and whistles you have
 in your car, the more features you

0:01:14.340000 --> 0:01:17.640000
 have in your car, the more things that
 could fail that force you to take

0:01:17.640000 --> 0:01:20.840000
 it back to the auto mechanic to have
 it diagnosed and troubleshooted.

0:01:20.840000 --> 0:01:21.920000
 So same thing here.

0:01:21.920000 --> 0:01:26.080000
 With neighbor relationships, those things
 they have to be checked could

0:01:26.080000 --> 0:01:30.820000
 potentially fail due to like a misconfiguration
 or an air of some sort,

0:01:30.820000 --> 0:01:32.940000
 which leads to further
 troubleshooting.

0:01:32.940000 --> 0:01:34.600000
 So that's a potential
 downside to that.

0:01:34.600000 --> 0:01:37.620000
 That distance vector doesn't
 have that problem.

0:01:37.620000 --> 0:01:39.040000
 Route maintenance.

0:01:39.040000 --> 0:01:40.960000
 How's the route still believable?

0:01:40.960000 --> 0:01:46.360000
 Well, in a link state routing protocol,
 initially when two routers discover

0:01:46.360000 --> 0:01:49.580000
 each other and they establish the ground
 rules, they will exchange between

0:01:49.580000 --> 0:01:51.200000
 each other everything they know.

0:01:51.200000 --> 0:01:54.740000
 So they'll basically do a full update
 of all their information.

0:01:54.740000 --> 0:01:58.380000
 At that point, they will start
 exchanging hello packets.

0:01:58.380000 --> 0:02:00.300000
 They're sometimes called
 keep-alives.

0:02:00.300000 --> 0:02:02.740000
 And these are going to be exchanged
 every few seconds, like every five

0:02:02.740000 --> 0:02:04.600000
 or ten seconds, possibly.

0:02:04.600000 --> 0:02:06.080000
 But they're very, very small.

0:02:06.080000 --> 0:02:07.740000
 They don't consume
 a lot of bandwidth.

0:02:07.740000 --> 0:02:13.360000
 And the idea is, if I send you everything
 I know, and then I exchange

0:02:13.360000 --> 0:02:16.520000
 keep-alives with you, you
 know I'm still alive.

0:02:16.520000 --> 0:02:18.220000
 Everything I know is still valid.

0:02:18.220000 --> 0:02:21.880000
 You can just trust me that everything
 I sent you is still valid.

0:02:21.880000 --> 0:02:25.980000
 And if something changes,
 I'll tell you about it.

0:02:25.980000 --> 0:02:27.980000
 I'll give you a triggered update.

0:02:27.980000 --> 0:02:33.740000
 I'll give you a partial or an incremental
 update about what has changed.

0:02:33.740000 --> 0:02:37.760000
 But I'm just going to send you keep
-alives and you can just trust that

0:02:37.760000 --> 0:02:40.440000
 what I sent you is okay.

0:02:40.440000 --> 0:02:47.440000
 Now, one sort of caveat to that is that
 with link state routing protocols,

0:02:47.440000 --> 0:02:53.660000
 they say, okay, I don't want to sit
 back and let's say the network never

0:02:53.660000 --> 0:02:58.940000
 changes for the next
 week, month, year.

0:02:58.940000 --> 0:03:04.480000
 Some people would say, well, you should
 probably re-send that route every

0:03:04.480000 --> 0:03:08.760000
 once in a while just to make
 sure it's still okay.

0:03:08.760000 --> 0:03:12.880000
 It's good to have keep-alives, hello
 packets going back and forth, but

0:03:12.880000 --> 0:03:17.680000
 just to be doubly sure, why
 don't you re-send the route?

0:03:17.680000 --> 0:03:19.340000
 Don't do it like a
 distance vector.

0:03:19.340000 --> 0:03:22.860000
 Distance vector resends the
 route like every 30 seconds.

0:03:22.860000 --> 0:03:27.040000
 Link state protocols say, let's wait
 a much, much, much longer period

0:03:27.040000 --> 0:03:32.800000
 of time. And if the route is still good
 for this long, then send it again.

0:03:32.800000 --> 0:03:36.660000
 The visibility into the network
 topology is complete.

0:03:36.660000 --> 0:03:40.280000
 In a link state protocol, a router
 not only learns about his directly

0:03:40.280000 --> 0:03:44.980000
 connected neighbors, he learns everything,
 who his neighbors are talking

0:03:44.980000 --> 0:03:47.380000
 to. Who they're talking to.

0:03:47.380000 --> 0:03:49.060000
 What types of links are out there?


0:03:49.060000 --> 0:03:50.260000
 Are they point to point?

0:03:50.260000 --> 0:03:52.180000
 Are they broadcast links?

0:03:52.180000 --> 0:03:57.840000
 Is able to actually build in its mind
 a topology map of the entire topology?

0:03:57.840000 --> 0:04:00.060000
 So it knows everything.

0:04:00.060000 --> 0:04:03.980000
 Some people say, that's good, a router
 should know about everything, a

0:04:03.980000 --> 0:04:07.740000
 router should be able to determine
 the best path for himself.

0:04:07.740000 --> 0:04:10.340000
 Other people say, that's overkill.


0:04:10.340000 --> 0:04:12.100000
 Distance vector is better.

0:04:12.100000 --> 0:04:15.700000
 Let your neighbor tell you what the
 best path is to a given destination.

0:04:15.700000 --> 0:04:18.300000
 You don't need to know what the entire
 topology looks like to figure it

0:04:18.300000 --> 0:04:19.840000
 out for yourself.

0:04:19.840000 --> 0:04:28.340000
 Depends on who you're talking to.

0:04:28.340000 --> 0:04:33.460000
 They actually are the most
 resource consumptive.

0:04:33.460000 --> 0:04:39.680000
 In other words, link state routing protocols
 have the routing table that

0:04:39.680000 --> 0:04:45.660000
 they feed into. They have a database,
 so everything they learn from their

0:04:45.660000 --> 0:04:48.220000
 neighbors is stored in a database.


0:04:48.220000 --> 0:04:50.740000
 They have another table
 of their neighbors.

0:04:50.740000 --> 0:04:53.260000
 They track, okay, I've learned
 these neighbors.

0:04:53.260000 --> 0:04:55.240000
 How long has it been since
 I talked to that neighbor?

0:04:55.240000 --> 0:04:57.740000
 What interface did I learn him on?


0:04:57.740000 --> 0:04:59.740000
 What kind of a neighbor is he?

0:04:59.740000 --> 0:05:03.040000
 All of that is stored in a different
 table, a neighbor table.

0:05:03.040000 --> 0:05:07.500000
 And then they build something called an
 SPF tree, which stands for shortest

0:05:07.500000 --> 0:05:13.160000
 path first. SPF tree basically is what
 the entire topology looks like.

0:05:13.160000 --> 0:05:16.680000
 That tree of I'm at the center of the
 universe and here's my neighbors

0:05:16.680000 --> 0:05:19.100000
 and here's their neighbors and
 here's how they're connected.

0:05:19.100000 --> 0:05:20.820000
 That is the SPF tree.

0:05:20.820000 --> 0:05:25.280000
 So link state protocols have to maintain
 all this different stuff to do

0:05:25.280000 --> 0:05:34.220000
 their job. And OSPF and ISIS are
 examples of link state protocols.

0:05:34.220000 --> 0:05:36.040000
 And please forgive me for
 the misspelling there.

0:05:36.040000 --> 0:05:39.300000
 It should actually be IS-IS.

0:05:39.300000 --> 0:05:42.980000
 And so that concludes this video
 on link state routing protocols.

0:05:42.980000 --> 0:05:46.220000
 In the next video, we will look at
 something called advanced distance

0:05:46.220000 --> 0:05:47.780000
 vector routing protocols.