Continuous delivery (CD) is the second phase in an automated software release pipeline, which follows continuous integration (CI). CI is the first phase where developers build, test, and merge code changes into the main software branch, while CD is about enabling code to be released for production in short cycles. Continuous delivery allows development teams to build, test, and deploy software rapidly via automation, APIs, and incremental updates—as opposed to spending a long time overhauling large portions of the product code.
The goal of CD is to make feedback loops as short as possible for constant improvements to software quality. Code is delivered on a regular basis to staging environments, where automated tests can confirm functionality and performance in production, speeding up software delivery cadence.
Continuous delivery aims to build automation into the entire software delivery process. As a core component of a DevOps strategy, CD creates a pipeline where developers can write and commit small pieces of distributable code to test environments for rapid and automated testing. Using automated tests to determine functionality, performance, and security, dev teams can quickly identify whether the pieces of code meet quality standards for release. This process enables developers to get software improvements in the hands of users in a safe, fast, and sustainable way.
As part of the CI/CD pipeline, developers can achieve continuous delivery by using APIs to automate development and test processes to ensure code is always in a deployable state. An important concept of CD is often referred to as a “shift left,” which means testing occurs early in the release cycle so developers can address fixes before moving on to other aspects of development.
Continuous delivery and continuous deployment are both an extension of continuous integration, but the difference between them lies in how updates are ultimately approved and sent to production.
In continuous delivery, code may flow automatically through testing processes and other steps to prepare it for production deployment, but it does require manual approval by operations to actually push that update live. In continuous deployment, production updates happen automatically without explicit, manual approval if code meets predetermined standards.
Continuous deployment is not a requirement of continuous delivery, but a further evolution of automated processes within the CI/CD pipeline.
While the benefits of continuous delivery are simple to understand, the implementation of CI/CD practices is not.
First, it requires a major mindset shift for software teams, who might be accustomed to more linear approaches to software development, such as the Waterfall method. The shift from older development methodologies to DevOps must be carefully planned, and organizations must provide resources, like training and seminars, in order to help teams shift their development mindset to be set up for success.
Maturing a DevOps practice for CD requires not only close collaboration between developers and operations teams, but also buy-in all the way to the top of leadership. Buy-in across the organization is the most important element for any big technological or process shift, but even more so for CI/CD since learning new work methodologies and transferring existing processes can be a time-consuming investment. From developers to system engineers, database administrators, CIOs and more—everyone who touches the CI/CD pipeline must be on the same page to enable a fast feedback loop.
Next, security and compliance in the world of continuous integration and continuous delivery can be frightening. But the automation capabilities of CD can be extended to security and compliant practices for consistency and repetition. Just like infrastructure as code, tools such as Terraform, Chef, and Puppet can deliver secured and compliant environments to developers without getting IT teams involved. Compliance tests can be run, so there are no deviations in the application before it reaches the deployment phase and privacy regulations are met.
Adopting CD practices might also align with a shift to a microservices-based architecture. Microservices are a software pattern where functional elements are decoupled and can be shipped independently of each other. It’s the antithesis of a monolithic architecture where components are deeply connected and every change impacts the overall codebase. Monolithic architecture and code don’t lend itself well to CD logic and processes; it will make executing a CD strategy much trickier for developers. Monolithic code from legacy apps might be too difficult to reconcile between multiple development teams to bring the promise of CD efficiency to bear
CD improves the software testing and release processes, so development teams can more efficiently ship software improvements at a faster pace. By shifting testing early in the process and working with bite-sized pieces of code, developers can replace components of larger applications without the worry of introducing new bugs or breaking the build or creating version control issues.
In comparison to other software development methodologies such as Waterfall, CD simplifies software deployment by ensuring code is always in a deployable state. Thus, eliminating the integration, testing, and hardening phases associated with large releases, and instead centering on continual updates and releasing code more often, in smaller increments.
Smaller releases reveal bugs in new code more quickly, and allows development teams to more easily isolate bugs since it had to occur within the last incremental update. Once the bug is identified, development teams can also more rapidly fix that issue, test the code again and redeploy it. Teams can also use feature flags to quickly disable individual functionalities—instead of the entire release—that aren’t yet ready or might cause an unexpected problem without using code. In addition, CD allows developers to work more collaboratively towards faster application iterations, since potentially thousands of developers can create code at different times without risk of breaking the build.
CD not only saves development time—giving developers the ability to work on new ideas, rather than patching old ones—it also allows for more consistent feedback from users. Customer input during the delivery lifecycle allows developers to quickly test ideas with users, so they can sort good ideas from bad ones before building out entire features. This means software teams can avoid creating features that don’t add value to the user experience—and by extension, the business.
As the software product or services evolves, CD processes can scale up or down to meet demand. This boils down to cost savings by eliminating fixed costs associated with bigger release processes. Instead CD makes it economic to work in small batches that are more scalable and sustainable.
Learn how Delphix enables DevOps teams to manage data with the same speed and agility as code with programmable data infrastructure.