WEBVTT

0:00:05.020000 --> 0:00:09.560000
 Continuing our discussion about comparing
 and contrasting routing protocols

0:00:09.560000 --> 0:00:13.780000
 for the purposes of ideally being able
 to select one that's appropriate

0:00:13.780000 --> 0:00:15.800000
 for your network.

0:00:15.800000 --> 0:00:24.960000
 We're going to continue with that now
 by focusing in primarily on IGP's.

0:00:24.960000 --> 0:00:29.780000
 So routing protocols, as it says here,
 can be classified into not only

0:00:29.780000 --> 0:00:35.360000
 the categories of is it an IGP or is
 an EGP, but all routing protocols

0:00:35.360000 --> 0:00:40.020000
 can also be put into one of these four
 different categories here of distance

0:00:40.020000 --> 0:00:45.980000
 vector, link state, advanced distance
 vector, and path vector.

0:00:45.980000 --> 0:00:49.920000
 And you can see here that most of these
 pertain to your interior gateway

0:00:49.920000 --> 0:00:55.200000
 protocols. Path vector only relates
 to your exterior gateway protocol,

0:00:55.200000 --> 0:00:58.020000
 which we know is BGP.

0:00:58.020000 --> 0:01:00.460000
 So BGP is a path vector protocol.

0:01:00.460000 --> 0:01:05.440000
 All of your other protocols fall into
 one of those three categories.

0:01:05.440000 --> 0:01:10.980000
 Now, if I tell you, hey, I'm running
 a routing protocol in my network,

0:01:10.980000 --> 0:01:15.680000
 and I'm not going to tell you what it
 is, but I will tell you it's distance

0:01:15.680000 --> 0:01:19.840000
 vector. Or I will tell
 you it is link state.

0:01:19.840000 --> 0:01:24.540000
 Or maybe I say, hey, I'm thinking of designing
 a brand new routing protocol,

0:01:24.540000 --> 0:01:28.320000
 and I think I'd like it to be
 a distance vector protocol.

0:01:28.320000 --> 0:01:33.840000
 Right there, you can tell certain operational
 characteristics of how that

0:01:33.840000 --> 0:01:36.880000
 protocol will work without
 even knowing the name.

0:01:36.880000 --> 0:01:44.300000
 For example, which category it falls
 into will determine if neighbors

0:01:44.300000 --> 0:01:46.520000
 are required or not.

0:01:46.520000 --> 0:01:50.680000
 In other words, some routing protocols
 say, hey, look, before I exchange

0:01:50.680000 --> 0:01:54.500000
 routes with that router,
 I need to discover him.

0:01:54.500000 --> 0:01:59.400000
 I need to make sure we agree on some
 basic ground rules here, and then

0:01:59.400000 --> 0:02:00.940000
 I'll exchange my routes with him.

0:02:00.940000 --> 0:02:03.520000
 That's called forming a
 neighbor relationship.

0:02:03.520000 --> 0:02:06.680000
 Other routing protocols
 don't care about that.

0:02:06.680000 --> 0:02:09.560000
 They just blindly send out their routes,
 and they don't even care if anybody's

0:02:09.560000 --> 0:02:11.700000
 listening or not.

0:02:11.700000 --> 0:02:14.720000
 So if I tell you I'm running link state,
 distance vector, or advanced

0:02:14.720000 --> 0:02:18.720000
 distance vector, just by telling you
 that you'll know if I need to form

0:02:18.720000 --> 0:02:21.200000
 a neighbor relationship or not.

0:02:21.200000 --> 0:02:22.200000
 Route maintenance.

0:02:22.200000 --> 0:02:25.420000
 Remember, I told you way back several
 videos ago, I said, if I send you

0:02:25.420000 --> 0:02:30.220000
 a route, how do you know an hour from
 now, a day from now, a week from

0:02:30.220000 --> 0:02:34.900000
 now? If that route's still reachable,
 if it's still good or not, these

0:02:34.900000 --> 0:02:38.660000
 different categories
 answer that question.

0:02:38.660000 --> 0:02:42.080000
 Visibility into the
 network topology.

0:02:42.080000 --> 0:02:48.940000
 So, I'm a router, your router, were
 directly connected via a cable.

0:02:48.940000 --> 0:02:53.640000
 So, I know about myself, I know about
 my host address, I know about this

0:02:53.640000 --> 0:02:57.440000
 link, this interface,
 and I know about you.

0:02:57.440000 --> 0:03:01.040000
 You've been sending me routes, you've
 been telling me your IP address

0:03:01.040000 --> 0:03:01.880000
 is the next hop.

0:03:01.880000 --> 0:03:05.440000
 So, as far as the topology is concerned,
 if I was to draw a map, I know

0:03:05.440000 --> 0:03:09.200000
 about myself, a line,
 and I know about you.

0:03:09.200000 --> 0:03:13.400000
 The question then becomes, do
 I know about anything else?

0:03:13.400000 --> 0:03:16.120000
 Do I know about what's behind you?


0:03:16.120000 --> 0:03:20.180000
 Do I know who you're talking to,
 and who they're talking to?

0:03:20.180000 --> 0:03:24.300000
 Can I actually draw, as a router in
 my CPU and my brain, can I actually

0:03:24.300000 --> 0:03:28.180000
 draw a picture of what
 the network looks like?

0:03:28.180000 --> 0:03:33.420000
 Some of these categories say, yes, you
 can, that's important, others of

0:03:33.420000 --> 0:03:37.580000
 these categories say, no, we don't need
 that information, we don't care

0:03:37.580000 --> 0:03:42.340000
 about that. And the necessity
 of different data structures.

0:03:42.340000 --> 0:03:46.880000
 Some of these categories require maintaining
 and building multiple tables

0:03:46.880000 --> 0:03:49.520000
 and databases, nor to work.

0:03:49.520000 --> 0:03:54.200000
 Others of them are much more simple,
 require less data structures to be

0:03:54.200000 --> 0:03:56.820000
 built and maintained.

0:03:56.820000 --> 0:03:59.520000
 And we're going to go into each one
 of them one by one, each one's going

0:03:59.520000 --> 0:04:01.560000
 to have its own separate
 video coming up.

0:04:01.560000 --> 0:04:07.980000
 Some other characteristics of routing
 protocols is how they handle the

0:04:07.980000 --> 0:04:09.940000
 routing updates.

0:04:09.940000 --> 0:04:14.100000
 For example, and these are terms you
 need to be familiar with, something

0:04:14.100000 --> 0:04:22.640000
 called an incremental update means I'm
 only going to send you a routing

0:04:22.640000 --> 0:04:25.520000
 update when something changes.

0:04:25.520000 --> 0:04:33.640000
 A full update means I'm going to send
 you incremental update, only changes

0:04:33.640000 --> 0:04:34.740000
 are sent in the routing team.

0:04:34.740000 --> 0:04:37.200000
 Okay, let me take
 a step back here.

0:04:37.200000 --> 0:04:42.560000
 So these first two bullet points sort
 of define what my routing update

0:04:42.560000 --> 0:04:44.700000
 to you looks like.

0:04:44.700000 --> 0:04:49.540000
 In other words, of everything I know,
 how much am I sending to you?

0:04:49.540000 --> 0:04:54.080000
 If I'm sending you an incremental update,
 that means I'm not sending you

0:04:54.080000 --> 0:04:55.340000
 everything I know about.

0:04:55.340000 --> 0:04:59.840000
 I'm only sending you what
 I know has changed.

0:04:59.840000 --> 0:05:02.760000
 A route just came up, or I'm
 just sending that to you.

0:05:02.760000 --> 0:05:03.780000
 A route just went down.

0:05:03.780000 --> 0:05:05.560000
 Okay, I'm just sending
 that to you.

0:05:05.560000 --> 0:05:08.940000
 That's an incremental update
 versus a full update.

0:05:08.940000 --> 0:05:13.420000
 So a routing protocol that works with
 full updates means it sends everything

0:05:13.420000 --> 0:05:16.420000
 it knows about as a full update.

0:05:16.420000 --> 0:05:19.460000
 So now some other things that make routing
 protocols different from each

0:05:19.460000 --> 0:05:22.640000
 other are when they send updates.

0:05:22.640000 --> 0:05:26.140000
 So this right here was talking
 about the format of the update.

0:05:26.140000 --> 0:05:27.160000
 What's inside of it?

0:05:27.160000 --> 0:05:29.240000
 How much is inside of it?

0:05:29.240000 --> 0:05:34.600000
 Now we're going to look
 at when are they sent.

0:05:34.600000 --> 0:05:39.880000
 A periodic update means I have a time
 interval and every time I get to

0:05:39.880000 --> 0:05:43.540000
 that interval, I send
 you my update.

0:05:43.540000 --> 0:05:44.580000
 So that's periodic.

0:05:44.580000 --> 0:05:47.900000
 Like for example, RIP
 as a routing protocol.

0:05:47.900000 --> 0:05:53.040000
 RIP makes use of full updates
 and periodic updates.

0:05:53.040000 --> 0:05:58.400000
 In other words, with RIP, every 30
 seconds I send you a full update.

0:05:58.400000 --> 0:06:01.660000
 Every 30 seconds I send you everything
 I have in my brain.

0:06:01.660000 --> 0:06:08.360000
 Full update. Now someone could have
 derived, I don't think anything like

0:06:08.360000 --> 0:06:12.900000
 this exists, but somebody could have
 created a routing protocol that does

0:06:12.900000 --> 0:06:17.440000
 an incremental update at
 a periodic interval.

0:06:17.440000 --> 0:06:23.620000
 In other words, let's say every 30 seconds,
 I only send you what has been

0:06:23.620000 --> 0:06:31.040000
 changed. So let's say I very first
 turn on and I send you everything I

0:06:31.040000 --> 0:06:34.000000
 know about. 30 seconds later.

0:06:34.000000 --> 0:06:35.740000
 Has anything changed?

0:06:35.740000 --> 0:06:37.880000
 Nope. I got nothing for you.

0:06:37.880000 --> 0:06:40.940000
 Now let's say nine
 seconds into that.

0:06:40.940000 --> 0:06:42.880000
 Oh, new network comes up.

0:06:42.880000 --> 0:06:46.220000
 I got to wait until my 30 second timer
 elapses and then I'll send you

0:06:46.220000 --> 0:06:49.700000
 an incremental update about
 just that change.

0:06:49.700000 --> 0:06:51.040000
 So that would be an example.

0:06:51.040000 --> 0:06:53.640000
 There's no routing protocols that do
 this, but that would be an example

0:06:53.640000 --> 0:06:57.920000
 of a periodic update, which means I'm
 sending it every a certain period

0:06:57.920000 --> 0:07:04.280000
 every so often, but what I'm sending you
 is only changes that have occurred.

0:07:04.280000 --> 0:07:06.300000
 That does not happen.

0:07:06.300000 --> 0:07:08.720000
 That nothing exists like that.

0:07:08.720000 --> 0:07:16.660000
 And then we have a
 triggered update.

0:07:16.660000 --> 0:07:27.280000
 So typically what you would see is full
 updates are paired with periodic

0:07:27.280000 --> 0:07:33.060000
 updates. If I'm going to send you a routing
 update every 30 seconds, every

0:07:33.060000 --> 0:07:36.260000
 30 seconds, it's going
 to be a full update.

0:07:36.260000 --> 0:07:38.880000
 Most other routing,
 that's like RIP.

0:07:38.880000 --> 0:07:41.660000
 The routing information
 protocol does that.

0:07:41.660000 --> 0:07:48.560000
 Most other routing protocols pair incremental
 updates with a triggered

0:07:48.560000 --> 0:07:54.560000
 update, meaning if a change
 happens, that's the trigger.

0:07:54.560000 --> 0:07:58.840000
 That's when I'm going to do something
 and what I'm going to send you is

0:07:58.840000 --> 0:08:00.380000
 going to be the change.

0:08:00.380000 --> 0:08:02.640000
 It's going to be what did
 I just learn about?

0:08:02.640000 --> 0:08:03.880000
 So that's everything else.

0:08:03.880000 --> 0:08:15.900000
 OSPF, EIGRP, RIP, even BGP,
 they operate that way.

0:08:15.900000 --> 0:08:18.980000
 So those are some examples of ways
 that we can categorize our routing

0:08:18.980000 --> 0:08:22.440000
 protocols. Now in the next video, we're
 going to go into distance vector

0:08:22.440000 --> 0:08:26.440000
 and talk about some of the characteristics
 of how distance vector routing

0:08:26.440000 --> 0:08:27.760000
 protocols operate.