If we wanna implement routing,
for example, having these three routers
to do logical routing of our traffic
for north-south traffic and east-west traffic.
To implement that functionality,
we're gonna configure it all from the NSX Manager,
so you and I interface with the NSX Manager
and then we specify that we want to have, for example,
gateway zero, and gateway A, and gateway B,
and connect them logically to those various NSX segments.
And when we create this logical routing inside of NSX,
the actual ESXi host transport nodes, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
the actual ESXi host transport nodes,
they can actually do the logical routing themselves,
and then if they need to forward traffic
to another ESXi host, they can go ahead and tunnel it over.
And that's known as a distributed router,
where the logical routers are implemented
on the actual host transport nodes.
However, sometimes
we may need to integrate additional services,
including things like network address translation, or VPNs,
or connecting our NSX routed environment
out to the outside world, and for those specific functions WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
out to the outside world, and for those specific functions
that can't be done by the host transport nodes themselves,
we have a separate entity,
and that, my friend, is an edge transport node.
Now we have a couple of options
for implementing an edge transport node,
the easiest option in my opinion,
is to implement a little VM.
So this little VM is running on a host somewhere,
and this little VM is implemented, and it's an edge node.
So we can have an edge node VM,
or we could also do a bare-metal edge node.
And that's where, instead of running the edge node as a VM,
we'd take a physical computer WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
we'd take a physical computer
and install the appropriate software there.
And so one of the questions might be why would we ever,
you know, wanna have a dedicated piece of hardware
as an edge node when we can implement
the functionality of these gateways as a VM?
And the answer is throughput.
If you wanna crank out
20, or 40, or 100 gigabits per second,
you may need some dedicated hardware to do that,
and that's why there's the option of a bare-metal edge node.
So let's imagine we wanna implement
the routing infrastructure and we decide to deploy a VM.
So to deploy that VM for the edge node, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
So to deploy that VM for the edge node,
as I mentioned, it's done right through the NSX Manager
and you simply specify what host you wanna run that VM on,
we're gonna specify which uplinks
on that host should be used by the edge node,
and let's go ahead and visualize that with an ESXi host.
Let's say this is an ESXi host here,
and here's our edge node VM running on that host,
and of course the host has some physical connectivity out,
and as part of our configuration of the edge node,
we're also gonna specify which uplinks
we want the edge node to use.
So let's say I have VM NIC zero, and one, and two, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
So let's say I have VM NIC zero, and one, and two,
and three, and four.
And very similar to the uplink profile
that we specified for an ESXi host
when it's acting as a host transport node,
we're also, when we deploy the edge node,
gonna specify which uplinks we want it to use
on the host that it's currently running on.
So, maybe we want this edge node to go ahead
and use VM NIC three as the active
and then VM NIC four as the standby,
I'll put a A there and S there.
And as a result, that edge node
is also going to get a tunnel endpoint.
So that tunnel endpoint, we'll go ahead and call this one, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
So that tunnel endpoint, we'll go ahead and call this one,
let's say it's 10.33.33.33.
And another question might be, well,
what would this need to tunnel to?
And the answer is
it could tunnel to any other transport node,
so we could tunnel over here to ESXi, let's say ESXi-A,
which is acting as a host transport node
with this tunnel endpoint address of 10.11.11.11.
We can add this edge node with a tunnel going to ESXi-B,
and perhaps this tunnel endpoint address is 10.22.22.22.
And the cool thing is WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And the cool thing is
that there is a function called a distributed router,
we'll call it a DR for short,
not to be confused with an OSPF designated router,
so I'll spell it out, that's a distributed router.
And that distributed router exists here
on the edge node on the local control plane,
it also exists here on ESXi-B and the ESXi-A,
and the entity that's coordinating all that
is the NSX Manager,
and up here we have the centralized control plane.
So the benefit of having a centralized control plane
and then a local control plane that's been coordinated
between the NSX Manager and that cluster, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
between the NSX Manager and that cluster,
and each of our nodes, which includes the ESXi host,
and also now the edge node implemented as a VM,
the benefit is if we have a VM list, call this VM-C,
and let's say that VM is over here on segment 30,
and that VM is sending traffic into the network,
and that VM is connected to this logical segment 30,
ESXi-B knows exactly how to forward it.
Is it gonna make the forwarding decision locally
because it has all the information that needs to do that
or is the destination reachable through one of our routers,
AKA an NSX gateway? WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
AKA an NSX gateway?
And if it is, ESXi-B can take it,
encapsulate it into the tunnel,
send it to the other side where it needs to go,
where it can be deencapsulated and processed.
Most of the time we're not just gonna have one edge node,
we'll have an edge node cluster.
So let's say this is ESXi-10,
and let's also draw a really thin ESXi host over here,
(laughs) because of the space, so.
So, here's ESXi-11,
and it also has an edge node VM,
and we can implement those as a cluster that work together.
Now here's the great news, in this skill, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
Now here's the great news, in this skill,
I wanted to present a big picture look at the concept of NSX
and the key players inside that architecture.
So with this warmup to the world of NSX,
what we're gonna do is we'll take a look
at implementing and verifying each of the components
in one nice little step at a time.