WEBVTT

00:00:03.090 --> 00:00:07.330
Let's go ahead and go through the Kubernetes command line tools.

00:00:09.670 --> 00:00:15.290
So the primary CLI tool for communicating with the Kubernetes control plane is kubectl.

00:00:16.090 --> 00:00:21.150
There are other CLI and state management tools that work with kubectl, such as Helm,

00:00:21.330 --> 00:00:22.490
Cilium, and ANSI.

00:00:22.670 --> 00:00:25.050
Kubectl communicates with the Kubernetes API.

00:00:26.190 --> 00:00:31.310
It looks for a config file in the home.kub directory.

00:00:31.310 --> 00:00:39.150
Other config files can be set using the kubeconfig localenv and kubectl is supported within one

00:00:39.150 --> 00:00:47.150
minor version of the kube api server. So if your kube api server is at 1.34

00:00:47.870 --> 00:00:55.870
then kubectl is supported at 1.35, 1.34, and 1.33. So any of those three kube

00:00:55.870 --> 00:01:04.030
control versions will work with your kube api server at 1.34. kube control uses the following

00:01:04.030 --> 00:01:10.590
syntax so we have kube control our command the type the name and the flags

00:01:11.790 --> 00:01:18.670
commands specifies the operation so we have create get describe delete apply

00:01:18.670 --> 00:01:25.310
exec, logs, and a few other ones as well. The type specifies a resource type, pods,

00:01:25.310 --> 00:01:33.150
nodes, service, deployment, etc. Some of them have abbreviations such as service can be abbreviated

00:01:33.150 --> 00:01:41.070
as svc. Name specifies the name of the resource like nginx pod, menu operator, kube proxy, etc.

00:01:41.070 --> 00:01:49.550
And the flag specifies optional flags, so hyphen n for namespace, hyphen capital A for all.

00:01:49.690 --> 00:02:07.910
KubeControl allows output in other formats using a flag, so you can have hyphen o json to output in json, hyphen o json path, hyphen o wide, hyphen o yaml.

00:02:07.910 --> 00:02:12.390
required for access to the kube control command line tool for the kube config file

00:02:13.190 --> 00:02:19.910
it may be descriptively named so we don't have to name it as config or config.yaml

00:02:19.910 --> 00:02:26.070
we can descriptively name it it normally resides in the kube directory of the client machine

00:02:29.320 --> 00:02:34.840
it's used to communicate with the kubernetes api server and minikube automatically exports

00:02:34.840 --> 00:02:46.740
the config file and location for the terminal. And this is an example of a CLI export for a

00:02:46.740 --> 00:02:56.100
multi-cluster environment. You can see exporting this to the terminal. In this case, the Kube

00:02:56.100 --> 00:03:02.580
config file is located in a config directory. So instead of naming it config, it's actually

00:03:02.580 --> 00:03:10.260
located in a config directory which is production and this is named cluster one and it's just named

00:03:10.260 --> 00:03:17.540
descriptively kconfig.yml you can name it whatever you want and then to unset kubeconfig it's just

00:03:17.540 --> 00:03:23.700
unset capital kubeconfig and that works kind of like this so we have our kube control

00:03:23.700 --> 00:03:31.940
which uses a kubeconfig. It contains the credentials and the API endpoint. In this

00:03:31.940 --> 00:03:40.480
case it would be the VIP to communicate with the API server on the node for the

00:03:40.480 --> 00:03:46.320
control. So we do have plug-in managers for kube control and they're maintained

00:03:46.320 --> 00:03:52.220
at a repo known as crew. It has several hundred plugins however many are not

00:03:52.220 --> 00:03:59.580
regularly maintained. Some of the plugins are special purpose and enables development packaging

00:03:59.580 --> 00:04:03.660
and distribution of your own plugin. So you can actually create your own plugin and push it up to

00:04:03.660 --> 00:04:10.860
GRU. It's just an example of a few that are there. You can see some have a thousand stars, some have

00:04:10.860 --> 00:04:17.900
fewer than a hundred stars. All right, we are going to check the kubeconfig expiration and

00:04:17.900 --> 00:04:24.700
signature algorithm so we have a fresh minikube profile and then we're going to create a single

00:04:24.700 --> 00:04:30.380
node minikube cluster that you currently have when already running then you probably don't

00:04:30.380 --> 00:04:41.210
need to delete it just to make sure you have a clear command line and assuming your cluster is

00:04:41.210 --> 00:04:52.650
up let's cd into our dot kube folder correct and then using uh no we can just use the existing one

00:04:52.650 --> 00:04:58.330
because we we were in a single mini kube and so that'll work for this i'll save it a minute

00:04:58.330 --> 00:05:08.650
if we cap the config that's all right um we cap the config uh where is the client cert located

00:05:08.650 --> 00:05:16.010
uh where is the client certificate located client.crt correct so now let's cd into that

00:05:17.290 --> 00:05:22.730
directory you just cut and paste it and then cd into it you know sometimes the cut and paste

00:05:22.730 --> 00:05:28.090
works well and sometimes not so well right right yeah i don't know why it does that

00:05:28.970 --> 00:05:35.130
okay so now we're going to um while we're in that directory we're going to cat the client.cert and

00:05:35.130 --> 00:05:42.010
then we're going to use OpenSSL to read it. So we're going to cat it in certificate format,

00:05:42.010 --> 00:05:47.850
and then we're going to use OpenSSL to actually display it in human readable. Once you do that,

00:05:48.650 --> 00:05:54.490
what is the not after date shown? Yeah, yeah, a little overboard on this one, didn't they?

00:05:55.210 --> 00:05:59.850
I don't think this cluster is going to be around in 2029. I know it won't because we're going to

00:05:59.850 --> 00:06:07.530
destroy it in a few minutes. And then what type of signature algorithm is used? Okay.

00:06:07.530 --> 00:06:15.130
And then what X.509v3 extensions are present? All right. And now we're going to view the

00:06:15.850 --> 00:06:26.750
kubectl config file. So we can use kubectl config and how would you output this in JSON? This is in,

00:06:26.750 --> 00:06:32.990
Well, we could do a hyphen O JSON. We just need to do a kubectl config view. And then I believe

00:06:32.990 --> 00:06:41.430
just hyphen O and then JSON. Yes, that is correct. And you could, you know, just output a portion of

00:06:41.430 --> 00:06:50.050
it. And I think we know how to delete users, but we can delete the user minikube. So you can see

00:06:50.050 --> 00:06:54.750
there's a user minikube in there. So we can delete the minikube user. And you can take a look at it

00:06:54.750 --> 00:07:02.810
again. It can take view. Now let's get the nodes. Yeah, did you try to get the nodes? Okay, and then

00:07:02.810 --> 00:07:09.110
did you try kubectl get nodes? Uh-huh. Yeah, we have no user anymore in the kubectl, so

00:07:09.110 --> 00:07:20.250
our user was minikube. Okay, in lesson three, we learned about the primary Kubernetes CLI

00:07:20.250 --> 00:07:27.130
kubectl, how kubectl commands are structured, how flags may be added to change the output,

00:07:27.130 --> 00:07:32.970
how to locate the kubectl config file, how to locate and verify the validity of the user cert.

00:07:32.970 --> 00:07:39.850
Those are generally good for 12 months maximum, with the exception of minikub.

00:07:39.850 --> 00:07:47.790
apparently, how to delete a user from the config file.

00:07:47.790 --> 00:07:51.530
Let's go ahead and go to lesson four.

00:08:03.490 --> 00:08:05.070
Kubernetes core components.

00:08:05.390 --> 00:08:11.030
So Kubernetes core components consist of namespaces, pods,

00:08:11.910 --> 00:08:16.170
pod labels and selector deployments, replica sets,

00:08:16.170 --> 00:08:23.850
stateful sets, daemon sets, liveness and readiness, and there are others as well

00:08:23.850 --> 00:08:30.570
that we'll get into here. Start out with namespaces. KH uses namespaces to isolate

00:08:30.570 --> 00:08:37.390
resources within an individual cluster. Resource names within a namespace need

00:08:37.390 --> 00:08:43.690
to be unique. Development clusters may contain a default namespace for testing.

00:08:43.690 --> 00:08:49.190
However, production clusters use unique namespaces instead of the default, so

00:08:49.190 --> 00:08:53.350
generally the only thing we should have in the default namespace in a production

00:08:53.350 --> 00:09:01.030
cluster is the Kubernetes service itself. So if you run kubectl get all and no

00:09:01.030 --> 00:09:06.130
namespace, it'll automatically assume the default and it should only show one

00:09:06.130 --> 00:09:10.810
resource in there. It should show a service for Kubernetes on the production

00:09:10.810 --> 00:09:17.850
cluster. The KubeSystem namespace is for control plane components. We'll have a namespace example

00:09:17.850 --> 00:09:24.250
here. A logging service with a unique namespace. So multiple databases deployed within an operator.

00:09:24.250 --> 00:09:32.010
In this case you can see that we have a GitLab Minio namespace. We have a Loki Minio namespace

00:09:32.010 --> 00:09:38.650
and then we have a Minio operator namespace. In this namespace example, namespace Loki Minio is

00:09:38.650 --> 00:09:46.250
for the Loki database, namespace gitlab-minio is for the GitLab database, and namespace

00:09:46.250 --> 00:09:53.930
minio-operator is for the S3 deployment operator. This enables a separation between applications

00:09:54.570 --> 00:09:59.130
and can assist in troubleshooting when using multiple instances of a resource. All right,

00:10:01.210 --> 00:10:08.410
hopefully you can see the black dashed lines and the blue dashed lines. So the black dashed lines

00:10:08.410 --> 00:10:14.890
represent the namespaces across nodes. The blue dashed lines represent the nodes themselves,

00:10:15.610 --> 00:10:21.050
as a representative example of how namespaces cross nodes and how we can pin our resources

00:10:21.050 --> 00:10:27.770
specifically to a namespace. Namespaces allow constraints. We can define default pod memory

00:10:27.770 --> 00:10:36.250
requests and limits. We can define default pod CPU requests and limits. We can define range of minimum

00:10:36.250 --> 00:10:42.650
and maximum memory constraints. We can define a range of minimum and maximum CPU constraints.

00:10:42.650 --> 00:10:50.010
We can define overall memory and CPU quotas. We can define how many pods can be created.

00:10:50.010 --> 00:10:56.650
Namespaces can be deleted with a simple kubectl command. However, be careful using this in

00:10:56.650 --> 00:11:05.990
production. Deleting the namespace deletes all resources within the namespace. It's useful when

00:11:05.990 --> 00:11:12.070
testing. If a test ended, for example, with a stuck pod, deleting the namespaces quick

00:11:13.190 --> 00:11:19.350
can save valuable troubleshooting time but should only be used when the namespace is unique to the

00:11:19.350 --> 00:11:27.990
resource. Namespaces can be labeled just like nodes. It is useful for features such as the

00:11:27.990 --> 00:11:33.990
gateway API shared access. Additional feature sets in K8s may require labels to work across

00:11:33.990 --> 00:11:39.350
namespace. So allow one namespace to work with a service from another namespace. All right, pods.

00:11:39.350 --> 00:11:44.790
Pods are the smallest deployable units of computing that you can create and manage in Kubernetes.

00:11:47.050 --> 00:11:52.090
Pod means a group of one or more containers. The term pod comes from a pod of whales.

00:11:53.370 --> 00:11:59.690
And pods can run with a single container and they may also run with multiple containers. You can use

00:11:59.690 --> 00:12:05.610
workload resources to create pods. Examples of workload resources are deployments,

00:12:06.330 --> 00:12:12.090
staple sets, and daemon sets. Pod labels are key value pairs that are attached to the pod.

00:12:13.850 --> 00:12:20.890
Label keys have two segments, an optional prefix and name separated by a slash.

00:12:22.970 --> 00:12:28.410
Labels without a prefix are assumed to be private. Labels allowing listing pods based on a unique

00:12:28.410 --> 00:12:38.170
label an example pod label might be pod dot metadata dot labels dot environment and the

00:12:38.170 --> 00:12:43.850
value is production and in that case the label would just be environment and then production

00:12:44.890 --> 00:12:52.090
and then we would query for that by querying for a label hyphen l environment equals production

00:12:52.090 --> 00:13:01.450
deployments enable stateless workloads a deployment controller manages the state of

00:13:01.450 --> 00:13:08.870
the deployment deployments create a replica set to manage the pods the deployment yaml file

00:13:08.870 --> 00:13:16.910
enables unique labels for each deployment and the spec.selector field is used by the replica set

00:13:16.910 --> 00:13:23.070
to find pods to manage. The replica set assigns a unique hash at the end of the pod name. For

00:13:23.070 --> 00:13:31.370
stateful sets, stateful sets enable pods to stick to a particular name. This ensures consistency

00:13:31.370 --> 00:13:37.930
after a restart. In a deployment, the hash will change after a restart. So the pod names typically

00:13:37.930 --> 00:13:45.450
end in a number starting with zero. So the index starting at zero. A stateful set with two pods

00:13:45.450 --> 00:13:53.130
will have the same pod name ending in 0 and 1. So it would be statefulset-0, statefulset-1.

00:13:53.190 --> 00:14:00.530
Statefulsets guarantee the order and uniqueness of each pod. When a pod restarts, the name

00:14:00.530 --> 00:14:07.750
and endpoint remain the same. Unlike deployments, when deleting, there's no guarantee the pods are

00:14:07.750 --> 00:14:16.060
deleted, however. With a statefulset, the general practice is to scale down to 0 and then delete

00:14:16.860 --> 00:14:23.280
So if you ever run a Helm uninstall with a stateful set, you may find that the stateful set is still running inside the cluster,

00:14:23.820 --> 00:14:27.320
even though Helm reports back that it has completed uninstalling it.

00:14:28.240 --> 00:14:36.880
And that is because, as a general purpose in Kubernetes, if you're running a stateful set, you need to scale that down to zero first and then do that.

00:14:38.040 --> 00:14:46.700
Stateful sets utilize a headless service, which relies on DNS and not IP addresses, and caution with headless services.

00:14:46.860 --> 00:14:51.440
Sometimes the upstream providers have errors in their headless service.

00:14:52.420 --> 00:14:59.480
You can spend hours or days trying to get a Helm chart with a stateful set and a headless service to work,

00:14:59.520 --> 00:15:05.420
only to find out that the headless service was not created correctly, and it's an issue with the upstream team.

00:15:05.420 --> 00:15:10.460
Typically, stateful sets are provisioned with a persistent volume, although it is not required.

00:15:11.420 --> 00:15:18.780
For daemon sets, they're designed to run a pod on all or specific nodes. This is useful on logging

00:15:18.780 --> 00:15:24.780
or monitoring applications. Daemon sets are used by CNIs like Cilium to deploy the agent to every

00:15:24.780 --> 00:15:30.460
node. Upon new node creation, a new daemon set pod will be created. So if you're adding a node

00:15:31.500 --> 00:15:36.300
and you had daemon sets set to run on your cluster, it would automatically add that daemon

00:15:36.300 --> 00:15:44.700
set pod. You can pin a daemon set pod to nodes with node selector spec. And so it

00:15:44.700 --> 00:15:49.680
would be done using a roll. Liveness probes determine when to start a

00:15:49.680 --> 00:15:55.960
container. So we could do a liveness probe after the init container is

00:15:55.960 --> 00:16:01.980
finished and then we'd be ready to start up the other container. If the liveness probe

00:16:01.980 --> 00:16:06.280
fails repeatedly the kubelet restarts the container. Readiness probes determine

00:16:06.280 --> 00:16:11.440
when a container is ready to accept traffic, and if the readiness probe fails, Kubernetes

00:16:11.440 --> 00:16:14.280
removes the pod from all matching endpoints.

00:16:14.280 --> 00:16:19.200
Startup probes verify whether the application within a container is started.

00:16:19.200 --> 00:16:23.720
A startup probe is useful for a slow-starting container to keep the kubelet from killing

00:16:23.720 --> 00:16:26.360
the pod before the container is up and running.

00:16:26.360 --> 00:16:29.900
Liveness and readiness probes can use the same endpoint.

00:16:29.900 --> 00:16:35.560
A common endpoint is health Z when you're building your own Helm charts and containers.

00:16:37.840 --> 00:16:41.600
And care must be used with blindness probes to eliminate cascading failures.

00:16:41.780 --> 00:16:45.460
Your application can go into a loop if you're not careful.

00:16:45.960 --> 00:16:49.170
All right, let's go into the labs.

00:16:49.170 --> 00:16:55.930
We're going to discuss namespaces, deployments of replica sets, and stateful sets, along with daemon sets.

00:16:56.910 --> 00:17:00.050
Make sure you have a fresh Minicoop profile.

00:17:00.050 --> 00:17:02.110
and we're going to create a single node

00:17:02.110 --> 00:17:03.270
Minikube cluster.

00:17:03.910 --> 00:17:06.690
Yeah, we wiped out the Minikube user.

00:17:08.270 --> 00:17:10.130
And once you have your nodes showing

00:17:10.130 --> 00:17:11.270
after it's up and running,

00:17:12.750 --> 00:17:15.710
then we can get all of the namespaces.

00:17:15.910 --> 00:17:19.090
And again, some of the resource commands

00:17:19.090 --> 00:17:20.570
have abbreviations.

00:17:20.570 --> 00:17:22.290
So namespace is NS.

00:17:22.690 --> 00:17:24.830
Services is SVC.

00:17:25.950 --> 00:17:27.510
Some of them have abbreviations.

00:17:27.790 --> 00:17:29.750
And there are times that I wish

00:17:29.750 --> 00:17:33.590
that all of them had abbreviations. In this case, once your pods are up you can

00:17:33.590 --> 00:17:38.470
type kubectl get ns and we'll be able to see all of the namespaces.

00:17:38.470 --> 00:17:48.510
Should have, I believe, four namespaces including a default, kube-node-lease, kube-public,

00:17:48.510 --> 00:17:54.530
and kube-system. So let's describe the namespace kube-system and it has a name

00:17:54.530 --> 00:17:58.710
label and active status and now we're going to create a namespace and we're

00:17:58.710 --> 00:18:08.950
going to call it app a so remember kubectl command resource name so this would be kubectl create for

00:18:08.950 --> 00:18:15.730
the command ns for the resource or namespace the name is app hyphen a and then we'll query the

00:18:15.730 --> 00:18:22.720
table to see if it exists and then we can also describe it all right now we're going to label

00:18:22.720 --> 00:18:27.380
it we're going to label that namespace with a label of environment equals develop and

00:18:27.380 --> 00:18:33.100
And we'll check to see if the label exists by describing that namespace.

00:18:33.260 --> 00:18:34.640
It should have an additional label.

00:18:34.960 --> 00:18:40.640
Now we're going to delete the namespace, app A, and verify that it's been deleted.

00:18:41.260 --> 00:18:42.460
Everybody delete it.

00:18:42.780 --> 00:18:43.340
All right.

00:18:44.900 --> 00:18:47.740
Okay, so now we're going to deploy your first pod.

00:18:48.560 --> 00:18:51.980
So we're going to sudo vim.

00:18:52.260 --> 00:18:54.100
I believe you have vim on your VM.

00:18:54.100 --> 00:18:57.100
And we're going to pod-deployment.yaml.

00:18:57.100 --> 00:19:03.900
You could just cd back to the home directory. Yeah, it's good to cd back to the home directory

00:19:03.900 --> 00:19:10.860
for sure. It should, yes. And we're going to use i for insert. You should see insert in capital

00:19:10.860 --> 00:19:15.740
letters at the bottom once you press the i button on your keyboard. All right, so now we're going to

00:19:15.740 --> 00:19:21.020
type this in. We'll have a few exercises at the beginning that involve a few lines of YAML

00:19:21.020 --> 00:19:28.200
just to learn the syntax and then once we get past the first few I'll provide a directory of

00:19:28.200 --> 00:19:33.260
all of the yaml files and you'll be able to just you can copy and paste them from your

00:19:33.260 --> 00:19:39.080
you know upload them to your desktop or you can just access them through the gitlab repo yeah

00:19:39.080 --> 00:19:44.480
and nearly half of deployment errors come from syntax errors with the yaml

00:19:44.480 --> 00:19:52.320
so with my courses i usually have students type out yaml files short yaml files for the first

00:19:52.320 --> 00:19:57.920
few times and then we'll cut and paste or just go ahead and apply the yaml files after that

00:19:57.920 --> 00:20:03.380
stanley's jumping ahead here uh so yeah so and then um you can hit the escape button if you've

00:20:03.380 --> 00:20:10.240
never used them before once you're done just hit escape and then what is it stanley it's um yeah is

00:20:10.240 --> 00:20:16.240
at a colon WQ after the escape button, otherwise you'll type that into the term.

00:20:16.240 --> 00:20:18.160
Um, what do you have at the end there?

00:20:18.160 --> 00:20:20.000
You have, if not present, okay.

00:20:20.000 --> 00:20:23.420
You hit escape now do a colon WQ.

00:20:23.440 --> 00:20:24.680
Yeah, I think it'll work.

00:20:24.680 --> 00:20:29.180
And you'll coup control apply hyphen F and then the name

00:20:29.180 --> 00:20:30.340
of the file you just created.

00:20:30.340 --> 00:20:31.120
Correct.

00:20:32.240 --> 00:20:38.480
Cause when we created the pod manifest, and this is a pod manifest file, we told

00:20:38.480 --> 00:20:44.640
to deploy the pod in namespace app hyphen a and then just do kubectl apply hyphen uh

00:20:45.920 --> 00:20:50.720
kubectl apply hyphen f and then your space and then the name of your file which is

00:20:50.720 --> 00:20:57.920
pod hyphen deployment dot yeah so go ahead and vim open you probably have just a syntax error

00:20:57.920 --> 00:21:06.000
somewhere in there and so as you can see um kubectl when you apply doesn't necessarily tell you

00:21:06.000 --> 00:21:12.000
every time what you have incorrect within your manifest file.

00:21:12.000 --> 00:21:13.000
Oh, are you missing?

00:21:13.000 --> 00:21:17.000
Okay, yeah, so you need to move your image.

00:21:17.000 --> 00:21:21.000
The I for the image needs to be aligned with the N for name.

00:21:21.000 --> 00:21:23.000
And the same for image pull policy.

00:21:23.000 --> 00:21:27.000
So those need to be, you know, tabbed over basically two spaces.

00:21:27.000 --> 00:21:30.000
And then there should be a space between the hyphen and name.

00:21:30.000 --> 00:21:33.000
And this is under spec containers.

00:21:33.000 --> 00:21:41.880
So the hyphen should be directly under the C. Again, this gets to syntax with YAML formatting.

00:21:41.880 --> 00:21:47.560
So the hyphen should be directly under the C, and then name, the N, should be under the

00:21:47.560 --> 00:21:48.560
N for contain.

00:21:48.560 --> 00:21:50.700
Oh, and I for insert.

00:21:50.700 --> 00:21:55.380
And we're up against 3.30, but as soon as we finish this exercise, we'll go ahead and

00:21:55.380 --> 00:21:58.800
call it a day for our training.

00:21:58.800 --> 00:22:08.800
So hyphen under, yep, there we go, and believe it or not this little exercise right here will get you

00:22:08.800 --> 00:22:17.440
so many times on trying to apply anything from Helm charts to manifest files. It's amazing how

00:22:17.440 --> 00:22:31.360
many mistakes based on CNN. That's correct, yep, and yep, and then if you notice you now have

00:22:31.840 --> 00:22:38.640
an error that your namespace is not found because we told it to create this pod with a manifest

00:22:38.640 --> 00:22:44.260
in the app a namespace but we don't have that namespace in our directory so we need to create

00:22:44.260 --> 00:22:50.820
that namespace and it's just a few commands up on your up bar where we created it and once you

00:22:50.820 --> 00:22:58.200
create it you can reapply that deployment.yaml file and it should be created you can get your

00:22:58.200 --> 00:23:07.450
pods now hyphen a and you should see it in there yep under namespace f a pod ns app a all right

00:23:07.450 --> 00:23:17.890
now you can delete it by running kubectl delete ns app a uh ns for namespace and then app a is

00:23:17.890 --> 00:23:24.370
the name of the namespace and it'll take it a second because it is destroying the pod and then

00:23:24.370 --> 00:23:29.190
when you go and you look at your kubectl get pods again hyphen a you'll notice that that pod is no

00:23:29.190 --> 00:23:34.830
And this is just a very quick way when you're developing or testing to just wipe everything

00:23:34.830 --> 00:23:35.830
out.

00:23:35.830 --> 00:23:36.830
So be careful using this in production.

00:23:36.830 --> 00:23:42.190
And if you do your kubectl get pods hyphen a, you'll see that it is now gone and the

00:23:42.190 --> 00:23:43.450
namespace is gone.

00:23:43.450 --> 00:23:47.210
Everything in that namespace was just deleted out.

00:23:47.210 --> 00:23:48.210
Okay.

00:23:48.210 --> 00:23:53.070
Tomorrow we will pick up on deploying a replica set.
