To really appreciate BFD, bidirectional--
I was going to--
I was going to chuckle about that--
bidirectional forwarding detection in a Cisco network,
let's first of all take a look at a topology
and take a look at if there's a change how long it
might take for the network to heal itself
or find another path.
And we'll also take a look at some reasons why that happens.
And as we progress, we'll take a look
at implementing bidirectional forwarding detection
to solve that problem.
Let's look at the topology. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
Let's look at the topology.
So in this topology, the critical ports
that we want to be aware of are these guys right here.
I've got gig 0/0 here and 0/2 here and up off
this switch is 0/0.
And if we're running a dynamic routing protocol like OSPF,
we would have adjacencies.
And I'll put those in blue here.
We have adjacencies here and also between R2 and R4
and also R4 and R5 and R3 and R5 and R2 and R3.
Great.
No problem.
So this is all ethernet.
It's all gigabit speed. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
It's all gigabit speed.
And if the current path, let's imagine the path from R1
to get to R4, which if all of the paths are equal,
that would be the path it would take,
let's imagine that's the path it would
take to reach the loop back of 4.4.4.4.
Now if there was a problem with this link
right there on R4 or if there was a problem with the switch,
let's say the switch on that port had a problem,
R2 is not going to directly sense
that there's a link failure, because it's got link coming
from its port on the switch.
And it might take 30 to 40 seconds WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And it might take 30 to 40 seconds
for the network to figure out, hey, you know,
this is not the best path.
It's says R2 to get to 4.4.4.
It needs to go ahead and use this path.
But that could take up to 40 seconds.
And that was a long time.
So instead of waiting that full time, what we could do is
we could implement BFD, the bidirectional forwarding
detection.
And what it's going to do, it's going
to send little messages back and forth, little love
messages over the, in this case, the physical pathway
over the switch.
The logical path would be between them. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
The logical path would be between them.
Little messages saying how are you, good, back and forth.
And we can control that.
We can specify how often that happens.
And it could be subsecond.
Like, we can send four or five a second back and forth.
And then we could train OSPF to be linked to BFD.
And so if the BFD session fails of if the BFD pings going back
and forth-- they're not really pings,
they're BFD messages back and forth--
if it fails, it can inform OSPF.
And OSPF can say, hey, whoa.
I don't need to wait any longer.
BFD's not working. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
BFD's not working.
So I'm going to go ahead and assume that's done.
And then it can go ahead and converge
with the rest of the network and the correct path.
So that's how bidirectional forwarding detection can work.
Now, it can be used for a lot of things.
We can use it for static routes, which is wonderful.
So if you have a static route, and the next hop no longer
becomes available, even though our link is up,
but the next hop is not available, with BFD it can say,
hey, it's no longer up.
And we can drop that out of the routing table
immediately and not just leave that static route
in the routing table.
We can also use it with HSRP, hot standby routing protocol. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
We can also use it with HSRP, hot standby routing protocol.
There's an R there.
We could also use it with BGP.
Fantastic stuff.
We could also use with EIGRP, although EIGRP is pretty darn
fast as far as converging.
But it's part of that too.
And also OSPF.
And so what I would like to do is in the next set of videos,
let me go ahead and do some demonstrations.
Now, in the NRC course or the NRC certification,
the objective is to describe or understand WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
the objective is to describe or understand
the concepts of what BFD is.
And I think that we've just covered that to some degree.
But I also think that reinforcing
that a little bit is going to be huge,
because when I was looking at some documentation regarding
this, I thought, wow, for some of these,
it's not quite as straightforward as I
would have guessed it might be.
So by demonstrating-- let's go ahead
and do demonstrations of BGP and static and EIGRP and OSPF.
That'll give us a good sampling of how to implement it, also WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
That'll give us a good sampling of how to implement it, also
how to look at it, and also verify
that it is working so we can test it as well.
So I'll demo these.
Now, one word of caution, if you want
to do these in your own lab environment,
virtual environments don't do well with BFD.
So BFD is really good if you have physical environments
with a lot of processing power and electronics
on the interface cards that are doing a lot of heavy lifting.
If you're doing it all in a virtualized environment,
the central CPU that's running the virtualization software WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
the central CPU that's running the virtualization software
is going to have to handle that.
So I just want to give you a word of caution
before you load this up with subsecond BFD messages
going back and forth in a virtual environment.
It may cause you grief.
But also, what it will do is this is Cisco Modeling
Labs, which I'm going to demonstrate this on and also
show you how we can tone it down a little bit for demonstration
purposes or so you can practice in a virtualized environment.
You can still practice with it without locking up
your whole system, which I've done a few times.
So I will see you in the very next video,
where we'll do an example of implementing and verifying BFD. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
where we'll do an example of implementing and verifying BFD.