When it comes to learning about DevOps, you might frequently come across 3 terms that sounds pretty similar: Continuous Integration, Continuous Delivery, and Continuous Deployment. In fact, seeing the word continuous over and over again might make these three terms blur together a bit, making it trickier to differentiate the three.
Continuous Integration and Continuous Deployment, in particular, both cover a vast range of automated processes to create a successful DevOps cycle (Continuous Delivery, by contrast, usually plays a more brief role in an end-to-end cycle). While they both start with the same term, these two methods are distinctly different.
Continuous Integration and Continuous Deployment both play roles in a CI/CD pipeline, which serves as an assembly line to build applications with both efficiency and quality. CI stands for Continuous Integration, while CD can either stand for Continous Delivery or Continuous Deployment. As the name implies, a complete pipeline requires the CI component and one of the CDs. Continuous Delivery generally plays a role in less mature DevOps cycles that are still in beginning stages, while Continuous Deployment works well for companies who have been operating with a CI/CD pipeline for a while already.
Implementing an effective CI/CD pipeline into your development life cycle will result in the following improvements for your software development lifecycle:
Fewer bottlenecks: Automation is the name of the game for CI/CD pipelines. Because of this, it’s less likely for artifacts or builds to get stuck somewhere down the line because automation performs many of the tasks that would have caused issues in a manual handoff process.
Better team collaboration: Because of the smooth passoff systems between siloed teams such as development, security, and QA, a CI/CD pipeline really helps teams learn how to work together as a unit.
Happier team members: the CI/CD pipeline minimizes the amount of menial tasks that each team member must do, leading to happier people within your organization! Plus, the process of a CI/CD pipeline includes lots of testing across the entire SDLC. This shortens the feedback loop for developers, meaning that mistakes are small and easy to fix, rather than growing as the builds continue downstream and eventually cause a need for major fixes and backtracking towards the end of the process.
Continuous Integration and Continous Deployment are the two most substantial and far-reaching practices when building a CI/CD pipeline. Remember in the early 2010s when the App Store used to offer “lite” versions of apps, so people could try them out before they paid money to purchase them?
Continuous Delivery is really just Continuous Deployment Lite, as it performs the first part of what Continuous Deployment does, but drops off after the testing stage, while Continuous Deployment continues a few steps further than that.
All CI/CD processes aren’t as simple as downloading an app, and each requires investment and upkeep costs. But Continuous Delivery is a great starting point for teams who are building out a CI/CD pipeline but doesn’t automate the deployment to production like Continuous Deployment.
To best explain what it looks like for a developer to use CI, we’ll invent a fictitious character. Doug works as a software engineer on a large, moonlike ship, creating applications for a helmet-wearing manager dressed in black who’s *definitely* not copyrighted by a well-known media corporation.
With Continuous Integration in place, Doug receives assignments on which artifacts to build, coding them into existence, then commits them to a central repository. As soon as he commits the artifacts, automated tests run on these new snippets of code. These tests can perform tasks like checking for bugs, and ensuring that any open source components that he put into his artifact are being used correctly.
The new code gets put into the repository, where it’s checked against other developers’ work. Its functionality is tested, alongside other tests to make sure that he didn’t write the same code as his colleague. After his artifact has been vetted by automated testing, it’s packaged into a bigger build alongside other related artifacts, using automation.
The Continuous Integration stage ends after artifacts have been committed to the repository, tested, and packaged into builds.
Continuous Deployment (or Continuous Delivery) will take over right after the CI stage. Continuous Delivery focuses on delivering builds from the source code repository into the test environment. Continuous Deployment does this, then goes a step further by automating release and deployment to production.
If we look back at the build containing Doug’s artifact and how it reaches the Continuous Deployment stage, we’ll see that it automatically gets delivered into a test environment and tested as a complete project, rather than just the unit testing that was performed previously.
If it passes the tests, the new changes gets deployed out of the test environment and straight into production. Because of Continuous Deployment, the only human intervention throughout this whole process was when Doug wrote his code at the very beginning of the SDLC. Past that, everything was automated.
The most significant aspect of using Continuous Deployment is having Doug’s changes travel directly through the software development lifecycle all the way to production. Doug makes his manager happy with both efficient and quality updates to the applications.
Continuous Integration and Continuous Deployment are dependent on each other, as they rely on each other’s automated processes to push code through the SDLC correctly. Without Continuous Integration, CD doesn’t have a standardized source repository to pull builds.
A cycle without CI also means that smaller tests haven’t been performed before the build reaches the test environment, meaning that there will have to be a much heavier lift when it gets to that stage. This would force human intervention to come into play and defeat the whole purpose of Continuous Deployment.
Continuous Integration without Continous Deployment or Continous Delivery, on the other hand, means that after CI has neatly packed up artifacts into great builds with minimal bugs, they will have nowhere to go. Or they’ll just be stuck in the repository, waiting for someone with an already-busy schedule to remember to take them out and do something with them manually.
While Continuous Integration and Continuous Deployment are distinctly different practices, they’re both important, and both rely on each other to function correctly. By building out a CI/CD pipeline with these important methodologies, your team will be able to push out software faster than ever, all while building quality features and communicating better with each other.
Here at Launchable, we work with organizations to put great testing practices into every stage of the CI/CD pipeline. Testing forms the cornerstone of all good CI/CD practices. We’re helping teams launch fearlessly with predictive test selection and testing insights.