Today’s users (or customers) have rapidly evolving needs, are mobile, and expect 24/7 connectivity and reliability. As software product developers and vendors, we need to release updates frequently to satiate our users’ needs or else we risk losing them to competitors or alternatives.
Our Response to Users’ Demands
What do we do to stay ahead? As software developers, we step up to the plate and:
- draw out product roadmaps with frequent releases
- organize around small teams and amp up agile practices
- automate where possible (tests, artifact creation, etc.)
- and deploy away … with our fingers crossed!
Speaking to the last bullet point, the unfortunate truth is that frequent change increases the likelihood of production errors and instability. Also, with frequent deployments often come some application downtime and disrupted users. Sounds like no fun.
How do we release updates frequently without disrupting user experience while ensuring release quality?
What’s stopping us from increasing release velocity?
Here are two blockers:
- Unsuitable release processes: Developers have a multitude of collaboration tools, Kanban boards, build tools and agile practices, and can build features quickly. But once it comes to releasing these changes through QA, staging and production, the process is more manual, ad hoc and slow.
- Mayhem and Production: Applications that flawlessly are known to fall short or fail in production. Productions face a unique set of problems that spawn from interacting with third party services, slow internet connections, regional ISP’s, firewalls and so on.
These two issues hold us back from delivering awesome updates frequently, while ensuring quality end user experience. So let’s start but addressing them in order to become DevOps mavens that deliver only the highest quality of software.
Releasing Great Software … Continuously
Now that we’ve broadly identified two blockers that stand between us and DevOps utopia, let’s address them one by one.
Streamline Release Processes
Developers enjoy streamlined processes with their collaboration and build tools to produce releases effectively.
However, the folks that release software through QA, staging and to end users do not share the same good fortune. Quite often, they get artifacts, scripts and resources from different members of the team, and run them in sequence in order to deploy and test the application. If one of the scripts happen to be erroneous or of the wrong version, the deployment will fail. This lack of coordination and automation greatly slows down the release process.
Here’s a plan for you.
Step 1: Collaborate Team-wide
The first step to addressing inconsistent release processes is to get everyone on the same page, acknowledge the problem, and collaborate to:
- Critiquing your processes. Look for dependencies and bottlenecks. Address them.
- Driving change. Communicate successes and celebrate them. Get others onboard.
Start with small opportunities that can bring big improvements.
Step 2: Automate
Once you have an optimized release process – not just in terms of tasks but also in terms of assembling and grouping release deliverables in a more consistent manner, look to automate repetitive and error-prone processes. Time and effort saved here can be put towards works on projects that innovate and add value to your users.
Depending on how far along your are on your project or product lifecycle, you can attempt to automate your optimized release process. Check out this report titled “Release Management for Enterprises” that discusses the issues and solutions to release management. It then goes on to building an automated release pipeline that can enable you to practice continuous delivery. What you will need is:
- a source code repository like Github
- a continuous integration tool like Jenkins or Bamboo to generate builds
- automated unit, integration and acceptance tests for these builds
- an artifact repository to store these builds
- LiveRebel to automate deployments – code, db and config – with zero downtime
The image above lays out what you can achieve when you safely automate your release pipeline with all the right checks and balances.
Now you’re ready to increase release velocity as needed, to the maximum.
Once Released, Monitor for Quality
By automating your release pipeline by addressing each of the steps in the release pipeline, you have already set yourself up for continuous delivery while ensuring that quality is not compromised.
However, no amount of preparation can ensure predicted results in production. Users tend to use software in the most unique ways that lead to undesirable outcomes. Network traffic, third party services and local ISPs or browsers can do just as much damage to user experience. The internet is rife with accounts of websites going down, causing brand damage and revenue. These outages are significantly noticeable and very public.
What About the Subtle Changes in Quality?
This is where the right tools – such as Stackify – can help identify prime violators that degrade application performance and behavior and diagnose them.
Look for Symptoms
Monitoring your application for performance and behavior, in production environments should be an ongoing activity. A keen insight into your application and infrastructure health can reveal snags that would otherwise go unnoticed. You really want to look for symptoms that compromise end user experience, such as:
- how are my servers and infrastructure performing at current capacity?
- how is one location faring compared to others?
- what parts of my application – internal or third party – impact performance?
Diagnose Issues and Make Decisions
Furthermore, you should be able to diagnose why these symptoms occur. Are they because of poor code, network conditions, server capacity or third party services? What do the logs and diagnostics say? What conclusions would you make based on the evidence?
The goal is to clearly understand the root cause of issues that impact your end user experience and make decisions on what can be optimized to ensure that the symptoms don’t occur again.
A Feedback Loop for Continuous Improvement
Especially in the case of continuous delivery, constant monitoring is a necessity. Identify symptoms with their diagnostics and action items should be taken into consideration for the next development iteration.
The goal is continuous improvement. To push farther to improve application quality and user experience with each release. This of course comes with the added benefit of catching issues early and holding parties accountable for services they provide.
Next Steps – Get Your Own!
That’s right. You can build your own automated release pipeline to practice continuous delivery safely and put a strong feedback loop in place to diagnose issues before your end users see them. Most of the tools required are either open source (Jenkins, Artifactory, Arquillian, Selenium), can be acquired for free (LiveRebel, GitHub).
Tools like Stackify are critical to make that production feedback loop quick. You need to know quickly when production problems arise and you need be able to troubleshoot them even faster. Sign up for a free trial of Stackify today
If you have any questions or comments, send me a tweet at @LiveRebel. Enjoy!
Guest Post by Krishnan Badrinarayanan
Krishnan is the product marketing manager for LiveRebel, ZeroTurnaround’s release automation tool that takes software to users quickly and safely. A Java geek turned product marketer, Krishnan is well versed with issues that plague IT teams and is passionate about applying technology to solve their challenges.
- What Is NullReferenceException? Object reference not set to an instance of an object - March 11, 2020
- C# Exception Handling Best Practices - March 4, 2020
- IIS Error Logs and Other Ways to Find ASP.Net Failed Requests - November 6, 2019
- List of .Net Profilers: 3 Different Types and Why You Need All of Them - October 30, 2019
- View SQL Queries From Your Code With Prefix - October 22, 2019