A Simple Introduction to DevOps Engineering
What you will learn from this article
- What is DevOps?
- The Software Development Life Cycle
- Why use DevOps?
- The DevOps Life Cycle
- Benefits of DevOps
What is DevOps?
DevOps integrates developers and operations team in order to improve collaboration and productivity by automating infrastructure, automating workflows and by continuously measuring application performance. It is a Software development approach that allows you to build faster and more reliable applications. To understand the various DevOps stages, you need to understand the Software Development Life Cycle (SDLC).
The Software Development Life Cycle
The software development life cycle is a project management model that defines the stages involved in bringing a project from inception to completion.
The SDLC consists of the various stages in the above diagram and listed below:
- Planning stage
- Defining stage
- Designing stage
- Building stage
- Testing stage
- Deployment stage
Let's look at what happens at each stage starting from the first stage;
- Planning stage: This is where the requirements of the software to be built, including the risks associated with the software, the costs of the software, the customer/client needs is analysed and taken into consideration.
- Defining stage: This is the next step after planning, where the requirements are clearly defined or documented.
- Designing stage: In this stage, the requirements that were documented in the previous stage are represented in an architectural format where the external and internal modules of the software are clearly represented with the data flow between the modules or parts of the software.
- Building stage: This is where the software designed in the previous stage is developed.
- Testing stage: Here the software developed is tested for issues and fixed.
- Deployment stage: This stage is where the software is released to the market/customers to be used.
The Software Development Life Cycle consists of models, these models are a simplified representation of a software process. Each model represents a process from a specific perspective.
LIST OF SOME SDLC MODELS
- Waterfall Model
- Iterative Model
- Spiral Model
- Big Bang Model
- Agile Model
Since the focus of this article is not on the SDLC models, I'd only give a brief explanation of the Waterfall model and the Agile Model.
The Waterfall Model: This SDLC model is a linear model with phases with a top-down approach, which means one phase must be completed before moving unto the next phase.
The Agile Model: This model breaks the software/product into small builds provided in iterations, where each iteration has its own stages that must be completed before moving to the next iteration that lasts up to 2 to 8 weeks. While this model brought agility to the development team, the operations team still did not come up to speed with the development team. As a result of this, there was constant conflict with the development team and Operations team, this conflict hampered the pace of the software development and the release.
SO THIS BROUGHT ABOUT THE DEVOPS APPROACH!!
Why use DevOps?
IT companies are migrating from the traditional culture of having siloed Development and Operations to a culture that focuses on collaboration. A culture that focuses on a centralized view across projects to overcome the challenges and complexities of faster release cycles.
DevOps help us in moving away from disconnected environments to a more cohesive and synchronized one with a common objective of delivering high-quality software with speed. DevOps shortens the software development life cycle while delivering features, fixes and updates frequently in close alignment with the business's objectives.
The DevOps Life Cycle
The DevOps life cycle consists of various stages like the SDLC stages. They are;
- Continuous Development
- Continuous Integration
- Continuous Testing
- Continuous Deployment
- Continuous Monitoring
- Continuous development : This stage involves the planning and coding of the software. It also includes the maintenance of the code with the use of Version Control system tools like Git, SVN, Mercurial, CVS. Version control systems are software tools that help software teams manage changes to source code over time.
There are two types of Version Control Systems:
- The Centralized Version Control system(CVCS)
- The Distributed Version Control System(DVCS)
In a CVCS, the source code lives in a centralized place, where it can be retrieved and stored. There are tools that fall under these category such as the SVN and CVS.
However, in DVCS, the code exists across multiple terminals useful in the development process. It’s faster and more reliable. Most often, DVCS is the chosen source code repository of today’s DevOps professionals. The Git and Mecurial tool fall under this category.
- Continuous Integration:
The continuous development of software in the previous stage produces updated code that needs to be continuously integrated into the existing code. With continuous integration, teams compile software and run it through a series of tests that mimic the production environment to ensure a successful build when pushed to production. The logic behind this is simple but only came in response to problems in the traditional deployment cycle. The more you can build and test during development, the less software engineers have to worry about pushing to production.
The popular tools used for continuous integration are the Jenkins, TeamCity, Travis.
- Jenkins is an open source Continuous Integration server tool that allow developers to integrate code branches during the development process and run a series of automated tests against them. Jenkins also runs in Java.
- TeamCity is a proprietary offering from JetBrains. Using either of these tools allows team members get immediate feedback when the software is ready for production. So, the process of building, running tests and deploying is done automatically.
- Travis is another CI tool that provides multiple runtimes, for example, nodejs or php versions, data stores and more. With Travis, you can test your software against multiple runtimes and data stores without having them locally installed.
- Continuous Testing:
This stage allows for continuous testing of the software for bugs with the use of automated tools such as; Selenium TestNG, Jenkins and JUnit.
- Selenium is a portable software testing framework for web applications that provides a record/playback tool for authoring tests without learning a test scripting language known as the Selenium IDE and a test domain-specific language (Selenese) to write tests in a number of popular programming languages including Java C# Groovy Perl PHP Python and Ruby.
- TestNG is an external framework used by Selenium for generating test reports and simplifying testing requirements.
- Jenkins which is a CI tool is used to automate the entire testing phase. This Automation testing saves a lot of time, effort and labor for executing the test cases.
- Continuous Deployment This is the stage where the code is deployed to the production environment and ensures that the code is correctly deployed on all servers. This stage consists of Configuration Management and Containerization.
What is Configuration Management? Configuration management is the process where a configuration platform or tools like Chef, Puppet, Ansible are used to automate, monitor, design and manage manual configuration processes.
- Chef tool is used to automate infrastructure provisioning. It is also used to deploy and manage servers and applications in-house and on the Cloud. It is developed on the basis of Ruby DSL language.
- Puppet is an open source configuration management tool mostly used on Linux and Windows to pull the strings on multiple application servers at once.
- Ansible is a tool that allows you to create groups of machines, describe how these machines should be configured or what actions should be taken on them.
What is Containerization? Containerization is defined as a form of operating system virtualization, through which applications are run in isolated user spaces called containers, all using the same shared operating system (OS). Docker and Vagrant are the popular tools of containerization which help produce consistency across the development, test, staging and the production environments.
- Docker container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings.
- Vagrant is a tool focused on providing a consistent development environment workflow across multiple operating systems.
- Continuous Monitoring This stage is a very crucial stage in DevOps Life Cycle aimed at improving the quality of software by monitoring its performance. The Operations Team monitors the user's activity for any bugs or improper behaviour of the software. The following monitoring tools can be used in this case; Splunk, ELK Stack, Nagios, New Relic.
These tools help monitor the application and the servers closely to check for any issues. Any issue found in this stage is reported to the Development team and fixed in the Continuous development phase. The stages are carried out in a loop continuously until the desired product quality is achieved.
The Benefits of DevOps
Increases the rate of software delivery and improves the company's time to market potentially from months and weeks to days and hours.
It maintains better business structure by automating their infrastructure so the company can focus on things that can improve or add more value to their organization.