Enabling DevOps Transformation in Enterprises

Integrating the work of your developers into a shared repository early and more frequently enables early detection of integration bugs that can be resolved faster. When small batch mergers are made a part of daily work, it enables frequent delivery of software. There are numerous version control tools that developers can use to commit frequent code changes to the main repository. The continuous integration server polls the version control system for code changes, retrieves the latest code, and builds it.

With continuous integration in place, automated testing is implied. Each code commit can be integrated with a build script and verified by automated tests. If testing is not automated, your team will continue to experience slow release cycles despite the increase in development velocity.

Unit tests, acceptance tests, integration tests, and even non-functional tests, such as performance and security testing, can be automated. Unit and acceptance tests can be set up to run in parallel. We may automate non-functional tests using tools like JMeter, NeoLoad, PenQ, and Browsera.

With some of the automated tests configured on the developer workstation itself, your developers will have even faster feedback on the quality of their work. For instance, Foodcritic can provide feedback to a Ruby developer on code structure and syntax while Sonarlint analyzes the Selenium tests written by the test automation engineer.

You just need to ensure the tests are reliable as false positives can create more problems than automated testing aims to solve. We often recommend clients to start small with a small suite of reliable automated tests and expand their coverage over time.

Just as you automate software builds, you should be able to automate the provisioning and operation of your environments (dev/test, staging, production). This can be achieved using modern provisioning and configuration management tools that allow you to programmatically set up environments and manage system configurations through code (Infrastructure as code).

For a consistent and reliable infrastructure that avoids configuration drift, you could choose the immutable infrastructure model where servers are never modified once deployed. Under such an approach, a new server with appropriate updates is provisioned to replace the existing one when change becomes necessary.

When infrastructure setup is written as code, you can use version control system and automated testing for environment provisioning and integrate it with the CI/CD pipeline used for application code. Tools, such as Foodcritic for Chef or puppet-lint for Puppet, can be used to analyze the code written to construct the environments. These and other security hardening checks can also be included in your automated test suite.

Organizations may choose to combine infrastructure as code with containers. It allows for decoupling infrastructure requirements from the application environment.

Containers bundle elements of the operating system (language runtimes, libraries, system files) with the application. Changes to these elements can be made without any changes to the host system so that specific development environments need not be set up every time. Containers also make it easy to clone environments and are lightweight compared to virtual machines.

Once you have continuous integration and test automation in place, we can build your deployment pipeline. Every change is a release candidate in this pipeline. Each code change runs a build that creates a package ready to be deployed. Automated tests (unit tests, static code analysis, acceptance tests) are run to provide fast feedback to your developers. Packages that pass these tests (often run in parallel) are made available for the next series of tests (exploratory testing) and finally for deployment to production. If a change causes the build to fail, we can configure the deployment pipeline to pull the Andon cord to alert all users and allow no new changes to be integrated until the error is resolved or the commit is rolled back to restore the green build state of the pipeline.

Your team can now push changes frequently, get fast feedback, and keep the codebase ready for confident deployments into production environment. With a mature continuous delivery setup, your codebase is ready to be deployed on demand and multiple times a day (green state). Thus, you are ready for frequent release of bug-free software.

Continuous deployment extends continuous delivery pipeline further to automate the actual deployment. At the last segment of the deployment pipeline, the codebase can be deployed automatically without human intervention. Such a system enables you to quickly roll out new features and gather user feedback.

With continuous integration, automated testing, and continuous deployment, DevOps methodology enables frequent code changes. This calls for comprehensive and real-time monitoring of your application code, environments, and orchestration technologies. Application performance monitoring tools such as New Relic can be used for continuous monitoring of applications in production environment. You can broaden the scope of continuous monitoring to staging, testing, and even development environments as your teams start to use production-like environments for dev and test.

Automated monitoring from the early stages of your DevOps pipeline will keep the pipeline flowing smoothly. While you monitor builds (track development milestones), automated tests, deployments, server health, and application logs, it is pivotal to gather this data at a central location to analyze and correlate. The derived metrics can be plotted as graphs or statistically analyzed to identify trends, detect anomalies, and generate alerts for outages.