Skip to main content

Everything about Devops

 

DEVOPS




Before jumping into Devops Lets discuss about few methods and their drawbacks.

Waterfall Model:

The Waterfall Model was the first Process Model to be introduced. It is also referred to as a linear-sequential life cycle model.

In a waterfall model, each phase must be completed before the next phase can begin and there is no overlapping in the phases.

As the Name suggests, This model works like a Waterfall. In water fall if the water reaches the bottom once from the cliff , there is no going back. Likewise, In this Waterfall Model Once phase/stage is completed in the development cycle , there is no going back.



Dis-Advantages:

  • No working software is produced until late during the life cycle. 
  • High amounts of risk and uncertainty. 
  • Not a good model for complex and object-oriented projects. 
  • Poor model for long and ongoing projects.

Agile:


  • In the Agile Methodology  each project is broken into several iterations.
  • All Iterations should be of same time duration.
  • At the end of each iteration a working model should be developed.

Advantages of Agile:

  • In AGILE, the delivery of the software is persistent.
  • After every Sprint, working feature(s) is/are delivered to the customer. This increases the level of satisfaction in them.
  • Customers can have a look at the developed features and check if they meet their expectations.
  • If the customers have any feedback or they want any changes in the features, then it can be accommodated in the current or maybe the next release of the product.



Dis-Advantages of Agile:

  • Poor understanding between developer and operations which lead to conflict.






To overcome above Difficulties We are going for Devops.





It consists of multiple phases that collectively become the DevOps lifecycle. 

  1. Continuous Development
  2. Continuous Integration
  3. Continuous Testing 
  4. Continuous Feedback
  5. Continuous Monitoring
  6. Continuous Deployment
  7. Continuous Operations

These seven phases are the main constituents that ensure DevOps optimizes all development processes, right from proposal to production and the complete delivery. Here is a phase-wise, complete break-down & analysis of the DevOps lifecycle.

DevOps lifecycle




1. Continuous Development 

The first phase of the DevOps lifecycle is where the planning and software coding takes place. The planning involves understanding the vision of the project and envisioning a software based on those perceptions. 

Planning doesn’t involve any major tools, but maintaining the code entails the use of a range of tools. Developing the source code for application begins by choosing from the different programming languages. JavaScript, C/C++, Ruby, and Python are prominently used for coding applications in DevOps. 

The process of maintaining the code is called Source Code Management (SCM), where version control tools such as GIT, TFS, GitLab, Subversion, and Mercurial, among others, are used. 

In the SCM process, GIT is a preferred tool that enables a distributed version control. It facilitates data assurance through circulated non-linear workflows. For large projects, where a vast number of collaborators are involved in the development activity, GIT establishes reliable communication between the teams through the Commit messages. 

With the help of a version control tool, a stable version of the application code is built in the continuous development phase. Developers can also package the code into .exe (executable) files by using Garden, Maven, and similar tools. 

2. Continuous Integration

The source code gets modified several times, and these frequent changes happen on a weekly or a daily basis. Code integration, the next phase, is the core of the entire DevOps lifecycle. In continuous integration, new codes that support add-on functionalities are built and integrated into the existing code. 

In this phase, bugs in the source code are detected early on. To generate new code that brings more functionalities to the application, developers run tools for unit testing, code review, integration testing, compilation, and packaging. 

The continuous integration of this new code into the existing source code helps reflect the changes that end-users would experience with the updated code.

Jenkins is popularly used as a reliable DevOps tool for procuring the updated source code and constructing the build into.exe format. These transitions occur seamlessly, and the updated code is packaged and proceeded to the next phase, which is either the production server or the testing server. 

3. Continuous Testing 

Some developers carry out the continuous testing phase prior to the continuous integration phase. Based on the updations in the application code, this phase can be repositioned around the continuous integration phase in the DevOps lifecycle.   

Here, the developed software is continuously tested for bugs. A test environment is simulated with the use of Docker containers. Through automated testing, developers save effort and time, usually lost in manual testing. Reports generated by automated testing improve the test evaluation process. Analyzing the failed test-cases becomes easy. After going through a UAT (User Acceptance Testing) process, the resultant test-suite is simpler and bug-free. TestNG, Selenium and JUnit are some of the DevOps tools used for automated testing. These tools can also arrange test-case execution in a pre-set timeline.  

Quality assessors (QAs) can use these tools for parallel testing of several other code-bases. 

It ensures the flawless functionality and inter-networking of the application. In the end, the tested code is re-sent to the continuous integration phase for updating the source code. 

4. Continuous Feedback

Continuous testing and continuous integration are the two crucial phases that ensure consistent improvements in the application code. Continuous feedback is a peculiar phase where these improvements are analyzed. 

Developers can gauge the outcome of these modifications on the final product. Most importantly, customers who tested these applications can share their experiences in this phase. In a majority of cases, this phase of the DevOps lifecycle provides a turning point to the application development process. The feedback is assessed promptly and developers begin working on the new changes. Sooner, there is a positive response in customer feedback, which paves the way for releasing new versions of the software application. 

5. Continuous Monitoring

Monitoring the performance of an application is of key importance for application developers. In this phase, developers record data on the use of application and continuously monitor each functionality. “Server not reachable” or “low memory” are some of the common system errors resolved in this phase. 

Continuous monitoring helps in sustaining the availability of services in the application. It also determines the threats and root causes of recurring system errors. Security issues get resolved and problems are automatically detected and fixed. 

Compared to the software development teams, the IT operations teams are more involved in this phase. Their role is pivotal in supervising user activity, checking the system for unusual behavior, and tracing the presence of bugs. 

Sensu, ELK Stack, NewRelic, Splunk and Nagios are the key DevOps tools used in continuous monitoring. These tools enable complete control in overseeing the performance of the system, the production server, and the application. The operations team can actively engage in increasing the reliability and productivity of the applications with the help of these tools. 

When major issues are detected in this phase, the application is swiftly rerun through all the earlier phases of the DevOps lifecycle. That is how finding a resolution to all sorts of issues becomes faster in this phase. 

6. Continuous Deployment

Conventionally, the phase of continuous deployment takes place before continuous monitoring. But, developers make sure that this phase is always active in the DevOps lifecycle, especially after the application goes live and starts receiving high traffic. 

In this phase, the finalized application code is deployed to the production servers. Configuration Management is a key process in this phase, and it carries out the precise deployment of application code on all servers. Consistency in the application’s performance and functional conditions is established and curated. Code is released to the servers, updates are scheduled for all servers, and these configurations are kept consistent throughout the production process. Ansible, Puppet, and Chef are some of the effective DevOps tools used for Configuration Management, where they frequently execute the quick and continuous deployment of new code. 

Containerization tools are used to achieve continuous deployment through the Configuration Management process. Vagrant, a containerization tool, develops coherence in different environments - from development and testing to staging and production. Similarly, the scalability of continuous deployment is handled by tools like Docker. These tools nullify all sorts of production failures and system errors by replicating and packaging the software couplings from testing, staging, and development phases. Ultimately, the application runs smoothly on different computers. 

7. Continuous Operations

The last phase of the DevOps lifecycle is the shortest phase and the least complicated one. The purpose of continuous operation is to automate the process of releasing the application and the subsequent updates. Development cycles in continuous operations are shorter, allowing developers to ongoingly accelerate the time-to-market for the application.









Comments

Post a Comment

Popular posts from this blog

Is-A and Has-A relationships in python

  In object-oriented programming, the concept of IS-A is a totally based on Inheritance, which can be of two types Class Inheritance or Interface Inheritance. It is just like saying "A is a B type of thing". For example, Apple is a Fruit, Car is a Vehicle etc. Inheritance is uni-directional. For example, House is a Building. But Building is not a House. #Is-A relationship --> By Inheritance class  A:    def   __init__ ( self ):      self .b= 10    def   mym1 ( self ):      print ( 'Parent method' ) class  B(A):    def   mym2 ( self ):      print ( 'Child method' ) d = B() d.mym1() #output: Parent method d.mym2() #output: Child method HAS-A Relationship:  Composition(HAS-A) simply mean the use of instance variables that are references to other objects. For example Maruti has Engine, or House has Bathroom. Let’s understand...
Post a Comment
Read more

Magic Methods in Python

  What Are Dunder Methods ? In Python, special methods are a set of predefined methods you can use to enrich your classes.  They are easy to recognize because they start and end with double underscores, for example  __init__  or  __str__ . Dunder methods let you emulate the behavior of built-in types.  For example, to get the length of a string you can call  len('string') . But an empty class definition doesn’t support this behavior out of the box: These “dunders” or “special methods” in Python are also sometimes called “magic methods.” class NoLenSupport : pass >>> obj = NoLenSupport () >>> len ( obj ) TypeError : "object of type 'NoLenSupport' has no len()" To fix this, you can add a  __len__  dunder method to your class: class LenSupport : def __len__ ( self ): return 42 >>> obj = LenSupport () >>> len ( obj ) 42 Object Initialization:  __init__ "__init __ ...
Post a Comment
Read more

Inheritance and Types in Python

  Inheritance   Creating a new class from existing class is known as inheritance . The class from which features are inherited is known as base class and the class into which features are derived into is called derived class . Syntax: class  derived- class (base  class ):       < class -suite>      Inheritance promotes reusability of code by reusing already existing classes.  Inheritance is used to implement  is-a  relationship between classes.   Following hierarchy is an example representing inheritance between classes:   Single inheritance   When a derived class inherits only from syntax, the base class is called single inheritance. If it has one base class and one derived class it is called single inheritance.   Diagram     Syntax class  A:  #parent class         #some code       class  b(A):...
Post a Comment
Read more