Now it's time for something called summarization. Now this is truly, really legit summarization we're talking about.
Type 3 summary LSAs, the misleading, right? At no point did we do summarization, did we?
No, we advertised each of those individual type 3 networks as they are.
10.0.0.0.24, 10.0.1.0.24, 10.0 right into the other areas. That's what we did.
And just to prove that to you, let's go over to somebody like branch and if we look at do show IP OSPF database,
and we look at our database, there they all are. All the individual ones right there, right?
We didn't summarize, we just did what? We created summary information.
We said 10.0.0.0.24 is via R2, that's it. That's what we did. That's what they mean by that.
Bad name, and the industry knows that. They changed the name for OSPF v3.
They changed the name for address families because they realized they named it pretty poorly.
So with summarization, what do we really mean? Well, with summarization, we mean let's consolidate when we advertise.
Let's stop advertising the individual networks and instead let's consolidate them together.
So why advertise them as four separate networks when we can advertise them as one giant network instead?
And when we do that, we get to reduce the size and number of updates.
We get to localize topological database changes. We get to reduce the size of our link state database,
and we get to ultimately reduce the size of our routing tables when it's all said and done.
So for example, when this router is sending the update or the, let's say, type three LSA to this router,
instead of sending all four individually, consolidate them together.
So this is about taking groups of contiguous networks like you have here, contiguous networks,
combining them together, and advertising them as a group instead of individually.
So how did we come up with that number? It's pretty straightforward.
For example, we got 10.0.0.0. That's the first one. And these are all contiguous.
So since they're contiguous, I only have to worry about the last one, which is going to be 10.0.3.0.
And what I'm going to do here in this particular case is I'm going to find out where the bits no longer are common.
So when you think about 10 and 10, those are the exact same binary bits.
So I'm just going to write a big giant 10 here instead of writing it all out in binary because it's the exact same.
And it's easier to work in decimal for me. All right. And then 0. 0 and 0 are the exact same, right?
So I'm just going to leave it at 0. But now you can see here in this third octet, 0 and 3.
So we'd have 0, 1, 2, 3, 4, 5, 6, 7, 8 and 3 would be 0, 0, 0, 0, 0, 0, 1, 1.
And then the last ones are 0. So I'm just going to put a big dot here with a nice big giant 0.
This is my little shortcut way of figuring these things out. Right. And now what I'm going to do is I'm going to work my way this way.
All these binary bits are the same. All these binary bits are the same. Same. Same. Same. Same. Same. Same. Stop.
See the difference right there. Now count the number of binary bits.
8 plus 8 plus 1, 2, 3, 4, 5, 6 equals 22.
Now I take the top number. And I put my new subnet mask with it.
This process will work for you 100 percent of the time on this certification exam because the numbers they give you are contiguous.
They work together. They're perfect powers of two. All of these different things that matter to be able to do it right.
Can you summarize any way you want in the real world? Absolutely. Go ahead.
But be mindful that you could cause black hole or you could black hole your traffic or you could cause suboptimal routing.
A lot of different things could happen to you if you're not summarizing only contiguous networks together.
Because if I summarize, for example, let's say we change this to 20. If I change that to 20, then that would mean I'm also including 4.0, 5.0, 6.0, 7.0.
But are they really over here? No, they're not. What if they're somewhere else that I could be causing suboptimal routing or causing traffic to get drops?
And you can have as many summarized routes as you want. You can have as many summarized routes as you want.
So if you have a block of continuous, you can do that summary. Another block is the summary. Another block is a summary. You go right ahead and do that.
Absolutely. But here's the gotcha for OSPF, which is different than EIGRP. With EIGRP, I can summarize on any EIGRP enabled interface, on any router.
That's right. Let me repeat that. With EIGRP, I can summarize on any EIGRP enabled interface, anywhere, anytime, for any network.
That's not how it works for OSPF. With OSPF, you can summarize on ABRs, and you can summarize on ASBRs. Make sure you know that.
So when you're doing it on ABRs, you're summarizing type 3s. You cannot summarize type 1s. Let's be clear about that. You can never summarize type 1s and type 2s.
Why? Because you have to have synchronized link state databases in here. If you're summarizing on this router but not this router, then all of a sudden, this router would know about the individual networks, but this router doesn't, or this router doesn't, or this router doesn't, because they only know the summary. Now your link state databases are not synchronized.
So you cannot summarize within an area. You can only summarize between areas, or you can summarize when you're injecting from external routing domains, like redistribution. That's when you can summarize as well.
Look at the difference in the commands. This is where they're going to get you on the exam. On the ABR, it's called area, the area number, range, the address, the mask. For ASBR, it's summary address you use.
So let me show you these in detail here, give you an example of it for the certification exam. So let's go ahead and summarize these four networks into area 1.
So remember, I can't do it on DSW1. I can't do it on 2. Why? Because they're not the area border router. I have to do it on the area border router going into that area.
And this command will crush you if you don't understand how it works. So let's go over to R2 right now. Before we do that, let's make sure we have a complete view of branch A's current link state database.
And let's make sure we have a current view of its routing table, so we can see the difference once summarization is done.
All right, so that's what we have right now. So let's go over to R2. We'll type in router OSPF1, so router OSPF configuration mode.
And what are we going to type in? Area. And then we have to type in the area number. Okay, this is where you're going to get crushed on the exam if you don't pay attention.
When you use this command for summarization, it's the area where the networks exist, not where they're going.
So right now, I want to summarize these as they go into here. So area 0, because that's where they live. Where do they live, those networks? Area 0.
Then I type in range. Then I type in the new number. And what was that new number we came up with, folks?
We came up with 10.0.0.0 slash 22, which equals 255.255.252.0. Correct me if I'm wrong, please.
10.0.0.0. 255.255.255. Nope, 252.0. Boom. There's your command in this case.
So what does that mean now? It means I am no longer going to create type three LSAs for these four networks anymore. I'm not going to do that anymore.
I'm going to suppress those, and I'm going to create one for this instead, which includes every single IP address in every single one of those networks.
So if we type in do show IP OSPF database now, take a peek at this. Where's the rest of them? Where is 1.0, 2.0, 3.0? They're gone. 0.0 is also gone.
Look, look, 37 seconds. It's brand new, folks. So let's crack that one open and see what it actually says. There you go. A summary address.
So what does that mean? It means if we go back to branch now, on branch, if I scroll up here, these four are no longer there, they're gone.
It's replaced with 10.0.0.0.0.22. These four are now gone, and what are we going to have? 10.0.0.0.0.0.22. That's what we're going to have.
So let's look at our database just to prove it to you. There it is. And if we look at our routing table, there it is.
So like we said, reduce the size of our link state databases. Reduce the size of our routing tables. If area one, the only way to get to all those networks this way, does it really need to know the individual networks?
No. A summary will get the job done. No matter what, we have to go this way. So why advertise the individual networks when you can advertise them as a single group?
And therefore what? Less link state advertisements, less updates, less changes. How much less are we talking about here? Oh, a lot less.
Because here's the reason why. Let's say we are not doing summarization. We're not doing summarization. That means what? We have a type three, a type three, a type three, a type three, one for 10.0.0.0, one for 10.0.1.0, one for 10.0.2.0, one for 10.0.3.0. You with me?
That's what we have. Without summarization, we have type threes for all four of those. So what does that mean? That means that if this goes down, up, down, up, down, up, down, up, down, up, then I have to add, remove, add, remove, add, remove, add, remove, add, remove, which means add, remove, add, remove.
Now, with type threes, we know it doesn't cause a Dijkstra shortest path first complete algorithm calculation, right? So it's not as detrimental as a type one. But in this environment here, that type one is detrimental, right? It's causing excessive calculations by all the routers.
But here, OK, it's not that big of a deal, but it's still a big deal, right? Because here's the thing. Ready for this one? If we do summarization, so let's summarize it now. If we do summarization, then we've got a T3 of 10.0.0.0 slash 22, which includes all four of these, doesn't it? Yeah, it includes all four.
So now if this goes up, down, up, down, up, down, up, down, up, down, up, down, up, down, then the type one LSA here is detrimental to area one. There's no denying that. But do we have to do anything with the type three? Yes or no? Do we have to do anything with the type three? No, not at all. Why?
Because the type three is going to be generated as long as R2 still knows about one of those other three, just one. This will always be advertised as long as one of those networks always exists.
Stabilizing your areas when changes happen in another area. That's why summarization is so good.
Let's say area one, folks. Let's say area one. Let's say this didn't exist. Okay, let's say this doesn't exist. And the only way in and out of area one was this way. What if we did something like this?
What if we just advertise the default route, folks? What if we just advertise the default route as a summary? Then that means every single network here would never affect here. Yeah, because there's only one way to go.
We could totally do that. And that is actually a recommended best practice if you can accomplish that. But there's other ways to do that as well. And for those of you with more knowledge, that's where we'd create a, for example, in our case, totally stubby area.
So I would do that instead with a totally stubby area instead of actually doing that summary. But yeah, you could totally do with a summary. But you could do a totally stubby area. I know. I know. Don't go. Don't go there, please. Let it go. I don't make these names up. I just teach. That's all I do.
It can sound insulting. I totally get it. But yes, totally stubby areas, totally not so stubby areas. Right. Another way that you can improve your routing tables, improve your databases, improve your synchronization, improve your LSA exchange like those you'll learn about in the advanced routing course.
Right. So that's just something to keep in mind. But there's a prime example, folks, of how summarization is going to stabilize the area that you're summarizing into. So you can summarize this way and you can also summarize this way.
So if you're summarizing this way, let's say we had over here 192.168.0.0, 1.0, 2.0, 3.0, and these are all slash 20. Now let's make them, yeah, we'll do slash 24s as an example. Slash 24, slash 24, slash 24.
Okay. So let's say we wanted to summarize it that way. Then it would be area. What area? One, right? One. Because they live here. If they live here, you got to put area one. Right. And we want to go this way. So area one range. And that'd be 192.168.0.0 slash 22 in our example again.
Right. So just keep that in mind. That's what you would be doing for that. Now, something I want to point out to you, though, is based on our discussion we just had. And that was that if all of a sudden, for example, we were summarizing 10.0.0.0 slash 22. And that's what we're summarizing this way. Then what happens if this goes up, down, up, down, up, down? Okay. Let's say it goes down. Down. Boom. Let's say it goes down here as well. Boom. Done.
Okay. So R2 doesn't know about it. Right. R2 does not know about it. So what's going to happen here if traffic leaves here and it's destined to 10.0.0.5? It would be routed this way because 10.0.0.0.22 includes that. Right. That's part of that summary. So we keep going. And we get here.
Now, does R2 have an entry for this network anymore? Does R2 have an entry for that network if it's down? The answer to that would be no. Why? Because if the network's down, Type 1 LSA would have told R2 it doesn't exist.
So if I don't have 10.0.0.0 slash 24 in my routing table anymore, what am I going to do with that traffic? What am I going to do with that traffic if it's destined to 10.0.0.5? Just think about what R2 has the ability to do.
Yeah. Yeah. Default route. You got it, Andrew and John. Boom. Out you go. Oops. That's a problem, isn't it? That's a problem. And what if it wasn't doing that, but what if all of a sudden it was sent from here to here and then sent back and then sent there and sent back?
Like that could happen too in other parts of the network called a routing loop. So when we do summarization, we run the risk of accidentally sending traffic via the default route, and we run the risk of actually causing routing loops. Yeah.
So what I want you to realize is that there's an automatic feature added to your router to stop that from happening. You ready for it? It's this entry right here on the router that created the summary. Look at that.
Look at that. It says 10.0.0.0 slash 22. Null zero. Null zero is the garbage can, the bit bucket, the point of no return, the place where packets go to die.
So if I had traffic right now going to 10.0.0.5, it leaves here. It goes to branch. It gets forwarded to R2. 10.0.0.5, it's in the routing table. Look at that. It's there. 10.0.0.0, it's in the routing table because it's up. Right? It's up. Okay. Let's crush this.
Okay. So now those two networks, 10.0.0.0 slash 24 is down. No longer in the routing table. Right? So traffic is still going from 10.0.0.5 arriving at R2. And what does it match now?
Does it match the default route or does it match the summary to null zero? This is perfect. It matches the summary to null zero. You see that? That is so cool. Now we just drop it. We drop it on the area border router.
So whenever you lose the networks that you're summarizing for, the furthest the traffic will go is to the area border router and then it'll get dropped. That is so cool. All right. You know that. How about that? And you're like, how about that?
All right. And lastly, let me just diagram this up for you. All right. Let's say we were running EIGRP here and we had the networks 192.168.0.0 slash 28. And we had 192.168.0.16 slash 28. And we had 192.168. Oh, shoot. I don't want 28. I want 26.
I want to make this simple for myself. I don't want to have to do too much math today. 64.26. That's what I want. 128.26 and 192.168.192.26. Okay. So I have these four networks over here in EIGRP.
So let's say I do redistribution. So I redistribute into OSPF. So I would type in something like redistribute EIGRP autonomous system 100 includes subnets. That's what I would do. Okay. What that would do is that would redistribute every single one of those as individual type 5 LSA.
So I'd have four type 5 LSAs that would get flooded everywhere in here. All right. Pretty straightforward based on what we've talked about before for type 5s. But now I can do summarization on the ASBR.
And what do we say the command was for that? We said the command for that was going to be summary address address mask. So let's go ahead and just write that out here for you so you can see what it's like. So when I'm doing my redistribution now, let's type in summary address.
And then the address in this case, if I did all the math for this, what would we end up with? I would end up with 192.168.0.0 slash 24. That's what actually it would break down to. So all four of those combined would be a single slash 24 network.
So summary address 192.168.0.0255255255.0. That would be the command I would type in if I was redistributing and summarizing on an ASBR. And now what we get is we get one type 5 LSA instead. One type 5 LSA instead.
And then all of them would be included in that. And we would also get one of these cool little funky routes to null zero as well on that ASBR as well for the same reason that if one of those networks go down, if the network goes down in there.
And the traffic gets to there, we don't all of a sudden loop it back via our default route because it could end up doing this. Yay! Out to the internet. No, that's not what I want. I don't want that. So I want to make sure if it gets to that ASBR and the network doesn't exist over there, I want it to get dropped. And that's what the route to null zero would do for me.
And that is true summarization. So for the exam, make sure you know things like why do we want to do summarization? Well, it improves the performance of our areas because the less information I have to send in an area, the less calculations have to be done. But also, therefore, we have smaller databases. Therefore, we have smaller routing tables. So performance enhancements.
But also when it comes down to it, if a network is flapping that is being summarized by an ABR, that does not at all now affect that area that we're summarizing into. So any instabilities in other areas can be isolated to that area by doing summarization on your ABRs and your ASBRs. And know those commands for the exam.
Thank you.