Originally written by Cristiano Caetano, Adaptavist
What are DevOps principles, and why should you care?
In this post, we’ll share how, by adopting key DevOps principles, you will benefit from a quick feedback loop by determining – quickly – whether the software is ready to progress through the delivery pipeline at any given time in an automated fashion.
What are DevOps principles, and why should you care?
DevOps principles are the backbone of the modern DevOps approaches and enable teams to release early, often and continuously. It takes advantage of automation as a core piece of the software delivery pipeline to help teams to minimize the friction points that are inherent in the integration, testing and deployment processes as well as streamline the entire DevOps pipeline.
With such a high rate of adoption, DevOps and all that it encompasses has become a hot topic in today’s world of tech. What started out as a set of practices which deliver continuous integration into production by combining developers and operations has evolved differently within each organization. DevOps unifies people, processes and technology to bring better products to customers faster. It is a set of practices that automates the processes between software development and IT teams so they can build, test, and release software at scale. The adoption of DevOps mindset, practices and tools optimize the collaboration and communication between development and operations allowing companies to streamline their product release cycles.
Ultimately, DevOps enables teams to sustainably reduces costs, accelerates release cycles and increases customer satisfaction. The cornerstone DevOps principles include:
- Continuous Integration (CI): Integrating code into the main repository frequently.
- Continuous Deployment (CD): Automatically deploying changes and fixes into staging or production environments.
- Continuous Testing (CT): Testing the product continuously, preferably in an automated fashion.
From a quality perspective, having automated tests that run each time code is deployed increases the chance of catching bugs before they are pushed to production, leading to a more reliable product. It also frees up time for the QA/testers to focus efforts elsewhere and removes the chance of a bottleneck forming towards the end of the development cycle. Effectively analyzing metrics from testing is a great way to highlight issues across the board, whether this is a problem in the process, a particular bug blocking development or inadequate test coverage. Not only does the team benefit from improvements made based on this, but the customer receives a more robust, complete product.
Continuous integration (CI) & Continuous Delivery (CD)
Continuous Integration (CI) is a DevOps practice in which you build and test software every time a developer pushes code to the application. Committing code triggers an automated build system to grab the latest code from a repository and to build, test, and validate the full master branch. This process is done several times each day, and the primary purpose is to enable early detection of merge conflicts and integration bugs. This continual merging mindset prevents a developer’s local copy of a software project from drifting too far afield as new code is added by others, avoiding catastrophic merge conflicts. In addition to that, with consistency in the integration process in place, teams are more likely to commit code changes more frequently, which leads to better collaboration and software quality. The aim of continuous integration is to minimize the friction points that are inherent in the merge-build-test processes.
Continuous Delivery (CD) expands upon continuous integration by building and packaging software in such a way that it can be released to production automatically at any time. In such a process, there is no need for a person to decide when and what goes into production (there is no large batching in staging nor a long UAT process before production). It automatically orchestrates software deployment all the way to the customer on each and every change. Continuous Delivery allows releases to happen more frequently, getting smaller more incremental changes live quickly rather than holding up a ton of changes for big-bang releases. Continuous delivery helps teams deliver updates to customers quickly in a sustainable way through a standardized and streamlined process.
Atlassian Bamboo is a continuous integration and delivery server (CI/CD) that can be used to automate the release management for a software application, creating a continuous delivery pipeline. Bamboo assists software development teams by providing: automated building and testing of software source-code status; updates on successful and failed builds and reporting tools for statistical analysis. It runs the build, unit tests, integration tests, and deployment whenever code is committed to the repository, to ensure that new changes integrate well into the existing codebase. By doing so, teams can release quality products frequently and predictably from source code repository to production in an automated fashion.
Image source: Atlassian
Continuous testing (CT)
Continuous integration and delivery require Continuous Testing (CT) because the ultimate objective is to deliver high-quality software to users. Continuous testing is often implemented as a set of automated tests that are executed in the CI/CD pipeline. Traditionally, testing would come towards the end of the development process and often cause a bottleneck for the team, delaying deployment. DevOps puts an emphasis on testing throughout the entire development process, with an aim to avoid this issue and increase the reliability of the product. Continuous testing provides a safety net to prevent the introduction of new code from causing unexpected behaviors, regressions, and defects. With more frequent testing, your team can discover and address bugs earlier before they grow into larger problems later. In addition to that, continuous testing enables a quick feedback loop which will help you determine whether the software is ready to progress through the delivery pipeline at any given time in an automated fashion.
Test automation plays an important role because it unlocks continuous testing throughout the software development lifecycle reducing the feedback loop and costs associated with manual testing. There are many tools available for DevOps practitioners using Jira that can be invaluable additions to the technology stack. Jira supports a collaborative environment with the Atlassian tool stack, 3rd party tools and its ecosystem throughout all DevOps principles. This is true for continuous testing as well. Tools like Selenium, Robot Framework and Cucumber are open-source options that help with automated functional testing and Test Management for Jira (TM4J) acts as the single source of truth inside Jira for developers and testers across the DevOps workflow. TM4J supports behavior-driven development (BDD) with Cucumber or your chosen Gherkin compatible tool for writing acceptance tests right inside Jira so teams can avoid ambiguity, ensure that all user stories are completed and all scenarios are taken into account (image below):
(Image caption: Creating BDD-Gherkin test cases)
With TM4J extensive REST API, which comes for free, you can publish automated test execution results to TM4J from any test automation tool. It supports out-of-the-box integration with Jenkins and Bamboo or your chosen CI/CD compatible tool to eradicate bottlenecks by performing the rights tests at the right stages of each DevOps phase. The API is HTTP-based and can be used from any test automation framework, programming language, or tool, including Cucumber, Selenium, JUnit, Nunit, Robot, Behave, Calabash and more (image below):
Want to give TM4J a try?
See for yourself how TM4J – Test Management for Jira can improve your DevOps processes with a free 30 day trial on the Atlassian Marketplace: