[AUDIO LOGO]
Now, about that loop.
We already saw that we've created
a routing loop because of our redistribution between OSPF
and IS-IS.
We also talked about the overall problem.
Although, we will review it in just a moment.
The problem is, we have our edge routers, in this case, router 1
and 3, that are not following.
Let's call them our native protocols.
In other words, we have a route that
should be in IS-IS that router is 3 actually learning
from OSPF.
Now, there are many ways to prevent this,
and we're certainly not going to go over all of them.
Most of them involve some form of route filtering.
And we've discussed route filtering quite a bit already.
We can use any of those methods.
However, the most common way to deal with this
is to do route filtering based on route tags.
Now, like I said, there are many other ways to handle this.
But that's the one we're going to focus on here.
So let's bring up our topology-- quick reminder of what it
is we need to block and filter.
And then we'll jump into the command line,
implement our filter, and see how it fixes our loop.
So as a reminder, we have router 8 sending a route to router 7.
Router 7 is then sending this to router 1 and to router 3.
These show up with an administrative distance of 115
because these are from IS-IS.
And then one of the two routers is going to redistribute first.
Truth be told, we don't really know which router it will be.
If they were to reload, the other router
would start doing it.
So our solution that we put in place
is going to have to be on both routers.
In this particular case, it's router 1.
But that's only because we've observed what the routes look
like that we know that.
Again, it could be either router that
learns the route from IS-IS first and redistributes it
into OSPF.
So again, in our example, router 1 redistributes this into OSPF.
And then that route gets learned through OSPF on router
3, which, of course, had an admin distance of 110.
So ultimately, router 3 replaces its IS-IS route
and redistributes the OSPF back into IS-IS,
creating our loop and our route feedback.
What we need to do is stop this feedback from occurring.
The best way to do that is to configure
router 3 to discard this route and not accept it from OSPF.
The most common way to do that is with tags.
Now, the good news is we've already set
ourselves up to do this.
When we configured our redistribution
of IS-IS and OSPF, we set this up to already tag the routes
as 115.
So all we have to do is configure our edge routers,
router 3 to stop the current loop,
router 1 just in case router wins next time.
So again, we want to do this on both.
But we just need to configure these
to not allow routes tagged with 115 to come in to OSPF.
So let's jump into our command line and configure that.
So we'll start here on router 1.
What we need to do is create a route policy.
Let's call it RP_OSPF_FILTER.
What it needs to say is if the tag equals 115
because that's what we're tagging our routes as,
then we want to drop the route.
Else, of course, we want to pass the route.
We'll end our if, and we'll end our policy.
Then all we have to do is apply the filter.
So we'll go into our address-family under OSPF 1.
We'll apply this as a distribute-list.
So simply say distribute-list route-policy RP_OSPF_FILTER,
and that will be in.
We'll commit those changes and exit configuration.
Now, remember, the problem isn't really here.
This is just putting in the solution on router 1 in case
the problem were to flip-flop in the event of maybe
routers reloading or something along those lines.
What we really need to do is put this on router 3.
And as we do so, let's investigate a little bit more
what's going on router 3 before we just throw the solution on.
So over on router 3, let's just start with a show ip route
isis.
Notice, we're not getting any routes from IS-IS.
This is because if I say show ip route ospf,
I'm literally learning about the entire network from OSPF.
Of course, router 3 being an edge router,
it shouldn't be learning everything from OSPF.
This is entirely the problem.
So now, let's go ahead and put our filter in.
Since we've already seen the filter,
we'll just go ahead and copy and paste it.
So again, we're just pasting that exact same policy here
on router 3.
We'll give it just a moment for the protocols to converge.
We can check it by doing a show ip route isis.
And let's see if we have any routes now.
So we can see that we are now learning some of the routes
from IS-IS, which is good.
Again, keep in mind, we're only going
to be learning the routes from IS-IS that are tagged as 115.
So we'll still be getting some of the other routes from OSPF.
So if we do a show ip route ospf,
we can see that we still have a large number of routes here.
Some of them even being externals.
So some of those are coming from the EIGRP.
And some of those are coming from the RIP domain, in fact.
But let's go ahead and check our loop again now.
So if we go over to router 5, remember
that this is the original test that we saw of a loop on.
What we see here is now that we've implemented our solution,
not only do we not have a loop, but we're also
properly multipathing through both edge routers.
The first hop, of course, is going between routers 2 and 4.
And then number 2, we can see we're using both edges.
It's going through router 3 and router 1 on that second hop.
Now, of course, the third half, ultimately,
just goes to router 7.
And then, of course, the fourth to router 8
because there's no multipathing on that side of the network.
But our OSPF environment is now multipathing correctly.
So in this video, we explored the most popular way
to solve routing loop issues.
Now, as I mentioned during the introduction,
there are other ways to filter.
There are some other ways you can do things,
like using split administrative distance where
your internal routes have a lower administrative distance.
And your external routes have a higher administrative distance.
EIGRP, for example, does that by default.
OSPF is also capable of doing it.
Although, it's not enabled by default.
The only problem with solutions like that
is they really only work if they're on the network edge.
They cannot be a transit domain for our routing and have
the split admin distance work.
One of the advantages to doing tags like this
is with a proper design, this will always
solve your routing loops.
And as you can see, when we solve those loops,
we can also pick up multipathing.
So that concludes everything we need to discuss in this skill.
That leaves us with just a review
in the form of a quiz, which we're going to do next.
Until then.
I hope this has been informative for you,
and I'd like to thank you for viewing.