[AUDIO LOGO]
So now, let's take our first look
at an automatic IPv6 over IP tunnel.
Specifically, we're going to look at 6to4 automatic tunnels.
Now, an automatic tunnel simply means
that the tunnel is going to learn
the destination on its own, but that does beg a question.
How is it going to do that?
Well, that's what we have to answer.
How does the tunnel learn the IPv4 destination
that it needs to build the tunnel for?
So that's going to be our primary conversation because
besides that, well, this is essentially a 6in4 tunnel.
So let's go ahead and jump in and talk about some
of the details on how this works specifically
for our 6to4 automatic tunnels.
So as we mentioned, 6to4 tunneling
is an automatic tunneling method.
So let's talk a bit about how this actually functions.
First thing, we did mention this during the introduction.
This is still using 6in4 encapsulation,
which simply means that, again, the IPv6 header is
coming directly behind the IPv4 header.
This does not use GRE headers.
It's also very important to note that this uses the reserved
address space of 2002::/16.
This is by definition, and it's not an option.
So any time we see this 2002 address space,
we should be pretty sure that this
is being used for a 6to4 tunnel, or well,
somebody using it incorrectly.
Then what we do is, each site is then
going to be given an IPv6/48 prefix.
Now, this /48 prefix is going to be based on the IPv4 tunnel
endpoint address.
Keep in mind, of course, IPv4 is 32-bit.
So when we add the 32 bits to the end of the /16,
that's where that /48 comes from that we're going to be giving
to that remote site.
Now, if that other site has the need to subnet further,
keep in mind that we can subnet that /48 maybe to a /64,
something along those lines, just as we would with any other
IPv6 prefix.
But ultimately, how does all of this help?
Well, this is the key factor right here,
when a packet arrives on this tunnel interface.
Now, this isn't really part of our discussion right now,
but how would it know to arrive at this tunnel interface?
Well, that's where the routing comes into play.
We're not focusing on the IPv6 routing right now.
But again, it's going to be from the routing protocols.
The packet arrives at this tunnel.
And then we extract the IPv4 address
of the tunnel destination.
We're pulling that out of this /48 prefix and using that
to then build the tunnel.
So this is the fundamental principle
behind how the 6to4 tunnels work.
So let's take a look at an example of the addressing
and how we would configure this.
So first, let's take a look at an example.
So we're given an IPv4 address of a tunnel endpoint
and what the IPv6 prefix would look like.
So here's how this ultimately works.
First, we have the part of the address that's
a given, which is the 2002.
Then the 210 is going to be converted to this d2 right
here.
The 112 is going to be converted to this 70 right here.
The 35 gets converted to the 23, and the 80
gets converted to the 50.
And of course, by converted, we simply
mean we're converting the decimal into hex.
This is how this becomes a /48, and this is what gets
configured when we set up our devices.
So to go over this, we, again, create an interface tunnel 100,
but notice the IPv6 address for the tunnel.
So this is how we would configure
this particular tunnel.
We would give it the address, and we configure it above.
We would set up our tunnel source,
and we set the tunnel mode to be IPv6 IP,
and then we add this keyword 6to4.
That's what tells it to look for this 2002 address
and extract the IPv4 address from it.
Then, of course, we're going to need a route
to send the traffic down this tunnel.
Now, it could be more specific.
But in most cases, since the 2002
is dedicated for 6to4 tunnels anyway,
we usually just route the entire address space down the tunnel.
So in this case, we're routing it down tunnel 100.
So ultimately, 6to4 tunnels work very well.
However, not everything is without drawbacks,
and this does have some drawbacks.
So let's go ahead and take a look.
So the drawbacks of the 6to4 tunnels,
the first one may already be a little bit obvious and that it
does require the use of that reserved IPv6 address space,
the 2002::/16.
Now, normally speaking, that may not matter.
However, this can definitely create a problem down the road
when you're getting rid of tunnels,
and you're actually going to switch over to native IPv6.
Because if we're on native IPv6, we
should no longer be using that reserved address space.
We should be using normal IPv6 address space.
So that's our first drawback.
Another drawback is what if that IPv4 address of the site
changes.
That means that the IPv6 prefix for that site
would have to change as well, and that
may take some manual intervention to get that tunnel
to function properly again.
And if we're going to provide our customers
with internet access using this solution,
this is going to require a 6to4 relay
router that we have to make available for them
to step this traffic off to the internet.
But these few drawbacks aside, 6to4 automatic tunnels
are actually a really good solution
for automatically configuring tunnels to send IPv6 over IPv4.
So in this video, we took a look at automatic IPv6 tunnels,
specifically 6to4 tunnels.
These, of course, require the use of the 2002::/16 reserved
address space.
Again, if all of this is for tunneling,
that's really not a big deal.
But hopefully, the plan is to migrate away
from tunnels at some point and run native IPv6.
And if that's the case, well, we wouldn't
want to be using these reserved address spaces anymore.
So what would be ideal would be to have
all the advantages of 6to4 tunnels, meaning they're
automatic and being able to use whatever address space
we want and assign that to the customers so
that they could use that long term.
Well, we actually have a solution for that,
and we're going to look at it next.
Till then.
I hope this has been informative for you,
and I'd like to thank you for viewing.