Intelligent Software Deployment: Leveraging Metrics and Feedback to Deliver Customer Value
Dec 30, 2022 by Adam Frank
As enterprises continue their journey from DevOps and GitOps to AIOps, they increasingly use additional telemetry, analytics, and machine learning. This progress towards efficient and intelligent delivery of software requires better observability and actionable feedback in two areas: (1) within CI/CD pipelines, and (2) during and after deployment.
The actionable feedback provided by the Armory platform creates a virtuous cycle that allows you to:
- Build quality into your software.
- Increase throughput of pipelines and stability of releases.
- Reduce the risks and ongoing costs of software delivery.
- Innovate, learn, and adapt rapidly.
- Improve the precision of software delivery and the accuracy of actionable feedback.
Observability and Actionable Feedback Within CI/CD Pipelines
According to Jez Humble, “relentlessly pursuing continuous improvement” is one of the core principles of continuous delivery. To improve continuous software delivery, developers must observe CI/CD pipelines in action and understand how their software is performing as it moves from development to production.
The Armory platform filters, sorts and displays the CI and CD monitoring and metrics embedded in the feedback loops illustrated in Figure 2. Although all applications and services are different, modern software delivery encourages organizations to focus their continuous improvement efforts on the four DORA metrics:
- Deployment frequency (of committed code to production).
- Change failure rate (percentage of deployments to production).
- Lead time for changes (time between when code is committed and released).
- Time to restore service (after an incident).
Manual steps like reviews or change approvals slow CI/CD pipelines, resulting in a negative impact on the first and third DORA metrics. Automation, guided by observability and actionable feedback, helps developers improve outcomes that have a positive impact on all of these metrics. In other words, reviews and approvals in modern software delivery are automated whenever possible, making manual judgments by people the exception rather than the rule.
The Armory platform exports APIs so that developers can integrate their favorite tools into automated CI/CD pipelines. The platform also has built-in support for many continuous integration tools, including Jenkins, Docker Hub, Travis CI and Circle CI. Providing such flexibility in constructing CI tool chains enables developers to make metrics- and data-driven decisions in their effort to improve how they release software. Metrics and alerts are visible through Armory’s software delivery dashboard and can also be communicated via email, Slack, MS Teams and SMS (e.g., via Twilio).
Observability and Actionable Feedback During and After Software Deployment
The trend away from monolithic applications toward microservices has made modern software delivery more important. Microservices have many advantages, including improved code reuse and scalability, increased reliability and support for incremental and more frequent releases.
With Armory Enterprise, you can provision, configure and manage software deployment based on microservices that are distributed among server groups hosted in different zones, regions and by different cloud providers (or on premises).
Because services provided by microservices are smaller, service discovery, connection and composition must all be choreographed to provide the highest quality customer experience while enforcing security & privacy policy, and managing the cost of running these services.
The Armory platform helps manage the complexity of releasing microservices-based software in a way that is reliable, repeatable, consistent and secure. In other words, interconnected CI/CD pipelines are the highways, complete with guardrails, that transport the application and infrastructure software, all written and committed “as code,” from developer teams to production.
Consider the continuous software delivery pipeline shown in Figure 4. Execution of this pipeline is triggered by specific events like the successful completion of a Jenkins CI job, a GitHub Action or a webhook. This pipeline performs a canary deployment to the staging environment at the first split in Figure 4. Testing this release candidate is performed with a mix of smoke test and live workloads for 30 minutes at most. Results of testing the canary are compared against criteria for a small set of KPIs, which may include:
- Application availability.
- Application performance.
- Error rates.
- Service levels.
- Customer ticket rate.
- If the canary deployment tests fail, the blue-green deployment is abandoned and the canary release is rolled back.
- If the canary deployment tests pass, the release is deployed to production, test coverage is increased and more rigorous testing occurs in production for the next two hours.
- If these tests fail, the deployment is considered a failure and is rolled back. If the tests in production pass, the deployment is a success. The old PROD servers are destroyed as software running on new PROD servers are created.
With Armory, you can observe almost anything that you want before and after software deployment, from the frequency of pipeline deployments to potential causes of latency while deploying to a particular cloud. Armory Enterprise provides an observability plugin API so that you can integrate your favorite metrics and alert management tools into an Armory-enabled deployment pipeline.
The Armory platform supports Prometheus, New Relic and any tool that uses the Micrometer instrumentation library. Telemetry and analytics provide high-level feedback to developers about what might have gone wrong with their software during a failed deployment. However, sometimes actionable feedback requires additional analysis of logs and traces with the help of third-party APM tools, like Datadog or Splunk.
Learn more about Armory’s continuous deployment solutions.
