Git is the bridge between developers and production
The DevOps movement says we’re supposed to bridge the gap between developers and production. But how do you actually do that? Arthur Schmunk is convinced that the answer is GitOps.
By adopting GitOps, you can turn your entire software-delivery pipeline into code, and make it very easy for developers to embrace the roles that they are now expected to play in production.
Let’s explore how.
In a DevOps-centric world, developers are king
To understand the full value of GitOps, you first have to step back and appreciate just how much the role of developers has changed over the past decade.
Once upon a time, developers wrote code, then passed it off to others for testing, building and deploying into production. In the past, developers rarely touched a production environment.
Fast-forward to the present, however, and the role of developers is much more expansive. Today’s developers don’t only write code; they are also expected to play a central role in deploying code and managing it in production (with the idea that doing so makes it easier for developers to gain the insights from real-world software deployment that will help them to write better code). This change is due largely to the influence of the DevOps movement, which encourages closer collaboration between developers and IT Ops.
To be clear, I’m not suggesting that developers are solely responsible for production; that’s clearly not the case at most organizations. IT Ops still exists. But IT Ops can no longer do its job without developers.
Thus, today, the developer is king of the entire software delivery pipeline. Other types of engineers play important roles, too, but developers take the lead.
Mind the developer/production gap
Even though the DevOps trend has brought about a world wherein developers are expected to play a much more active role in production, DevOps hasn’t done a great job of actually helping developers to make that jump.
Instead, DevOps has focused mostly on abstract, high-level prescriptions of how developers and IT Ops should interact. They are supposed to embrace concepts like “continuous delivery” and “constant collaboration.”
But how do you do that in practice? How do you operationalize things like continuous delivery? Those are tougher questions, and DevOps doesn’t offer much in the way of specific answers.
Thanks to GitOps, however, we now have a solution to this conundrum.
What is GitOps, you ask? In a nutshell, it’s the practice of using Git to manage all aspects of the software delivery process. Thus, it’s both a tool (Git) and a process that is based on that tool.
By embracing GitOps, software delivery teams can use Git events to record, manage and monitor every step along the software delivery pipeline. They can also collaborate and communicate via Git, and keep an end-to-end revision history of all changes not just to code, but also to any part of the CI/CD pipeline.
SEE ALSO: GitOps, Jenkins, and Jenkins X
How GitOps helps developers reach production
In many respects, GitOps is the critical tool and process that developers need to actualize the role that they are supposed to play in production. That’s true for several reasons:
- Git is a tool that developers already know well. There is no learning curve.
- GitOps allows developers to manage production-level issues in the same way that they would manage code — which is also a process they are already familiar with. Instead of managing hardware and troubleshooting infrastructure, GitOps allows you to do everything in code.
- By creating a constant, central and universally accessible audit trail of work across the software-delivery pipeline, GitOps makes it easy for developers to translate information about production environments into new application code, thereby achieving one of the key goals of DevOps — better software quality thanks to fewer silos.
In each of these respects, GitOps helps developers to put DevOps fully into practice by embracing their roles in helping to manage production environments (not just producing code).
GitOps provides the solution for operationalizing DevOps that has been missing for years. Traditionally, organizations have attempted to include developers in production by hiring specialized DevOps engineers, or adopting new communication tools (like Slack) and hoping that they’ll magically insert developers into production. Those approaches may work somewhat, but they’re expensive or tedious, and they don’t hit the nail on the head.
In contrast, GitOps is a strategy that is free and easy to implement (Git costs nothing, and your team very likely already knows how to use it). And GitOps directly addresses the problem of connecting developers to production environments. It allows developers to be the kings of CI/CD not just in theory, but also in practice.