CI/CD: A CraneCloud Outlook.
You have probably heard about how organizations mostly tech companies are able to increase their ability to improve and deliver services and applications faster through DevOps automation. CI/CD is a key area of DevOps and is in fact considered the backbone of this process, so what is CI/CD?
CI is short for Continous Integration and CD in this case will mean Continous Deployment. CD in some cases stands for Continuous Delivery which is still part of the DevOps/SDLC but we will not talk about it here. SDLC stands for Systems/Software Development Life Cycle.
Continuous Integration, in brief, is a process where Developers merge changes(new functionalities/code) into the main branch as often as possible while Continuous Deployment means that the new code that has been merged through CI gets to pass some tests and is released into (production) the live application so that users can start making use of it.
The automation of the CI/CD process is what is called a CI/CD pipeline.
Allow me to use the above graphical image to share insight on the CI/CD process at Crane Cloud. Let’s start off by understanding the different squares in the image.
Developer: This is any member of the Sofware development team.
Version Control System(VCS): It is a key tool we use in keeping track of the different files for the project and enables us to work simultaneously as a team. At Crane Cloud we use Git but if you need to read more about VCSs see what Wikipedia says here.
CI(Circle CI): We make use of a Continous Integration and Continous Delivery platform called Circle CI which handles crucial parts of our CI/CD pipeline.
Staging: This is a workspace where the development team can work on anything without those changes affecting the live application that users are working with. Merges to the integration branch add new changes to this workspace.
Prod(Production): This is the live application workspace where everything therein is what users of our application interface and work with.
Our CI/CD pipeline has been configured to work conjointly work with all the tools we use and those tools are, Git, Github, Circle CI, Docker, GCR, and Kubernetes. Let us see how all these work together:
A developer on our team creates new functionality for our platform in a new Repository branch, to have it merged to our integration branch the developer raises a pull request.
Part of the configurations for the CI/CD pipeline requires that any pull request raised against the integration branch requires reviews and approvals of the new code by a set minimum number of members from the development team.
Once team members review and approve of the new code for a merge to the integration branch, our in-place configurations trigger an action on the CI server(the Circle CI platform)which runs a new build of the entire system and runs all integration and unit tests.
In case the build fails or the tests fail, we automatically know that the new code contains a bug that will or may break our staging environment so the team jumps in to fix the issue and re-run the build.
If the build is successful and the tests pass, the merge to our integration branch is successful and a new docker image is created and pushed to our Google Container Registry. When the image is updated all pod deployments are replaced. Then the developer’s functionalities will have been added to the staging environment.
At staging, the new functionality is tested rigorously to adequately make sure it is ready for use for our users, and then the process is repeated as we try to merge our integration branch to our main branch(Production environment) so our users can finally make use of it.
In brief merges to our integration branch update our Staging while merges to our main branch update our live application which we call releases and have versions. Since this process is automated we have configured Slack to notify the team at every step of the process.
That is a non-comprehensive outlook into Crane Cloud’s System Development Life Cycle where our intention of DevOps specifically CI/CD is to create better-quality software quickly and with more reliability.