WEBVTT

00:00.367 --> 00:04.733
In this video,
we're going to go through the mock exam.

00:05.800 --> 00:09.533
There are about 12 questions
to be done in about one hour

00:09.653 --> 00:11.403
or a bit more than one hour.

00:13.523 --> 00:17.693
This one is a fairly simpler mock
exam compared to the others.

00:18.953 --> 00:20.913
As and when you go
through the different mock exams,

00:20.993 --> 00:22.673
the difficulty increases.

00:23.200 --> 00:24.153
Let's get started.

00:24.233 --> 00:27.053
The first question is to deploy
a pod named nginx-pod

00:27.133 --> 00:28.653
using the nginx:alpine image.

00:28.733 --> 00:31.296
That's pretty simple and straightforward.

00:31.523 --> 00:35.223
First, let's see if the environment
is set up in a way that we want.

00:35.303 --> 00:37.613
Alias for kubectl is not set.

00:37.793 --> 00:41.363
Also,
let's check if auto-completion is set up.

00:44.093 --> 00:47.573
There seems to be--
Auto-completion is set up.

00:47.843 --> 00:54.033
Now, one of the common questions
that we get is if auto-completion

00:54.113 --> 00:56.363
is enabled in the exam environment.

00:56.933 --> 00:59.763
Now, one of the thing
is if it's not mentioned

00:59.843 --> 01:05.843
in the next foundation documentation
about the Kubernetes exams,

01:06.473 --> 01:09.473
then nobody is supposed
to answer that question.

01:09.743 --> 01:12.653
Here's what I would suggest,

01:13.553 --> 01:15.993
you don't have to worry
about whether it's enabled or not,

01:16.073 --> 01:17.587
because either way,

01:17.667 --> 01:20.963
it's super easy to enable
it in a few seconds.

01:21.263 --> 01:23.373
The first thing
that you can do is first type K

01:23.453 --> 01:25.703
and see if the kubectl alias is set.

01:26.003 --> 01:27.213
In this case, it's not set.

01:27.293 --> 01:31.143
The other thing you can do is run
a kubectl get, and then hit tab twice

01:31.223 --> 01:34.103
and see if auto-competition is set up.

01:34.463 --> 01:36.963
This means that auto-compilation is set.

01:37.943 --> 01:41.313
Either ways, what you could do is,
if it's set or not,

01:41.393 --> 01:45.573
you could just go to the Kubernetes
documentation pages

01:45.653 --> 01:47.466
and search for kubectl cheat.

01:47.873 --> 01:51.713
Then select the kubectl cheat
sheet and just copy and paste this.

01:52.523 --> 01:55.463
It would take about five seconds
to get that done.

01:56.033 --> 01:58.563
That would enable auto-completion

01:58.643 --> 02:02.783
and this would enable the alias as well as--

02:02.993 --> 02:08.033
This is important for the auto-completion
to work with the alias K.

02:08.843 --> 02:10.863
Then when you're on K, you get kubectl,

02:10.943 --> 02:14.753
and then you have auto-completion as well.

02:17.363 --> 02:19.173
That would take about 5 to 10 seconds.

02:19.253 --> 02:22.953
I would recommend just doing
that if you need auto-completion

02:23.033 --> 02:25.408
and alias at the beginning of an exam.

02:26.423 --> 02:27.553
Let's get started.

02:27.633 --> 02:29.613
The first question is to deploy a pod named

02:29.693 --> 02:32.131
nginx-pod using the nginx:alpine image.

02:32.273 --> 02:35.273
For this, we run the kubectl run command.

02:36.203 --> 02:38.703
We'll try to stick to imperative
commands as much as we can,

02:38.783 --> 02:41.723
just so it's faster and easier
to get things done.

02:42.173 --> 02:46.043
We're going to do a kubectl run,
and the pod name is nginx-pod.

02:46.253 --> 02:48.483
I'm just going to copy and paste that.

02:48.563 --> 02:52.583
Then we have image
and the image is nginx:alpine.

02:55.283 --> 02:57.183
Then we always verify what we did.

02:57.263 --> 03:01.583
We do a get pod and we see that the pod
is created and it's also running.

03:02.243 --> 03:06.093
We'll also describe the pod

03:06.173 --> 03:09.073
and make sure that the image
is in nginx:alpine.

03:10.133 --> 03:11.183
Let's proceed.

03:13.253 --> 03:14.973
The next one is to deploy
a messaging pod using

03:15.053 --> 03:18.893
the redis:alpine image with
the labels set to tier=msg.

03:20.753 --> 03:24.963
If you're not sure
about the options for setting labels,

03:25.043 --> 03:27.543
you can quickly take a look at the help.

03:27.623 --> 03:29.198
Here you have labels.

03:29.603 --> 03:32.483
We can even just copy and run this command.

03:36.713 --> 03:41.433
The pod name has to be messaging,

03:42.400 --> 03:44.783
and the image name,

03:47.100 --> 03:52.073
redis:alpine, and the label

03:56.933 --> 03:59.100
is tier=msg.

04:01.067 --> 04:02.800
Let's verify that.

04:03.367 --> 04:05.047
We have the messaging pod.

04:12.143 --> 04:14.081
It uses the redis:alpine image.

04:14.783 --> 04:16.908
The label is also set to tier=msg.

04:18.293 --> 04:19.983
Let's just make sure
that it's in a running state.

04:20.063 --> 04:21.876
Yes. It's in a running state.

04:24.593 --> 04:28.613
The next question is to create
a namespace named this.

04:29.093 --> 04:30.153
That's easy as well.

04:30.233 --> 04:34.593
We do a kubectl create namespace, this.

04:34.673 --> 04:37.793
Then we do a kubectl get namespace.

04:38.967 --> 04:40.092
That's created.

04:41.873 --> 04:44.343
Now, get the list of nodes in JSON format

04:44.423 --> 04:47.963
and store it in a file at this location.

04:49.943 --> 04:54.293
We know to get a list of nodes,
we have kubectl get nodes.

04:56.033 --> 04:58.803
What we want is to get the list
of nodes in a JSON format.

04:58.883 --> 05:02.543
We need to use the option -o JSON.

05:03.023 --> 05:05.643
This is in the JSON format,
and all we need to do

05:05.723 --> 05:08.903
is redirect that to this particular path.

05:11.993 --> 05:15.353
Let's just verify
that it has that information.

05:20.033 --> 05:24.123
The next question is to create
a messaging service to expose

05:24.203 --> 05:28.433
the messaging application
within the cluster on port 6379.

05:29.063 --> 05:33.203
Here, we know that we have the messaging pod

05:33.683 --> 05:36.443
and we don't have a service for that.

05:36.863 --> 05:40.053
The goal is to create a service
called messaging service

05:40.133 --> 05:41.493
to expose the messaging application,

05:41.573 --> 05:44.513
which is the messaging
pod within the cluster.

05:45.353 --> 05:46.420
Says within the cluster,

05:46.500 --> 05:50.933
that's basically a service type
of cluster IP and on port 6379.

05:51.473 --> 05:55.613
Let's do kubectl expose command,
and we can take a look at the help.

05:58.373 --> 06:00.520
We want to do a kubectl expose and then pod,

06:00.600 --> 06:02.587
the name of the pod, and the port.

06:02.667 --> 06:05.230
That's basically what we are going to do.

06:07.343 --> 06:11.093
Kubectl expose pod messaging.

06:14.153 --> 06:16.043
Port is 6379,

06:16.373 --> 06:20.073
but also remember that we need
to specify a name for the service.

06:20.153 --> 06:23.393
For that, we have to use the name option.

06:25.583 --> 06:27.033
That's how we create that.

06:27.113 --> 06:31.013
Let's do a get svc, and we see
that we have a messaging service

06:31.343 --> 06:32.993
and it is cluster IP.

06:33.263 --> 06:34.613
The port is 6379.

06:34.973 --> 06:38.767
Let's also make sure that

06:42.967 --> 06:44.313
it used the right labels.

06:44.393 --> 06:45.893
Tier=msg is the one.

06:46.073 --> 06:47.973
The most important thing is the endpoints.

06:48.053 --> 06:49.628
It has the endpoints.

06:49.823 --> 06:51.603
You can verify if that is the endpoint

06:51.683 --> 06:54.953
of the messaging pod
by looking at the IP here.

06:55.033 --> 06:56.320
It's 10.244.0.6.

06:56.400 --> 06:57.687
10.244.0.6.

06:57.767 --> 07:00.017
The pod numbers are correct as well.

07:00.863 --> 07:02.513
That seems to be good.

07:03.263 --> 07:06.603
The next question is to create
a deployment named hr-web-app

07:06.683 --> 07:10.313
using the image
kodekloud/webapp-color with two replicas.

07:10.913 --> 07:13.973
Let's do a kubectl create deployment.

07:16.223 --> 07:21.113
The name of the deployment
is hr-web-app using the image.

07:21.413 --> 07:28.193
Image is web-app-color and replicas is two.

07:31.300 --> 07:33.233
Let's verify that.

07:34.373 --> 07:35.553
We have a deployment.

07:35.633 --> 07:37.313
It's called hr-web-app.

07:39.767 --> 07:40.593
They're not ready yet.

07:40.673 --> 07:41.433
We want to make sure they're ready,

07:41.513 --> 07:44.993
but we can just look at

07:49.073 --> 07:52.593
that in detail just to know
it's used the right image.

07:52.673 --> 07:56.933
That's the right image, and replicas
is two and there are two available.

07:57.733 --> 07:58.733
That's good.

08:01.163 --> 08:04.083
Now, create a static
pod named static-busybox

08:04.163 --> 08:07.143
on the controlplane node
that uses the busybox image

08:07.223 --> 08:09.863
and the command sleep 1000.

08:10.523 --> 08:14.733
We know that for static pods,
we create as a normal pod,

08:14.813 --> 08:16.613
so we do a kubectl run.

08:17.466 --> 08:19.900
The pod name is static-busybox

08:20.500 --> 08:22.833
on the controlplane node
that uses a busybox image.

08:22.913 --> 08:27.743
Image is equal to busybox and the command.

08:28.553 --> 08:29.583
We have to specify the command.

08:29.663 --> 08:31.913
For that, we do a dash dash command.

08:32.843 --> 08:36.783
We've learned that before specifying
a command or argument,

08:36.863 --> 08:38.133
we add the double dash.

08:38.213 --> 08:41.573
That way,
everything after that is the command.

08:42.563 --> 08:45.533
Now, the command is sleep and 1000.

08:47.333 --> 08:52.163
Now, we don't want to create
this because this is not a normal pod.

08:52.313 --> 08:54.063
It's going to be a static pod.

08:54.143 --> 08:56.253
We're going to get the YAML output for it.

08:56.333 --> 09:00.683
We're going to do a dash
dash dryrun equals client.

09:00.893 --> 09:04.043
Always remember dryrun option

09:06.053 --> 09:07.887
has to be before this because it's an option

09:07.967 --> 09:12.983
of the kubectl utility
and it has to be in a YAML format.

09:15.443 --> 09:16.443
That's that.

09:16.523 --> 09:20.553
Now, what we want to do is we'll redirect

09:20.633 --> 09:26.633
that output to a file called

09:26.800 --> 09:30.367
static-busybox.yaml.

09:34.333 --> 09:35.653
Let's check that file.

09:35.733 --> 09:37.293
This file is [?].

09:37.373 --> 09:38.823
It has the required information.

09:38.903 --> 09:39.903
It has the busybox image.

09:39.983 --> 09:41.858
It has the sleep 1000 command.

09:43.333 --> 09:44.543
All looks good.

09:44.783 --> 09:50.763
Now, all we need to do is move
this file to the directory

09:50.843 --> 09:53.153
where you have the static pod details.

09:53.233 --> 09:57.503
This will be etc, Kubernetes, manifest.

09:57.600 --> 09:58.800
That's the file.

09:58.943 --> 09:59.613
That's the location.

09:59.693 --> 10:03.983
Or you can save time by just
specifying the complete path right here.

10:05.903 --> 10:08.693
Let's see if it's created the pod.

10:09.143 --> 10:12.900
We have static-busybox controlplane

10:13.467 --> 10:16.283
and describe pod.

10:16.433 --> 10:18.609
It's in the running state so that's good.

10:18.689 --> 10:24.989
If you do a describe we can see
that it has the sleep 1000 command

10:25.133 --> 10:29.933
and it has the busybox image.

10:36.173 --> 10:40.087
The next one is to create
a pod in the finance namespace

10:40.167 --> 10:42.563
named temp-bus with the image.

10:43.913 --> 10:44.583
That's easy.

10:44.663 --> 10:48.487
Kubectl run temp-bus.

10:48.567 --> 10:49.842
Let me copy that.

10:51.983 --> 10:56.273
It has to use image redis:alpine,

10:57.563 --> 11:00.833
and it has to be in the namespace finance.

11:03.773 --> 11:07.553
Let's check the pods
in the finance namespace to see

11:07.633 --> 11:10.523
that we indeed have the temp-bus pod.

11:12.413 --> 11:13.613
We will describe

11:19.943 --> 11:21.593
the finance namespace.

11:21.683 --> 11:25.793
We see that it indeed
is using the redis:alpine image.

11:28.100 --> 11:29.467
That's good.

11:32.833 --> 11:34.120
The next question says

11:34.200 --> 11:36.663
that there's a new application,
orange, deployed.

11:36.743 --> 11:38.103
There is something wrong with it.

11:38.183 --> 11:39.903
Identify and fixed the issue.

11:39.983 --> 11:42.693
Let's check the pods.

11:42.773 --> 11:45.563
We see that there is an orange pod

11:45.893 --> 11:48.363
and it's in an Init:CrashLoopBackOff state.

11:48.443 --> 11:50.763
Now, we have seen
this CrashLoopBackOff state,

11:50.843 --> 11:52.773
and it's usually something
wrong with the pod

11:52.853 --> 11:55.728
or the process running
inside the pod crashing.

11:57.983 --> 12:02.003
If there's this init text
that you see before the status,

12:02.393 --> 12:04.353
then that indicates the issues
with the init container.

12:04.433 --> 12:07.593
This tells us that there's one container
on the pod,

12:07.673 --> 12:09.783
but there's also an init container

12:09.863 --> 12:13.163
and it's the init container that's crashing.

12:13.883 --> 12:19.863
We can take a closer
look at the pod by running

12:19.943 --> 12:22.443
the kubectl describe pod orange command.

12:25.103 --> 12:30.803
We'll do a kubectl describe
pod orange command.

12:31.823 --> 12:35.123
We see indeed there are two containers.

12:35.333 --> 12:37.553
There's the actual container here,

12:37.853 --> 12:40.666
but then there's also the init
container here.

12:40.793 --> 12:42.473
If you look at it here,

12:43.373 --> 12:47.993
we are seeing that there's an issue
with the init container.

12:48.773 --> 12:51.398
It says pod initializing and it's waiting,

12:51.593 --> 12:53.223
and there seems
to be something wrong with this.

12:53.303 --> 12:55.253
We could look at the logs of this

12:55.333 --> 12:58.913
by running a kubectl
logs command against this.

12:59.963 --> 13:02.026
We're going to do a kubectl logs.

13:02.753 --> 13:07.013
The pot's orange, but we'll also specify
the init container service.

13:07.523 --> 13:11.843
When you run that, you see that it says
the command sleeeep is not found.

13:12.203 --> 13:14.703
There is indeed something wrong with that.

13:14.783 --> 13:20.823
If we look at pod again,
and if you look at the command

13:20.903 --> 13:25.503
that's drawn to initialize this service,
we see that the command

13:25.583 --> 13:29.423
has an incorrect command sleeeep here,
so that needs to be fixed.

13:29.933 --> 13:32.523
Let's go ahead and try and fix that.

13:32.603 --> 13:36.173
Let's do a kubectl edit pod orange.

13:39.263 --> 13:40.263
We go down

13:42.713 --> 13:46.613
and we remove these and fix the command.

13:47.033 --> 13:48.158
It's now sleep.

13:48.653 --> 13:49.553
Let's save that.

13:49.633 --> 13:52.120
You're not allowed to save that.

13:52.200 --> 13:57.863
Let's do a kubectl replace force minus F.

14:01.533 --> 14:05.123
It'll delete the pod and recreate it.

14:07.630 --> 14:09.196
It's back.

14:09.700 --> 14:11.388
Let's check the status now.

14:13.883 --> 14:15.758
It's in an initializing state.

14:16.253 --> 14:17.763
Let's watch the status.

14:17.843 --> 14:20.753
It's now in a running state already.

14:22.733 --> 14:24.413
That's the fix for that.

14:24.713 --> 14:27.653
Let's move on to the next question.

14:31.067 --> 14:35.513
The next question is to expose
the hr-web-app as a service

14:35.733 --> 14:40.943
at hr-web-app service on port 30082

14:42.443 --> 14:44.193
on the nodes on the cluster.

14:45.263 --> 14:46.293
There are a few things here.

14:46.373 --> 14:49.203
The service that we want
to expose is hr-web-app.

14:49.283 --> 14:52.023
The service name
should be hr-web-app-service,

14:52.103 --> 14:59.013
and on port 30082 on the node,
so that means it's a NodePort.

14:59.093 --> 15:02.633
We want to exposed the application
on the ports on the node.

15:03.113 --> 15:06.353
This is the NodePort,
and the application is on 8080.

15:07.103 --> 15:09.783
Let's first look
at the application that we have.

15:09.863 --> 15:12.003
We're going to do a kubectl get deploy,

15:12.083 --> 15:14.223
and we see
that we have the hr-web-app service.

15:14.303 --> 15:16.473
To create a service-- Sorry.

15:16.553 --> 15:18.773
We have the hr-web-app deployment.

15:19.073 --> 15:19.803
To create a service,

15:19.883 --> 15:25.553
we do the kubectl expose command
so we can expose this deployment.

15:26.903 --> 15:33.473
We specify deploy and the name
of the deployment, so that's hr-web-app.

15:34.493 --> 15:39.533
Then we want to specify
a name for the service.

15:40.163 --> 15:43.173
We use the --name=

15:43.253 --> 15:45.263
and then we specify this name.

15:46.163 --> 15:48.993
Then this is also a NodePort service,

15:49.073 --> 15:52.043
so we're going to do a type NodePort.

15:53.543 --> 15:59.843
Then the port that this application
is exposed on is just port 8080.

16:01.883 --> 16:04.773
We cannot specify NodePort on this command.

16:04.853 --> 16:06.633
That's something that we know.

16:06.713 --> 16:09.347
We'll have to just create
the service like this,

16:09.427 --> 16:11.927
and then later go and edit the NodePort.

16:12.473 --> 16:15.573
If you have specified everything else,
so the name of the service,

16:15.653 --> 16:17.943
the type NodePort, and the port itself,

16:18.023 --> 16:21.803
as well as the deployment hr-web-app,
that should be sufficient.

16:22.223 --> 16:23.643
Let's take a look at the service.

16:23.723 --> 16:27.143
We have the hr-web-app
service and it's off type NodePort.

16:28.463 --> 16:31.523
The NodePort isn't correct
but this port is correct.

16:31.883 --> 16:36.263
We can also just verify if it has detected

16:38.783 --> 16:39.833
the endpoints.

16:42.623 --> 16:46.143
It has indeed has the two endpoints,

16:46.223 --> 16:49.073
which are the two pods for the deployment.

16:49.633 --> 16:50.553
All of that looks good.

16:50.633 --> 16:52.593
The only thing that we need to do is edit.

16:52.673 --> 16:57.503
We're going to do a kubectl
edit service hr-web-app.

16:59.483 --> 17:06.267
Then we're going to go in here
and change the NodePort to 30082.

17:07.679 --> 17:08.879
Let's save that.

17:10.193 --> 17:11.463
Okay, that's done.

17:11.543 --> 17:17.467
Let's do a kubectl get service,
and we see that the port is now 30082.

17:18.413 --> 17:19.433
Okay.

17:21.367 --> 17:22.753
That's good for that question.

17:22.833 --> 17:24.513
Let's move on to the next.

17:27.323 --> 17:31.400
The next one is to use a JS0N
pathway query to retrieve the osImage

17:31.667 --> 17:34.083
of all the node and store it in a file.

17:34.163 --> 17:36.053
The osImages are under the nodeInfo section

17:36.133 --> 17:38.008
under the status of each node.

17:38.543 --> 17:43.223
We know that to get the nodes,
we run the kubectl get nodes command.

17:45.563 --> 17:49.313
If we look at it in the JSON format,
-o JSON,

17:49.943 --> 17:51.881
we get all of this information.

17:53.873 --> 18:01.343
The next task is to extract the osImages,
the osImage property,

18:01.733 --> 18:05.253
from the nodeInfo section
under the status section.

18:05.333 --> 18:09.003
There's a lot of information here,
but if you look at it, so you have--

18:09.083 --> 18:09.963
This is the JSON document.

18:10.043 --> 18:14.153
You have items, and inside items
is an array and each one is a node.

18:14.243 --> 18:16.083
Currently, there's just one node.

18:16.163 --> 18:17.163
You have node.

18:17.243 --> 18:18.003
You have the document.

18:18.083 --> 18:18.813
You have items.

18:18.893 --> 18:20.643
Under items, you have nodes.

18:22.673 --> 18:23.973
From what's given here,

18:24.053 --> 18:27.453
what we want is under the status
section under nodeInfo section.

18:27.533 --> 18:31.193
You have the nodeInfo section,
and then you have the osImage,

18:31.703 --> 18:37.793
and the nodeInfo section
is actually under the status section.

18:39.113 --> 18:40.500
This is how it is.

18:41.423 --> 18:44.403
This is the entire document,
and then you have items.

18:44.483 --> 18:45.787
Then items is an array,

18:45.867 --> 18:51.213
and then within each array, you have status.

18:51.293 --> 18:53.523
Within each item
in the array you have status,

18:53.603 --> 18:56.993
and under the status
section you have nodeInfo,

18:57.263 --> 18:59.253
and under that you have the osImage.

18:59.333 --> 19:02.273
We want to extract osImage of all the nodes.

19:02.603 --> 19:06.833
For that, what we have to do is,
we're going to use the JSON path.

19:07.193 --> 19:11.333
Within the kubectl cheat sheet,
we have a JSON path section.

19:11.607 --> 19:13.287
Let's try and find that.

19:14.183 --> 19:15.683
Something like this.

19:18.113 --> 19:20.988
Instead of JSON,
we're going to do a JSON path.

19:30.143 --> 19:33.018
As we discussed,
we have items, so that's good.

19:33.803 --> 19:36.083
Then the star is for all the nodes.

19:37.853 --> 19:40.313
Within items, each item is a node.

19:40.973 --> 19:42.993
We want to extract
this information for all the nodes,

19:43.073 --> 19:44.403
so that's why this star.

19:44.483 --> 19:46.133
Then we'll just follow

19:48.413 --> 19:50.163
the hierarchy that we found.

19:51.653 --> 19:55.600
We have status and then we have nodeInfo,

19:56.533 --> 20:00.233
and then we have the osImage.

20:03.367 --> 20:04.287
That's that.

20:04.367 --> 20:06.363
That's how it's to retrieve the osImages.

20:06.443 --> 20:07.833
If there are multiple nodes,

20:07.913 --> 20:11.343
the single command would just
capture the osImage of all those nodes

20:11.423 --> 20:13.103
and this star out here.

20:13.613 --> 20:16.043
We then redirect this to this file.

20:19.613 --> 20:24.543
Then we verify our work by looking
at the file, and we see that it indeed

20:24.623 --> 20:27.743
has that information that we requested.

20:29.423 --> 20:30.998
That's that question.

20:32.183 --> 20:33.753
The next one is to create a persistent

20:33.833 --> 20:37.013
volume with the given specification.

20:38.843 --> 20:43.143
To create a persistent volume,
there is no imperative command,

20:43.223 --> 20:44.987
so we're going to search

20:45.067 --> 20:50.813
for persistent volume
here and we'll get this.

20:59.303 --> 21:02.013
If you look at it here in the subsections,

21:02.093 --> 21:03.573
we have persistent volumes here,

21:03.653 --> 21:06.723
and this is going to give
you a good template that you can use.

21:06.803 --> 21:12.143
I'm going to use this template
and most likely till here.

21:14.833 --> 21:17.873
I'm going to create my v1 pv.yaml.

21:20.273 --> 21:21.773
I paste the template

21:21.933 --> 21:27.083
and then I'm just going to modify each one.

21:27.533 --> 21:29.108
We have pv analytics.

21:30.533 --> 21:33.233
The storage is going to be 100Mi.

21:35.753 --> 21:39.773
Volume mode, there's no volume
mode specified so we don't need that.

21:40.463 --> 21:45.143
Access mode is ReadWriteMany,
so that's many.

21:46.763 --> 21:53.003
The claim policy is not given here
so we're going to get rid of that.

21:55.253 --> 21:59.333
Storage class name isn't requested
as well so we can get rid of that.

21:59.543 --> 22:04.463
The only other thing is host path,
so the host path.

22:05.363 --> 22:09.293
The path for this is what is given here.

22:14.567 --> 22:19.283
Pv analytics is the name,
100 Mi is the capacity,

22:19.583 --> 22:22.223
requested access mode is ReadWriteMany,

22:22.613 --> 22:26.013
and the host path is pv data analytics.

22:26.093 --> 22:27.093
That's good.

22:28.463 --> 22:30.593
Let's create a file.

22:32.873 --> 22:34.686
Let's make sure it's created.

22:35.273 --> 22:41.063
We have Pv analytics, pv,
the write capacity, ReadWriteMany,

22:41.723 --> 22:44.963
and the rest is okay.

22:45.143 --> 22:49.763
Let's also just make sure
the host path is set correctly.

22:51.803 --> 22:54.553
We have the source
which I've typed host path

22:54.780 --> 22:57.413
and the path is pv data analytics.

22:57.967 --> 22:59.167
That's about it.

22:59.633 --> 23:05.303
Let's end the exam and wait for the results.

23:15.633 --> 23:18.833
That's 100%.

23:19.600 --> 23:21.683
Well, thanks for watching.