So let's begin by jumping in and looking
at the concept behind the BGP path selection process.
We'll start by looking at what it is, why we need it,
what it's for.
But then we'll also take a little bit of a look
at how it works, the logic behind it,
and how it actually chooses that best path.
So let's go ahead and jump in and take a look
at some of those details.
So at first, we have what might seem to be an obvious statement
here, that BGP will quite often learn, well,
quite a few different paths to get to any given destination.
But we have to have a premise as far as
why we need to choose the best path.
If there is only one path, that path
will, of course, be the best.
But if not, the path selection criteria
is used to choose the best path.
In the case of BGP, this is going
to come down to one best path.
So how do we choose that best path, then?
Well, we're going to be using the BGP attributes
as our primary factor.
So of course, our goal here is to look at these attributes,
discuss what order they're considered in.
And then we'll be using that to design our own path selection
criteria.
When we change attributes to influence the best
path, what we're doing is, we're implementing a routing policy.
One of BGP's biggest strengths is our ability to control this.
Please note, I'm very carefully calling this routing policy,
not policy routing or policy based routing.
Because PBR is actually something different.
Now I have heard people refer to BGP as policy routing.
There's not necessarily anything wrong with that.
I just didn't want to have any confusion here.
So we're going to be very careful
and say that we're implementing a routing policy.
Now interestingly enough, unlike a lot
of other routing protocols, one of the criteria or attributes
is actually not bandwidth.
BGP does not look at bandwidth as part of its criteria.
We could, of course, base our policy on bandwidth
if we choose to.
However, these attributes that we spoke about, well,
one of them is not bandwidth.
So that's why we say it's more based on policy.
Now the way this works is, all of the paths--
so we're talking about all of these
that we mentioned up here at the top,
that we're going to learn multiple paths
to a destination.
Each of these are considered against the selection criteria
until, again, like we mentioned before, one
is considered the best.
So essentially, we can Enter the top of the BGP route selection
criteria with, let's say 10 paths to a destination.
And maybe at rule one, this eliminates two.
So we're down to eight paths.
Maybe the next rule doesn't eliminate anything.
And as we go down, we keep eliminating paths,
until eventually, we end up at one.
Once we get to that point, of course,
we'll stop going down the list.
But our path selection criteria is
acting almost as a filter here to get us down to one route.
And one last statement here before we jump into the path
selection criteria itself--
there's sort of a prerequisite.
Before it can even be considered,
it has to be a valid path.
That means that the next hop has to be reachable.
There can be no AS loop.
And the route must be synchronized.
As long as we meet those criteria,
we'll then Enter the path selection process
and start eliminating down to one path.
In this video, we just jumped in and took a look
at the overall concept behind the BGP path selection
process, how it goes down the list of all of the paths
that it's learned to a particular destination,
and how it chooses the best path out of that list,
based on BGP attributes.
I hope this has been informative for you,
and I'd like to thank you for viewing.