CS F213 Object Oriented Programming

DevOps - beyond OOP in industry

Aritra Mukherjee, Dept. of CSIS

DevOps - Development and Operations
Before DevOps
After DevOps
DevOps Stages
Plan – The planning phase is exactly what
it sounds like: planning the project’s
lifecycle.

In contrast to conventional methods to the

development lifecycle, this model assumes
that each stage will be repeated as
necessary.

In this manner, the DevOps workflow is

planned with the likelihood of future
iterations and likely prior versions in mind.
Stages of DevOps
Code – The developers will write the
code and prepare it for the next phase
during the coding stage.

Developers will write code in

accordance with the specifications
outlined in the planning phase and will
ensure that the code is created with the
project’s operations in mind.
Stages of DevOps
Build – Code will be introduced to the
project during the construction phase,
and if necessary, the project will be
rebuilt to accommodate the new code.

This can be accomplished in a variety of

ways, although GitHub or a comparable
version control site is frequently used.
Stages of DevOps
Test – Throughout the testing phase,
teams will do any necessary testing to
ensure the project performs as planned.

Teams will also test for edge and corner

case issues at this stage. An “edge
case” is a bug or issue that only
manifests during an extreme operating
event, whereas a “corner case” occurs
when many circumstances are met.
Stages of DevOps
Release – The release phase occurs
when the code has been verified as
ready for deployment and a last check
for production readiness has been
performed.

The project will subsequently enter the

deployment phase if it satisfies all
requirements and has been thoroughly
inspected for bugs and other problems.
Stages of DevOps
Deploy – In the deploy phase, the
project is prepared for the production
environment and is operating as
planned in that environment.

This would be the responsibility of the

operations team; in DevOps, it is a
shared responsibility.

This shared duty pushes team members

to collaborate to guarantee a successful
deployment.
Stages of DevOps
Operate – In the operating phase, teams
test the project in a production
environment, and end users utilise the
product.

This crucial stage is by no means the

final step.

Rather, it informs future development

cycles and manages the configuration of
the production environment and the
implementation of any runtime
requirements.
Stages of DevOps
Monitor – During the monitoring phase,
product usage, as well as any feedback,
issues, or possibilities for improvement,
are recognized and documented.

This information is then conveyed to the

subsequent iteration to aid in the
development process.

This phase is essential for planning the

next iteration and streamlines the
pipeline’s development process.
Continuous Integration between the stages
Continuous Development
This is the phase that involves ‘planning’ and ‘coding’ of the software.

The code can be written in any language, but it is maintained by using Version
Control tools.

Maintaining the code is referred to as Source Code Management.

The most popular tools used are Git, SVN, Mercurial, CVS, and JIRA.

Also tools like Ant, Maven, Gradle can be used in this phase for building/ packaging
the code into an executable file that can be forwarded to any of the next phases.
Continuous Development
Continuous Testing
This is the stage where the developed software is continuously tested for bugs. For
Continuous testing, automation testing tools like Selenium, TestNG, JUnit, etc are
used.

These tools allow QAs to test multiple code-bases thoroughly in parallel to ensure
that there are no flaws in the functionality. In this phase, Docker Containers can be
used for simulating the test environment.

Selenium does the automation testing, and the reports are generated by TestNG.
This entire testing phase can be automated with the help of a Continuous
Integration tool called Jenkins.
Continuous Testing
Continuous Integration
This stage is the heart of the entire DevOps life cycle. It is a software development
practice in which the developers require to commit changes to the source code
more frequently. This may be on a daily or a weekly basis.

Every commit is then built and this allows early detection of problems if they are
present. Building code not only involves compilation but it also includes code
review, unit testing, integration testing, and packaging.

Jenkins is a very popular tool used in this phase. Whenever there is a change in the
Git repository, Jenkins fetches the updated code and it prepares a build of that code
which is an executable file in the form of a war or a jar. This build is then forwarded
to the test server or the production server.
Continuous Integration
Continuous Deployment
This is the stage where the code is deployed to the production servers. This done
by Configuration management and Containerization tools.

Configuration Management is the act of establishing and maintaining consistency in

an application’s functional requirements and performance.

Containerization tools also play an equally important role in the deployment stage.
Docker and Vagrant are the popular tools used for this purpose.

Containerization tools help in maintaining consistency across the environments

where the application is developed, tested and deployed.
Continuous Deployment
Traditional Pipeline
CI/CD Pipeline
Continuous Monitoring
This is a very crucial stage of the DevOps life cycle where you continuously monitor
the performance of your application. Here vital information about the use of the
software is recorded.

This information is processed to recognize the proper functionality of the

application. The system errors such as low memory, server not reachable, etc are
resolved in this phase.

The popular tools used for this are Splunk, ELK Stack, Nagios, NewRelic and
Sensu.
Tools of Devops
Tools of Devops
Scripts are the connector pieces that bring the disparate tools and classes together
into a more coherent whole. Scripts also help with automated and complicated
build, deployment, and automation tasks. Scripting is incredibly flexible and with it,
you can do almost anything.
Tools of Devops
Continuous Integration/Delivery Tools are almost the enterprise level package in
the DevOps world. They try to do all of the things. They schedule, gather results,
kick-off scripts/processes/tools, integrate with other tools, and report on success.
Tools of Devops
Build tools are an essential foundational piece of DevOps. With more developers
working on a code-base, checking in code, and moving your product/project
forward, it’s essential there be a tool that can automate bringing together the right
dependencies and generating an installable compiled package.
Tools of Devops
With the distributed nature of teams in the DevOps world, powerful, enabling source
code management tools are essential. These tools help to manage multiple
simultaneous update streams for the codebase and ensure code coherency through
branching and merging mechanisms.
Tools of Devops
With the levels of automation that are becoming standard in the DevOps
ecosystem, it makes sense that there be an automated capability for code to be
deployed into your desired environments. It’s necessary for automation to happen,
but may also be desired for manual testing or UAT steps. Deployment tools need
to be able to integrate with your virtualization solutions as well.
Tools of Devops
With the concept that each application or service you wish to deploy having a
different optimal server configuration grew the idea that every application could run
in its own independent container. As this concept grew, it greatly empowered
testers and developers who worked best in their own walled environment.
Tools of Devops
Test automation is one of the biggest topics in DevOps with numerous threads,
intents, and tool systems. The number of tools and their target is large. Any
automation solutions/tools that you decide to include in your solution should be
capable of integrating with the other tools in your DevOps ecosphere.
Some common concepts
Microservices is an architectural design
for building a distributed application
using containers.

This architecture allows for each service

to scale or update without disrupting
other services in the application. A
microservices framework creates a
massively scalable and distributed
system, which avoids the bottlenecks of
a central database
Some common concepts
Unit testing: is the
practice of testing
individual units or
components of an
application, in order to
validate that each of
those units is working
properly

a unit should be a small

part of the application—
in Java it is often a
single class.
Some common concepts
REST API: the key elements are

a client or software that runs on a

user’s computer or smartphone and
initiates communication;

a server that offers an API as a means

of access to its data or features; and

a resource, which is any piece of

content that the server can provide to
the client (for example, a video or a
text file).
Some common concepts
CRUD applications need HTTP
calls namely

POST to Create a resource,

GET to Retrieve a resource,

PUT to Update a resource, and

DELETE to Delete a resource.

Some common concepts
Version Control refers to a system
that records changes to a file or set of
files over time, called the ‘versions’. In
other words, these versions help you in
tracking the changes in your
codes/project and if necessary, undo
those changes as well.

There are three types of version

control.
● Local Version Controls
● Centralized Version Controls
● Distributed Version Controls
Some common concepts
Containerization is a form of virtualization
where applications run in isolated user
spaces, called containers, while using the
same shared operating system (OS).

One of the benefits of containerization is that

a container is essentially a fully packaged
and portable computing environment.

Everything an application needs to run — its

binaries, libraries, configuration files, and
dependencies — is encapsulated and
isolated in its container.
We have not even scratched the surface!

DevOps is huge.
Keep practicing and
learning on the way!
Don’t be this guy ->