Continuous Automation, from Source Code to Production
Automation is necessary to achieve the benefits of DevOps principles, so teams may use automation at every step of software development.
This involves the following stages:
- Developers commit code changes to a central repository
- Code is built into usable software and unit tests run
- Software is deployed in a staging environment and different tests gauge its production readiness
- Software is deployed to production
Let’s explore the roles of automation in software development and deployment.
Continuous Integration
Stages 1 and 2 involve committing code changes and compiling the code. The source code for software is typically developed by multiple developers each making multiple code changes and committing code changes to a central repository such as GitHub simultaneously.
One developer may download code from the central repo and start making changes, and soon after a few other developers may download code and start making their changes, then commit the code back to the repo. Without coordination among the developers, the code and changes could become completely out of sync. Some code changes may not get submitted for an extended duration, while other developers may have changed the code in a different direction.
Designating certain developers to manage sections of the code could fix some issues, but if all developers do not submit their code changes regularly, the code repo as a whole cannot be built into software that can be made available for use. This is the whole basis of continuous integration.
Continuous integration has two aspects to it:
- Developers commit their code changes regularly and frequently
- The build process is automated with some tool
Continuous integration has several benefits. Frequent code integration and testing helps find bugs quicker and earlier, software updates are delivered faster, and automation of the code build process results in improved productivity.
Continuous Delivery
Continuous delivery encompasses code integration and refers to the process of automatically making built software ready for deployment to production.
Continuous delivery depends on continuous integration. It involves deploying built code to a staging or test environment and running tests for production readiness, such as integration tests, load tests, GUI testing, and API tests.
After tests have been run in the staging environment, software has to be approved and deployed to production by a user. The deployment to production is not automated, as noted in figure 3.
Continuous delivery adds automation of the software release process.
Continuous Deployment
Continuous delivery only takes built and tested software up to production readiness using automation. A user then has to approve the software and deploy to production.
Continuous deployment, on the other hand, automates the deployment to production also. No user intervention is needed after code has been submitted to a repository.
By having automatic deployments, you can focus on improving your tests rather than having to stop processes to coordinate a release.
If you want to gain the benefits of DevOps principles, start with continuous integration and continuous delivery. Once you start releasing software on a daily basis, you can look into continuous deployment.
