Hello everyone welcome back to this session in DevOps training. Today in
this session we are going to discuss what is DevOps right so without wasting
any time let's go ahead and start with these session. So guys like I told you
guys earlier DevOps is nothing but a methodology, it is an idea right it is
not a tool, it is not a software, it's an idea or methodology of solving the
problems between developer and operation skies right. Now this methodology
involves a life cycle which as you can see in the diagram that the first thing
that you do is you plan what you have to do right then you code your way in, then
you build the code, building the code means if you have a Java file for
example you'll have to create a jar file or an executable file out of that so
that is called building right so building your code and then you will be
testing your code, so what executable you have built you'll basically test that
code for any faults in the functionalities and if there are no
faults you will basically release the code to the ops team. Now there are two
kinds of release guys, there's an internal release and there's an external
release right, the internal release talks about releasing the software to a
different team of the company and this is what exactly is happening. Then comes
a release phase where the developer guys release the software to the operation
guys for their work right, the operations guy will in turn deploy the software on
to the target system, it could be a testing server which basically will test
or do automated tests on it or it could be you know at the production server
where everything has happened the testing has happened and you are
deploying it on the production server right
so once you have deployed it of course now becomes the operation phase
the operation phase can be done internally or it could be done by your
customers where in you know you're operating the software or you release
the software for internal employees to see whether you know the traffic when is
it doing good when it holds when it's getting traffic on to it is it doing
good when normal people are doing tasks on your software and then you are
also continuously monitoring it to see if you know your task is or your
application is functioning properly and if it is not functioning properly you're
basically creating a log of events which are happening right which this this is
called monitoring. And after monitoring again comes the planning phase which
means if you get any kind of feedback from the monitoring part you again start
planning it how to do it, how to solve this kind of a problem that you're
getting in the monitoring phase and then code your weigh-in builds the code again
test it again release it to the Ops guy and this goes on and on until you get
the perfect application and there is no perfect application guys right always
there will be new requirements coming in, always there will be some bugs, always
there will be some security patches and therefore this life cycle goes on and on
so this is what DevOps is guys right and if you were to think about it how is it
solving the problem between the dev and the Ops guys is by automating this
lifecycle basically that means that now that developer does not have to give the
code to the Ops guy it will basically be given through a tool which we have which
there is a tool called docker right so basically the dev guy will enclose his
code inside docker and will push it to the ops team and the ops team just have to
run docker and this code will run fine right there is no problem for dependency
there is no problem for configuration management everything happens
automatically in this life cycle. So don't worry if you don't understand
exactly what DevOps is because in our next slides we are going to discuss how
it actually works right so going forward now let's discuss
how the DevOps life cycle actually works right so if you were to that that
infinity sign that we had it if you if you were to condense it or if you want
to expand it so that that DevOps life cycle diagram that we had the infinity
diagram that we had if you want to expand it it would look something like
this right so you have something called as planning you have something called as
coding, building and testing now this used to happen on the developers side
right and then we go on to the ops side where we have
release we have deploy you have operate and then you have monitor right. So in
between this we have to integrate this part of the developers side to this side
of the operator side and this is done using continuous integration. Now what is
continuous integration we'll discuss in a while but for integrating the
developer and the operations guys we use continuous integration right. Now before
moving on to what is continuous integration let's pay attention to what
we have over here as well right so the planning and coding phase we contribute
or we collectively call it as continuous development. What is continuous
development? I'll explain you in a little while building and testing we
call it continuous testing okay, releasing and deploying we call it
continuous deployment. Operation and monitoring we call it continuous
monitoring okay? so you start with planning a new coding you build it you
test it you then release it to the ops team then you deploy it then you operate
it and then you monitor it and this gives rise to five stages that is
continuous development, continuous testing, continuous integration
continuous deployment, continuous monitoring which again goes back to
continuous development. Now let's understand these terms let's understand
what is convenience development, testing, deployment, monitoring and integration
okay so this is the life cycle guys now why are we calling it continuous
continuous basically means it goes on and on right it never stops so like I
told you in the diagram for DevOps that the cycle goes on and on it's never
stops the product it is always being developed right it is always in some
part of the life cycle, so if you were to explain continuous development and
continuous integration, continuous testing this is the best way to learn it
okay so we have a developer who basically will be pushing his code to a
version control system okay and this version control system will basically
any changes in this version control system will be taken up by
continuous integration tool okay. So what is a continuous integration tool? A
continuous integration tool does nothing but it joins each of these stages to
each other for example if I have to go from continuous development to
continuous testing and if this happens in separate software's, continuous
integration will join these and this right? continuous integration will join
testing and then deployment. Continuous integration will join monitoring and
then again coming back to development and how does this happen it happens like
this. So there is a software of which which basically does continuous
integration okay. Let's let's understand yes this has a black box this is a
software which does continuous integration and the function for this
particular software is the moment you push your code to a version control
system this version control system is nothing but a software which takes care
of storing your code okay. So the moment you push your code to a version control
system or you change your code in the version control system, the continuous
integration tool automatically identifies okay so there's a change in
the version control system so what it does is, it takes this code and it builds
it on the testing server. It first builds it and tests it on the
testing server and this is called continuous testing reason being every
developer who does this continuous integration does the job similarly right
so if there are hundred developers in the team so for every developer if we
configure a version control system that for every developer and it has to test
the code it'll always do that okay. So every developer was doing the version
controls who is pushing this code to version control system continuous
integration software is going to test their code on the testing server right
and this is the reason it's called continuous right because it happens
continuously okay so continuous development we push up go to version
control system it is identified by the continuous integration tool so the first
job that continuous integration tool does is it pushes on to the testing
server the code where it is and tested and if the test succeeds
continuous integration tool pushes it on the production server okay now either if
it's on the production server or if it's on the testing server now if on the
testing server there are some bugs which are identified the feedback is given
through continuous monitoring to the developer or or if the production server
if there are some problems on the production server or like I said when
you deploy your code on the production server it basically gets available to
the world and it gets continuously monitored right for any kind of problems
which are occurring it gets continuously monitored and the logs are generated and
these logs are being stored somewhere using continuous monitoring so your
production server is continuously monitored for any kind of activity which
is happening on it and the logs are being generated now the developer is the
team now when I go back to the developer why am i coming back over here because
this identifies or this tells us basically now that now when the
development team is done with the release and now they have to see what
all what other work I have to do all they have to do is check the logs from
the carnist continuous monitoring the tool right and they'll be able to
identify so okay so this one this is causing a problem this and this is
causing a problem and also the key users are saying that you know we should have
this feature the client also came in he also wants some feature so they plan a
release right and once the planner release they again start coding and
again once they are done with the code they'll push the code to version control
system which will be identified by the continuous integration tool which will
then automatically test it once it's been tested if it's successful it'll
push to the production server again the logs will be identified by the
continuous monitoring stage again it will go to the developer after planning
and then you code his way into version control system and the lifecycle goes in
on on and on right so this is exactly how DevOps work right now let's look at
each of these stages independently to understand what exactly happens in
continuous development what exactly happens in continuous
okay so in continuous development you basically push your code to a version
control system the version control system could be a software like gate or
a software like SVN right now you when the moment you push your code to the
version control system it basically creates a new version of your code for
example if you wrote ABC on on a text file right now that ABC you wrote and
you upload it on the version control system so this was the first version the
version control system automatically makes it version 1 the moment you make
some changes and again push it to the version control system what happens it
it creates the version 1 was the text file having ABC now the new version that
you have pushed it becomes version 2 and the file would be ABC and probably
whatever changes you have made to the file okay so it creates a new version
and at the same time it also holds on to the previous version so that in any case
in any problems that you might have in the future if you want to revert back to
the previous version you can easily do that right and that is why we have a
version control systems like git and SPN and continuous development is an
integral part of pushing code to your version control system okay now this was
this was continuous development then you have continuous integration now what is
continuous integration this is nothing but integrating your life cycles with
each other right for example once you push the code to your version control
system it obviously has to be picked up and pushed on to the testing server for
testing where it could be built and tested right so all these life cycles
are integrated or there is someone who is doing the manual job of a person of
putting clicking code from one stage and put it pushing it onto another then
taking the results from there pushing it down to the another then taking the
results from there pushing on to another and that manual effort is being done by
a tool which is called the continuous integration tool okay then you have
continuous deployment continuous deployment basically means you will
deploy your code onto a particular server it could be a test
server or it could be production server and deployment basically involves
putting the right kind of software on it and then pushing the build on to your
server so that it has the right software in one where it will function right and
again putting installing software and system and everything is also automated
using a tool which is used in continuous development life cycle okay then we move
to continuous testing now continuous testing is a gainer life cycle a life
cycle stage wherein you continuously test your software so like I told you
guys in this what happens is you continuously build and then test your
code so your code is pulled from the version control system it is built so
when I say built it basically is converted to an executable file and this
executable file is then run right now the continuous testing how it happens is
you create autum testing suits which are basically pre-installed in the testing
server and the moment it gets a new executable all those test suits are
executed on this particular executable file to check if all the tests are
passed or not right and if all the tests are passed it is then again picked up by
the continuous integration tool and then pushed on to the production server once
it reaches the production server again it gets monitored right it gets
monitored for user activity it gets monitored for any errors it gets
monitored for any user comments on version upgrades right on version
upgrades or you can say any feature requests so all those feature requests
all those errors all those logs are then visualized or then are then stored
inside a monitoring tool right and this monitoring tool helps us in sorting
these logs based on what we wanted it will basically sort it on the basis of
general logs is sorted on the basis of error logs it will sort it on the basis
of feature requests right so it becomes a one destination stop for you where you
can check and plan your day ahead or plan your team's work for the near
future okay so this is continuous monitoring so these were all
cycle stages of DevOps guys and this lifecycle stages basically make it
possible for us to have shorter release cycles because all these stages are
automated right and these are automated using tools and these tools we'll be
discussing in our next session where we'll get an introduction to all the
tools which basically come together to create a divorce so in the next session
we are going to talk about DevOps tool scales so this brings us to the end of
this session so have a great day ahead and good bye