What is DevOps?
DevOps is a way of working that focuses on regularly shipping quality software that meets a business need. It's often achieved through better collaboration inside the organization, with special attention paid to improving throughput by removing roadblocks.
DevOps stems from the movement that began with lean thinking and agile development. The goal? Quickly shipping high-quality, relevant software in a sustainable way. Agile development generally centers on the role of software engineers and focuses on rapid, incremental development of software. In keeping with the agile philosophy, there is increasing emphasis on continual, incremental, and rapid delivery of software functionality. Thus, agile has necessarily broadened to include speed and quality in operations–the set of activities that transform software from code complete to supported in production (e.g., build, test, provisioning, configuration, deployment, and ongoing management). Shipping software quickly like this requires the joint cooperation of developers (Dev) and IT operations (Ops), not to mention project managers, finance, and business stakeholders.
DevOps is fluid, and avoids much of the traditional handoff friction and delays between product development and IT operations through greater collaboration, communication, and joint responsibility for the success of software delivery.
DevOps stands in stark contrast to the traditional enterprise software delivery mindset. Generally comprised of separate software development and IT operations organizations that work independently, most enterprises encounter a disconnect between developers and IT operations and are poorly positioned for rapid software delivery. For example, most enterprise developers generally cannot easily self-provision configured infrastructure (controlled by IT Ops), and thus cannot spin up repeatable, standardized environments. As a result, they end up developing their portion of code in their private environments with unique configurations that enabled efficient development and testing. They then hand it over to IT operations to take the various software artifacts (developed and tested by multiple developers in heterogeneous environments) and then manifest them into a running application deployment that has desirable enterprise characteristics such as high availability, scalability, and security.
This is generally a complex, manual, slow, and error-prone process for IT Ops to accomplish without support from the development team. Problems encountered in deploying software usually leads to friction and mistrust between the teams. Such friction is exacerbated in a modern, continuous delivery context where developers are incentivized to deliver features rapidly, while IT operations is incentivized to ensure stability, and the only way that is practically possible (without modern automation) is by limiting changes.
DevOps is not prescriptive in how it should be practiced. Nevertheless, successful and high-functioning DevOps practices tend to share several characteristics and impact the culture, process and tooling in an organization.
A culture of valuing collective success, collaboration, and joint accountability permeates successful DevOps practices. Developers and IT professionals are jointly held responsible for successful application delivery. This can be facilitated through organizational changes (e.g., functional silos where personnel are matrixed into projects are jettisoned in favor of co-locating development and operations personnel who build and run their services together).
DevOps also places emphasis on empathy and encourages developers and IT operators to understand each other’s roles better so they can adjust their work to easily accommodate the other party and collaborate more effectively. For example, understanding the production deployment environment would enable developers to have a better understanding of potential operational failures and design around them. Alternatively, IT Ops can gain a better understanding of application design and goals helping them optimize the deployment configuration.
Successful DevOps practices actively eliminate potential sources of friction resulting from misaligned success measures (e.g., developers incentivized to release features quickly while IT Ops is incentivized to minimize changes to production deployments).
Manifesting a DevOps culture in practice requires establishing joint processes such that both developers and IT operations have a forum for communication and sharing of expertise, and a well-defined collaboration framework for rapid and structured software delivery and failure recovery. Such a framework, for example, might designate that developers are responsible for self -provisioning of capacity through APIs, but that IT Ops implements and supports them. Or it may provide for an agreement/contract that the APIs will not distinguish between dev, test, or production environments, thereby eliminating environmental parity issues - a significant source of delays and problems.
Another example of joint process might be agreement and use of a centralized store for software dependencies that is maintained current through jointly developed scripts. Over time, such collaboration yields learning, iterative improvement, and the ability to push out incremental and frequent software changes into production with repeatability and little risk of downtime.
Rapid and reliable software delivery requires consistency and repeatability in processes that are streamlined to eliminate unnecessary manual intervention. For example, enterprises routinely struggle with slowdowns related to capacity provisioning, disparity of development and production environments, and manual complex compile/test phases.
High performing DevOps practices utilize shared tooling to help crystallize and streamline collaborative processes such that there is common understanding of the entire software delivery process. As a result, they are able to drive consistency and automation that helps DevOps practitioners deliver faster and avoid spending time in ad hoc fire-fighting during deployment or failure recovery in production. Many enterprise vendors now offer tooling for continuous integration or infrastructure automation and configuration. However, integrating these disparate point solutions is a complex exercise that adds significant overhead, but little to an enterprise’s bottom line.
“DevOps is firmly in the mainstream today...DevOps is no longer a nice to have or a differentiator but is now essential to compete effectively in the market.”
Ovum Research; Changes Within and Driven by DevOps; June 2016