ADAPT AND THRIVE: The Right Way To Do Automation
In the second installment of our Adapt and Thrive series, we explore how GitOps can help organizations to automate the process of developing and delivering software features.
By using automation judiciously, you can develop and update your applications faster and with reduced investment. Here’s how.
You can’t automate everything. That’s because there are some things that need human brain power – everyone knows that. But identifying the best candidate processes isn’t always easy. In this article, we explain how GitOps can be used to automate much of the routine tasks involved in software delivery, saving you money without risk.
- DevOps brought software development and operations together
- It introduced the idea of automation in software delivery
- Kubernetes, the ubiquitous container platform, made automation more practical
- It also provided the basis for GitOps, a combination of software and best practice
- GitOps automates the monitoring and management of cloud applications
- It is proven to increase speed of deployment and cost-effectiveness
Be sure to check out Part I and Part II of our Adapt and Thrive Series:
Part I: ADAPT AND THRIVE: Digital Transformation for Business Success
Part II: ADAPT AND THRIVE: The Importance of Locking Down Your Software Development Pipeline
We all want to achieve more with less
All other things being equal, all improvement will plateau at some point. In business, this is as good as a law of nature. However successful you are at improving productivity, streamlining your operations, boosting the skill levels of your workforce or anything else that delivers increased business value, you will, at some point, hit a wall. It’s the point at which you either need to make a significant extra investment – which could fail to deliver a return – or accept that you have reached the end of that particular road, and focus your attention elsewhere. Neither is particularly appealing.
But even rules like this one have their exceptions. When it comes to the way in which you develop, deliver and update software features (whether for websites, mobile apps or integrations with partners), there are relatively inexpensive changes you can make to improve even the most keenly optimized process.
Why don’t we just automate everything?
Automation is a hot topic in the IT world. Imagine how much money could be saved if we could build a business without hiring people. But as everyone in business knows, you can’t automate everything. In fact, when you examine every core process in your business, you may well find that the candidates for automation are few and far between. There are numerous reasons for this, of course, from the obvious ones – cost, potential for disruption and greater risk, for example – to the basic inability of computers to do things that require the flexibility only a human brain can bring to the table. But that doesn’t mean that the judicious application of automation cannot pay dividends.
Maybe DevOps can help…
One area in which automation can bring numerous benefits is the way in which you develop and manage the delivery of new software features – and the best way to do this is via an approach that has been gathering steam for over a decade: DevOps.
Broadly, DevOps is a fusion of processes, job roles and cultural rules, with some extremely valid aims: “…to reduce the time between committing a change to a system and the change being placed into normal production, while ensuring high quality,” according to computer science researchers Len Bass, Ingo Weber and Liming Zhu from the CSIRO and the Software Engineering Institute. In other words, to speed up without breaking anything. But the key word there is right at the beginning of this paragraph – ‘broadly’. Because outside academia, there is still no specific, industry-wide definition of what DevOps actually is, which means that when it comes to working out how to do it, you’re on your own.
It's not all bad news, however. In the last decade, a rich ecosystem of DevOps tools and technology vendors has sprung up. DevOps now appears in job descriptions and job titles, right across the globe. And in combining two functions that were historically separate – software development and operations – this nebulous term has begun to solidify around three key principles: shared ownership of the applications and the infrastructure they run on, rapid feedback and, crucially, workflow automation.
How Kubernetes accelerated automation
The more you think about it, the more it starts to make sense. DevOps is about going faster, without breaking things. And one of the ways it achieves this is by automating some aspects of the development and operations worlds. The question is, which ones?
As it turns out, this decision has, to a great extent, already been made. That’s because one of the key weapons in the DevOps arsenal is a container management platform called Kubernetes. Originally developed by Google and later shared with the world as open source software, Kubernetes has fast become the de facto container orchestration for enterprise cloud applications. You can run it on hardware on your premises, you can run it on public clouds, you can run it at the edge of your network and you can run it on any combination of the above. But more important than all that is a characteristic that was baked into the software from the beginning: it is declarative.
While most software relies on being told what to do very specifically, Kubernetes allows its users (usually operations teams) to declare what they want to achieve in simple terms, then leave it to the software to work out the best way to do this. In the fluid world of cloud infrastructure, where workloads are often moved from cloud to cloud and the failure of a computer or cluster behind the scenes just means another one must step in to take the strain, the ability of Kubernetes to handle the dynamic management of clusters without human intervention can be considered its superpower.
Kubernetes was just the beginning
Automation didn’t start with Kubernetes. The whole idea of DevOps was fueled by the idea of software that could pick up some of the administrative tasks that are best suited to computers. But Kubernetes took the automation element of DevOps to a whole new level.
In recent years, as DevOps has been joined by broader, more business-wide philosophies such as value stream management, the tools that have driven its success have evolved too. What started out as a software development pipeline combining continuous integration with continuous delivery to speed up the deployment of software, has become the foundation of something new: GitOps.
GitOps is, in principle, a way of doing DevOps. Like DevOps itself, it is a combination of tools, rules and best practices. But unlike DevOps, GitOps is very clear about what it is and what you need to do to realize its benefits. In a sense, GitOps is refreshingly prescriptive.
GitOps combines Kubernetes with Git, the ubiquitous, open source version control system for software development, to take DevOps automation much further than Kubernetes alone. The declarations of the application’s ideal state (usually YAML files) for interpretation by Kubernetes are placed in a Git repository, just like the application code. Git thereby becomes what is known as a ‘single source of truth’ – a central record of the way the application should remain, whatever happens to it as it runs.
Crucially, GitOps adds a third component to this pairing of Git and Kubernetes: a software agent that monitors the production application for any divergence from the single source of truth. This monitoring agent ‘closes the loop’, by alerting operations teams the moment the production application begins to look different from its ideal state.
This is DevOps automation in practice: a system that monitors its own health and that can, to a degree, reconfigure itself. If not – and human input is required – it can alert operations teams who can take the necessary action. The result is far less time wasted on the kinds of mundane management tasks that can easily be handled by software – and more uptime, at lower cost.
Faster, more secure and more cost-effective
By adopting GitOps, you can achieve something of a holy grail. It enables your developers to work more productively, without asking them to learn to use new tools. And this acceleration doesn’t come at any cost in terms of security and compliance. In fact, it improves both, thanks to the guardrails it places on the process and the audit trail it constantly generates. Crucial, however, is the cost. GitOps is based heavily on open source software. The chances are, two of its three key components – Git and Kubernetes – are already in constant use in your organization. So whether you choose to implement GitOps without external help or via a vendor such as Weaveworks, the financial costs are unlikely to be excessive – and its results are proven.
Ultimately, this is all about eliminating wasted investment in the process of developing and delivering new software features. Automation is not a panacea and it certainly cannot be applied to every part of that process, however GitOps makes the best use of automation in the context of today’s technology.