DevOps emerged as a result of the rapid pace and efficiency achieved by agile software development. It evolved from the necessity to cope with the increased speed and productivity of agile methods. The progress made in agile practices and principles during the past decade highlighted the requirement for a comprehensive approach to managing the entire software delivery process.
Agile development encompasses various iterative and incremental methodologies for software development. Among the widely recognized agile approaches are scrum, kanban, Scaled Agile Framework® (SAFe®), lean development, and extreme programming (XP).
Although each agile methodology has its distinct approach, they all share a common vision and core values outlined in the Agile Manifesto. All of them fundamentally embrace iteration and value continuous feedback as a means to progressively refine and deliver software systems. They all emphasize continuous planning, continuous testing, continuous integration, and other forms of ongoing evolution for both the project and the software. Agile methodologies are characterized by their lightweight nature, particularly when compared to traditional waterfall processes, and they inherently possess adaptability. Most importantly, agile methods prioritize the empowerment of individuals to collaborate and make swift and effective decisions collectively.
In the beginning, agile teams were predominantly composed of developers. As these teams gained proficiency and effectiveness in software production, it became evident that maintaining separate quality assurance (QA) and development (dev) teams was inefficient. As a result, agile methodologies evolved to incorporate QA practices, aiming to enhance the speed and efficiency of software delivery. Now, agile is expanding once again to encompass the involvement of delivery and support members, extending the agility of the process from the initial idea to the final delivery.
DevOps principles build upon agile development practices by further optimizing the flow of software changes across the stages of building, validating, deploying, and delivering. Simultaneously, DevOps empowers cross-functional teams by granting them full ownership of software applications, encompassing the entire lifecycle from design to production support.
DevOps is an IT mindset that promotes effective communication, collaboration, integration, and automation between software developers and IT operations. Its primary goal is to enhance the speed and quality of software delivery.
DevOps teams prioritize standardizing development environments and automating delivery processes to enhance predictability, efficiency, security, and maintainability in software delivery. The principles of DevOps empower developers with greater control over the production environment and a deeper understanding of the underlying infrastructure. DevOps emphasizes the importance of empowering teams to take ownership of building, validating, delivering, and supporting their own applications. With DevOps, the concept of “throwing over the wall” is eliminated, fostering a culture of shared responsibility and collaboration.
Before the advent of DevOps in application development, teams had distinct roles and responsibilities. One team would gather business requirements and write code, while a separate QA team would test the program in a separate development environment. If the requirements were met, the code would be released to the operations team for deployment. The deployment teams were often divided into separate groups such as networking and database. This traditional approach resulted in bottlenecks and inefficiencies whenever a software program was “thrown over the wall” by an independent team. The main issue with this paradigm was that the teams worked in isolation, leading to the following challenges:
DevOps tackles these challenges by fostering collaborative cross-functional teams that jointly take responsibility for both the maintenance of the system running the software and preparing the software to run seamlessly on that system. This approach incorporates enhanced quality feedback and automation mechanisms to address issues effectively.
A common pre-DevOps scenario
The development team aims to maximize the number of features released and passes a new release to the QA team without close collaboration. The testers, in turn, focus on identifying as many bugs as possible. However, when the testers report their findings to the development team, defensive behavior arises, with developers blaming the testers for issues encountered. The testers counter by stating that the problem lies with the developer’s code rather than their testing environment.
Eventually, after resolving the issues, the QA team delivers the debugged release to the operations (Ops) team. The Ops team’s objective is to minimize changes to their system, but they reluctantly release the code, only to experience system crashes. Finger-pointing resumes.
Ops claim that the development team provided them with faulty artifacts, while the development team insists that everything worked fine in the test environment. The situation devolves into urgent debugging and stabilizing the production environment. Dev and QA distance themselves, considering the production environment to be Ops’ responsibility, while Ops spends the entire night resolving the production issues.
Enhance cooperation among all stakeholders throughout the entire project lifecycle, from planning to delivery, and automate the delivery process to achieve the following objectives:
A common pre-DevOps scenario
Before commencing a new software project, the software team convenes to strategize. This multidisciplinary team consists of developers, testers, operations, and support professionals, who collaborate to plan the creation of functional software ready for deployment.
On a daily basis, new code is deployed as soon as developers complete it. The code undergoes automated testing to ensure its readiness for deployment. Once the code successfully passes all automated tests, it is deployed to a limited number of users. This deployment phase involves monitoring the new code for a short period to identify any unforeseen issues and ensure its stability. Following successful monitoring, the code is gradually rolled out to the remaining users. Importantly, many, if not all, of the steps beyond planning and development are accomplished with minimal or no human intervention.
The DevOps continuum provides a valuable framework for understanding different aspects of DevOps. The horizontal axis at the bottom represents the primary focus that individuals attribute to DevOps. Some strongly emphasize the cultural aspect of DevOps, while others tend to prioritize the use of tools.
The vertical axis illustrates the three levels of the DevOps delivery chain: continuous integration, continuous delivery, and continuous deployment. Within the DevOps community, organizations located in the top right of the continuum are often referred to as “pink unicorns.” These organizations, such as Netflix, Etsy, Amazon, Pinterest, Flicker, IMVU, and Google, are relatively rare to find in practice. They represent exemplary cases that have achieved high levels of DevOps maturity and success.
In a recent poll, participants were asked to indicate where their organizations stood on the DevOps continuum, reflecting their position in terms of culture and tooling focus as well as their progress along the continuous integration, continuous delivery, and continuous deployment spectrum.
Prominent figures in the field, such as thought leaders, coaches, and bloggers, often depict a vision of DevOps located in the top right corner of the continuum. They frequently exhibit a strong inclination towards either emphasizing DevOps culture or highlighting the importance of automation tools. While it is natural to engage in discussions about whether culture or tools hold greater significance in DevOps, the truth is that DevOps cannot exist without tools, and conversely, relying solely on tools will be ineffective without a robust supporting culture.
It is important to recognize that progressing towards the top right corner of the continuum takes time, and many organizations’ initial steps involve a combination of culture, tools, and implementing continuous integration. Therefore, there is no need to feel discouraged if you come across articles suggesting that you are “not doing DevOps” unless you have achieved fully automated deployments into production without any human intervention.
DevOps is a fusion of culture, tools, and maturity that should align with your organization’s specific needs, and this understanding is likely to evolve over time. The crucial aspect is to consistently strive to dismantle barriers and bottlenecks in the software delivery process by enhancing collaboration and automation. In the subsequent sections, we delve deeper into each dimension of the DevOps continuum to provide a better understanding of where your organization fits in.
DevOps maturity encompasses multiple stages, and it is essential to familiarize yourself with some of the significant phases.
In the pre-continuous integration era, development teams used to write a substantial amount of code over a span of three to four months. Following that, these teams would merge their code to prepare for the release. However, since the versions of the code would be significantly different and include numerous changes, the integration step alone could take several months. This approach proved to be highly unproductive.
Continuous integration involves the practice of swiftly integrating newly developed code with the main codebase intended for release. By embracing continuous integration, teams can significantly reduce the time required for code release, thus saving valuable time and resources.
The term “continuous integration” was not coined by DevOps itself. It actually emerged as an agile engineering practice within the realm of extreme programming methodology. Although the term has been in use for quite some time, DevOps has embraced it due to the vital role automation plays in effectively implementing continuous integration. In many cases, continuous integration serves as the initial phase in the journey toward achieving DevOps maturity.
From a DevOps standpoint, the continuous integration process entails several steps. Firstly, it involves checking the code into a version control system. Subsequently, the code is compiled, typically resulting in the creation of usable binary executable code. Finally, basic validation testing is conducted to ensure the integrity and functionality of the code.
Continuous delivery, which is an extension of continuous integration in the DevOps journey (stage 2), builds upon the foundation of continuous integration. It introduces further levels of automation and testing to go beyond frequent code merging and aims to prepare the code for deployment with minimal human involvement. The objective of continuous delivery is to maintain a state where the codebase is consistently ready for deployment, ensuring that it is nearly deployable with minimal additional intervention.
Continuous deployment, distinguished from continuous delivery (often regarded as the ultimate DevOps aspiration), represents the pinnacle of evolutionary advancement. It encompasses the practice of seamlessly deploying software directly into the production environment without the need for any human involvement.
In teams that embrace continuous delivery, untested code is not deployed. Instead, newly developed code undergoes automated testing before being released into the production environment. Typically, the initial code release is limited to a small percentage of users, and an automated feedback loop is established to monitor quality and usage. Only after the code has proven its stability and effectiveness through this monitoring process is it propagated further to a wider user base.
Only a select few companies have achieved true implementation of continuous deployment. Prominent examples of such companies include Netflix, Etsy, Amazon, Pinterest, Flickr, IMVU, and Google.
Although reaching the state of DevOps nirvana, characterized by continuous deployment, may not be the ultimate objective for most enterprises, they typically strive to progress toward the goal of continuous delivery.
DevOps places significant emphasis on fostering a collaborative culture and enhancing efficiency through the utilization of automation and DevOps tools. While certain organizations and individuals may lean towards prioritizing one over the other, the truth is that achieving success in DevOps necessitates a balanced combination of both culture and tools. Here is essential information about these two core values in DevOps.
The culture of DevOps revolves around fostering enhanced collaboration, breaking down organizational silos, promoting shared responsibility, empowering autonomous teams, striving for improved quality, valuing feedback, and embracing increased automation. It is worth noting that many of these values in DevOps align with those of the agile methodology, as DevOps can be seen as an extension of agile practices.
Agile methodologies offer a comprehensive approach to software delivery, where the progress is measured in terms of tangible, functional software. Product owners, developers, testers, and UX professionals collaborate closely, sharing the same goals and working together in synergy to achieve successful outcomes.
DevOps essentially involves integrating the operations mindset and, potentially, assigning a team member with related responsibilities to the existing agile team. In the pre-DevOps era, progress was gauged by the presence of functional software. However, in the context of DevOps, progress is measured by the successful deployment of functional software into the hands of customers.
Development and operations must dismantle silos and engage in collaborative efforts to achieve this objective. They need to jointly shoulder the responsibility of maintaining the system that supports the software and diligently prepare the software for seamless execution on the system. This entails incorporating enhanced feedback mechanisms and leveraging automation in the delivery process to ensure improved quality and efficiency.
DevOps tools encompass various components such as configuration management, test and build systems, application deployment tools, version control systems, monitoring tools, and more. These tools play an important role in enabling practices like continuous integration, continuous delivery, and continuous deployment. Although it is possible to use the same tools for all three practices, as you advance through the delivery chain, you may find the need for additional tools to support your evolving requirements.
Earlier, DevOps briefly discussed some of the tools used in DevOps; here are some of the key tools and practices you need to know.
A source code repository serves as a centralized location where developers can check in and modify code. It effectively manages different versions of the code that are checked in, preventing conflicts and overwriting of each other’s work.
Source control, which has been in existence for approximately forty years, plays a vital role in supporting continuous integration. Several popular tools for source code repositories include Git, Subversion, Cloudforce, Bitbucket, and TFS.
The build server, an essential automation tool, takes the code stored in the source code repository and transforms it into executable code. This process involves compiling and preparing the code base for deployment. Some popular tools used for building servers include Jenkins, SonarQube, and Artifactory.
Configuration management involves defining and managing the configuration settings of servers or environments. It ensures that the desired state of a system is consistently maintained. Puppet and Chef are widely used configuration management tools that enable organizations to effectively manage and automate the configuration of their infrastructure.
Examples of virtual infrastructures include Amazon Web Services (AWS) and Microsoft Azure. These infrastructures are offered by cloud vendors who provide infrastructure or platform as a service (PaaS). They offer APIs that allow you to programmatically create new virtual machines and utilize configuration management tools like Puppet and Chef.
In addition to public cloud offerings, there are also private clouds available. VMware’s vCloud is an example of a private virtual infrastructure. Private virtual infrastructures allow you to establish a cloud environment within your own data center, utilizing the hardware resources available.
Virtual infrastructures, when coupled with automation tools, provide organizations practicing DevOps with the capability to configure servers without manual intervention. This means that if you wish to test newly developed code, you can automatically deploy it to your cloud infrastructure, set up the necessary environment, and execute all the required tests without the need for human involvement.
Automated testing has a long history, but in the context of DevOps, the focus is on incorporating automated testing within the build pipeline. The goal is to ensure that when you have a build that is ready for deployment, you can have confidence in its readiness. To achieve continuous delivery and reach a stage where you can deploy code without significant human intervention, it is essential to have a robust automated testing strategy in place. Selenium and Water are popular tools used for this purpose.
A pipeline in the context of DevOps can be likened to a manufacturing assembly line. It encompasses the entire process starting from the moment a developer considers their work complete to the point where the code is deployed in either a production environment or a late-stage pre-production environment.
Here at CourseMonster, we know how hard it may be to find the right time and funds for training. We provide effective training programs that enable you to select the training option that best meets the demands of your company.
For more information, please get in touch with one of our course advisers today or contact us at training@coursemonster.com