What is CI/CD? Continuous Integration and Continuous Delivery
Thomas Hamilton
⚡ Smart Summary
Continuous Integration is a software development practice where team members merge their work into a shared repository at least daily, and every commit triggers an automated build and test to catch integration errors early.
What is Continuous Integration (CI)?
Continuous Integration is a software development method where team members integrate their work at least once a day. Every integration is verified by an automated build that detects errors. The concept was introduced over two decades ago to avoid “integration hell,” which happens when integration is put off until the end of a project.
After a code commit, the software is built and tested immediately. In a large project with many developers, commits happen many times a day. With each commit, the code is built and tested; if the test passes, the build is checked for deployment; and if deployment succeeds, the code is pushed to production. This commit, build, test, and deploy cycle is continuous, which gives the practice its name.
What is Continuous Delivery (CD)?
Continuous Delivery is a software engineering method in which a team develops software in short cycles and ensures it can be released reliably at any time. The aim is to build, test, and release software with good speed and frequency, reducing the cost, time, and risk of delivering changes through frequent production updates.
Difference Between CI and CD
Continuous Integration is an approach of testing each change to the codebase automatically, whereas Continuous Delivery is an approach to obtain changes such as new features, configuration, and bug fixes into production safely and quickly.
Development Without CI vs. Development With CI
| Development without CI | Development with CI |
|---|---|
| Lots of bugs | Fewer bugs |
| Infrequent commits | Regular commits |
| Infrequent and slow releases | Regular working releases |
| Difficult integration | Easy and effective integration |
| Testing happens late | Testing happens early and often |
| Issues are harder to fix | Problems are found and fixed faster |
| Poor project visibility | Better project visibility |
Difference Between Compilation and Continuous Integration
While compilation only converts code into machine language, CI performs several broader activities:
- DB integration: Keeps the database and code in sync and automates creation of the database and test data.
- Code inspection: Ensures a healthy codebase, identifies problems early, and applies best practices.
- Automated deployment: Allows you to release the product anytime and keeps it in a continually demo-able state.
- Document generation: Keeps documentation current and produces build reports and metrics.
- Compilation: Converts high-level code into machine language and ensures it compiles on every target platform.
Ideally the build runs from the command line rather than depending on an IDE, happens continuously on a dedicated CI server (not a cron job), is triggered on every check-in, and provides immediate feedback with no developer effort.
What Do You Need to Conduct the CI Process?
- Version Control System (VCS): A reliable method to centralize and preserve changes made to your project over time.
- Virtual Machine: A spare server or at least one virtual machine to build your system.
- Hosted CI tool solutions: To avoid managing servers, hosted solutions maintain the whole process and offer easier scalability.
- Tools: If you choose a self-hosted variant, install a CI tool such as Jenkins, TeamCity, Bamboo, or GitLab.
How Does Continuous Integration Work?
An old example is Nokia, which once used a procedure called nightly build. After multiple commits from many developers during the day, the software was built every night. Because it was built only once a day, isolating, identifying, and fixing errors in a large codebase was painful.
Later the team adopted Continuous Integration. The software was built and tested as soon as a developer committed code, so any error was detected immediately and the responsible developer could fix the defect quickly.
Features of CI
- Allows you to maintain a single source repository.
- Lets you test a clone of the production environment, kept close to production.
- Provides constant availability of a current build.
- Makes the whole build, test, and deploy process visible to all stakeholders.
Why Use CI?
- Helps you build better-quality software and conduct repeatable testing.
- Scales the delivery output of engineering teams and lets developers work on features in parallel.
- Increases visibility and communication across the team.
- Provides immediate feedback when an issue appears and reduces risk by making deployment faster and more predictable.
- Avoids last-minute confusion at release time.
Best Practices of Using CI Systems
- Commit early and often, and never commit broken code.
- Fix build failures immediately and act on metrics.
- Build in every target environment and create artifacts from every build.
- Automate the build so it does not depend on an IDE.
- Build and test everything when it changes, including the database schema.
- Keep the build fast and use automated deployment.
Disadvantages of CI
- Initial setup time and training are required to get used to a CI server.
- Suitable test procedures must be developed, and a well-built test suite needs significant resources.
- Familiar processes must be converted, and additional servers and environments are required.
- Waiting times may occur when multiple developers want to integrate their code at the same time.
Tools for the CI Process
Jenkins
Jenkins is an open-source continuous integration tool written in Java. It facilitates real-time testing and reporting on isolated changes in a larger codebase and helps developers find and solve defects quickly while automating build testing.
Bamboo
Bamboo is a continuous integration build server that performs automated build, test, and release in one place. It works seamlessly with Jira and Bitbucket and supports many technologies such as Docker, Git, SVN, Mercurial, and AWS.
TeamCity
TeamCity is a continuous integration server with many powerful features. It keeps the CI server healthy and stable even when no builds are running and provides better code quality for any project.
