WEBVTT

0:00:08.160000 --> 0:00:12.860000
 In this video, I'd like to introduce
 the concept of GRE tunnels.

0:00:12.860000 --> 0:00:15.860000
 And before I do that, let me just back
 up for a moment and talk about

0:00:15.860000 --> 0:00:18.780000
 what is a tunnel in
 the first place.

0:00:18.780000 --> 0:00:22.760000
 Here's a real high level of looking
 at this concept of a tunnel.

0:00:22.760000 --> 0:00:25.280000
 So imagine for a moment
 an IP packet.

0:00:25.280000 --> 0:00:29.500000
 Okay, so imagine in binary you have
 a string of bits which is your data,

0:00:29.500000 --> 0:00:31.760000
 maybe your web browsing
 or whatever.

0:00:31.760000 --> 0:00:34.400000
 And then in front of that string of
 bits you have another string of bits

0:00:34.400000 --> 0:00:38.260000
 which is your TCP segment header.

0:00:38.260000 --> 0:00:42.300000
 And then in front of that you've got
 another string of bits which is your

0:00:42.300000 --> 0:00:44.500000
 IP header. And that's
 where it ends.

0:00:44.500000 --> 0:00:49.060000
 So you've got your IP header, your TCP
 header, and then all of your data.

0:00:49.060000 --> 0:00:51.500000
 Now that long string of bits.

0:00:51.500000 --> 0:00:56.980000
 Can you take that as it is and put
 it on a wire and send it out?

0:00:56.980000 --> 0:01:01.800000
 Hopefully you said, well no Keith,
 you can't take a layer three packet

0:01:01.800000 --> 0:01:04.100000
 and place it directly on a wire.

0:01:04.100000 --> 0:01:06.640000
 You can't just bypass
 the data link layer.

0:01:06.640000 --> 0:01:08.280000
 We need the data link layer.

0:01:08.280000 --> 0:01:10.500000
 Why do we need the
 data link layer?

0:01:10.500000 --> 0:01:15.400000
 Well because that wire, let's just
 assume it's an Ethernet wire.

0:01:15.400000 --> 0:01:21.140000
 That Ethernet wire is expecting ones and
 zeros to take the form of Ethernet.

0:01:21.140000 --> 0:01:25.280000
 In other words if I send a string of
 bits to you and it arrives on your

0:01:25.280000 --> 0:01:30.000000
 Ethernet nitcard, your Ethernet nitcard
 is assuming the first few ones

0:01:30.000000 --> 0:01:32.220000
 and zeros are the preamble.

0:01:32.220000 --> 0:01:36.260000
 And then the next few ones and zeros
 after that are a destination Mac.

0:01:36.260000 --> 0:01:37.860000
 And then there's a source Mac.

0:01:37.860000 --> 0:01:40.720000
 So if I just sent you a string of ones
 and zeros that started with the

0:01:40.720000 --> 0:01:43.460000
 IP header and there was no Ethernet
 header in front of that.

0:01:43.460000 --> 0:01:45.560000
 You wouldn't be able
 to interpret that.

0:01:45.560000 --> 0:01:47.400000
 You wouldn't know what
 to do with that.

0:01:47.400000 --> 0:01:52.360000
 So I need to take that IP packet and
 wrap it inside of something that

0:01:52.360000 --> 0:01:53.300000
 you will understand.

0:01:53.300000 --> 0:01:57.880000
 Something that this cable supports
 that I can send to you because your

0:01:57.880000 --> 0:02:01.040000
 nitcard does not natively
 understand IP.

0:02:01.040000 --> 0:02:06.340000
 But it does understand another protocol,
 Ethernet, which carries IP.

0:02:06.340000 --> 0:02:11.240000
 So typically we say that that's
 the process of encapsulation.

0:02:11.240000 --> 0:02:15.820000
 We're on taking some protocol, in this
 case a layer two protocol, Ethernet.

0:02:15.820000 --> 0:02:20.760000
 And I'm using it to encapsulate something
 else, which in this case is

0:02:20.760000 --> 0:02:23.460000
 a layer three protocol,
 which is IP.

0:02:23.460000 --> 0:02:26.080000
 Another way of saying
 that is tunneling.

0:02:26.080000 --> 0:02:29.700000
 In other words, I'm taking some protocol
 that does not natively go across

0:02:29.700000 --> 0:02:33.680000
 this wire. I can't put on this wire
 and I'm saying, well, how can I put

0:02:33.680000 --> 0:02:34.820000
 across this wire?

0:02:34.820000 --> 0:02:39.640000
 What if I take this data, the structure
 here, whatever it is, and wrapped

0:02:39.640000 --> 0:02:44.620000
 it in something else that is supported
 on this wire and got it through?

0:02:44.620000 --> 0:02:48.100000
 Now in the case of Ethernet, it's
 just point to point, right?

0:02:48.100000 --> 0:02:53.560000
 On Ethernet, you and I share an Ethernet
 wire so I encapsulate the Ethernet.

0:02:53.560000 --> 0:02:55.560000
 But let's take it
 one step further.

0:02:55.560000 --> 0:03:02.460000
 Let's say that I had a situation like
 this, where I have a couple of routers

0:03:02.460000 --> 0:03:08.580000
 on the end that have
 an IPv6 network.

0:03:08.580000 --> 0:03:12.500000
 But in the middle,
 there is no IPv6.

0:03:12.500000 --> 0:03:18.000000
 Could I put an IPv6 packet
 on this wire right here?

0:03:18.000000 --> 0:03:23.660000
 No, I couldn't because fast Ethernet
 00 on R1 doesn't even have an IPv6

0:03:23.660000 --> 0:03:27.580000
 address. That interface does
 not understand IPv6.

0:03:27.580000 --> 0:03:32.420000
 And even if somehow I could put an IPv6
 packet on there, when it got to

0:03:32.420000 --> 0:03:35.800000
 this device right here, he
 doesn't understand IPv6.

0:03:35.800000 --> 0:03:42.040000
 There's no way I can natively put an
 IPv6 packet from R1 to R2 because

0:03:42.040000 --> 0:03:45.480000
 the devices in the middle
 don't support IPv6.

0:03:45.480000 --> 0:03:47.640000
 But what if I could do this?

0:03:47.640000 --> 0:03:55.840000
 What if I could take my IPv6 packet
 so maybe on R1, I type ping, 2001,

0:03:55.840000 --> 0:03:59.860000
 2222, 2222, 2222, colon colon 2.

0:03:59.860000 --> 0:04:02.020000
 So I'm doing an IPv6 ping.

0:04:02.020000 --> 0:04:06.880000
 In order to get that to go across,
 what if I took that IPv6 packet and

0:04:06.880000 --> 0:04:17.060000
 at the front of it, I put an IPv4 header,
 an IPv4 header with 1.1.1.1

0:04:17.060000 --> 0:04:22.860000
 is the source, and how about
 2.2.2.2 as the destination?

0:04:22.860000 --> 0:04:24.920000
 That could go across that wire.

0:04:24.920000 --> 0:04:28.640000
 That could go from router 1 to router
 2 because all these devices know

0:04:28.640000 --> 0:04:31.440000
 how to route IPv4.

0:04:31.440000 --> 0:04:35.720000
 That is what's called tunneling,
 where I create a tunnel.

0:04:35.720000 --> 0:04:39.080000
 And in this case, the two endpoints
 of the tunnel will be router 1 and

0:04:39.080000 --> 0:04:46.840000
 router 2. And what this tunnel is doing
 is it's taking information in

0:04:46.840000 --> 0:04:51.420000
 that normally could not go across this
 connection and it's somehow wrapping

0:04:51.420000 --> 0:04:55.980000
 it in some additional header that my
 intermediary, my transit network

0:04:55.980000 --> 0:04:59.540000
 does understand and can
 carry it through.

0:04:59.540000 --> 0:05:02.900000
 And then once it pops out the other
 end of the tunnel, then we can strip

0:05:02.900000 --> 0:05:07.560000
 off that outer header revealing the native
 packet inside and we can process

0:05:07.560000 --> 0:05:10.180000
 it. That's what's
 called tunneling.

0:05:10.180000 --> 0:05:12.620000
 Now there's a variety of
 ways to do tunneling.

0:05:12.620000 --> 0:05:16.880000
 A lot of times in a lot of devices,
 you will actually create a tunnel

0:05:16.880000 --> 0:05:20.520000
 interface. Just like we've talked about
 loopback interfaces, which are

0:05:20.520000 --> 0:05:24.500000
 logical interfaces, we've talked about
 sub interfaces, which are logical

0:05:24.500000 --> 0:05:27.080000
 interfaces. I talked about
 dialer interfaces.

0:05:27.080000 --> 0:05:30.560000
 Well, now we're going to do another logical
 interface that does not exist

0:05:30.560000 --> 0:05:36.040000
 until you create it by typing it
 in, which is an interface tunnel.

0:05:36.040000 --> 0:05:41.520000
 Now when you create an interface tunnel,
 then the question is, okay, well,

0:05:41.520000 --> 0:05:43.820000
 how is it going to encapsulate
 something?

0:05:43.820000 --> 0:05:44.820000
 What's it going to do?

0:05:44.820000 --> 0:05:47.080000
 And there's a variety
 of ways to do that.

0:05:47.080000 --> 0:05:51.400000
 And the default way that tunnels encapsulate
 something is called generic

0:05:51.400000 --> 0:05:55.840000
 route encapsulation, which is GRE.


0:05:55.840000 --> 0:05:57.920000
 So let's talk about GRE.

0:05:57.920000 --> 0:06:02.340000
 So that's what GRE stands for,
 generic route encapsulation.

0:06:02.340000 --> 0:06:07.060000
 It is a standard way of doing tunneling,
 one of many ways of doing tunneling.

0:06:07.060000 --> 0:06:09.800000
 And it's defined here in RFC 2784.


0:06:09.800000 --> 0:06:11.660000
 You actually could
 probably read that.

0:06:11.660000 --> 0:06:12.700000
 It's very short.

0:06:12.700000 --> 0:06:16.600000
 The way GRE works is
 very, very simple.

0:06:16.600000 --> 0:06:20.260000
 So GRE, why is it called generic
 route encapsulation?

0:06:20.260000 --> 0:06:23.500000
 Because GRE says, look, I don't really
 care what's in the payload.

0:06:23.500000 --> 0:06:24.380000
 What's in the payload?

0:06:24.380000 --> 0:06:25.740000
 Is irrelevant to me.

0:06:25.740000 --> 0:06:30.120000
 And I'm just going to slap a new header
 on that and then send it out onto

0:06:30.120000 --> 0:06:38.800000
 the wire. So GRE basically has a concept
 of an inner payload that it's

0:06:38.800000 --> 0:06:41.860000
 carrying that it's wrapping.

0:06:41.860000 --> 0:06:46.660000
 And then GRE itself relies on some
 outer protocol as what we call the

0:06:46.660000 --> 0:06:48.080000
 delivery protocol.

0:06:48.080000 --> 0:06:51.500000
 Like in my example of what I just drew
 right there, my inner protocol

0:06:51.500000 --> 0:06:56.420000
 would be my IPv6 packet and my outer
 or my delivery protocol would be

0:06:56.420000 --> 0:07:01.840000
 IP version 4. And GRE would stick its
 own special little header right

0:07:01.840000 --> 0:07:04.960000
 in the middle. So this is
 what it would look like.

0:07:04.960000 --> 0:07:11.760000
 So for example, if I was doing GRE
 in the example I showed you, then I

0:07:11.760000 --> 0:07:18.260000
 would have my IPv6 packet right here
 with my IPv6 header and all that

0:07:18.260000 --> 0:07:22.900000
 stuff. And then GRE
 adds this stuff.

0:07:22.900000 --> 0:07:28.200000
 So GRE adds its own header, which
 is consisting of a protocol type.

0:07:28.200000 --> 0:07:31.680000
 And the protocol type uses the exact
 same type values as Ethernet.

0:07:31.680000 --> 0:07:34.100000
 So if you think about, okay, think
 about an Ethernet frame.

0:07:34.100000 --> 0:07:39.100000
 If I send you an Ethernet frame and
 that Ethernet frame has IPv4 packet

0:07:39.100000 --> 0:07:42.760000
 in it, and then right behind that I
 send you another Ethernet frame that

0:07:42.760000 --> 0:07:48.840000
 has an IPv6 packet at layer 2, how's your
 knit car going to tell the difference?

0:07:48.840000 --> 0:07:52.340000
 Well, because in that Ethernet frame
 in the header, there's an Ether type

0:07:52.340000 --> 0:07:54.480000
 fat values called the type code.

0:07:54.480000 --> 0:07:57.980000
 And there's one type code that says
 I'm an Ethernet frame carrying IP

0:07:57.980000 --> 0:08:01.700000
 version 4. There's another type code that
 says I'm an Ethernet frame carrying

0:08:01.700000 --> 0:08:06.160000
 IP version 6. Well, those numbers are
 the exact same numbers are used

0:08:06.160000 --> 0:08:09.000000
 right here in the protocol
 type field.

0:08:09.000000 --> 0:08:14.060000
 And then we have a version, which is
 0, and then the flags, which isn't

0:08:14.060000 --> 0:08:15.900000
 really used for anything.

0:08:15.900000 --> 0:08:19.660000
 And then GRE says I don't care what the
 delivery protocol is, but usually

0:08:19.660000 --> 0:08:22.600000
 the delivery protocol
 is IP version 4.

0:08:22.600000 --> 0:08:28.100000
 So in the IP header, the protocol number,
 well, instead of 6 for TCP or

0:08:28.100000 --> 0:08:33.160000
 17 for UDP, you would actually
 see the protocol number 47.

0:08:33.160000 --> 0:08:37.400000
 That means that behind this
 IP header is a GRE header.

0:08:37.400000 --> 0:08:41.400000
 So when you configure a tunnel interface,
 the default encapsulation type,

0:08:41.400000 --> 0:08:44.520000
 if you don't specify anything
 else, will be this.

0:08:44.520000 --> 0:08:50.260000
 It will be GRE. And configuring a
 tunnel interface is really simple.

0:08:50.260000 --> 0:08:53.960000
 You just type interface tunnel
 and you give it a number.

0:08:53.960000 --> 0:08:57.080000
 For example, when you create a loopback
 interface, does the number really

0:08:57.080000 --> 0:09:01.900000
 matter? No, most people usually start
 with interface loopback 0 or interface

0:09:01.900000 --> 0:09:05.740000
 loopback 1. But hey, there's nothing
 stopping you from creating interface

0:09:05.740000 --> 0:09:08.500000
 loopback 99. Same thing here.

0:09:08.500000 --> 0:09:12.260000
 Mies will start with interface tunnel
 0, but you can put any number after

0:09:12.260000 --> 0:09:16.260000
 that you want. And yes, just like you
 can have multiple loopback interfaces

0:09:16.260000 --> 0:09:20.280000
 in a router, you can have multiple tunnel
 interfaces in a router as well.

0:09:20.280000 --> 0:09:26.520000
 Now, the question you have to ask yourself
 is, what kind of data is going

0:09:26.520000 --> 0:09:28.420000
 to be in the payload
 of this tunnel?

0:09:28.420000 --> 0:09:30.680000
 What is this tunnel going
 to be carrying?

0:09:30.680000 --> 0:09:36.000000
 In my example, I said, well, I'm going
 to want IPv6 packets tunneled across

0:09:36.000000 --> 0:09:38.140000
 an IP version 4 cloud.

0:09:38.140000 --> 0:09:43.200000
 So IPv6 is going to be in the payload
 of what's being tunneled.

0:09:43.200000 --> 0:09:49.740000
 So if it's IPv6, then I would need an
 IPv6 address on my tunnel interface.

0:09:49.740000 --> 0:09:54.400000
 If I plan on taking IPv4 packets and
 tunneling them, then I would need

0:09:54.400000 --> 0:09:56.180000
 an IPv4 address.

0:09:56.180000 --> 0:09:57.700000
 Here's the key thing
 to think about.

0:09:57.700000 --> 0:10:02.320000
 Remember this basic rule that an interface,
 whether it be a logical interface

0:10:02.320000 --> 0:10:06.540000
 like a loopback or a tunnel or a physical
 interface, like a fast Ethernet

0:10:06.540000 --> 0:10:11.980000
 or a serial, an interface in order
 to carry some sort of protocol like

0:10:11.980000 --> 0:10:18.960000
 IPv4, IPv6, has to have an address
 for that protocol on itself.

0:10:18.960000 --> 0:10:22.400000
 In other words, if I create an interface
 tunnel and I don't enable it

0:10:22.400000 --> 0:10:27.620000
 for IPv6, I don't put an IPv6 address
 on there, there is no way IPv6 packets

0:10:27.620000 --> 0:10:32.200000
 will ever use that tunnel interface
 because it doesn't know what IPv6

0:10:32.200000 --> 0:10:36.980000
 is. Now, the second step in creating
 my tunnel interface.

0:10:36.980000 --> 0:10:44.500000
 So I'm going to have my tunnel interface
 and we know that some sort of

0:10:44.500000 --> 0:10:47.360000
 data is going to be
 going across here.

0:10:47.360000 --> 0:10:51.620000
 In my case, it was IPv6 and we know
 that the tunnel itself in order to

0:10:51.620000 --> 0:10:55.820000
 transport it is going to have some,
 is going to slap on there some sort

0:10:55.820000 --> 0:11:00.620000
 of destination address and some
 sort of source address.

0:11:00.620000 --> 0:11:05.720000
 Now, my particular case, this is going
 to be a source IPv4 address and

0:11:05.720000 --> 0:11:07.740000
 a destination IPv4 address.

0:11:07.740000 --> 0:11:11.720000
 So there's going to be some router
 here, we'll just say router A, some

0:11:11.720000 --> 0:11:15.260000
 router here, which is router B, and
 some routers in the middle, which

0:11:15.260000 --> 0:11:17.440000
 are just carrying this packet.

0:11:17.440000 --> 0:11:23.280000
 So the source IP address is going to
 have to be some IP address on router

0:11:23.280000 --> 0:11:26.440000
 A because he's sourcing
 the tunnel.

0:11:26.440000 --> 0:11:31.760000
 The destination IP address is going to
 have to be some IP address on router

0:11:31.760000 --> 0:11:35.640000
 B because that's where the tunnel destination
 is, that's where it's ending.

0:11:35.640000 --> 0:11:40.540000
 So the commands we actually use for
 that are tunnel source and you can

0:11:40.540000 --> 0:11:44.900000
 either reference an IP address on your
 router itself or you can reference

0:11:44.900000 --> 0:11:48.380000
 an interface, say, okay, on my router,
 all these packets are going to

0:11:48.380000 --> 0:11:50.360000
 be leaving fast ethernet 00.

0:11:50.360000 --> 0:11:55.140000
 So why don't I just borrow the IP address
 of fast ethernet 00 as my tunnel

0:11:55.140000 --> 0:11:59.480000
 source? So you can do that tunnel
 source interface fast ethernet 00.

0:11:59.480000 --> 0:12:03.780000
 And then you can use the tunnel destination
 command, which gives the IP

0:12:03.780000 --> 0:12:06.060000
 address of the destination.

0:12:06.060000 --> 0:12:07.480000
 So let's do a real
 example of this.

0:12:07.480000 --> 0:12:11.740000
 So this topology I actually already have
 set up, I've already pre-configured

0:12:11.740000 --> 0:12:19.940000
 everything. And my objective here is
 I want router one to be able to IPB6

0:12:19.940000 --> 0:12:23.680000
 ping this address right here.

0:12:23.680000 --> 0:12:27.540000
 Problem is I don't have
 any IPB6 in the middle.

0:12:27.540000 --> 0:12:34.280000
 So I need to create a tunnel between
 router one and router two.

0:12:34.280000 --> 0:12:42.940000
 So on router one, I'm going to
 create an interface tunnel.

0:12:42.940000 --> 0:12:46.000000
 And I'll just give it
 interface tunnel zero.

0:12:46.000000 --> 0:12:54.380000
 And now if I want this tunnel to carry
 IPB6 traffic, it has to understand

0:12:54.380000 --> 0:12:56.700000
 IPB6. So I have a choice.

0:12:56.700000 --> 0:13:00.300000
 I could come up with a completely different
 IPB6 address and put on the

0:13:00.300000 --> 0:13:05.700000
 tunnel. But one thing nice about
 IPB6, I can just enable IPB6.

0:13:05.700000 --> 0:13:09.800000
 I could say IPB6, enable.

0:13:09.800000 --> 0:13:18.740000
 And that will create a link local address
 on my tunnel, an FE80 address.

0:13:18.740000 --> 0:13:22.500000
 And then I'm going to
 have a tunnel source.

0:13:22.500000 --> 0:13:26.520000
 Let me expand this
 a little bit here.

0:13:26.520000 --> 0:13:34.660000
 Tunnel source. And I'm just going
 to point to fast ethernet 00.

0:13:34.660000 --> 0:13:36.560000
 In other words, I'm going
 to be telling router one.

0:13:36.560000 --> 0:13:42.320000
 Okay, when you take your IPB6 packets
 and you apply a GRE header, and

0:13:42.320000 --> 0:13:45.960000
 then in front of the GRE header, you
 add an IP header, I want the source

0:13:45.960000 --> 0:13:48.380000
 address to be 1111.

0:13:48.380000 --> 0:13:50.720000
 What we see right here.

0:13:50.720000 --> 0:13:57.740000
 And then I'm going to have a tunnel
 destination of router two.

0:13:57.740000 --> 0:14:05.080000
 Tunnel destination is going
 to be two, two, two, two.

0:14:05.080000 --> 0:14:08.600000
 So just those three commands, actually
 those four commands creating the

0:14:08.600000 --> 0:14:14.020000
 tunnel in the first place, enabling the
 tunnel for IPB6, saying my source

0:14:14.020000 --> 0:14:17.540000
 is fast ethernet 00, my destination
 is two, two, two, two.

0:14:17.540000 --> 0:14:19.460000
 And then there's one other
 thing I have to do.

0:14:19.460000 --> 0:14:25.020000
 If I want to be able to ping this IPB6
 network, R1 has to learn about

0:14:25.020000 --> 0:14:35.720000
 it. So across the tunnel, I'm actually
 going to be running for V6.

0:14:35.720000 --> 0:14:39.600000
 I will actually form an EI-JRP relationship
 between router one and router

0:14:39.600000 --> 0:14:42.120000
 two across this tunnel.

0:14:42.120000 --> 0:14:44.820000
 So I'll enable EI-JRP V6 on here.

0:14:44.820000 --> 0:14:48.380000
 And then I'm going to replicate that
 same thing, but in reverse on router

0:14:48.380000 --> 0:14:51.060000
 two. I'll create a tunnel
 interface on router two.

0:14:51.060000 --> 0:14:53.960000
 I will also say IPB6 enable.

0:14:53.960000 --> 0:14:59.240000
 I'll say tunnel source will be his fast
 ethernet 01, so that he uses two,

0:14:59.240000 --> 0:15:01.360000
 two, two, as the source
 IP address.

0:15:01.360000 --> 0:15:04.460000
 Tunnel destination will be 1111.

0:15:04.460000 --> 0:15:09.600000
 And then I'll enable IPB6 EI
-JRP on his tunnel interface.

0:15:09.600000 --> 0:15:18.260000
 So let me go ahead and build that
 and show you how that works.

0:15:18.260000 --> 0:15:23.860000
 Okay, so let's start by taking
 a look at router one.

0:15:23.860000 --> 0:15:28.760000
 Let's look at my configuration
 so far.

0:15:28.760000 --> 0:15:35.580000
 So on router one, I have
 my loop back address.

0:15:35.580000 --> 0:15:40.680000
 And I'm going to want EI-JRP for IPB6
 to advertise that loop back once

0:15:40.680000 --> 0:15:42.080000
 my tunnel is built.

0:15:42.080000 --> 0:15:44.560000
 I have not created any tunnel yet.


0:15:44.560000 --> 0:15:47.260000
 And then here's the physical interface
 that's going to be carrying that

0:15:47.260000 --> 0:15:49.700000
 tunnel traffic, fast ethernet 00.

0:15:49.700000 --> 0:15:53.460000
 So let's go ahead and build
 the tunnel on this side.

0:15:53.460000 --> 0:15:58.280000
 Interface, tunnel, and you can see here
 I've got a wide range of numbers

0:15:58.280000 --> 0:15:59.080000
 I could choose from.

0:15:59.080000 --> 0:16:01.240000
 I'm just going to start
 with interface tunnel 0.

0:16:01.240000 --> 0:16:06.680000
 Now, let's just stop right there.

0:16:06.680000 --> 0:16:08.280000
 No other configuration.

0:16:08.280000 --> 0:16:15.020000
 Show, interface, tunnel 0.

0:16:15.020000 --> 0:16:19.300000
 So right now it's down because I haven't
 given it the necessary information.

0:16:19.300000 --> 0:16:21.180000
 I haven't told what
 the source is yet.

0:16:21.180000 --> 0:16:23.220000
 I haven't told it what
 the destination is yet.

0:16:23.220000 --> 0:16:30.040000
 But look at this tunnel protocol
 is GRE transport method is IP.

0:16:30.040000 --> 0:16:34.440000
 So this is saying by default, it's going
 to use IP version 4 as the source

0:16:34.440000 --> 0:16:35.300000
 and destination.

0:16:35.300000 --> 0:16:37.980000
 I just haven't told it what
 addresses to use yet.

0:16:37.980000 --> 0:16:42.080000
 And then behind the IP version 4 header,
 it's going to create that additional

0:16:42.080000 --> 0:16:45.260000
 GRE header as well.

0:16:45.260000 --> 0:16:50.020000
 So let's finish out my configuration
 of that interface tunnel 0.

0:16:50.020000 --> 0:16:53.480000
 So I'll save tunnel source.

0:16:53.480000 --> 0:16:57.880000
 And according to my picture right here,
 I want the tunnel source to be

0:16:57.880000 --> 0:16:59.180000
 fast ethernet 00.

0:16:59.180000 --> 0:17:10.280000
 I want you to borrow that IP address
 as your destination of your packets

0:17:10.280000 --> 0:17:13.960000
 is going to be 2.2.2.2.

0:17:13.960000 --> 0:17:22.140000
 And now that I've given it a source
 and destination, the tunnel came up.

0:17:22.140000 --> 0:17:25.740000
 Now it's not fully up yet because I
 haven't configured the other side.

0:17:25.740000 --> 0:17:30.920000
 Now if I want IPv6 to go across
 that, I have to enable IPv6.

0:17:30.920000 --> 0:17:33.120000
 I could give it an IPv6 address.

0:17:33.120000 --> 0:17:35.680000
 I'm just going to say IPv6 enable.


0:17:35.680000 --> 0:17:41.100000
 Because if I want EIGRP running across
 this tunnel, remember your IPv6

0:17:41.100000 --> 0:17:45.560000
 routing protocols like EIGRP and OSPF,
 they form neighbor relationships

0:17:45.560000 --> 0:17:48.500000
 with their link local addresses.

0:17:48.500000 --> 0:17:52.800000
 I don't even need a global address to
 form a neighbor relationship between

0:17:52.800000 --> 0:17:56.920000
 two routers running EIGRP
 or OSPF for IPv6.

0:17:56.920000 --> 0:17:58.960000
 So I'm just going to enable that.

0:17:58.960000 --> 0:18:03.060000
 And then I'm going to
 enable IPv6 EIGRP.

0:18:03.060000 --> 0:18:09.800000
 So before I complete the tunnel on
 the other side, on router 2, let's

0:18:09.800000 --> 0:18:12.080000
 look at what I've done so far.

0:18:12.080000 --> 0:18:17.700000
 Okay, so I've got
 my loop back here.

0:18:17.700000 --> 0:18:21.480000
 I've already got that included
 in my EIGRP process.

0:18:21.480000 --> 0:18:24.520000
 Now I create my tunnel interface.

0:18:24.520000 --> 0:18:29.620000
 I said I'm allowing you to have
 IPv6 run across this tunnel.

0:18:29.620000 --> 0:18:32.800000
 I'm allowing you to have EIGRP
 run across the tunnel.

0:18:32.800000 --> 0:18:35.820000
 So whoever's at the other end of the
 tunnel, if they're also participating

0:18:35.820000 --> 0:18:41.120000
 in EIGRP Autonomous System
 100, you can talk to them.

0:18:41.120000 --> 0:18:43.960000
 And then I have my tunnel source as being
 the fast ethernet and the tunnel

0:18:43.960000 --> 0:18:48.700000
 destination being R2 over
 on the other side.

0:18:48.700000 --> 0:18:54.320000
 So let's go ahead and I'm just
 going to copy all that.

0:18:54.320000 --> 0:18:58.860000
 And now I'm going to go over
 to R2 on the other side.

0:18:58.860000 --> 0:19:04.340000
 I'm going to paste it in and just
 make a couple of minor changes.

0:19:04.340000 --> 0:19:10.920000
 Okay, so number one, tunnel destination
 is not going to be 2222.

0:19:10.920000 --> 0:19:16.320000
 So now my tunnel destination is going
 to be pointing back to 1111.

0:19:16.320000 --> 0:19:25.000000
 And my tunnel source is not going
 to be fast ethernet 00.

0:19:25.000000 --> 0:19:38.340000
 My tunnel source is going to
 be fast ethernet 0 slash 1.

0:19:38.340000 --> 0:19:39.520000
 And there we go.

0:19:39.520000 --> 0:19:43.980000
 Look at that. Not only did the tunnel come
 up, but my EIGRP neighbor relationship

0:19:43.980000 --> 0:19:46.960000
 across that tunnel immediately
 came up as well.

0:19:46.960000 --> 0:19:53.720000
 Show IPv6, EIGRP neighbor.

0:19:53.720000 --> 0:19:58.420000
 And we can see that I have formed a
 neighbor across my tunnel interface.

0:19:58.420000 --> 0:20:00.060000
 How do I know it actually worked?

0:20:00.060000 --> 0:20:03.200000
 Show IPv6, route.

0:20:03.200000 --> 0:20:08.580000
 And we can see that I learned of the
 loopback interface of router one

0:20:08.580000 --> 0:20:11.120000
 across that tunnel.

0:20:11.120000 --> 0:20:13.700000
 The tunnel interface
 is the next top.

0:20:13.700000 --> 0:20:18.940000
 And now I can ping it from router two,
 I can ping via IPv6, the loopback

0:20:18.940000 --> 0:20:22.160000
 interface of router one.

0:20:22.160000 --> 0:20:26.320000
 And that's because it's
 going across the tunnel.

0:20:26.320000 --> 0:20:39.400000
 If I do a debug IP packet and then do
 that same ping, let's turn off the

0:20:39.400000 --> 0:20:47.160000
 debug packet now.

0:20:47.160000 --> 0:20:50.640000
 Okay, so here was my IPv6 ping.

0:20:50.640000 --> 0:20:53.440000
 And notice it created.

0:20:53.440000 --> 0:21:00.420000
 So this is OSPF because I actually
 have OSPF running across IPv4.

0:21:00.420000 --> 0:21:03.580000
 That's how router one even
 knew how to get to 222.

0:21:03.580000 --> 0:21:06.700000
 And that's how router two even
 knew how to get to 1111.

0:21:06.700000 --> 0:21:11.540000
 If I did not have reachability of my tunnel
 endpoints, it would be pointless.

0:21:11.540000 --> 0:21:14.640000
 So I had to have some sort of routing
 protocol running between all four

0:21:14.640000 --> 0:21:18.820000
 devices. So my tunnel endpoints
 could actually reach each other.

0:21:18.820000 --> 0:21:27.620000
 But here we see here is my IPv6 packet
 is actually inside of that.

0:21:27.620000 --> 0:21:29.500000
 And actually, I think
 we could do even more.

0:21:29.500000 --> 0:21:36.920000
 If I do, let's do this
 debug IP packet detail.

0:21:36.920000 --> 0:21:39.460000
 And then do the ping again.

0:21:39.460000 --> 0:21:45.020000
 Debug IP packet detail.

0:21:45.020000 --> 0:21:51.640000
 Come on, where is that ping?

0:21:51.640000 --> 0:22:04.200000
 There we go. So right here,
 come on, stop, stop, stop.

0:22:04.200000 --> 0:22:10.120000
 Unall. Okay, so this is
 what I'm looking for.

0:22:10.120000 --> 0:22:12.100000
 Now we can actually see
 the protocol field.

0:22:12.100000 --> 0:22:14.720000
 Notice protocol 47.

0:22:14.720000 --> 0:22:17.620000
 That is the protocol that's
 reserved for GRE.

0:22:17.620000 --> 0:22:22.920000
 So this is me router two, sending an
 IPv4 version packet to router one.

0:22:22.920000 --> 0:22:25.280000
 But the protocol is 47.

0:22:25.280000 --> 0:22:29.020000
 So when router one gets that, he'll
 say, oh, 47, I need to redirect that

0:22:29.020000 --> 0:22:33.520000
 to my tunnel interface, because that's
 the one that's actually doing GRE.

0:22:33.520000 --> 0:22:36.620000
 And then the tunnel interface will
 strip off this IP version forehead

0:22:36.620000 --> 0:22:39.820000
 revealing the IPv6 inside.

0:22:39.820000 --> 0:22:44.340000
 And that's why my IPv6
 ping is successful.

0:22:44.340000 --> 0:22:47.320000
 Which is way up here.

0:22:47.320000 --> 0:22:50.500000
 That shows my successful
 IPv6 ping.

0:22:50.500000 --> 0:22:55.760000
 So that concludes this discussion
 of configuring GRE tunnels.

