1
Introduction to DevOps

“It is through improving our ability to deliver software that organizations can deliver features faster, pivot when needed, respond to compliance and security changes, and take advantage of fast feedback to attract new customers and delight existing ones.”

—Nicole Forsgren, PhD

What You Will Learn in This Chapter

• Definition and Overview of DevOps
• History of DevOps
• The DevOps Life Cycle
• The Benefits of DevOps
• The Current State of DevOps
• Summary

How do we build secure, resilient, and rapidly evolving systems at scale? This was the question that led to the birth of DevOps. Prior to DevOps, this was an important problem that organizations were facing. As time passed, software engineering evolved, and more innovative software has been built to provide solutions in interesting business sectors. This software is currently transforming and accelerating different kinds of organizations.

DEFINITION AND OVERVIEW OF DevOps

DevOps is a culture or a set of practices bridging the gap between two formerly siloed units, software developers (Dev) and IT operations staff (Ops), throughout the entire product development life cycle. The adoption of the DevOps culture, tools, and applications has empowered teams with the ability to build and securely scale their software development practices, engage customers to get feedback more efficiently, and ship software that helps organizations meet their business goals faster.

HISTORY OF DevOps

To appreciate where DevOps is today, we should learn what existed before it. The DevOps trend was born in 2007. Prior to that, software developers wrote their code and worked differently from the other IT professionals who tested and deployed the code. This meant that there was a huge disconnect in software development and deployment practices.

One of the major factors for this was that software developers and IT professionals had different goals within an organization. The software developers only wanted to write code for software, and the IT/Ops professionals deployed the code when it was time. This made the product feature release timeline really long; a software development team would work on a feature for months before handing it over to the IT/Ops team for deployment. The IT/Ops team would also take some time to deploy the large feature that was introduced to the application. This created room for software bugs, slow deployments, and unstable applications. Over time, releasing software of poor standards would affect the experience of any customer using the application.

Prior to DevOps, the waterfall methodology was largely used. This methodology illustrates software development processes in a sequential manner. This means each process must be completed before the next process starts. Figure 1.1 illustrates the waterfall methodology.

During this time, requirements were gathered and planning was done before any system architecture, design, or coding commenced. Once the software design was validated, programmers would start writing the code required to build that software. After software development was completed, software testing commenced, and deployment of the large application followed. Maintenance happens when the application is now live in production, and that is done in its own silo.

With this model, no version of the application gets deployed until late in the cycle, which means months of working without seeing tangible results. If requirements also change halfway through the project, the entire plan is destabilized, and the team might have to end the project and start again. In the early 2000s, as software engineering evolved and quick innovation became an organizational advantage, organizations started adopting the agile methodology for building software because it was iterative and more flexible for long-term innovative projects.

The agile methodology is an iterative way to build software applications. This model involves a continuous loop of planning, implementation, testing, and feedback in short cycles. With the agile methodology, organizations could now deliver value quickly to their customers. However, as time went on and the agile methodology became the standard for project management and software development, innovation was still moving fast, and the desire to automate processes and iterate faster came to the limelight. This was how DevOps came to exist.

FIGURE 1.1: The waterfall methodology

THE DevOps LIFE CYCLE

With the DevOps life cycle, software development and IT/Ops teams are no longer siloed. The different steps integrate well with one another into stages for a broader and more cohesive engineering team. The stages are continuous, and the output of a stage is usually the input of the next stage. The stages are as follows:

• Planning: The planning phase involves teams identifying business requirements and then itemizing and strategizing for the different features of the application currently being built. This is an important stage in the management of the project. Here, the product teams also create a product roadmap and continuously track the progress of this task so that they can incrementally deliver and maximize value across the team.
• Development: During development, the teams work on different tasks created in the planning stage. This work involves writing the source code for the software feature. At this stage, different software developers are able to work on the same codebase simultaneously because of the integration of some DevOps tools that make this possible.
• Continuous integration: This stage commences when the software developers writing code integrate their own changes to the existing repository or codebase. This integration involves testing the code, merging the code to the larger repository, and creating build artifacts or executables that would be used during deployment.
• Deployment: In this stage, the output from the build step is deployed to different production environments across multiple geographic locations. Apart from source code deployment, application infrastructure can also be deployed in this step. This infrastructure is a foundational piece and the environment that the source code would run on.

  For this deployment phase to be effective and secure, software development teams set up approvals and access policies for these production environments. This is important to control the deployments moving to production and anticipate the results of different deployments. This way, teams can automate code deployments with ease and confidence.

• Monitoring and operating: At this stage, a new version of software has been released to production and is currently in use by customers. The software development teams can now monitor user behavior, application performance, and other metrics. This monitoring helps teams improve the application so that they can always provide software with high availability to their customers.

  With monitoring, software development teams can spot performance bottlenecks in real time and come up with solutions. If there is an error in the application, team members debug and troubleshoot until they can mitigate or resolve the problem.

• Feedback: User feedback is how teams improve on software. This involves communicating with customers to learn about their experiences using the software application. The output of the feedback process can be feature requests or application improvements. This output is usually the input for the planning phase of the next DevOps life cycle iteration (Figure 1.2).

FIGURE 1.2: The DevOps life cycle

THE BENEFIT OF DevOps

The main goal of the DevOps culture is automation. The ability to automate different stages in the product development life cycle that were initially manual has the following benefits:

• Speed: As more tech companies come into the limelight, speed has become an important factor in innovating and keeping customers satisfied. DevOps makes speed possible. Teams can now build and release stable software in a timely manner due to automation.
• Shorter release cycles: DevOps teams implement the agile methodology. The agile methodology is an iterative software development methodology that allows teams to update software in bits, learn from that experience, and improve in the next software update iteration. Because of this, teams are not waiting to build out the entire application for as long as 18 months. Features can be iteratively worked on during short cycles called sprints; these cycles make code releases and debugging easier.
• Collaboration: DevOps fosters collaboration within teams. This culture eliminates the siloed approach to software development that once existed and makes it possible for team members with different skill sets (e.g., software developers, product managers, QA testers, site reliability engineers, etc.) to work cohesively together toward the launch of a product or feature.
• Learning: When software is released, monitoring starts. Here, teams are able to learn about the performance of their application and correct their mistakes to build better and faster software that their customers would enjoy. The DevOps model makes learning possible in the monitoring and feedback phase. Teams can learn from data obtained from logs, metrics, and traces. Teams can also take...