Nowadays, the efficiency of a company’s IT infrastructure is commonly measured in how often it can deploy new versions of the software. Faster, better deployments are one of the main goals of the DevOps mindset. Therefore, to not fall behind the competition, one needs to implement DevOps practices. But DevOps isn’t just about deploying fast and often. DevOps is a set of practices and tools that help deliver better-quality software faster. The “quality” is the key here. To implement DevOps successfully, you need to improve delivery times, but also to have a good understanding of the quality of your code and your deployments. In this post, you’ll learn about a few must-have tools for the DevOps team and suggested examples for each type of tool you need.
Version Control: Git
One of the core necessities of DevOps is to have code versioned and accessible for every team member from anywhere. To achieve that, you’ll need a version control system. These days, Git is pretty much the most commonly used system. But before we give you examples of Git tools, let’s take a step back to understand why we actually need it and what it does. Simply put, Git is a system for tracking and managing changes in files.
The tracking part is simple to understand—whenever something changes in the source code, we need to know what changed and who changed it. This is crucial for any software development team. Without source code tracking, you wouldn’t be able to understand what’s happening with the code and who works on what.
The managing part is about, for example, ensuring that two developers don’t change the same lines of code, and encouraging frequent check-ins so that multiple versions and merge conflicts are minimized. That’s how Git works in general.
So which tools do you need to learn to know Git? For starters, Git itself. You can find instructions for installing Git and the Git tutorial. While Git is a fully distributed version control system, most projects centralize around one of the major Git hosting services like github.com or gitlab.com. These are the two most commonly used Git systems, primarily because of the additional features they offer like pull requests and issue tracking. Understanding these features will help you be a better practitioner.
The most popular way of building software nowadays is by using containers, and the most popular container platform is currently Docker. Containerization has become a de facto industry standard. There are a few reasons for that, but the main reason is that it helps to achieve the DevOps goal of delivering faster and more often. Docker drastically simplifies deployment. Developers don’t need to worry anymore about installing specific versions of the libraries and runtimes needed for their software. Everything can be packaged into a Docker container and run on any system.
Of course, there are still use cases and companies where Docker isn’t used, but you should know it anyway. Even if your company doesn’t use Docker, you can still benefit from it—for example, using Docker on your local machine for development purposes. You can learn more about Docker containers from the official Docker website.
After getting familiar with Docker, it’s definitely worth it to jump onto the Kubernetes (sometimes abbreviated K8s) boat. The more Docker containers you work with, the more difficult it will be to manage them. Restarting a failed container, finding the logs, making sure enough copies of each container exist to handle your workload, or updating the version of your Docker image when you have dozens of containers running isn’t a trivial task.
Kubernetes is a container orchestration platform. It handles all aspects of running microservice-based applications—scheduling and restarting containers, networking, storage, service discovery, etc. Therefore, Kubernetes itself is a pretty complicated tool, but it’s relatively easy to understand the basics of it. You can also make the learning a bit easier by using a managed Kubernetes service from one of the major cloud providers, such as Google Kubernetes Engine or Amazon Elastic Kubernetes Service. They’ll offload the Kubernetes management from you so you’ll be able to focus on using it.
CI/CD: Jenkins/Argo CD/Flux
While Docker and Kubernetes help to speed up development, the actual deployment of the software happens on a different level. A key benefit of DevOps is the ability to deploy more often, ideally multiple times a day. For that, you need an automated CI/CD pipeline. A pipeline can be created and managed with tools like Jenkins, Argo CD, or Flux. These are just a few popular choices.
They all work differently because there are many ways of deploying software these days. But the underlying idea stays the same—you have source code, and you need to build and run an application from it. These tools can do exactly that. You build a pipeline, meaning you define where your source code is; how to build an artifact, binary, or Docker container from it; where to push it; and where to deploy it. Once you’re done with defining the pipeline, the CI/CD tool will take care of executing it after each code change.
It would be great to learn the basics of more than one CI/CD tool. Jenkins has been the most popular CI/CD tool for many years and can still be found in many companies. Therefore, it’s worth getting a grasp of Jenkins, but if you want to be on top of the DevOps landscape, you definitely should look into more modern tools, such as Argo, too.
Configuration/Host Management: Ansible/Puppet/Chef
In the world of Docker and Kubernetes, traditional software provisioning and configuration management tools aren’t really needed. However, not all companies have moved to Kubernetes yet, and some aren’t even planning to. Therefore it’s still a good idea to learn one (or more) non-container configuration management products. Before Docker, to deploy software on a server you had to configure the operating system, probably create some users and directories, install necessary runtimes and libraries, then install the actual software, and, finally, probably populate some config files.
All of that can be automated using Ansible, Puppet, or Chef. They all work slightly differently—for example, Ansible uses YAML language, while Puppet and Chef use their own languages. Ansible is also in theory easier to start with since you need only to install the Ansible binary and you’re good to go. By contrast, Puppet requires some more components to be installed. Nevertheless, it doesn’t really matter that much which one you learn. The general idea of a provisioning and configuration management tool stays the same.
Observability and Monitoring: Splunk
So far, we’ve covered tools that help you deploy faster. But without proper monitoring and observability tools, you won’t achieve a good DevOps-driven system. The complexity of modern applications (look at all the tools already mentioned) makes an observability platform more essential than ever.
DevOps isn’t just about deploying faster but also about deploying good quality software. No one wants to deploy more often if they’re not sure if the deployment won’t create downtime. You need to be able to get feedback not only on whether the deployment was successful, but also if it performs as expected. Monitoring and observability are crucial for a successful DevOps team.
Splunk is a tool that can help you achieve true DevOps (or even DevSecOps). What’s great about it is that it covers pretty much every level of monitoring you may need. Splunk’s Observability Cloud product works with any architecture at any scale, and includes all of the necessary components of an observability system. From Infrastructure Monitoring, through application performance monitoring and log investigation to integration with security analytics (SIEM). There’s also real-time alerting so that you can resolve issues faster, continuing to deliver quality experiences for your users. If you want to see it for yourself, sign up for a free trial of Splunk’s Observability Cloud and start monitoring any application today.
Sometimes people talk about DevOps only in relation to CI/CD pipelines. It’s not only about that. To create true DevOps teams, you need to understand all the building blocks of modern environments—from Git and containers to extremely important monitoring and observability tools.
If you want to implement DevOps practices successfully, you need a combination of a few tools that work together. But in order to not lose track of what’s happening, you also need a good monitoring system. Having a clear overview of the whole software delivery lifecycle is a must for a DevOps engineer. This, however, doesn’t have to be a difficult task. With Splunk, it’s easy to get a bird’s-eye view on everything and drill down into the issues to find a root cause when needed.
This post was co-written by Dawid Ziolkowski. Dawid has 10 years of experience as a Network/System Engineer at the beginning, DevOps in between, Cloud Native Engineer recently. He’s worked for an IT outsourcing company, a research institute, telco, a hosting company, and a consultancy company, so he’s gathered a lot of knowledge from different perspectives. Nowadays he’s helping companies move to cloud and/or redesign their infrastructure for a more Cloud Native approach.