[AUDIO LOGO]
So let's begin our discussion on tunneling by talking about some
of our manual tunneling choices.
That would be specifically GRE tunnels and 6in4 tunnels.
Now, these are very similar.
The main difference, as we'll see
as we go through this video, is what
the headers are on the packets.
Essentially, how it's encapsulated for the tunnel.
There's a slight difference there,
and that's one of the things we need to discuss.
But what do we mean by manual tunnels?
Well, quite simply, we mean that not only do we
have to configure all of the attributes of the tunnel,
which, of course, would be normal,
but when it comes to the tunnel source and destination,
we are going to have to specify both.
We'll see in some upcoming videos
when it comes to automatic tunnels,
the destination for that tunnel is
going to be learned some automatic way.
Now, there's different ways for that to happen,
and we need to discuss that.
But these are going to be manual tunnels, which
means we, as administrators, are going to be configuring
not only the source, but also the destination for the tunnel.
That makes these pretty much just point-to-point tunnels.
And of course, our main goal here
is going to be to support IPv6 over the tunnel and IPv4
as the underlying transport.
So let's go ahead and jump in and take a look
at some of these details about the manual tunnels,
and of course, a little bit about what's
the difference between a GRE tunnel and a 6-in-4 tunnel.
So let's go ahead and take a look at those details.
So as we basically mentioned, the idea
behind tunneling itself is that we
want to connect these islands of IPv6
over a network or a transit network
that only supports IPv4.
That's the main reason we're doing this.
If we were doing dual stack, like we discussed previously,
we wouldn't need tunneling.
So let's talk about the requirements
in order to do this tunneling.
First, let's talk about the underlay or the underlying
network, which is IPv4.
What we need to have is reachability, specifically
for those tunnel endpoints.
Remember, the IPv6 itself is going to be encapsulated.
Therefore, the underlay network doesn't
have to know anything about the IPv6.
It will never see this IPv6 that's
just going over the tunnel.
So what we care about is simply reaching these endpoints.
That's really all we need from the underlying IPv4 network.
Now, as we have mentioned previously,
those endpoints are going to have to be dual stacked.
The IPv6 is going to be used for the connected networks
or again, those islands that we're
trying to connect over the IPv4 network, and of course, running
over the tunnel itself to connect those islands
of IPv6 networks.
IPv4 is simply used for the underlay network
or the transport network.
Now, there are a few or many different tunneling
protocols which can handle IPv6 over IPv4.
Some of these are manual.
And of course, that's what we're going
to be discussing in this video.
And some of those are automatic.
And we'll be talking about those in upcoming videos.
And just a quick note here, when we say there are many tunneling
mechanisms, we're going to be talking
about the ones primarily used in a service provider core.
Keep in mind, there's other tunnel types
such as ISATAP tunnels.
We also have Teredo tunnels.
So there are different tunnels available for IPv6
that are a little beyond the scope of this course
because they're not really focused on service provider.
But there are other types of tunnels out there even
beyond what we're going to be discussing here.
So as we mentioned, the two tunneling types
that we're going to be discussing in this video
are both manual options.
And again, what that means is that both the source
and the destination of the tunnel must be configured.
And again, this would be by the administrator.
So that's what really makes these manual tunnels.
So the first one we want to discuss is the GRE tunnel.
Now, again, GRE stands for Generic Routing Encapsulation.
This is a tunneling protocol that was actually
developed by Cisco a long time ago,
and its main job is to be able to carry multiple protocols
over another protocol.
Now, these are generally going to be point-to-point tunnels.
Although, we certainly have multipoint
GRE tunnels for other technologies such as DMVPN.
So again, not something we're going
to get into in this course.
But just be aware that GRE is not necessarily always
point-to-point, but it is for this discussion.
Just as a quick note, DMVPN is not really
one of our discussions in this course
simply because it's more of a customer side technology.
However, just as a quick note, it supports IPv6 as well.
So that is another tunneling option.
Now, at the end of the day, it's still using GRE headers.
So it falls under this same umbrella.
It's just that it's multipoint and automatic
but still using the GRE encapsulation.
So back to some more detail on GRE itself,
this is transported directly on top of IP as protocol 47.
This means that there is no TCP header or UDP header that's
used in this environment.
The GRE headers come directly after the IP headers.
Now, this does add a 4-byte header,
and this is in addition to the new outer IP header.
Remember that the IP header is 20 bytes.
We need this header because it's a tunnel.
So we're going to be putting a standard IPv4 header
in front of either the GRE header or the IPv6 header.
This means that for GRE, we are picking up
an additional 24 bytes of overhead over the IPv6 packet
by itself.
That's the cost of the tunnel or the tunneling overhead.
Now, IPv6 can be enabled on a GRE tunnel, in addition
to other protocols such as IPv6 4 because of this GRE header.
The GRE header, which is that 4 bytes, has a protocol header.
The protocol header tells it what the payload is.
The reason that's important is, this header
is what allows that tunnel to carry multiple protocols
at the same time.
It can support IPv4 and IPv6 simultaneously
on the same tunnel.
The reason we're bringing this up
now is simply to contrast this to 6in4 tunnels
that we're going to talk about in just a moment.
So now, let's jump in and take a look
at how we configure these tunnels on both IOS XR and IOS
XE.
So starting with IOS XR, all we have to do
is create an interface, specifically
the interface type is going to be tunnel-ip.
We, of course, give it a number.
Then, we specify an IPv6 address for the tunnel itself.
We set the tunnel mode to be GRE over IPv4.
We then set the tunnel source and the tunnel destination.
One quick note as we're going over configurations here,
I'm only showing configuration related
to the exact tunnel or technology
that we're talking about at the moment.
Keep in mind that everything else involved in this
would have to be configured.
We would have to have routing protocols,
other interfaces configured, and so on.
This is just focusing on the tunnel configuration
itself just so we're clear.
That's going to apply for the whole rest of the skill.
Now, we're going to see that IOS XE's configuration is actually
very similar.
We, again, create a tunnel, but this time, we
don't have to say tunnel-ip.
We just say interface tunnel.
We, again, give it an IPv6 address.
We say tunnel mode gre.
Now, you can say tunnel mode gre ip,
or you can leave this command out completely.
Notice, I have a little note there that this
is the default, which means, you don't actually
have to put that command in at all.
That is the default operational mode on IOS XE.
We, again, specify the tunnel source and the tunnel
destination.
And just as a reminder, through our routing protocols
and the underlay network, the tunnel source,
whatever that is, in this case, a loopback,
has to be able to reach whatever the destination address is.
So what makes 6-in-4 tunnels different.
Well, the main difference is that this carries
the IPv6 header directly on top of,
or you could say directly behind the IPv4 header.
There is no GRE header.
So the GRE header is gone in this case.
And ultimately, what that means is,
it means we're going to save those 4 bytes of overhead that
were taken up by the GRE header.
Now, that's not a lot, but if we're
talking about millions and millions of packets,
that can certainly add up as far as the overhead.
Now, of course, the downside of this
is, since we no longer have the GRE header
to identify that protocol field, that means that this can only
carry one protocol because there's no GRE header to say,
is this IPv4?
or is this IPv6?
when a packet arrives at the receiving end.
And that also means that both sides
are going to have to be configured
to be a 6-in-4 tunnel.
Both sides have to understand that the packets coming
through this tunnel are going to be IPv6 because again, there
is no protocol field to tell them which protocol it is.
So they just have to be configured appropriately.
The way we do that configuration,
notice that on IOS XR.
The only thing that's different here is the tunnel mode.
It's an IPv4 tunnel.
On IOS XE, we simply change the mode, and it's IPv6 IP.
So this is how we configure our GRE tunnels
and our 6-in-4 tunnels on IOS XR and IOS XE.
So in this video, we saw how to configure manual tunnels,
specifically GRE and 6-in-4 tunnels
between our different devices over an IPv4-only network.
This, again, allows us to connect islands of IPv6
without the transport network having to know anything
about IPv6 at all.
Now, again, the big thing here is
we have to configure both the source and destination, making
this a point-to-point manual tunnel.
Now, the obvious problem with this from a service provider's
perspective, this isn't going to scale very well.
We have thousands, if not, millions of customers.
We sure as heck can't build these tunnels
for all those customers.
So a lot of times, we're going to need a more automatic
solution, and that's exactly what
we're going to look at next.
We're going to jump in and start looking
at some of the various automatic options.
Until then.
I hope this has been informative for you,
and I'd like to thank you for viewing.