[music]
So we have spent the vast
majority of our day today
talking about taking networks,
a single network that you've
leased or rented from your
service provider,
and by modifying some of the
host bits,
taking that network and cutting
it up into little subnets,
cutting it up into
multiple pieces,
replaced on this LAN over here,
that LAN over here,
this LAN over here.
Summarization is just the
opposite of that - starting out
with a bunch of networks
and saying,
I want to shrink them all down
to something they have
in common.
Summarization is the process
of that.
So it's the process of
combining multiple subnetworks
into a single
network advertisement.
Also, we'll refer to this as
route aggregation.
Efficient and large networks
provides addressing hierarchy.
Okay, so let's talk a little
bit about why would we want to
do this.
I'm going to use my
favorite analogy.
Ready? Here we go.
If you've seen any videos
of me,
you'll see me do this a lot.
I'm a router and you're
a router,
and we're connected together.
I do that all the time so play
along with me here.
I'm a router and you're
a router.
We have a cable between us,
and we're running some kind of
a routing protocol.
Take your pick: RIP, OSPF,
EIGRP, BGP.
It doesn't matter.
The fact is,
the networks I know about,
it's my responsibility to
advertise them to you so that
you know you can get to them
through me.
That's the whole point.
Now normally when you turn on a
routing protocol - like I said,
take your pick - as that router
learns about networks,
it doesn't matter if they're
subnets or classful networks.
The router doesn't care.
The router says,
Hey, let met tell you,
neighbor, about what I know.
So imagine if behind me there's
a whole bunch of LANs.
Let's say there's a LAN out
there that's 10.10.0.0/16,
10.30.0.0/16,
10.64.128/17.
Now normally,
as a routing protocol,
I would send all those to you.
I'd say, Okay,
here's your routing update.
Let me tell you about 10.10/16,
10.30/16,
10.40.120.
So I'd give you all these
specific networks that
I know about.
Well, there can be a downside
to that.
What if you are running out
of memory?
Because all these routes that
I'm sending to you,
you have to store them in
memory somewhere in a place
called an IP routing table,
an IPv4 routing table.
What if you've got so many
routes already that if I send
you, let's say, oh, 500 routes,
that's going to overwhelm you.
You're going to say,
Look, I'm busting at the
seams here.
I don't have enough memory left
over to store 500
additional routes.
That's going to be bad.
It might cause your router
to crash.
Least case scenario,
you're probably going to drop
some of my routes because
you're just not going to have
any place to put them.
And certainly,
when we're talking about
service provider networks,
this is a big concern.
If we're talking about a router
that's owned by Time Warner
Cable or Comcast,
that router could literally,
if it knows about everything in
the Internet--
currently in the Internet
there's well over
400,000 networks.
Think about that,
400,000 networks in the
entire world.
Imagine how much memory that
would consume to store in a
single routing table.
And that's not the only thing
that routers keep in track of.
That router is also keeping
track of access lists and ARP
tables and all kinds of
other stuff.
And now he's got to store
500,000 routes?
Yikes. Better be a big,
powerful router with a lot of
memory to do that.
Well, a lot of times,
what service providers will do
is they'll say,
look, yeah,
I could send you all these 500
routes I know about: 10.10,
10.30, 10.90.128.
But when I think about it,
they all begin with 10.
Every router I have back here
begins with 10,
so why don't I do this?
Why don't I just send you a
single route that says,
hey, look, any packet you have
that starts with 10,
10/8, send it to me.
I know about all networks that
begin with 10.
That'd be nice wouldn't it,
because that, now,
conserves your memory.
You don't have to know about
every specific little thing.
I'm just sending you a single
aggregated route,
a single summarized route.
And that's what route
summarization is all about.
Now, routers don't do this,
technically, by default.
You have to get in them and
configure them.
And this is something at the
CCNP level,
you learn how to do that.
But theoretically on paper,
you do have to know how to take
a bunch of subnets like 10/1,
10/2, 10/50, 10/98,
and ask yourself, okay,
if I thought about these as
binary patterns,
from left to right,
is any of the binary pattern
consistent and the same across
all of these?
That's what I'll send to my
neighbor.
So for example--
let's look at an example
of this.
Here we have two networks,
10.10.32.0 and 10.10.48.0.
They both, in this case,
have the exact same mask,
although really,
the subnet mask of the original
network is irrelevant in the
case of route summarization.
We really could care less.
So that's to serve like
a distractor.
So if we convert these networks
into binary, remember,
what is our objective here?
What's our goal?
We're trying to figure out,
from left to right,
what do these networks have in
common, if anything.
Well, clearly,
they have the first 16 bits in
common because they both start
with 10.10.
But do they have any more
than that?
When we go into the
third octet,
we see, Oh, wait a second,
the number 32 and 48,
when I start converting that
into binary, sure enough,
those two numbers have the
first 3 bits in common.
They both start with 001.
The 128 and 64-bit are off,
the 32-bit is on.
After that,
I start experiencing some
variation where they're
not the same.
So what do these guys have
in common?
What they have in common is the
first 19 bits.
All 8 bits of 10,
all 8 bits of 10 in the second
octet and then 3 bits of 001.
So I can shrink that down to a
single summarized route of
10.10.32.0/19.
And that's how you summarize
something like that.
Well, let's do one--
let's see here.
Actually, I've got a whiteboard
pre-built that we can work on
this. There we go.
Let's do a couple examples
of this.
Let's start with these three
networks right here.
So we can see pretty clearly
right off the bat that all
three of these networks start
with 20.20.40,
so their first 24 bits,
clearly, are in common.
Well let's see if we can create
summarized route that's even
more specific than that,
that has even more in common.
So, in the fourth octet, .90,
let's see here.
It's got the 128-bit
turned off.
Also, 82 has the 128-bit
turned off,
and 88 has the 128-bit
turned off.
So far, so good.
Let's keep going.
.90 has the 64-bit turned on,
82 has the 64-bit turned on,
and 88 has the 64-bit
turned on.
So far we've identified 26 bits
that all three of these
networks have in common.
Can we go further?
Can we keep going?
Let's see.
The 32-bit is off here because
64 plus 32 would be 96.
So that's off.
32-bit is off here,
32-bit is off here.
Oh, so far, so good.
Let's keep going.
Can we go even further?
What about the 16-bit?
64 plus 16 is 80.
So yeah, 16-bit is on,
on and on.
So we're up to 80 right now.
Now if I go to the 8-bit,
80 plus 8 is 88.
Yeah, we got the 8-bit on here.
The 8-bit is off there and the
8-bit is on right here.
So now I can stop.
I can see that of
these networks,
in addition to the first
24-bits in common,
they actually have the first
28-bits in common.
So all these networks start
with 20.20.40.0101 and then I
have my variability.
So that would come up with
20.20.40.0101000.
So my single summarized route
is 20.20.40 - just make sure I
got this right here - 64 and
16, yes, 80/28.
So all 3 of these subnets are
encompassed or included in this
one aggregated or
summarized route.
Let's do one more example of
that, down here.
So these clearly have the first
two bytes in common,
so our variability is going to
be somewhere in the
third octet.
They all have the 128
turned off.
They all have the 64
turned off.
They all have the 32
turned off.
They all have the 16
turned off.
This has the 8 on.
This has the 8-bit on.
This has the 4-bit on.
8 plus 4 is 12.
This has the 4 bit on.
This does not.
This has the 4-bit turned off.
So now I can stop.
In this particular case,
they all have this bit pattern
in common, 130.75.00001.
Let's see 1, 2, 3, 4, 5, 6 7, 8.
So if I convert that down,
that's 130.75.--
which is 130.75.8.0/16 plus 5, 21
So there is my single
summarized route for
these three.
So I've got one quiz question
here to give you, guys
practice on this yourself.
There you go.
So do the same thing.
See if you can come up with the
most specific summarized route
that will collapse all three of
those subnets down into one
summarized route.
I'll give you 30 seconds
for this.
Okay. Time's up.
Here is our answer.
So all three of these networks
had the first 27 bits in
common, 135.75.42,
and then on the fourth octet,
they all had 011 in common,
which gives us 135.75.42.96
with a /27 subnet mask.
All right.
We have one topic left to go,
which we'll actually get
through pretty quickly.
One last topic
that's called supernetting.
So, supernetting is essentially
exactly the same thing as route
summarization that we just
looked at.
The logic that you used to do
supernetting is exactly the
same logic you use to
do summarization.
There's only one
main differentiator.
With summarization,
look at that last
bullet point there.
Whatever the summarized
route is,
it does not break the
classful boundaries.
What do I mean?
Let's go back to
this here, 135.
Technically, if we were talking
about classful addresses,
what class of address would 135
fall into?
Hopefully you said Class B.
135 is Class B.
Which means that if I'm
doing summarization,
whatever subnet mask
I come up with,
one of my summarized route,
it has to be /16 or bigger.
Like in this case,
it would be /27, /16 or bigger.
Well, supernetting is coming up
with the mask.
It's actually smaller than your
classful address.
For example,
take a look at this.
Let's say that my router knew
about these two Class C
networks - 192.168.1 and
192.168.2
There's no way I could
summarize this.
If I want to shrink this down
into just one advertisement and
send it as a summarized route,
I couldn't.
Why not?
Well, because the mask is
already at the classful
boundary of /24.
Summarization means I can't go
any less than a /24 if what I'm
starting with is essentially a
Class C.
This is where supernetting
comes into play.
So use the exact same logic.
Let's look at this and say for
a second, Okay, well,
from left to right,
if I was to convert this into
binary, from left to right,
what do these two networks have
in common?
The first two octets
were the same.
And then in the third octet--
in the third octet,
they're the same up to here.
So really this first--
these two networks both have in
common the first 22-bits.
So I could collapse them down
into one route,
192.168.0.0/22 and this is
called a supernet.
Because even though if you take
a look at that first byte,
you'd say, Oh 192.
Well in binary that's 110,
that's Class C.
But Class C means /24 and here
I'm doing a /22.
That's what makes it
a supernet.
That's what makes it
a supernet.
Now as far as summarization
is concerned.
Some routing protocols,
when you turn them on,
and it depends on the version
of software you're dealing with
in the code,
some routers perform route
summarization by default.
They will take some subnets,
shrink them down into a single
route, advertise it out,
and the subnet mask--
the mask, I should say.
I shouldn't say subnet mask.
The mask associated with that
summarized route does not break
the rules of
classful addressing.
Supernetting can only be
done manually.
Typically this is something you
would see done in BGP.
You wouldn't normally see it
done in your interior gateway
protocols, although you can.
But this is usually something
that ISPs would do to
each other.
For example,
if I'm Time Warner Cable,
I might say, well--
let's do an example of that.
Let's say that we have here
two routers.
This router here is owned by
Time Warner Cable.
This router here is owned
by Sprint.
Two different routing domains.
Now, Time Warner Cable,
as a service provider,
own thousands and thousands,
tens, probably even hundreds of
thousands of subnets.
Let's say they say,
okay, well,
I own every subnet from
1.anything,
2.anything, 3.anything.
Let's see if I can figure out a
nice, easy way to do this.
Let's do Class B instead of
Class A.
Let's say 130.1.0.0, 130.2.0.0,
130.3.0.0.
Let's stick up here at the top
130.0.0.0
So Time Warner Cable actually
owns the--
I'm just making this up here.
Time Warner Cable,
let's assume,
owns these four full Class Bs.
Now, chances are,
they're probably not going to
hand out these Class Bs to
their customers because each
one of those Class Bs supports
over 65,000 hosts.
So if a customer goes to Time
Warner Cable and they say,
I need a network from you.
Time Warner Cable might say,
okay, well let's see here.
How many hosts does your
network support?
And if the customer says,
my network supports 300 hosts,
Time Warner Cable is not going
to give them this entire
Class B.
They'll probably carve out a
subnet of that Class B and sell
that to the customer.
But Time Warner Cable,
as a whole, as a company,
is responsible for these four
Class Bs.
They've been allocated these
from the Regional
Internet Registry.
Well, using BGP or something,
They could send all four of
these to Sprint,
or they could say,
Let's do supernetting here.
What do these guys have
in common?
Well, they all start out
with 130,
and then in the second octet,
128, 64, 32, 16, 8, and 4,
those bits are all zeroed out,
and the last two bits have
various combinations.
So Time Warner Cable could
instead send a supernet,
which looks like this:
130.0.0.0/14.
All four of these networks have
the first 14 bits in common -
130 and then 6 bits of 0.
This is a supernet.
So when performing
summarization or supernetting,
like I said,
the logic you work through is
exactly the same.
Simply ask yourself,
what bits from left to right do
all of these networks have
in common?
[music]