Summarization

Why We Summarize

In one of my prior videos, I had mentioned that these are routers. They route traffic. They look at the destination IP address and make a determination of where that packet needs to go. What these routers do is route that information, and in order to route that information, they need to know where all the networks are at on the network. So they create these tables of all of the different networks that they can see out there, and they exchange this information back and forth, so they have a running idea of all of the networks and where all those networks are located at.

Now, the problem is that these routing tables can get really large. If you've got lots of networks that are out there, they can get really long, especially if you're doing VLSM and breaking them down into all these really small little tiny pieces, all these different networks, and you've got this huge routing table.

So there are ways that we can condense that routing table, and summarization allows us to do that. Summarization allows us to take a lot of smaller networks and group them all together in a much larger network. So that's network summarization.

One way that that might look is, let's say you subnetted and you've got 0 through 31 here. You've got 32 through 47 as another network. You've got 48 through 55 as another network, and 56 through 63 as another network. You could summarize this all as one statement that represents all of those networks. You wouldn't want to do this on the router that's touching all of these different networks, because it needs to know how to get into each one of those networks. But then from that router to the rest of the routers, it would just advertise one route. It's a way of consolidating a lot of these smaller networks into one network.

An Example

Over here I have one network and over here I have a different network. Over here, let's say this is a 172.16.0.0 network with a /24, so we've borrowed 8 bits, and so it's just the last octet that has the hosts in it. And then over here, let's say this is a 172.16.1.0/24.

These within this network right here would be routed back and forth between these two networks. But going out of this network, they don't necessarily need to know that this network is a separate network from this network. So we could actually summarize this as a 172.16.0.0/23. That /23 would include both of these networks right here as it goes out, and so this would be a summary. It's summarizing these multiple networks down here — in this case, just two networks — to the rest of the world.

Or perhaps maybe we have a lot more networks that are in here that are all connected throughout here, and maybe we just advertise it as a 22, or, you know, it could be whatever networks cover all of the ranges that we have in our whole network here. So that is a summary route, when we group everything up into one network statement and that's what gets advertised out.

Supernetting

There's also this idea called supernetting. Supernetting is the idea that we don't have to stay within the classful boundaries. An example of this is, let's say this is a 192.168.0.0/24 and this is a 192.168.1.0/24. A summary route that would summarize both of these would be a 192.168.0.0/23. That would include both of these networks in that one statement.

And what it also is, is it goes beyond that. We've actually gone where we're not borrowing bits from a class C, it's taking away that class C altogether, because it's a /23. A class C is supposed to be a /24. So we've gone outside the boundaries of this classful routing. So that's this idea of supernetting: it's when you're grouping them all up and it's going beyond the boundaries of those classful addresses.

How to Summarize

So how do you do this summarization? Well, one is you can use the visualization, either box or table, to summarize these routes, and I've really already given you a glimpse into how to do that. But you can also do it using the binary numbers.

So here I have several binary numbers — several networks, I should say — that I want to translate. It's a 10100.0/24. I've got a 101.024, a 102.024, 0/24, and a 103.0/24.

The first thing that I'm going to do is convert those all into binary numbers, so I've got that all already done for us. And then I look at what are the similarities. So all these zeros are the same, all these zeros are the same. I'm going to go through and I'm going to find the first place where they're actually different, which would be where the line would be drawn right here. All of these are the same bits right there, so that's where I'm going to want to summarize this.

So what I could do is I could then drop these down, the ones that are all similar. I can drop down to this last line right here, and I will end right there, so that's where my line is drawn. And then I'm going to zero out the rest of these, just like that.

Now this is going to be my network address. So if I turn that back into a decimal number, I'd get 10.100.0. And this would be a slash — if I count this up it would be a /22. So now I've summarized all of these networks into one address, 101 100.0/22. So that is how you summarize.

A Caution About Discontiguous Networks

There is one caution that I have with that, and that is with discontiguous networks. This works as long as you're summarizing at a router that has all of these networks behind it. But let's say there's one of these networks — let's say this network right here exists in a far off distance somewhere, not anywhere close, not connected to this router, not behind this router, somewhere else. Then you could cause some problems if you try to summarize with this network being in a whole other location, and that could possibly be problematic. So you would want to watch out to make sure that if you are doing some sort of summarization, that it makes sense, that you don't have some network that's out of bounds, that's way off in another location.

Here's another visualization of that. Let's say I'm breaking this down into — I've got this network here, and I've got this network here, and this network here, and I create a network summary of this right here, and that's what's being broadcasted out from my router. However, this network that's right here exists in a whole other location. What could end up happening is that some devices may be sending traffic to your router for this network right here, even though that network really is somewhere else. So that's what you need to watch out for.

I'll explain this in one other way as well. Once again, I don't want to get too much into the routing things of this, because it really is not part of this course about how routing happens, but I just want to make sure that we understand one of the things you need to watch out for. So here again, let's say this router right here is telling the rest of the world, direct all traffic going to 12.0.0.08 to me. So all traffic going to any of the networks in there is going to go to this router right here. But let's say far off in a different part of the world we have a 12.0.1.0/24 network. Then traffic going to this network right here could accidentally be getting to this router right here, and that's a problem. So that's just the thing that we want to watch out for with these discontiguous networks.

Recap

We talked about summarization, how we can summarize many different networks into one network statement. We also talked about when that goes beyond those classful boundaries — we call that supernetting. We also talked about just how to do that, how to break it down into binary numbers and figure out what is exactly the same, and then draw a summary network based off of that information. And then we wrapped things up by talking about discontiguous networks: that you wouldn't want to advertise a summary route that includes a network that could be way off in some distance that's not behind that router. Just something to watch out for.