So it's about five minutes since we finished the last video.
And it looks like it's ready to go.
So here with the applications tab selected here at the controller,
at the controller interface, with dashboard selected,
it's showing the web servers 192.5.
That's the virtual service.
And it shows a really healthy score right there of 100.
And if we click here on pools on the left-hand side,
it's showing us that we have three out of three available.
So to test this virtual service that we just made,
if we click around logs, we shouldn't be able to see too much WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
if we click around logs, we shouldn't be able to see too much
yet because even though we told logging to be on,
we haven't had any requests from clients.
So let's put a little virtual machine over here
on the 192.1 state 1 network.
And then we'll connect or attempt to connect to 192.1 state 1.5.
And what should happen is the service engine that's
in charge of the data plane for that virtual IP address
should receive that request and then act as a proxy
over to one of the available servers.
In fact, let's also just verify which of these service
engines it is. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
engines it is.
We can hover right here on the name.
And this is showing us right here the name of the server.
Let me move this graphic out of the way a little bit.
And let's hover once again.
So it's the one ending in Q-H-Y-P-N.
So that's the service engine that's actually
doing the data plane work for us or will be when we connect.
Also, what would be interesting to see
is if we went to that VM, we would
see it has now three interfaces.
One interface is connected to the management network,
the 1060 network.
One's going to be connected to the 192.1 state 1 network. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
One's going to be connected to the 192.1 state 1 network.
And another interface is going to be connected over here
to the VLAN 51050 network.
And we can confirm that just by going over to vCenter
for a moment and taking a look.
So here in the vSphere client, here
is that specific service engine, the one ending in YPN
right there.
And if we right clicked on it and then we went to edit settings,
here we could verify that its management interface is
on VLAN 6, that it has one interface in VLAN 5.
And then another interface here on the 192 network.
And it shows us connected to all three.
And the entity that did that magic of carving out WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
And the entity that did that magic of carving out
all those interfaces and configuring them
was the instructions from the controller
who specified exactly what that service engine needed
so it could do the proxying and the load balancing
between clients who are requesting the IP address here at .5
and the servers on the back end over here.
And then we went back to infrastructure
and we went down to cloud resources
and clicked on our service engines.
Here it's showing nothing because it's using the default cloud.
So if we selected our cloud, NSX cloud 4,
here are two service engines.
Now these numbers are very likely going WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
Now these numbers are very likely going
to be better and better over time
because they just came up.
In fact, that one just changed from a 50 to a 67.
We could also say, please display the last 30 minutes.
So the longer that these service engines are up
and don't have any problems, the better and better
the health scores are going to be over time.
All right, so it's time to test.
Let's bring up a little VM over here on this 192.168.1
network.
And here is that VM right here.
The first thing I want to do is just verify its IP address.
So here on this computer, we'll do an IPA for address, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
So here on this computer, we'll do an IPA for address,
press center and its IP address is right there 192.168.1.123.
So we should be on the same subnet
as that little virtual IP address.
Let's go ahead and give it a shot.
We'll open up a browser.
And then here in the browser, let's go to 192.168.1.5
and press enter.
So that's going to default to HTTP and look at that server A.
So each of the servers I put .51, its default homepage WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
So each of the servers I put .51, its default homepage
has a server A message and 52 has server B.
And the one at .53 says server C.
So if we are to do a control shift R, which is a refresh,
because we set the pool to round Robin,
that should cycle through all three.
And if we do a control shift R again to refresh,
that is working like a champ.
So I'm just doing a control shift R, R, R.
And that is just doing a refresh
and going through all those servers on the back end.
Where if I just did a refresh right here, for example,
and again, it's just pulling now from the cache. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
and again, it's just pulling now from the cache.
And then if I did a F5, that also is just pulling
from the cache.
So I'm gonna be careful about making sure
that I'm doing a full new request and control shift R
is a great way of getting that job done.
All right, so now we set some traffic through.
Let's go ahead and minimize our client right there.
And let's click on our virtual service.
So we click on our virtual service.
And once again, we get hover over the name right up here.
And it'll just tell us all the details
about the virtual IP address, the service port,
whether it's Chup or not, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
whether it's Chup or not,
which service engine is supporting it.
And also what the profiles associated
with this virtual service are.
There's also options of scaling out and scaling in.
So if we clicked here on scale out,
for this virtual IP address,
we could say I wanna create a new service engine,
or we could scale out to the other existing service engine,
which already has been deployed.
However, for our one little virtual IP address
that one virtual service,
having one service engine is enough.
So I'm gonna go ahead and cancel that.
And because we enabled logging,
if we clicked here on logs for this virtual service, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
if we clicked here on logs for this virtual service,
and this is the new log view that I opted into.
So I'm gonna go ahead and close that.
Here is showing me just the significant logs by default.
And I could also say, you know what?
I wanna see the non-significant,
as well as the significant by clicking
that additional checkbox right there.
And that's giving us a bunch more detail
regarding the load balance that's going on.
So if we grab one of these 200 messages,
in fact, let me collapse the left-hand side.
So if we wanted to see the details here
for this log entry, we'll click on the eyeball.
So here in the output, it has three tabs.
One is for summary. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
One is for summary.
It just jumps down to that part of the output.
There's another tab for application,
and another tab for header detail.
So if we go back to the summary and scroll all the way up,
here's the graphical representation of what happens.
So the client made a request.
The round trip time was one millisecond
between the client and the load balancer.
And then between the load balancer and the server,
it was two milliseconds.
And here shows that the app was really quick to respond.
Then if we scroll down, here's the original IP address.
So there's the IP address of our client at .123, WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
So there's the IP address of our client at .123,
going to the virtual IP address that we set up
as part of the virtual service.
And that was proxy from our service engine
over to the actual server.
And for this transaction here, it was at .51.
And there's the service engine that did the work.
And then if you scroll down, here's the summary.
Including the browser of the client was using Firefox
and the user agent associated with that browser,
has timestamps.
If we scroll down, it was a HTTP get request.
And if we scroll down further,
because we said to go ahead and include header logging,
it has details about the headers as well. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
it has details about the headers as well.
And if we do it side by side comparison,
it looks like most of the content was sent over
the way it was sent from the client.
And if we scroll down, it has the response.
This is the response from the server back to the load balancer,
and then from the load balancer back to the client.
So let me go ahead and close that.
And let me expand the left hand side again
and go back to the dashboard.
So now that we have configured and verified
a virtual service with a virtual IP address over here,
let's do it again.
But this time a virtual IP address that's out here. WEBVTT X-TIMESTAMP-MAP=LOCAL:00:00:00.000,MPEGTS:900000
But this time a virtual IP address that's out here.
And this could represent where we have
a routable global address that's in DNS for some service.
The client hits that IP address.
And that's really being responded to by our load balancer
who's then feeding it down to one of our respective servers
on the back end.
So to implement this, let's implement this
as a separate virtual service.
And we'll do that in the very next video.
And I'll see you there in just a moment.