Hello everyone, welcome to this session on Docker. Today, in this session, we're
going to learn docker end-to-end, so let's get started. The first topic that
we're going to discuss is an introduction to docker, after
that, we're going to discuss the common docker commands that you will be using
in your day-to-day life. Once we're done with that, we'll move on and talk about
docker files, what are they? and why exactly are they used?
After that, we'll understand what are Docker volumes? Then move on to break
a monolithic application into micro-services and then deploy it
using Docker. Once you're done with that, we'll move on and understand what is
Docker Compose. Once we're done with Docker Compose, I'll explain you guys
on what is Container Orchestration. So, in container orchestration, we will be
basically using Docker Swarm, and after that, once you've understood
what Docker Swarm is, we'll move on and deploy a multi-tier application using
Docker Swarm. So guys, this is the agenda for the session. I hope it's clear to you.
So, let's move on and start with the first topic on what is Docker? Docker
was essentially a need which came out of the problem that we're going to discuss
just now. So, imagine yourself as a developer and probably you're just
creating a website on, say PHP. So, if you create a website on PHP, the first
thing that you would do is write some code. Now when you test that code,
the kind of environment that you would be putting it in, let's see what all
components would be there in that particular environment. So, the first
thing that you would need in this environment, that is around the PHP file,
is an operating system. So, an operating system probably would
have a browser or would have a text editor. So, you need an
operating system to work on. Secondly, because you are developing a PHP
application, of course you need the PHP software installed on that operating
system so that your file can actually work. When you are developing a
web application on a particular language, it's not just the language which will
suffice with what you are doing, you also have to take into consideration the third-party
applications and the third-party libraries that you would be
including in your code. So, the third component that you would need when you
are developing a website is libraries. For example, if your PHP website
has to connect to a MYSQL OS, then it would need a PHP MYSQL library for
connecting to it. So, these are the components that are basically required
by a developer to run his program. So, what he does is he writes a program,
he configures the environment according to the program, and when everything goes
fine his program works well. Now, the problem occurred when this particular
program had to be given to someone else. So, the developer finished his job
and it is the job of a tester to check this program. So, the developer would give the
PHP file to the operations guy, and let's see what the operations guy
would do. Now the operations guy is in the same exact position that the developer
was when he was starting to develop his code, but the difference over
here is now the PHP file is running, and it is just that he has to run this file on
his system. So, the first thing that the OPs guy would do is
replicate the environment that the developer is having. So, he would
get the same OS, the same software, and the same libraries to run that PHP
program. Now there are a lot of versions for a particular software, for example,
for PHP you have PHP 7 which is currently running, but there are
companies still working on PHP 5.6 because of
probably legacy problems or because the commands have changed, and if they
want to move on to 7, they will have to change all the commands in the codebase, so
there are lot of reasons. So, there is a particular
version that this company is also following. So this ops guy has
to have the exact same version so as to make the file of the developer work.
Now, he tried his best possible judgment in it and he installed the PHP
software, and he installed the libraries, installed the OS, but still the problem
was that the OPs guy couldn't make the file run, and he came to a conclusion that the
code is faulty, but the developer says it ran fine on my system, and it's your system
which has problem, so fix it by yourself. So, these
were some of the statements which were exchanged between developers and
operations guy. I mean if you think about it, it was actually nobody's
fault. The operations guy did what he
could in the best of his ability to replicate the environment, but it didn't
work out. Now you guys might argue that why don't we use VMs in
this case, probably the developer could work in a particular VM and then just
give that VM to the ops guy and then he can work on the same VM and probably run
the file, I mean that is a viable solution, but the problem is the size of
VMs is too large to give to the OPs guy and give to the testing guy on
every feature that a developer has. In that case, every developer has to
have a VM that he's working on and has to have his own version of the VM because
if you are adding, say, feature A and feature A requires three or four more
libraries that you have included into your particular VM, then it will become
inconsistent with what other developers have. Now imagine the OPs guy having
several versions of VMs and not knowing what kind of VMs he has to impose
on the production server or on the testing server which basically will act
as the final version of the image on which all the features of all the
developers will work. It's a very hectic situation. So, the problem was the
VMS were very large and they were complex as well to handle. When we are
talking about a staging area or the deployment area, the production area,
they were a little difficult to handle. Now this was the problem that was there
before docker. So, what did we need. We basically needed a wrapper like in the
case of what we just discussed, the wrapper was a VM wherein it basically
contained all the operating system files, all the software, all the code, and all
the libraries together and could be basically lifted and shifted to a
different system where it would execute, but we needed something more
portable, we needed something more smaller that could easily
be given to some other person for testing. We needed something like
that. We needed a wrapper around our files and the answer to this
particular scenario is that now if we get a wrapper which will basically contain all
the files, in that case, each and every environment of ours will become the same.
The developer environment is going to be the same, and the moment it gets
passed on to the OPs guy, he will again deploy the same wrapper and his problem
is also solved because the ops guy does not have to match the versions of the OS,
the software, the libraries, because everything is there inside that wrapper,
everything is there inside that container. He just has to run that
container, and he can just see if the code is working properly according to
what has been specified or not. So, the answer was that all the environments,
i.e., the developer environment, the staging or testing environment, the production
environment, all of these environments are now going to be the same.
This was possible using docker. So, what is docker? Docker is basically a software
which helps us creating this wrapper around the files of a code the operating
system and the libraries that we mentioned that are required for a
particular code to work, but the awesome thing about docker is that you
do not need the environment to be in GBs. It need not
be somewhere around 900 MB or 800 MB or 1 GB or 1.5 GB. A container could be as
low as 50 MB, that is, the size of a container called Alpine is as low as
50 MB, so it becomes very easy to basically give it to other people to
test your code with all the environment set up in that particular container.
So, docker is a software which helps us enable that. Docker is
basically a tool which helps us in containerizing an application.
Now let's see how basically docker is doing this. How is it so portable?
how is it so low in size? So basically this is the architecture of
docker. So, at the base level, you have the hardware that basically means that you'd
have a computer, and on that computer you would have an operating system present.
So this is your operating system. So it's as simple as you have a laptop
and on that laptop you have Windows or Linux installed. Now once you have
the operating system installed, the next thing is the container engine that you
would install. So, the container engine is nothing but the docker software that you
would install on top of your operating system and that is it. Once you have
installed the container engine, you can run any type of container that is there
in the repository or on the web which is available. For example,
if your code needs an Ubuntu container, all you have to do is
write docker and Ubuntu, and what would it do? It would basically download the
ubuntu container, and then you can add your code files inside that ubuntu
container and start working, but how is it low in size how is it not in
GBs when we compare it to the Ubuntu operating system which is around 800-900 MB,
the Ubuntu desktop version, but how come this container is so small. So, the
answer for that is the container does not contain all the operating system
files. So, as you can see, the container engine actually shares its
space with the operating system. So, a container is void. A container does not
have a kernel in place. It shares the underlying kernel of the operating
system on which the container engine is installed. So, if I talk about, say,
you have an Ubuntu operating system or you have a Windows operating system,
and what you do is you download the container for CentOS. So
Cent OS is basically a Linux distribution. So you download the
container for CentOS and now when you're working in that container you
feel as if you are in CentOS, but the point is that CentOS operating
system is actually not installed, what is
happening is your container is sharing the resources from the operating system
but your container has the minimum binaries and libraries that are required
to run the CentOS commands, for example, for installing anything on
CentOS, you pass the command, yum install and then the package name.
So, it would have the yum package in there in the container. It would
have all the repository URLs there in the container, and that's how it behaves
like a CentOS operating system, although the container is nothing but a set of
binaries and libraries which are important for the CentOS commands to
work. That is all what a container is, but with the underlying
virtualization of the kernel or the bios of the operating system your container
seems to be like an operating system although it is not. Because of
this very reason that it virtualizes the underlying kernel or BIOS to make it as
if it's running on its own, that is, its own kernel or BIOS. This is the
reason that the containers are very lightweight because they don't need to
have all the files required for an operating system. They just need the bare
minimum binaries or libraries for that particular environment to work.
So, if you again come back to see this architecture, you have the hardware. On
top of the hardware, you have the operating system, on top of operating
system you install the docker software, and on top of docker software you run
containers. So, all these containers have the minimum binaries or libraries, and on
these you basically just put your code. In my case, I will put my PHP code on top
of the container and that would be app 1, and there could be multiple containers
running on my system, for example, one code file is running in ubuntu, the
other code file could be running in CentOS container, the third could be
running in and some other operating system or some other
Linux container, and all this is possible using the Docker software.
So, this is the architecture for a docker container or a container in general.
Now, let us compare it with the VM. So, I gave you the example of VM when I
said that VMs are heavy in nature. So, let us understand how containers are
different from VMs. So, on the right side you can see the architecture
of VM. So, on the VMs you have the hardware which is the same as the
docker architecture that we saw. Then on top of hardware you have the host
operating system which is the same as the docker container that we saw. Now on
top of the host operating system, you have a hypervisor or a VirtualBox kind
of software which will basically virtualize the hardware from the
operating system and give it to the VMs running on top of it. So, you have
hypervisor software in case of VM architecture, and then you have the
container engine software in case of a docker architecture, then on top of the
hypervisor, you have the guest operating system, and this is where
all of the difference is. So, in case of containers, you just have the
bare minimum binaries or libraries which are present, but in case of VMs you
have the whole operating system which is basically installed on top of the
hypervisor. Because you have the whole of the operating system
installed size of the VM is quite bigger than what you have in the
container. The VMS could be multiple in nature when we talk
about how many VMs can be run on a machine. It totally depends on the specs
of the machine. Regarding VMs,
you can run multiple VMs on a single machine and also one thing to
notice over here is that there could be or there could not be a host operating
system in case of VMs. So, in case of virtualization technologies, it has
advanced this much that the hypervisor itself does not require a host
operating system. It directly works on the hardware level as
well, but usually when we guys work in R&D or when we have the kind of laptops
that we have or the kind of specification that we have, we go ahead
with this kind of an architecture where we have an existing operating system on
top of that we install tools like VMware or VirtualBox and on top of that we
install the VMs. So, this was the basic
difference between a docker architecture and a virtual machine
architecture. Moving forward, we have understood why
we need docker and we have understood that what docker is exactly right now.
Let's go ahead and see how we can install docker on our machines. When
it comes to installation, there could be basically three kinds of insulation that
you might come across: you could either have an apple or a Mac system that you
are working on, you could have a Windows system that you're working on, or you
could have a Linux distribution that you're working on. So, let me walk you
through all the three domains in basically the installation. So that we are on
the same page. Once we come out of installations and when we are doing
hands-on, I hope you guys all will be able to go along with the video
as we are performing the hands-on. So, if you're on Mac, all you
have to do is go to this link. So this link is basically going to download the
docker toolbox for Mac, and once you have the docker toolbox,
it basically installs everything. It will install compose, it will install the
docker software, it will install the other components of docker, so you don't
have to worry about which component is for what, so just go to this
particular link, download the docker software. Once you have the docker
software, just come back to this CLI and just pass the command docker
version and if you get the reply as the version of the docker which
is running on your system, then your software is successfully
installed. So, this is the installation for Mac. If you talk about
installation on Windows, just go to this link, download the docker
toolbox and everything is going to be set up automatically for you.
When we talk about ubuntu, things are little
simple on the ubuntu side. All you have to do is pass these commands and your
docker would be up and ready. So, for our sake, we will be basically
doing hands-on today on the Ubuntu distribution of Linux, so what
I'm going to do is, I'm going to just go back to my terminal so that we can use the
putty software to basically connect to our ubuntu distribution, so just give me
one second.
So this is basically my Ubuntu distribution. So, what I'm
going to do is I'm going to install docker in it. So, the first thing that I would
pass is the command sudo apt-get Update.
So, the first command that I'm going to pass is sudo apt-get update. Once I've done that,
the next command that I'm going to pass is sudo apt-get install docker.io
and then you'll be prompted for a yes or no. Just type in Y which will
mean yes, and this will install all the packages required for docker to work on
this particular system. So, if your Internet is fast, it will hardly take a
minute to install docker, and once install docker is all installed and set
up, we can go ahead and check whether docker is working on a system or not by
typing in sudo docker version. So, just give it a minute and
this will all be over soon. So, docker is installed now and
all we have to do now is check the version. So, it's docker - - version,
and as you can see that the docker version is 18.06.1-ce
and the build is as shown. This basically confirms that docker has been
installed on our system so it successfully installed docker. So now let's go ahead
and see what is in store for us on our next slide. So, we have
installed docker on our system, and
depending on the kind of OS that you are working on, I hope you guys have also
installed docker on your system. If not, you can pause this video, do that first,
and come back because I would want you guys to learn as much as you can from
this session, and I would want you to follow me while I'm doing the hands-on
so that you get the maximum knowledge possible from this session, alright. So,
the next thing that we're going to do in this session is get acquainted with the
docker container life cycle. So, basically this is the
whole lifecycle of what a container goes through when we talk about the docker
ecosystem. Now, if you guys know what github is or if you guys have worked on
github, you guys might know that there is a central repository.
Whenever you have to start working on a particular codebase, the first thing
that you have to do is pull the codebase from the central repository.
That central repository is nothing but something on the cloud or
something on the Internet which holds all the codebase for your organization
or for your team that everyone is working on right. So that is basically a
central place where you can download everything from. Similarly, in docker
we have something called as docker hub. Now docker hub would contain all the
open source images that are present,
for example, I told you that you could run a container on ubuntu, you could run
a container on CentOS, you could run a container on Alpine, you could run a
container on some other operating system. So, all of that is present on docker.
So, the first thing that you do is pull an image from docker hub onto your
system, and this is your system where docker engine is installed and basically
what you download from docker hub is an image of a
container. So, you get the image and the next step that you do is you run
that image, and the moment you run an image it becomes a container. So
you can run that image and that would basically be the normal
state of a container that is running. Once you want to stop a
container, that is again a life cycle. So, when you're done with
working on the container you can stop it, and once you are done with everything,
you don't need it on your system anymore, you can remove it. So, this is the
life cycle of a container. The first thing that you do is you pull it from docker
hub, it becomes an image. Then you run that image, and it becomes a container.
The containers can either be in a running state, in the stop state, or in
the deleted state. So, this is a
summary of what happens inside docker,
but of course, there is more to it and we will see as we move along in the session.
So, we've understood the common ecosystem of docker,
we've understood what docker is, how the containers work
inside the docker ecosystem: You first download them, they become an image, then
you run that image, and then it becomes containers. So, with this knowledge,
with docker installed on our systems, let's go ahead and perform some
common docker operations that you would be doing when you are working on docker
in a day to day life. So, this is the first command that we can try out
when we are working on docker. So whenever you want to find out which
version of docker that you're working on, you can simply pass this
common docker version and then you can basically get the version that you're
getting on. Let me quickly change the color of the
terminal because I feel that this color is a little dull so so that it becomes
better for us to see just give me one second
all right much better. So when we pass this command docker version, you get the
the current docker version that is installed on your system along with
the build name. This is exactly what this command does. The second
command that you can go ahead and try is docker pull. So, we saw the container
life cycle, the first thing that you do is pull the image from docker hub.
Syntax for pulling the image is docker pull and then the
image name. So, as you can see in the screenshot, we pass a command docker pull ubuntu
Ubuntu and what it did was it downloaded a container from docker hub
automatically. So, what we can do is we can also try that out. So, let me just
clear the screen all right
So, we'll type in docker pull and then the image name. So, this is the
image name and we'll hit enter.
So, sudo docker pull ubuntu , hit enter, and this would download the latest
ubuntu image on your system. Now remember guys, we'd have just downloaded the image.
We have not run the container yet. So, our next command would be docker
images. So now if you want to check what image did you download and is it
existing on your system to verify, all you have to do is type in
sudo docker images, and then you would be able to see the
image that it just downloaded. So this is the image that we just
downloaded and you can see the size. It's 86.2 MB, well that's too
low to be an operating system, right imagine the beauty guys. So, an ubuntu
operating system, a VM that you're working on, is I think around 1.5 or 2 GB,
but when we talk about this container, it's hardly 86.2 MB, awesome, right. So,
once you have seen the images, the next step would be to run this image.
Now to run this image, the command is called docker run and along with the
image name. So, you use some flags as well when you are using docker. So
let me explain you while I am executing this command. So, sudo docker run, this is
the syntax. The next flag that you add is - IT which basically means make the
terminal interactive - D which means run the container as a daemon, run the
container in the background. So, whenever I run the container make it running in
the background till basically I stop the container, so that is what -
D does. So, the command would be sudo docker run -it -d
-it means make the container interactive in the terminal so that I
can also pass on commands - D which basically means make the country
container a demon that it should be running in the background even though
I'm not working on it and then you pass in the image name. So, the image name is
Ubuntu and then you hit enter. So, can you see you just got an ID of the container.
So basically if you get something like this, then this means that your
container has just started and then to view all the running containers all you
have to do is pass the command docker ps and that would list down all the
containers which are currently running in your system.
So, let us do that as well. So, let me just clear the screen so just pass in sudo
docker PS, and this would basically show you the container which you have just
started. So as you can see, I started Ubuntu container 29 seconds ago, and this
is the container ID for that particular container. So my container is
running. So what's next? Next step would be that docker PS would basically show
you the containers which are n the running state, but what if you want to
see all the containers which are there in the system, for example, what I can do
is I can do a sudo docker stop and I can stop this container. So, this
container is now stopped and what I can do is I can run one more container which
would be sudo docker run - it - d and then one - sorry about that, so if I do a
docker PS I would only be able to see the container which is currently running
so you can see it is up seven seconds ago but if I want to see all the
containers which are there on my system that could either be in the start state
all stop state all I have to do is type in the command sudo docker PS and then -
a with this I can see the containers which
are running so this is container which is running which was made around 20
seconds ago and this is a container which has exited which we manually
stopped and we can see that also by passing the command sudo docker PS - eh
okay now the next step would be to work with the container so we have started
the containers but the next step would be to start working on them and how can
we do that we can basically do that using the command docker exec so what
we'll do we'll just first get the container ID so that when train ID is
docker PS
So, this is the container which is
currently running. Now if I want to get inside this container, the command
for that would be sudo docker exec - it make it
interactive give the container ID and then bash. Bash
would be that I want to run this container in the current terminal space
that I am working in and the current terminal space is bash, and I'll hit
enter. So, let me just clear the screen, so can you see that you are now inside the
container. So, this is the container ID and this is the user of the container.
So, we are basically acting as a root or the container ID that is we are inside
the container and we are acting as root so
this is the environment that I was talking about that the developer will
start working in, and this is basically an ubuntu container. So, all the
ubuntu commands are going to work inside this particular container. So, once you
are inside the container, you can do whatever you like. For example, if I have
to update the container, I can do an apt-get update, and it will start
updating the container as if it's a new operating system which is running on the
system. Also to show you guys that this is different or this is
completely independent from what we were doing outside the container, you
remember we have docker installed on our host operating system. Now if I try
to access dock from here I will not be able to do that so if I do a sudo docker
PS you can see that it says ok let me do a command docker PS you can see that it
says docker command not found right so basically docker is not installed inside
of the container and that is the reason it is not able to access docker also an
interesting thing that you can see over here is that I passed a command sudo
docker PS and it says sudo command not for
so the pseudo library is not installed in the container right so I told you the
bare minimum libraries which are required for a container to make it
behave as a particular operating system is only present in the operating system
is only present in the container and nothing else and that is why you can see
even pseudo as a command is not present inside the container all right so if you
are inside the container haven't you want to exit the container all you have
to do is type in the command exit and this will make you come out to your host
operating system but mind you guys your container is still running so if you do
a docker PS you can still see the container running in your docker PS
space all right so this is how you can get inside a container all you have to
do is docker exec - IT and then the container ID space the terminal that you
are working in which in my case was bash all right okay now again so this I
already showed you that if you want to stop a container all you have to do is
sudo docker stop and then the container ID hit enter and the container will be
stopped and then if you do a docker PS you will not be able to see any
containers which will be running inside the system so as you can see once we do
it once you did a stop there are no continuous running over there in a
docker PS space now okay you can also kill a container in case a container
becomes you know non-responsive and you're stopping the container but it's
not able to exit what you can do is you can kill a container it's similar to
that of stock but when you stop a container it basically gracefully exits
the container it's just like shutting down your computer or just switching off
the power switch from behind the computer's power outlet right so if you
have the stop the container but the container is still not stopping because
of some program which is comparing in loop inside the container or something
like that you can immediately kill the container using the command docker kill
and then the container ID then you have something
call des docker RM so basically I told you guys that if I if you do a docker PS
- eh you can still see the containers which were stopped which were in this
top state right but as we saw in the lifecycle there's a third stage of
docker containers which is basically the delete stage and to reach the lead stage
you pass in the command docker RM and then the container ID and this would
basically delete the container from your system now let's see how we can do that
for example if we want to remove or both these containers from the system all I
have to do is take the container ID pass in the command sudo docker RM and then
pass the container ID hit enter and this would remove the container from my
system so similarly if I want to remove the second container as well I just have
to pass in the command sudo docker RM the container ID hit enter and the
containers will be removed and now if I pass in the command let me just quickly
clear the screen now if I pass in the command sudo docker PS - eh you can see
there are no containers which now exist because they just removed them from a
system using the command docker RM alright moving forward now what to do
when you have to remove an image now you guys know we already have an image in
our Dockers system which is
this we have the Ubuntu image now if you want to remove this image from the
system the command for that is talker RMI and then the image ID and this would
remove the image from your system so if I want to remove this all I have to do
is type in sudo docker R M so RM was to remove the container if you want to
remove the image just type in I as well in front of the RM command and then the
can image ID which is this passengers hit enter and this would delete the
image from your system so if you do a sudo docker images now you can see that
the image is not present in the system anymore all right so this is how you can
remove image from your system and this was it guys so this is how you can
basically go ahead and do these these are some of the common operations that
you would do in your day to day life while you're working on talker and I
hope you guys are well acquainted with all these operations so what I would
suggest you guys is pause this video to try to do all those commands together
and once you're done with that let's resume the video to going ahead right so
our next topic is basically to create a docker hub account so like I was
comparing it to github so if you guys have worked in github you also have to
create an account on github in case you want to have your own repository where
you want to push your own personal stuff or your personal code for you're
probably rnt or whatever you want to call it right similarly you have
something in docker hub as well if you have created a container for your own
testing purposes or are in the purposes and you want to push it to docker up so
that in later time probably you can pull it whenever you want or if you want to
share that container with the other people all you have to do is create a
docker hub account and push your container image on that docker hub
account right so that is possible but the first step would be to create a
talker up account and for that you have these steps so first you have to go to
the the the website hub decorum so let me quickly show you that so all I
have to do is go to the browser go to hobknocker comm and you would see a
website which will look something like this alright the next thing that it
would have to do is you will have to sign up on this website so just choose a
docker ID now this docker ID is basically like your username and this
username has to be unique right into the docker ID enter your email address your
password agree to the terms of conditions and just click on sign up
after this you would get a verification email on the email address that is
specified over here verify your email and that's it your docker hub account is
all set up right I already have a Tokarev account let me just quickly show
you that so my docker hub kuma account looks
something like this whoops give me one second
all right so guys this is my daugher of account and as you can see I have some
personal continuous that I've plotted over here and I'll show you guys also
how you can do this but before that let's come back so once you have set up
your talk up account you would be able to see your docket up account which
would look something like this right and always remember guys remember you user
ID because it's going to help you out in the future when you are basically
pushing your custom images onto your account that is your token up a comment
also always keep your user ID handy alright so guys this is how you can sign
up for drop a cup once you have signed up let's go ahead and see how you can
save changes to a container alright so what does this basically step means so
this step basically means that if I am on my system and say you know I run my
docker command
now see Aaron docker container
all right so this is basically download and run the container for me so sudo
docker PS this is the container that I want to go into
all right I'm the continuum now what I want to do is
let us do an ll and you can see these are all the directories which are
present inside the container as of now now what I want to do is I want to say
create a directory and say I create a library called app right so if I do an
LS now you can see there is a new directly app which has been created
inside this container right now if I exit this container and say I do an LS
sorry if I do a sudo doc PS I can see that the container is running but the
catch here is that if I delete this container say I delete this container
okay so one more thing guys if you want to remove or delete a container which is
running you can pass in the command sudo docker RM hyphen F and then the
container ID the other way to do is to stock the Pantanal first and then delete
it that is a general way of doing it but if you are in a hurry and you want to
delete the container which is run in the running state right now just type in the
command sudo docker RM hyphen F and then the container ID and this would remove
your container all right so I've deleted my container now and if I now type in if
I again run the image to the sudo docker run - I T - D and then the image name
and if I go inside this container
and if everyone LS you can see the directory that I created it caught it is
not nowhere present over here now the reason for that is whatever changes you
made to the container they were only present inside the container and these
this container went deleted these changes do not propagate into the image
that you downloaded originally all right now if you want to make changes to a
container and want those changes to be saved inside an image so that you can
later on again launch a new continent and it should have all those files that
or files or folders or profits that you inside installed inside the container
you would have to save these changes inside the container and for that you
would have to learn how to save changes inside a container let's let's go ahead
and learn how you can save these changes inside a container alright so for saving
changes inside a container the command is called docker commit okay so you have
to pass in the command docker commit the container ID that you want to save and
then the new image name so basically this will create a new image of a
container and once you pass it the container ID space you have to give the
new image name that you want that custom image to have right so for example in my
case if I create the folder say app and when I les I can see the app folder is
there now right I just accept the container I'll do a sudo docker PS
I can see this is the container ID so I just copy that and sudo docker commit
passing the container ID and then the new image name so the insi image name
let's say I say that image name is test alright so with this if I now do a
docker images
I can see that there's a new image which is present which is called test alright
and now I can run a container on the image test and all I have to do is
pseudo docker run - ID - D and then test this would run the container and if I go
inside the container now I can see that my changes would be there inside this
container so if I do an arrest I can see that the app folder is present and this
is how you can create a custom container so I for demo purposes says just created
a folder you can also install software's inside a container like for example you
install Apache you install my sequel or any other kind of software that you want
then all you have to do is save the container using the docker commit
command and you're all set whenever you run that image again you could have all
those offers installed inside that container alright and this is how you
save changes to a container alright so now let's do this example so basically
what you're going to do is we cannot run an ubuntu container we're gonna install
Apache on it and once the Apache is install we're gonna save that container
into an image alright so let's see how we can do this so let's clear the screen
let's exit this container and let us first clear everything up so sudo docker
PS so there are two containers running okay so let me show you one more command
which is basically like a shortcut so if you if there are like tens of fives or
more than five or more than three containers running on your system you
always do not have to pass in the command sudo darker docker RM hyphen F
and then pass the container IDs the shortcut to remove all the containers at
once is the command sudo docker RM hyphen F and then pipe it with another
command this is the pseudo docker PS - a and then having cube you pass in this
command it would remove all the containers which are present in your
system so if I do a pseudo docker PS now
you can see there are no continues running anymore alright so this is the
shortcut that you can use while working with docker alright
so my next step is to basically install so first I have to run and open to
container so I will do a sudo docker - run I have an ID I'm going to alright so
my container is now running the next thing that I have to do is install a
patches over on this container okay okay so let's take it a little differently
now so basically okay so let it be like this we'll come back to the path that I
wanted to explain to you guys later so basically now I'll just exact into
this container okay I'm in first thing that I'll do I'll just update the
container so apt-get update
once is updated the next step is to install Apache and for other commanders
apt-get install Apache to
and this install the Apache software
all right and
apache2
status would give us whether Apache is installed or not so it says the Pacha 2
is not running so let's start the service so as Apaches to start hit enter
and if I now check the status status of a budget - I can see that Apache 2 is
running inside the container now also this is what I wanted so let me just
accept the container now and let me save the container so we have installed
Apache on our container next step is to commit these changes to the container so
that it becomes an Apache container alright so I'll do a sudo docker PS this
is the container ID and it's a sudo doc commit give the container ID and now
give the image name so let's give it as Apache or let me make it a little more
simpler for me when I move ahead so whenever you want an image pushed to
your docket of account there's a certain nomenclature that you have to follow
when you're naming your image so first of all you would have to write the
username for your docker up account remember I told you to remember your
user ID and this is exactly for that so specify your user ID slash and then
whatever name you want to give to your container so that would be Apache right
so the naming would be specify your user ID slash your container name that you
want to give alright so sudo docker commit container ID and then the
container image stain that you won't give to your custom image hit enter and
this should basically save your images so if I do a sudo docker images now you
can see that our image has been saved over here with the name SSH our slash
Apache you should also notice that now my size of the container is 212 MB
because I have installed a software the size has gone up it was 86 MB before
but because we have installed and software on it
has now become to 112 MB which is fine all right so now we have the new image
so what I'm going to do is I'm gonna remove all the containers which are
running now so sudo dock up yes this is the
container running so let me just remove it
okay for what - D - f
also so now what I'll have to do I just to check whether my image is functioning
properly or not what I can do is I just pass in the command sudo docker run - i
t i fin d and then the image names is the it's a har slash Apache okay I'll
introduce you to a one more flag which is - P now what - P does is it basically
does port mapping so when I have installed Apache if I want to check if a
patch is working or not normally a patch it works and put 80 right
so one containers put 80 a pass a would be running but if I want to check the
port of the container or if I want to check if everything is running inside
the container fine I'll have to map the internal port of the container to the
outside host operating system so in this case I have to map it say if I want to
map it to port 80 - of my waist of my host operating system to the 80 port of
my container this is the command to do that - P space port number that you want
to specify : the port number of the container that you want to link it with
so I want to link the port 82 with the internal port 80 of my container which
has the image running sshi slash Apache alright
I'll hit enter this would create the container and if I do a sudo docker PS
if I can see the container is now running
so let's exact into this container so sudo docker exec - I T give the
container ID bash and if now I do a service a partner to start it should
basically give me either an error that Apache - not found or it should start
the server so let's see what happens so it says service Apache web server
purchases this basically means Apache was present inside this container
because we did the sudo docker commit Apache was installed inside this
container and this now service has been start
now remember guys we have mapped it to port 82 so now let's check if we can
access the apache software on port 80 to of this server alright so let me just go
to the IP address of the server so basically this server is running on AWS
so this is the IP address of the server and I have opened it on port 80 - right
so right now if I hit enter it will not work reason being I'd have to open the
ports on this so let me just do that if you open all traffic so that we are
on the safer side okay so IP address : port number which is 82
hit enter and you can see the Apache is successfully running so mind you guys
Apache is not installed on the server it is installed inside the container and
that that software able to access on the browser using the port that you mapped
on the container alright so for our for our verification what I'll do is sudo
docker PS and I'm gonna stop this container now sudo docker stop pass this
ID and now if I do a refresh over here you can see that it says the site can't
be reached reason being I have stopped the container over here alright and this
is how you can save changes to a container install software and create a
new image out of it now next step would be to push it to docker hub right so I -
I told you guys once you are done I mean working on your container and you
created a custom clinic container that you probably you want your team to
access or you want it to be there on docker up for safety purposes you can
push it to docker up and to do that the command would be sudo docker push which
I'm gonna explain in a little bit but before that we saw the life cycle right
we saw we can push or pull from the docker hub so this is the pushing state
so we had open to container we installed Apache on it and then we committed the
changes and now we have an image on a local system the next step is to push it
to docker hub right and let me show you exactly how to do that so this is your
docker hub guys and the first thing that you would have to do is you would have
to login to your docker hub from your console and to do that you will have to
type in the command sudo docker login in this command you'll be asked the
username so passing the username of the docker hub and then pass the password so
if there is any problem with your password it will give you this error so
let me just try once more so I'll pass in the username and then I pass in the
password and on a successful login you will get this message that is login
succeeded awesome so I have logged into my daugher up now what I want to do I
want to push my image so I'll have to do a sudo docker push and what was your
image name it was a chess har slash Apache this is the image name right that
we gave to our custom container image hit enter and just start pushing your
image to docker hub and once it has pushed the image all you have to do is
you can just visit your dog or herb repo and you'd be able to see your image
listed over here just do a refresh and just go to the - bid and you can see
this is the image that I just pushed to the positive which is HS har slash
Apache awesome so we have successfully pushed our image to knock it up so it's
very easy just type in the command sudo docker push and that should be it
all right so our next topic now is introduction to docker file and let us
go ahead and learn what is the aqua 5 but before that let us recap what we
have just learned so we understood what docker is why do we need docker what is
docker exactly then we went through some of the darker operations the day-to-day
operations that you would be going through we got acquainted through that
then we saw how to run a container and then how to do some changes to the
container and save it on your local system and finally how to push that
container onto a docker hub this is what we have learnt now the next step is what
is a docker file so a little introduction about a docker file so you
just saw that if I had to make changes to a container I basically had to run
the container first go inside the container
install whatever software I want install whatever I want and then come out commit
the container and only then it will get saved but there's a shorter version of
this when you're working on production grade environment when you're working in
a production grade remember everything has to be lightning-fast right and for
making changes to a particular container image you can also use something called
as a docker files right so we're going to discuss what a docker file is now so
let's go ahead and start with this topic now so a docx file is nothing but a text
document in which you write how do you want your container to be customized
right so one example like I just told you guys was when I did it manually I
ran a container I went inside it I installed software came out committed
the container and then pushed it onto docker hub now what is
changes can be automated using a script style which we call the docker file now
our doctor file is very easy to write and there are basically some
nomenclatures or there's some some syntaxes that you would have to learn
but I'm sure they are very easy to learn and once you learn them it'll only be
docker file that you would be using rather than doing everything manually
all right so let's go ahead and see how we can
create a docker file so guys these are some of the sin taxes these are some of
the important sin taxes that are relevant to creating a docker file now
the first line of a docker file is always wrong right so the image on which
you want to make changes for example we made changes on the Ubuntu images where
we installed Apache alright so what we did we did docker run - iti have Indy
and then Ubuntu so in docker file the first one base image that you want to
work on you'll have to specify it on the first line using the command frog okay
so this this area of your of your presentation will basically tell you the
docker file content so this is exactly how the content of the dock or file
should look like so the first command is from so from Ubuntu so the base image
that I'm going to work on is a bun - so this would be the first line second
command would be to add all the files so add is basically used to add files
inside a container now for example say I create a HTML file and I want that HTML
file to be added inside the abun - container so for doing that and the
command add the first argument would be the place value where the files are
present and the second argument would basically be the location inside the
container where you want all those files to be copied all right
so add space and dot the meaning take files or take all the files from the
current directory and put it inside slash where slash double double
blue and slash HTML all right so this is what the add command does the third is
done so whenever you want to run any command in the container for example I
ran apt cut get update and apt-get install apache2 inside the container
right now if you want to run the same commands from the docker file you can do
that using the command run so over here there are two commands that I want to
run the first is apt-get update and the second is if it get install apache2
right the - Vice significant the option that
we get that whether you want to go ahead with installation yes and no so if you
specify - by implicitly in dhaka file it will not ask that option it would
continue the installation without any prompts all right so run command is
basically used to run any command inside the container on the on on the terminal
that you would have run okay then you have a command called CMD so CMD key
word is basically used to run or any command that you want to run and this
start of the container right and these commands run only when there is no
argument specified while you're running the container so while you're running a
container you can also specify any command that you want to run so in case
you specify a command while so for running your container the cont the
command is docker and - ID - D and then the image name now after the image name
you can also specify a command that you want to run inside the container okay so
if you don't specify anything like we did then in the docker file this
basically this command will be running when we are starting the container
otherwise whatever command we specify in docker on come on that would be running
ok then so this was about the CMD command line so in this case what we are
doing is what we want to do is like remember when we started the container
we always had to go inside the container and start the Apache service manually
that is once the image started or once the container started
inside the container and type in the command service a party to start right
so that had to be done manually but when you pass it using the command CMD which
is nothing but all the commands run on the startup time whenever the container
will start this command will execute automatically if you specify it under
CMD so CMD Apache CTL - the fokker foreground would do nothing but the run
Apache the movement the container starts and this is exactly what we want right
so this was possible using CMD so again I'll repeat it CMD is used to run
commands and the run time of a container and they run only when there is no
argument specified in the docker run command if there is no argument
specifies the CMD command will run otherwise it will be skipped from the
docker file all right the next command is entry point now entry point is
exactly the same as CMD that it that is it runs at the starting of the container
but the only difference is CMD will not run if you specify an argument in the
draw current but entry point will run irrespective of the fact whether you
have specified an argument or not all right so CMD an entry point can be used
interchangeably but if there are cases when you are will be running the
container with an argument so it's better to use entry points so that the
command does not get skipped CMD command will get skipped if you specify an
argument after the rockin command okay so in our case we use the Apache CT life
in the foreground with the entry point command all right the next command is
env so if there are any environment variables that you want to set inside
the container you can pass it using the command env space the name of the
variable and space the value of the variable all right so in my case I
specified a variable name which has the value devops in telepath all right so
these are some of the commands that you can use to
create an aquifer now let us create this naka file on our system as well so what
I'm gonna do is I'm gonna go to my party software and I'm gonna specify
Nano and then the aqua file so let me just create a directory for so let me
create a directory called the aqua file itself simply a dacha file let us go
inside it so see the naka file and now whenever you are creating an aqua file
the name of the file always has to be dacha file itself right so I'll specify
Nano and then taco file we went inside so the first thing that we want to do is
we want the open - image to be called then we want to update this image so
apt-get update then we want to install Apache inside it apt-get - why so for
that so if it get - bye and stole Apache
- all right sounds good then we are going to add all the files from this
directory to the directory where our www.h tml so we're going to create this
file do not worry we'll just create this file right once we have done that the
next step would be to run Apache in the foreground that has run it so Apache is
CTL
- D ground
so this would run a party automatically
okay and you specify the entry point and say I also want to specify environment
variable say let me create an environment with a blue called name and
I want to specify the value s in ten apart
okay sounds good so this is my end aqua file and I just save this now and let me
create a HTML file as well so it's create and one dot HTML and it is
make it a little simple this will be a HelloWorld HTML file
okay the body
morning you see I have an h1 which will say hello from in teleport close the
header close the body
and then close THD LF all right this is what I wanted to and shave this and now
we are done with the dacha file and we have the HTML page in place so the next
step would be to build this dockerfile now let's see how we can build it so for
building this dacha file all you have to do is talk build
where do you want build it I want to build it from the current directory and
the image that it will create I want to name that image as CE pneu underscore
naka file okay so it will be named like this so I'll hit enter and I have forgot
to mention sudo so let me just clear the screen all
right so let me first teach you guys how to run a docker Dokic amount without
sudo so for doing that let's type in sudo use a mod - a and G and then talker
and then dollar user enter and now all I have to do is just real log in into your
session
and they should work
Sofer do a docker PS now without you know
you can see the command is running also so what I want to do is I want to go
inside the NACA file okay and now I want to build this talk of as a docker build
dot - T new underscore aquifer
so you can see the dockerfile is now being executed and basically this
is
creating the container for me to basically come up with an image which
will have all the changes that we just told to the Container so now if I do a
docker images I can see that there is a new image
which has been created which is new underscore dockerfile
so let us run this new underscore docker file a docker run - I T - D also let us
specify the port number so let us open it at port 84 and then - D new
underscore docker file
and then hit enter okay so the container is launched now so if I do and talk PS I
can see that a container has been launched seven seconds ago awesome and
it being opened on port 80 four so let's check if everything is working well for
us so we just have to change this to 84 and you can see Apache is running
awesome Apache is running and now let's check our webpage if it's there in the
container on rod so we named it as one dot HTML and yes so this is the HTML
that we created which has been added inside the container so let me show you
inside the container what exactly happened okay so docker exact - 9 T
continue named mm bash and let me just clear the screen okay and let me compare
it with my Hakka file so the first thing that we did was apt-get update apt-get -
why install apache2 this basically installed a patches so this was clear
then we added everything from the current directory to where www.h tml
right so if we go inside where and then www and then HTML and do an LS over
there you can see that the one dot HTML file has been added and at the same time
docker file was also added so inside the doc inside the directory we had these
two files so it $1 xtml and aqua file so both of these were added inside the
container now to not have the aqua files inside your container what you can do is
instead of dots specified dot slash + 1 dot HTML that would solve this problem
it would only add one dot HTML in the container ok so it added one dot HTML
and index dot HTML is basically the default page of a party that you see
right so we added 1 dot HTML so this was added by the daka file at the same time
what we did again was we defined apache to run in the
foreground so as you can see but did not invoke the apache service by going
inside the container we just went directly to the port number that we
mapped the container to and the apache was up and running so that is awesome
and the last thing that we did was we defined an environment with evil so what
I can do is I can echo the variable which was darling name and you can see
this is the value of the variable that are specified in the Rockefeller I
specify the variable names to be in telepods and if I specify echo dollar
name this is the value that I get automatically so this was set by the
docker file in the container image that I just created and now what I can do is
I can just exam this container and if I want you guys to use it all I have to do
is do a docker push to this container on my docker hub and you guys will also be
able to access this particular container alright so for that I just have to
change the name do a docker push and you should be able to use it but I'm sure
you would not be needing it because if you pass the same commands that are
written over here you would get the exact same container that I created
alright so let me know if you guys face any problems in the comment section and
we'll be happy to answer all the queries see you alright moving forward now we
got to know how to create taça files we got to know how to build images from the
docker file automatically kind of like a script kind of thing alright so now
let's start with a next topic which is introduction to a docker volume so what
is the dock volume so the volume is basically used to persist data across
the lifetime of a container for example I demonstrated it to you guys that when
you create a continue you make some changes in the filesystem
you delete the container and you launch it again and the changes are not there
anymore right so that can be fixed so imagine it
like this for example you using a patch a container and you have a website
inside of it and the container stops responding because of some reasons what
you do you delete the container and you launch it again but with that what
happens is your website content is also deleted and if your website content is
not present in this new container it becomes a problem so to solve these kind
of problems we came up with docker volumes so what doc volumes does is it
basically Maps or it basically hosts the storage outside of the container and
maps it to inside the container that is the storage is there on the host system
rather than on the container but rather than the files being written on the
container itself they are written outside the container and that location
is basically mapped inside the container so irrespective the fact whether the
container is deleted or started again the container which is being attached to
that volume will have the same file system as that of the older container
and that is how this problem is solved that is of persistence of data across
the container lifecycle all right so there are basically two ways to do it
one is called a bind mount and one is called a docker volume now what are the
differences between a bind Mountain a docker volume let us see that so
basically a bind mount would be that let me just come out of the directory a bind
mount would be that I mount a particular file location inside the container okay
for example I created this docker file directory right so what I can do is I
can map this docker file directory inside a container now to mount this
particular docker file folder inside my container all I have to do is talker
run - i.t and then there's a flag - V that I left a specifier specify the
location of the directory with the slash of moon - slash home slash open - slash
- aqua file now this is the location of my folder and then what is the mount
point or if inside my container so say I say it slash up right so I've specified
that I'll specify - D and then I specify a bundle and hit enter and my container
is now launched now if I go inside this container I can I will be able to see
that there is a folder called slash up which has been created right so if I go
to app and if I do an LS you can see the folder the files inside this container
are that of the taça file now these files are not actually copied inside the
container but these are actually being mirrored from the directly on the host
operating system that is if i do if i duplicate this session
let me just duplicate this session so I just go inside the directory docker file
right if I do an LS and say I touch a file say - dot HTML right so if I do LS
in the container now I can see that there is one more file - dot HTML right
so it is inside the container so whatever changes I make inside this
directory will automatically or dynamically be available inside this
container okay the reason for that is that this directly directory is mapped
to the directory slash up in the container all right so this is called
bind mount but there's a disadvantage with this the disadvantage is that a
bind mount will only work when the filesystem is the same that you have
specified like over here in this container right for example what can
what can happen is I can specify this mind mount to be in the configuration of
the container and I can push it to docker hub so anyone who is downloading
this container will automatically have this bind mount on his operating system
but the problem which will arise is that say you download this container on a
Windows operating system right in the Windows operating system
this file path that again slash home slash up unto slash docker file is not
going to exist and that is where where it is going to give you an error it and
will cause you a problem right so this way of persons persisting data is a
little difficult or is a little I'd say complex when it comes to different
environment setups when you're wheeling dealing with different demands for
example if I have to talk about say a different operating system say I want to
work incentives so in that the file structure would be a little different
right for for for any other operating system a
little efficient for Windows it is completely different right so a bind
mount will not work in different environments and that is where it has a
disadvantage but then this advantage is basically overcome by
now what are volumes volumes are basically entities or are basically
storage which is managed by docker bind mounts are not managed by docker because
you create the directory you decide which directory your data is gonna
reside in right and inside that directory you are making the changes and
that will being reflected in the container but if you create a volume the
docker engine the docker engine which is has which has been installed on a host
operating system automatically identifies where this volume has to
exist okay and then creates that volume over there
also in bind mount it is a little difficult to basically migrate the data
in volumes it is very easy you just pick take the volume up and then just put it
on some other system and should work but in case of bind mount you will have to
decide at which place you want to keep it and then bind that place to the
container only in that case if you all right let me show you what happens in in
kinds of a volume right so in case of volume we want to create a volume this
is the syntax so the syntax is dollar volume create and then name of the
volume so let me show you how you can create it so let me just top cur volume
to it and let us create a volume say test okay so this would create a volume
called it test as you can see where they ignore the warning guys so this created
a volume test and if you want to see all the volumes which are present on your
system you can pass the command docker volume LS and this would give you all
the volumes which are present on your system so on my system right now only
the test volume is present I don't want have to know where is it present because
docker manages the handling part of the file system itself I don't have to worry
about that I just want to know that if there is a volume so yes there's a
volume on your system which is called test awesome all right so the next thing
that I have to do is basically I have to type this command docker run - I T - -
and so basically if I were to give you the syntax this is the syntax for
mounting a volume so docker and - ID - - mount source easy would be equal to the
name of the volume so in our case the name of the volume is test then the
target would be the where do you want to mount it inside the container so we want
to mount it inside slash app
right and then - D and then the image name alright so once the container is
launched now what we can do is we can go inside this container to check if
everything is working fine
and we go inside app and doing it less so there's nothing inside this volume as
of now right so what we can do we can create say touch then one dot HTML and
then touch two dot HTML we can do all this and then what we can do we can also
do you placate the session let me just duplicate the session and what I'm gonna
do now is I'm gonna launch one more container okay so I'm gonna launch and
talk
run - IP - - mount and then say source is equal to test and target could be
some other folder as well but for the sake of simplicity let's keep slash up
and then - Deana bun - this would launch one more container right let's go inside
this container docker exec - IT this and then bash okay let's go inside app if I
do an LS you can see that whatever changes are making in this volume is
also being reflected in this container so say I create three dot HTML over here
if I go here and do an LS I can see the three dot HTML as well alright so this
volume is basically being shared between two containers even a bind mount can be
shared between two or more containers a volume can be shared between two or more
containers but in case of volume you do not have to worry where your volume is
being stored it is automatically handled by the docker engine okay the other cool
thing over here is that if you delete this container and launch it again it
will all be the container or your your end user will not even realize if
anything changed for that let me give you an example so let me just exit this
container and we created a image called new underscore docker file okay so what
I'm gonna do is I'm gonna launch docker run - mighty and then
source say is equal to source is equal let me create one more volume docker
volume create and let us create a volume for Apache okay now what I'm gonna do is
I'm gonna launch docker run - IT and then - - mount source would be Apache
now you look at this closely look at the difference so source is Apache and what
I want to do is I want to target this particular directory where www and then
HTML so whatever would be inside this directive it automatically comes inside
the volume okay so I don't have to add anything to into the volume and I'll
show you how to do that so you specify this - deed new underscore proper file
this was a image name and let us hit enter so it created the container let's
go inside this docker exec - IP and then this container and then bash
okay so we are inside the container now now if I go to CD www HTML
and when an S you can see the files are still here but these files are also now
mounted on the volume and that is evident over here so if I exit this
container and if I launch a new container with the mount as Apache
and target would be say slash up slash up and the image is this okay so this is
the a bun to image right so it should not have the files inside it but if I go
inside this container now
can you see the files over here as same as what was there inside this container
vas / travelerbill sash HTML okay now the beauty is this guys that if I come
out say if I create a - - HTML over here right so what I do is I come out of this
directory okay and what I do is I create nano do dot HTML a clear file and then I
specify that HTML body h1 this is the new
HTML file close the header close the body close the HTML
come out okay now I will have I want to copy this to date dot HTML inside this
container so what I will do I'll do a docker CP dot slash 2 dot HTML and then
slash vast lighter Lulu HTML and then the container ID
- laughs I should do a blue slash HTML okay so now - dot HTML is present inside
the container okay now what I will do I'll just delete
the container I delete the new underscore dockerfile container Dockers
RM - f delete okay so idly if now launched a
new docker run - IT - - mount source is equal to Apache
target is equal to / r / r LW / HTML okay and - we also we specify that we
want a t1 port to be exposed and - D and then the image name new underscore drop
a file so what will happen now is this that if I go on the browser
if I go to port 81 the container is running if I go to to dot HTML you can
see that the new file is also there in this container that is new underscore
docker file so it does not matter if your container has the file or not if
you have mounted the volume and that volume at some point had that file
inside bit it will have it inside this container as well okay
originally inside this image you don't have the to dot HTML right and let me
prove that to you as well so if I do not mount the volume and I launch this
container
you
right so if I go to this IP address and but on page 82 you can see the container
is up and running if I go to dot HTML it will say to dot HTML it was not found on
this so reason being the volume is not attached to this server this file only
has one dot HTML that we wrote using the docker file right for volume we have it
in attached in the container which is mapped to port 81 and that has the file
to dot HTML which is this so awesome guys we have successfully understood
what Daka volumes are and I am sure that you guys also understood if there are
any doubts guys you can mention it in the comment box and we'll be more than
happy to help you out with your doubt alright so with that guys now we come to
the next topic of our session which is how our micro services relevant right so
till now we have seen how we can deploy a single container and do things with it
but usually in a production grade environment we have multiple docker
containers which are working with each other now why do we have that let us
understand that using this topic so first let us understand what are the
monolithic application so guys a monolithic application is an application
which has everything inside one particular program right for example let
us take the scenario of an uber app so our uber app has things like
notification we have things like mail payments location services customer
service and persons amendment this is there inside one app right you can see
all of these things inside one app so if you can see it inside one app that does
not necessarily mean that it is actually one program of uber that they have
written right but for now let's consider everything is an under one program and I
say one program probably you have written a Java file or
you have written a C file and everything is there in that C file or everything is
there in the project in different different files basically everything is
there on the on one server is what I mean right so if that is the scenario
what will happen that if I want to change code in notifications I will have
to pull the whole codebase I have to pull up the whole codebase I will have
to go to the notifications file you have to change the code over there and then I
have to push the whole code again back to github which will basically get
deployed on production after being tested and everything right but the
problem over here is that if there is any problem in the notifications code
that I just changed it will have a replication on all the components of my
app right there could be that I did a mistake and probably there is something
wrong with the mail program now although I my intention was not to touch the mail
program but because I had to work with the code base which had everything
probably something went wrong over here or something went wrong over here or
something went wrong where so this was a problem with a monolithic application
that is that you had to submit the whole codebase even if you had to change the
minimis thing that is there in the code all right and this also led to downtime
because when you are changing the codebase there will be a certain amount
of downtime that will occur there is also a lot of risk because like I said
the other files of the same project could be impacted for example in our
case I said that if notifications or a safe location services is not working
probably it happened it will have an effect on payments or it will have an
effect on mail if the code is related to each other or if a function is being
called from each other etc etcetera that is how a normal you know a program is
yeah in one file you define a function in the second file you are basically
calling that function that happens right so all of these are dependent on each
other and whenever the components whenever the module so all of these
small small things like notification mail payments passenger management
customer these are all small modules of a program if the modules are
interdependent to each other it will be called a monolithic application right
but when we talk about the disadvantages of a monolithic application they are the
following so like I said if the application is large and complex it will
be very difficult to understand so if your app is now having more and more
features and if someone has to add a new feature he first has to understand all
the dependencies between the components right he has to understand the whole
codebase and then only you can add a feature as to understanding what will be
the repercussions or what all files he has to he has to handle if he's going to
put a code inside the codebase it so it is a little difficult to understand
second thing is the whole application is redeployed so like I said the whole code
is again deployed and then there will be a certain amount of downtime which will
be pertained to you updating the application right the third thing is if
there is bug in any of the module and because in a monolithic application
everything is dependent on each other it can lead to the an entire downtime of
your own application right you can bring down your entire application just
because of a bug in a single module so this is also a problem in monolithic
application because the components are dependent on each other and the last one
being it has a barrier to adopting new technologies and this basically means
saying your notification code is in Java and your customer pass and you pass in
the data program because it's a monolithic application also has to be in
Java all of your modules that you're defining all of the features that you
have defined have to be in one particular language that is what a
monolithic application means right so there was a restriction to adopting new
technologies as well so it could not it could not be like one module of mind is
written in some other language the other module is written in some other language
this was what I'm only thing application was now to solve this we came up with
the micro-services architecture now what is the microservices architecture
each and every module that is to my services function or the
notifications function on the female function the payment function passenger
management function location services function they're all segregated from
each other they all exist independently that is they are not dependent on each
other so if they have to interact obviously they'll have to interact with
each other for example in uber until and unless you don't make the payment you
will not be allowed to book cab right so still communication has to be there
between these two components that is the payment and the booking has to be you
know communicating with each other but now they don't have to communicate
through in between the program they can communicate through probably HTTP ways
or you know by hitting the API of each other they can do that by probably
sending JSON to each other and stuff like that so they can communicate in
that way they don't have to communicate from within the program and there that
is the beauty of micro services that the services that we are defining now are
not dependent on each other for example say if the notifications is not working
the notifications module is not working then in that case it's not like your
ruber app will go down probably in that case it will say we are notifications
and so is having some problems but you can still book a cab you still be able
to book a cab because booking of cab is no way related to notifications but if
we compare it to a monolithic application in that case because the
code was dependent and if there was something wrong in the notifications app
the whole application could come down right because the code was not isolated
to their member functions or to the member modules but now because each and
every function of the application can exist on a different server altogether
the downtime of the application becomes almost zero when we have to update a
feature for example if a developer has to update a feature in say the payments
app for example he has to add a new payment method even only download the
code base for the payments app make the changes over there up
the code on the payments module and if there are any problems there will be
problem only to the payments model the other services will not be affected okay
and this is what micro services are now you might be wondering that this is a
docker session why and how is how are these micro services later docker so to
the answer that question these applications all these micro services
are deployed on docker containers okay so all these act as separate entities
and these containers then interact with each other and now this also solves the
problem of barrier of adopting of new technologies reason being your
containers could be of different technologies for example a customer
service could be written in Python your notifications could be written in Java
but if your customer service and notifications programs have to interact
with each other they can interact through JSON in JSON is a way of writing
a file just like we have CSVs where n value is separated by commas in JSON you
have a structure right any kind of program beat any language can convert a
file into JSON probably using libraries or having inbuilt functions for that
right and then pass it on to the other service which has to read the
information so with Michael services our problem of barrier restriction sorry of
Technology restriction was also solved so the advantages would be because the
application is distributed can be understood really well it is not like if
a developer has to work on a particular feature he has to understand all the
features of the application he should know which applications should
he or which which modules of the program should he should that particular program
that he's developing communicate to and that's all that all he has know and of
course the code of his own function as well right and of course if he makes any
changes and if he makes any bugs also in the program it will not affect the whole
application it will probably affect only that function which is creating okay I
guess we have covered all the advantages so the first one being
you understand then the code which has to change will only be changed for the
micro service which has to be worked on then the bug in one service will not get
into all the components of the application it will only be isolated to
that particular function and of course you can do use any technology that you
want with the micro service that you are working with okay and all of this is
possible using containerization okay now because we were talking about
deploying multiple containers we have to talk about how to deploy them using
docker compose now if we were to deploy multiple containers till what we have
learned so far the only way to do this is by either using docker run or
probably creating a script file which will build multiple docker files and
then hence build those images but there is even a shorter way to basically build
images and run them and that is possible using docker compose now what is docker
compose docker compose is basically a tool which can be used with docker to
create multiple containers at once create and configure multiple creators
at once with a single command right and the way you can do that is by writing a
yeah Mel file right so you write a yeah Mel file with all the configuration
required for the containers and of course I am talking about container that
has more than one containers you can have 100 containers also that you can
launch with one single command using the docker compose file okay and this docker
compose file is written using a camel format now we are working with us now if
I want to demonstrate the power of docker compose to you I can do that
using a sample dock of file that I have created
so this amble taco file what will it do it would basically deploy a WordPress
website now a WordPress DEP website has a lot of dependencies guys it has to has
my sequel in the backend it has to have the WordPress container in the front-end
and of course you will have to configure the DB password and everything inside
the container as well right now one way of doing it is doing manually that you
know installing WordPress and then configuring the variables inside it and
then doing the same with my sequel there's a shorter way to do that and
that way is using docker compose now this rocker compose file has actually
been written in camel file so if I would take you through it the version of the
docker compose file is version 3.3 and there are basically two kinds of
containers that we are launching the first kind of container is the DB
container and the second type of container is the WordPress container
okay so the first we launch DB container and the image that we are trying to pull
for the DB container is my sequel 5.7 ok in the my sequel 5.7 container we are
defining a volume which is DB underscore data and this is the target of the
inside the container where it should be mounted that is value of my sequel okay
so the environment variables for this container are my sequel root password
that is my sequel data is my sequel to user my secret password these are the
values to these environment variables that we are also configuring inside the
docker compose file itself right so inside this container these are the
environment values which will be configured and then so this is the end
of it this is what we have done in the levy container now we are talking about
the WordPress container in which we specify that it depends on DB which this
will basically create a link between the WordPress container and the my sequel
container or the DB container right and with this the WordPress container will
be able to communicate with the DB container then we specified the image of
the container that we want to download so it's WordPress and that to the latest
version the port's that we want to expose so inside the container the
WordPress is available on port 80 and we are mapping it on the hosts with port
8000 okay and then the environment variables we specify that the WordPress
DB host is DB : 3 3 0 6 so DB is basically the host name for this service
that just got created which has my sequel inside of it and my sequel is
always always available on 3 3 0 6 port number so that we specify over here then
we have the WordPress DB user so we specified the DB user that
is the my sequel database user as WordPress so that is exactly the same
value that we were specifying over here and the DB password is again WordPress
and that is also that we specified over here okay and what else so this is it
and after that we specify that the of the volume which has to be created is DB
data so this is for the whole gamal file that there is volume which is being
created which is called DB data now this is a yam l file which will create two
containers which would configure it and then this will happen in like three
seconds right so let us go ahead and try this sample docker file out but before
that doc compose guys actually has to be installed on the system irrespective of
the fact whether you have installed docker or not right so docker when you
install it does not install docker compose automatically except the users
who have installed it on Windows and Mac using docker toolbox if you installed
using docker toolbox it has everything installed but if you have installed it
on Linux and you have just installed dr dot io it will just install the
communicating community edition version and the docker swamp core docker compose
is not installed by default now to install docker compose all you have to
do is let me first demonstrate it to you that docker compose is not present so
doc compose - - version so you can see it is
not there as of now so what I can do I can go to my professor I will search for
install doc compose and
the first link is basically the official alright so for installing it on Linux
just click on Linux and these are the commands for installing compose so first
we copy this command that is we'll have to curl the file so the file has been
curled now and then we'll have to change the permissions for it for the file just
switch which has just been downloaded to be converted into an executable file and
that's it and now if I run docker compose version
I can see that the docker compose version is 1.2 3.1 and the builders so
docker compose have been installed automatically now the next step is to
basically create a Yama file so for that let us create an AML file for so let me
first create a directory so it would be compose and it's get inside compose and
now let's create a Yama file for a word press dot gabble okay and if you
basically this word press compose file is available on docker Docs so you can
directly go here and you can try this Yama file on your own as well just copy
the CML file paste it into your gamal file that you are creating and then save
it just let's let's verify if everything else copied correctly so yes it has
and now finally save this Yama 5 and then pass the command ok so there's one
more thing that I want you know but that will be evident from the error which is
that the docker compose file has to be named a proper has to have a proper name
for example if I pass the command docker compose
for basically running your docker compose Yama file the command is docker
compose up and then - D you pass it and then you it will give you an arrow
can't find a suitable configuration file in this directory right so it says that
file can only be of this name docker composed or Tamil or docker compose dot
yml right so what we're gonna do we'll just name it the same so I just rename
the file to be docker compose dot yeah okay so the file has now been renamed
and now let's pass the command docker compose up - d I'll hit enter and as you
can see everything has started automatically and it is pulling the
containers as of now once it has pulled the containers it will start configuring
the container so DB container has been completed now it is downloading the
WordPress container and then we'll configure it and once the configuration
has been done yes so it's done so our WordPress website is now up and what we
have to do is go to the ec2 dashboard go to the running instances so this is the
these are the instances that we launched this is my instance I'll just copy the
IP address and WordPress would be available on port 8000 hit enter
and here you go so website is up and running and if I go on continue I just
have to specify the value so let's give the site title as in telepods user name
as in teleport as well password would be Intel 1-2-3 and then your email so it
would let be something random and tell apart at the raid in teleport dot-com
and we'll click on install WordPress login and then username or password so
we let us specify it has the same that we gave right and now if it locks in
that basically means that the it is being able to communicate with the
database as well right so your WordPress website is all up and running it is now
configured with your my sequel database and that is how it is interacting and
this is your dashboard this is basically from your WordPress container your data
is all being stored on the my sequel container and this is a classic case of
a multi tier app that you have just launched on docker compose so if I do a
dock of PS you can easily see that this is the WordPress container which is
running right and it is being exposed on paid port 8000 and then you have this my
sequel container which is running which is being exposed on port 3306
on which this wordpress container is being able to interact alright so guys
this is how you can launch multiple containers at once using toggle compose
and this is also kind of like a micro service although this can be further be
broken down but those broken down services can also be launched through
docker compose and everything can be configured in the docker compose yam
will file itself alright but again micro services are actually not launched to da
go compose they are basically put on something called ours and container
orchestration tool so what is exactly a container
orchestration tool all right so a container orchestration tool is when you
have multiple containers that you have launched and you want to monitor their
health as well for example if I come back to this this example that we just
did what I'll do I just docker RM - F and then specify
the container ID and hit enter the container is removed right and now when
I go over here and if I hit enter he'll say the site can't be reached if I hit
enter again it'll again say the same thing because
your sight is gone you'd accidentally removed your container or your container
stopped working because of some reason and now I know you're not able to access
your container your website is down it's gone this was a problem which was there
with traditional methods of using containers or micro-services on docker
but then there was something called as container orchestration which everything
which became very popular which basically says that all your containers
health will be monitored by docker itself so if there is a container which
goes down if there is if there is a container which is not heavy anymore
what dr. Swann does is it automatically repairs it by stopping the container and
launching a new one in place of it and the end-user will not even realize what
happened all right so this automation led to what we today known as container
orchestration now container there are a lot of container orchestration tools
with docker prepackaged comes docker swarm so we're gonna discuss docker
swarm now so what is locust swarm so it's basically a clustering and
scheduling tool which is used for container orchestration of docker
containers and with docker swamp you get the functionality of automatically
monitoring the health of containers and it helps you keep a healthy number of
containers that you have specified always in the running state that is the
basic aim of having a docker Saum up and running now how does the Dorcas wan
basically work so our darkest one basically works like this so a topless
one will cannot work with just one machine alright so because like
containers even machines can be faulty sometimes maybe you know you have
configured docker swarm on a single machine which can automatically repair
containers but what happens if the machine goes wrong right so to mitigate
those kinds of things as well we came up with distributed kind of an architecture
where you have multiple machines running in the swarm so they're in the swarm
there will be one machine which will be called as the lead
which will basically tell the workers what to do and the workers will have the
containers running on them right so you have the leader like we have it over
here and then you have multiple workers which are running on the cluster and
these workers will run the containers that we want to launch
so this was about docker song but this is not it
why let's go ahead and start a container or let us go ahead and start a cluster
using docker swamp so let us see how we can do that so for that let's go ahead
and first launch a machine on AWS so we have the master let us launch a vaca so
for that let us launch in a bun to system
okay so now our Ubuntu system is now launching let's name this instance as a
worker okay so while this is launching you'll have to do some steps on your
leader so say this is the instance that I want to become the leader for my
daugher swamp cluster so what I'll have to do I'll have to say docker swarm in
it and then I have to specify the
advertised address so advertise address is basically the private IP address of
the instance so in my case the instance is this is the private IP of my instance
it shall have to specify this over here and then I'll hit enter so with this you
will get this command swarm is initialized current node is this and it
is now a manager so manager is nothing but a leader okay and for any node which
has to join to this manager they'll have to pass this command like that a docker
swarm join and then this command that they'll have to pass so for this so
basically I'll have to login to this particular worker of mine who installed
docker first and then we'll go ahead and join it to the cluster so let us connect
to our worker
and let me make the font a little bigger so that you can also see what I'm typing
okay great so this is my instance now what I'll have to do
I'd have to first install docker so let me do an update first
so docker is ablated now let me sorry the machine is updated now let me
install docker so sudo apt-get install
talk dot IO
you
alright so docker is installed let us verify that by typing sudo dock version
great so docker is installed now swarm is automatically installed when you
install docker so all you have to do now is go here copy this command and paste
it over here right and also while we are doing that I'll have to open the port
ports for these instances to interact with each other so let me put all
traffic over here and now my instances should be able to interact I just passed
a command here and hit enter
all right so I figured out what the problem
the problem was I have not specified the address correctly so my master is
basically on this IP address let me copy that
and if you pass the command again now this is the command that we get let us
copy this let us paste it over here hit enter and you can see then it says this
node joined as a swarm worker all right awesome
now if I go here and I do a darker nude LS you can see that that I have two
nodes which are there this is my current node which is the leader and it's in the
ready State and so is the second node which is also in the ready state and has
joined the swamp so this is how you can create a docker swarm cluster guys so
again to be to be very clear the first thing that you will have to do is do a
docker swarm in it on the master node then you will get a command just pass
that command and the worker and your workable directly connect to your master
now if you want to leave the cluster all you have to do is say sudo Dorcas one
through dole docker swarm
leave and you can see to say nude left the
swamp and if you do a docker node LS on the master it
well in a few moments when the health check-up has failed
it will say the status is down for this particular node okay if you want even
the master to leave leave the Swan all you have to do is pass the command go
home leave on the master as well now as you can see over here this node which
because it has left the status is now down which basically needs means that
the node is no longer reachable okay now if you want the master to also leave the
swamp cluster all your flu is say docker swarm leave and then say - - force keep
enter and it will say node left this form and yours form cluster has now been
left okay so this is how you can go ahead and create a docker swarm cluster
and the command like I said is docker swarm in it advertised address equal to
IP address of leader specify that hit enter and just copy this command on the
worker and it will work like a charm all right so our next step is now to
deploy an app on the dock his form so before that let me quickly launch the
swamp cluster again locust swarm in it advertise address
and specify the IP address of the master
which is this so this is the IP addresses specify that hit enter
and then copy this command and pass it on the fucker
okay and if I do a doc or node LS over here you can see the cluster is ready
awesome now what I want to do I want to deploy
an app on darkus form but before that we'll have to understand how does an
application actually work on docker swamp so an application works something
like this so basically you create services on docker swamp and that
service will basically create containers for you for that particular image that
you have specified right so all right so let's go ahead and create a service so
guys this is the syntax for creating a service in docker swamp what we'll have
to do is we'll have to type in docker service create and then specify in the
name of the service say I'm on this name the service to be Apache and then
specify the number of replicas that we want to learn so I say I want to run
five replicas and then the port mapping so basically I want to do it to be
launched on port 80 three right and then the name of the image so say I'm
launching it on HSH a our slash Rabat okay I hit enter
if you run five containers it will verify if everything is running fine and
once everything is running great it will exit so now if you want to see what all
services are running on your swamp class so all you have to do they say Dockers
home service LS NACA service LS and we'll show you that this is the service
which is running it is running in the mood replicated right and it has five
out of five replicas running and this is the image name now I will show you a
very awesome thing so basically this port is 83 is exposed right so what I'll
do I'll go to the Masters IP address which is this Kohi here I'll type this I
go to put 83 all right this is working now what I will do I will go here
and we'll go to the woodworker I will again go to the workers IP address and I
will go to port 83 awesome isn't it so basically in swamp any IP address either
of the master or the worker that he go on they will have the application ready
on both these servers on port 83 and the most awesome thing is that I showed you
guys that if I do a docker PS over here I can see that there are two out of five
containers there is there are two containers which are running on the
leader and there should be two containers running over here on the
worker so there are three containers running over here so what I can do is I
will basically just do a sudo docker RM hyphen F and what I do I will remove
water containers
removed and if I go to my masters IP address again and hit enter I still have
the containers running over here right similarly if I go here sudo docker P RM
hyphen F and then I say I want to remove everything
I forgot the suit over here
it removed three containers but if I go to my web browser and refresh the Voges
IP address I still have the container running over here right this basically
means that my containers are being Auto scaled which means if they get deleted
it again gets created so you can see I deleted the containers over here but if
I do a docker PS again
can you see it has three containers now launched and I guess if we go on the
worker and do a PS over here now it should have two containers exactly as we
saw right so it automatically creates the containers again and it will always
maintain the number of replicas to be five because that is what you have
specified right that is why that is what it will always retain now you can always
scale the replicas and for that all you have to do is docker service
scale Apache and then just specify the number of replicas that you want say I
want to need two replicas to be there and hit enter and then what we'll do it
will basically scale down to only two replicas now what now if I do a service
PS docker service LS you can see there are only two replicas
running now so if I do a docker PS here I have one container over here and if I
do a docker PS here I have one container running over here alright so you can
also scale up and scale I can also scale up right so I can again just go over
here and type in the command ten he'll start 10 containers for that web
app right and you can verify that you can verify if I do a pseudo doc appears
over here it'll it has around 5 containers here and if I do a docker PS
here it has around 5 containers here if you want to remove a service if you want
to remove an application from the cluster all you have to do is docker
service RM and then specify the name of the service and it should remove that
service and now if I do a docker PS it should slowly remove everything out of
here so it talked of the user can slowly it'll remove everything from the
container so see the containers are gone over here and similarly if I see here
the containers are also gone over here as well
ok and again like I told you guys if you want to leave the node all you have to
say is to sudo Dockers form leave this node have left this form it will say and
similarly if I want to leave the master as well I will have to say it is Dockers
one leave and on the master will always have to force and it'll leave this form
as well and then you'll have a clean machine again alright so this is how you
can deploy an application on docker swarm alright so thank you guys for
attending today's session I hope you guys learned something new today so as
always if you liked this video please click on the like button and subscribe
to our channel for any future updates and if you have any doubts regarding any
of the topics that we discussed today I would request you all to comment it in
the comment section that is mentioned below and we'll be happy to answer it
for you alright so with that guys I will take a
leave from you guys have a great day and good bye