Jenkins is the way to reduce deployment costs and time
Video Streaming Android App for a Startup
Reducing human error and improving the software development lifecycle with Jenkins-based automation.
Background: Information technology reduces the human intervention in many of the tasks and reduces human errors, ultimately improving the lifecycle of software development by using an automated building, testing, and deploying approach. Before DevOps, there used to be a "blame game" between the dev and ops team for not releasing the specific feature in the production cycle. It frees the experienced developer for more productive and innovative work like spending more time on coding. You can utilize the talented and experienced developer on the creative product feature and it reduces the overall cost of hiring. IT reduces the overall time of deploying, launching or upgrading the infrastructure or the product. You just need to write the code and upload it. Then the whole automated lifecycle will carry on the tasks like building, testing, and deploying.
Goals: Automation server for automating many of the software development parts related to building, deploying, testing facilitating continuous integration and continuous delivery.
Solution & Results: Here are the steps to my solution:
- Code is built and tested locally using Nebula
- Changes are committed to a central git repository
- A Jenkins job executes Nebula, which builds, tests, and packages the application for deployment
- Builds are "baked" into Amazon Machine Images
- Spinnaker pipelines are used to deploy and promote the code change.
I like Jenkins because of its user-friendly command-line interface and because there are no external dependencies for implementing the basic features. These features truly make Jenkins rock and, for newbies like me, it's definitely a must-try.
There were so many key capabilities I relied on.
Continuous Integration/Continuous Delivery is commonly known as CI/CD. A developer writes the code and pushes the code to any of the DSCM (Distributed Source Control Management) tools like Git and Github. Then, further tasks like build, test, and deploy can be carried out using Jenkins. You can use triggers to track the changes in the Github repo and as soon as the code is pushed. It will build and test the code on the automated server architecture in any of the setups like Master-slave architecture. This is known as continuous integration and the code is deployed and a new feature is delivered without any human intervention. This is known as continuous delivery.
Let me tell you about the results now.
- Build: Nebula enables them to easily build the application automatically.
- Integrate: Once the code is built and tested locally using Nebula, it is ready to be pushed and for continuous integration and continuous deployment. The code is pushed to the central git repository and once the change is committed, a Jenkins job is triggered. It'll pull the code and continuous integration takes place.
- Bake: begins with the creation of AWS AMI or Amazon Machine Image and to generate AMIs, they created the "Bakery" that enables the AMI creation globally. When the Jenkin job is complete successfully, then Jenkins triggers the Spinnaker pipeline.
- Deploy: Once the bake is complete, Spinnaker makes the built AMI available for deployments to thousands of instances. Successful bake triggers the next stage of the Spinnaker pipeline and deploys to the test environment. Automated tests will be exercised and after these teams use customized deployment strategies like red/black, canary, or multi-region deployments.