Artboard 1 copy 4@2x

4 DevOps tools shaping the future of the CI/CD pipeline

Posted by Mike Whittingham

When considering the tools that will shape DevOps and Continuous Integration/Deployment, we need to start by looking at the foundations of DevOps: namely Culture, Automation, Measurement and Sharing and then how these tools are building on those foundations.

CAMS was first defined by Damon Edwards and John Willis in 2010. After the first US-based DevOpsDays in 2010, Damon and John coined the acronym CAMS. Jez Humble later added an L, standing for Lean, to form CALMS.

Patrick Debois, a godfather of the DevOps movement, says DevOps is a human problem. Edwards claims it is a management problem. These problems can be addressed by the use of tools, but only if they contribute to automation and measurement to engender new behaviors (culture) and collaboration (sharing).

The main phases of DevOps

In addition to understanding the foundations of DevOps, It is important to call-out the phases of the DevOps toolchain and CI/CD pipeline. There are many different ways to divide the DevOps toolchain. A common categorization includes seven phases.  

  1. Collaboration – tools that ensure everyone can agree and share across multiple platforms
    for complete integration.
  2. Planning – tools to share ideas, brainstorm, comment, and work towards a common goal
  3. Development -  tools to speed, and optimize the production of code.
  4. Continuous integration – tools for obtaining constant and immediate feedback through the process of merging code.
  5. Continuous deployment – tools for deploying predictable, reliable, and frequent applications to keep production running smoothly and risks low through automation.
  6. Operate and monitor –  tools for application and server performance monitoring that records and watches data around the clock to ensure it’s working correctly.
  7. Continuous feedback – tools to process user comments, analyze support tickets, observe performance, collect NPS data,  bug identification, and other feedback collected to determine if what’s being built is working.

Finding the right tool for the right phase is important. The tools we are going to look at here are transforming how the CI/CD pipeline operates — changing the relationship between stages and developing new best practices. 

1. Slack: Bringing collaboration to every business team

In truth, Slack isn’t a development tool — it is a communication tool for developers. It is also a communication tool that has taken the entire business world by storm. Growing from nothing to a $7 billion company in less than five years, Slack holds the record as the fastest growing business app of all time.   

Slack has made a home for itself in DevOps as a hub of collaboration and communication. The fluidity and agility central to DevOps depend on communication. Without channels of effective and efficient communication, cross-team collaboration is limited, rapid response is impossible, and the potential of DevOps is left unrealized.    

Many non-development-specific collaboration tools, from Asana to Trello, have found their place next to development-specific collaboration software like Jira. However, the extensibility, flexibility, and convenience of Slack puts it in a league of its own.

Pulling together chat, file-sharing, conference calls, and external system alerts within a single, channel-based platform that can keep everyone up to date while only alerting relevant team members is simple but revolutionary. For many, it is hard to remember work before Slack. For DevOps, this impact is just as, if not more,  important. With a proper collaboration platform, team members can connect not only with one another but also with their dev environments: sharing data, leveraging the correct diagnostic tools, and managing workflow to a successful resolution.

Slack’s integration into DevOps work-life is truly remarkable. The centrality of communication to DevOps and the CI/CD pipeline puts Slack first on our list of tools shaping the future.

2. Kubernetes: Making containers move

DevOps is not tied to any particular technology, but there are tools that make DevOps fly. Containers are one such tool. They enable applications, data and even functions to be housed and held separately — creating building blocks that significantly improve a CI/CD approach.

Continuous integration merges developer working copies several times a day. If you design your application to run inside a container, you can test it, build it and deliver it to users inside the same container. This reduces complexity and adds consistency. Around 80% of containers in production today are built with Docker.

Less than five years old, Kubernetes is the container orchestration platform that takes containerization to the next level. Kubernetes groups application containers into logical "packages" for simple, fast management and discovery. It also automates the deployment and scaling of containerized applications.

The automation of Kubernetes is what makes it stand out. Central to an effective CI/CD pipeline is speed. That means removing manual processes. The simplicity that Kubernetes brings to containers is actually astonishing. When paired with the utility of containers by themselves, Kubernetes is rapidly accelerating deployment cycles, improving outcomes and bringing DevOps to another level.  

There are alternative to Kubernetes, just like there are alternatives to Docker — OpenShift, Docker Swarm and Heroku are just a few. But, the speed, flexibility, open source platform, and popularity of Kubernetes puts it (in our estimation) ahead of the pack. As an innovator in this space, it deserves recognition. What is for certain is that automation deployment software for containers are here to stay, and are shaping the future of the CI/CD pipeline.

3. RevDeBug: Bringing True Observability to the DevOps toolchain

DevOps depends on feedback. Without feedback from production environments directing the continuous integration and deployment strategy, few improvements will be made. If something goes wrong, you need to know the root cause. Agility requires observability to be effective.

Software faults are inevitable, particularly with the high-velocity release cycles of CI/CD. Containers eliminate a whole class of troubleshooting issues but introduce others. The disaggregated nature of modern, containerized and microservice architecture makes monitoring in-production activities hard.

Problems with observability

Traditional Application Monitoring Tools (APM) are limited to telling you that something has gone wrong. Understanding why something has gone wrong, traditionally, requires logging. Even in monolithic architecture, logging demands a lot of guesswork and time. In microservices, knowing what to log is nearly impossible. In reality, if you know what to log, you probably already know what the problem is. Even with the right log, you are still stuck attempting to piece together what happened based on decontextualized snapshots of information.

Old school in-production error-fixing is too slow for DevOps and the CI/CD pipeline. Rather than delivering root-cause error fixes, many DevOps teams simply create tape-over fixes, creating technical debt that will likely erupt into issues down the road. Even this process is too slow.    

True observability delivered

Enter RevDeBug, the youngest solution on this list. Centered around a change in how software flight recorder (record & replay) technology is instrumented (dropping the standard performance impacts of 10x, 100x or more to between 10% and almost nothing), RevDeBug is bringing true, granular observability into production.

This technology is partnered with global heat maps of production environments and automated rollbacks to provide high-level visibility and control with contextualized and specific root-cause analysis. Faults are identified and removed from production in milliseconds, and 100% reproducer information is fed back into the CI/CD pipeline, allowing for a root-cause solution to be deployed — often within minutes.

This is a gamechanger for observability and information feedback within the CI/CD pipeline. The future of monitoring application is true observability platforms. Other record and replay debuggers are likely to follow suit, expanding this ecosystem RevDeBug has created.

The flexibility and detail of information enable speed. This is drastically changing how production data can inform development, along with almost completely removing the negative impact of software faults and enabling rapid, root cause solutions. This rapid information feedback system is truly shaping the future of the CI/CD pipeline.

4. Jenkins: the challenge of integration and going live solved

Releasing software isn't an art, it is an engineering discipline. Continuous deployment is about releasing software on to production servers continuously in an automated fashion. This requires tools.

Much of the modern CI/CD pipeline has been shaped by Jenkins. It is the go-to open source DevOps automation tool for continuous deployment. Pulling together different tools, automating interactions, enabling deployments and making build simpler, CI/CD would not be what it is without Jenkins. Flexibility allows you to customize a CI/CD pipeline according to your own needs. It requires little maintenance and offers numerous plugins to support building and testing virtually any project.

Proprietary challengers

While Jenkins is the pre-eminent free open source product, there are others available. Bamboo is an interesting example of a tightly integrated CI/CD server solution. The advantage of Bamboo is that it seamlessly integrates with other Atlassian products such as Jira and Bitbucket and includes access to built-in Git and Mercurial branching workflows and test environments.

TeamCity is another popular alternative to Jenkins. Provided by JetBrains, TeamCity is other proprietary solutions with good integrations, supporting Java, .NET, and Ruby.

Jenkins is still the future

Despite its age, we still see Jenkins as the tool of the future. It is open source and growing. Currently, it offers more than 1,000 plugins, integrating with almost all DevOps tools, from platforms to user interface to admin, source code and build management.

Jenkins may be slightly harder to use than proprietary options, but it is flexible and free. For those projects and teams looking for a one-stop shop approach, something like Bamboo may be worth a look. Proprietary tools come with pre-built functions, taking less time to configure.

We believe that the utility of Jenkins, its open source approach and long-standing market dominance means that it will remain the CI/CD tool shaping the future of DevOps. Regardless, CI/CD orchestration tools remain the backbone of DevOps. Integrating new capabilities, such as true observability platforms can massively impact the value that your whole CI/CD pipeline will create. However, the driver of that pipeline will remain a steady hand such as Jenkins.

Don’t forget culture and sharing

The tools we highlighted are shaping the future of DevOps. While tools underpin and facilitate the DevOps journey, they must be supported by culture. Technology is never a solution by itself. To be used effectively, you need cooperation from people. Workflows need to reflect technological capabilities and agile methodologies embraced.  

Using tools effectively also requires knowing how they interact. For example, true observability platforms remove the risk of releasing bad code by allowing rollbacks within production environments within milliseconds of a fault. This allows you to push the high-velocity automation of a tool like Jenkins to the limit. A tool like Kubernetes brings further automation and complements other counter tools like Docker.

If an enterprise focuses only on the more technical aspects — Automation, Lean, and Measurement—they will be in danger of ultimately missing the point and the incredible benefits of DevOps. DevOps is about aligning tools and culture. The future of DevOps and the CI/CD pipeline requires an investment in tools and people.

Download for free

Submit a Comment