Application Release Automation

Intro to Application Release Automation

Application release automation (ARA) provides automation and orchestration to package and deploy application code as it transitions from development through to production.

Businesses are being pushed to respond to market feedback and deliver new experiences to end users faster than ever. To remain competitive in these new market conditions, teams have turned to application release automation software to speed up delivery. By leveraging application release automation, organizations can easily handle fast software delivery and updates and decrease human error, missed steps and potential production issues.

ARA tools seek to bring visibility and speed to the slow and complex software release process. While there are many build automation, test, and deployment tools available, modern software delivery remains slow and difficult to track. This is because build automation, test, and deployment tools are loosely – if at all – integrated with each other. There are review and approval processes, as well as and sign-offs between steps. It is easy for teams to lose sight of the state of the overall application release in these handoffs. ARA is needed for teams looking to bring visibility into approvals processes while tying together different platforms and tech. By using application release automation software, teams can improve speed, quality, and delivery.

An exceptional application release automation solution will do more than just improve the delivery process. It should be a fundamental piece in ensuring continuous delivery by allowing teams to maintain audit records, manage deployment access rights and more.

The Automated Application Release Process

The graphic below illustrates a simplified process overview as application code goes from developers to source control and through the pipeline to deployment:

1. Application code is developed and entered into application release automation tool
2. Code is automatically checked into version control
3. Code is reviewed, tested, and approved
4. Code is packaged and prepared for deployment
5. Code is automatically deployed

In red is the corresponding change flow for database updates through schema migration.

This database change management workflow can also be automated with a solution like Liquibase. When the slow, manual process of database schema migration code review is automated within the CI/CD pipeline, it can happen as easily, accurately, and quickly as application deployments. The process generally flows as:

1. Database code is developed and checked into source/version control systems like Git, SVN, TFS, or similar
2. Jenkins (or other CI tool) calls Liquibase to validate database code against preset rules and policies, then produce an artifact stored in a repository like Nexus Sonatype or JFrog Artifactory
3. XL Deploy pulls the latest artifact and uses Liquibase to deploy to DEV using XL Release as the orchestrator
4. After XL Release validates the DEV deployment, XL Deploy uses Liquibase to deploy the artifact to QA
5. After XL Release Validates the QA deployment, XL Deploy uses Liquibase to deploy the artifact to Production

For a more in-depth look, check out How Liquibase Works.

How Can Application Release Automation Speed Up My DevOps Team?

DevOps teams need transparency and automation to deliver high-quality application code faster. Application release automation tools orchestrate the entire software lifecycle to provide all application team stakeholders with the transparency they need. Without an ARA tool, organizations can fall prey to optimizing individual segments of the software lifecycle and ultimately still fail to realize the velocity
and quality benefits of DevOps.

Additionally, by orchestrating the steps in each stage, ARA solutions foster greater collaboration between teams and necessitate a clear definition of the inputs and outputs of each stage of the software lifecycle. Effectively, ARA tools bring transparency to otherwise tribal processes and reshape the entire software release process. Teams can no longer keep a myopic perspective of their specific area – be it the build process, automated validation, or something else – but instead, start to think in terms of their contribution to the larger pipeline. By using ARA, DevOps can work alongside other teams with a collaborative and unifying tool to automate processes across the whole lifecycle and transform software delivery into a high-performing solution. ARA brings the much-needed structure and visibility required to accelerate release velocity.

Application Release Automation Tools and Vendors

There are many ARA vendors and tools available. Some popular tools include:

ARA Tool

• XL Deploy & XL Release
• Visual Studio Release Management
• Deployment Automation (formerly Serena Deployment Automation)
• CA Release Automation and Automic

Vendor

• digital.ai
• Microsoft
• Micro Focus
• CA Technologies

The Evolution of Application Release Automation

Quick. Draw the simplest diagram of your application architecture.

It probably like three blocks: one connected to another with lines. Those boxes represent the
presentation layer, application layer, and database layer. It probably looks similar to this:

When we started to think about Application Release Automation (ARA) we wanted to speed moving the compiled code to a server. As applications have become more complex and interdependent, the term ARA has expanded to comprise many other tasks. As our deployments have changed, so should our concept, idea, and definition of ARA. These new tasks include (virtual/cloud) server provisioning, automated testing post-release, network changes (putting servers in and out of load-balancer rotation), and database change.

Just like the rise of Agile led to the need for ARA (frequent releases begat frequent deployments), Application Release Automation tooling itself is now leading to the need for database change automation functionality. With the increased need for collaboration between Dev teams, Release Managers and DBAs, it has become more important that tooling in processes are able to provide transparency and ease communication for all. If all team members can easily work together, your release and deployment cycle becomes a seamless, efficient machine.

ARA Vendors are starting to get it, but are still woefully behind

Additions to automation release tools have benefited a large number of users in customer installs. Things such as server provisioning, rolling updates, and even the beginnings of canary deployments leveraging automated testing tools and more. But there is one area completely neglected: the database.

Of course, there is some messaging around database change management. IBM’s UrbanCode describes their Deploy tool as: “IBM UrbanCode Deploy orchestrates and automates the deployment of applications, middleware configurations and database changes into development, test, and production environments.” Inedo BuildMaster does the same. When performing a demonstration, every ARA vendor will say they manage database change. However, look around the room and note the number of DBAs. It will be zero. The DBAs are not part of the DevOps Inner Circle. No one will perform a demo to the DBA team. Moreover, no one pushes to production using ARA tools today. As one Liquibase Enterprise customer put it: “Using ARA to execute our SQL scripts helped us destroy the database much faster than if we had done it manually.”

Top 5 Reasons to Combine Database Release Automation with Application Release Automation

Software is reshaping industries, from healthcare to finance to retail and beyond. The pace of change is accelerating, and companies must master their applications to survive in the digital era. In the software economy, speed is the new standard.

To get a faster time-to-market, companies are adopting quicker, more iterative development methodologies. They have replaced age-old waterfall development methodologies with agile practices. From an infrastructure perspective, they have also invested in modern architectures and cloud technologies to achieve higher efficiencies. Some companies have even combined these 2 approaches by adopting DevOps — investing in new tools and processes such as infrastructure automation and continuous integration — to clock even faster speeds.

As companies have adopted application release automation (ARA) technologies to help increase software delivery rates, a new constraint has emerged: data. Data has long been the neglected discipline, the weakest link in the tool chain. In fact, most companies are still managing and deploying database changes manually, anchoring development teams. Many organizations attempt to support modern, agile development environments with decades-old database management processes. The result is like mounting a modern Ferrari on Model T tires. It’s a great way to get nowhere fast.

Integrating an automated database change management process into the quickly moving application pipeline extends DevOps to the database - and the rising tide of database deployment optimization lifts the entire SDLC to a higher standard.

The costs of ignoring the database release process accrue on many fronts. For your organization to survive, you must employ database automation. Let’s examine the impact upon four key areas.

1. Eliminate the Cost of Adding DBAs

Are you relying on DBAs for all release-related upgrades? Then you’ll need more DBAs as you increase the rate of application releases. If 10 DBAs can handle 100 changes per week, then you’ll need at least 20 DBAs to handle 200 changes per week.

And, as you hire more DBAs to keep up with the work, you’ll also have to hire more managerial people. You’ll have to devote more resources to support infrastructure. You’ll have to invest more in training. And you’ll have to account for the months/years of on-the-job experience that the 10 new DBAs will need to become as efficient as the original 10. The costs add up fast, especially compared to the substantially lower cost of scaling through automation. However, empowering database DevOps with change management automation can overcome a lot of the problems faced by DBAs and let them focus on more compelling, innovative projects.

2. Reduce Mistakes and Risk

No matter how large your staff of DBAs, you’re always just one human error away from a mistake. Every DB schema change review and deployment relies upon the skill, reliability, and dedication of a human.

The result is the inevitability of mistakes and less-than-machine-like reliability. The carryover can be an application that significantly underperforms or mis-performs, or that crashes altogether.

The human touch also increases the risks to data integrity and security. For example, grants embedded in stored procedures offer a huge opportunity for human error. Either that or malicious intent will happen to derail an application and expose its data. The true cost of manual database changes to the pipeline, team, and business must weigh the impacts of downtime, data loss, and degraded user experiences.

3. Improve Collaboration and Feedback Loops

Integrating database release automation with application release automation fosters a more collaborative environment between application developers, DBAs, DevOps managers, and other stakeholders across the organization. This synergy ensures that database changes are aligned with application updates, facilitating a smoother, more efficient development process.

Automated pipelines and database observability enable faster feedback loops, allowing teams to detect and rectify issues early in the development cycle. This immediate feedback is crucial for CI/CD pipelines, where quick iterations and adjustments are key to rapid development and deployment. By automating both application and database releases, organizations can significantly reduce bottlenecks, improve communication across teams, and accelerate the delivery of features and fixes to the market.

4. Improve Deployment Consistency and Reliability

Automating database releases along with application releases ensures consistency across all environments, from development to production. This consistency minimizes deployment failures caused by human error or environment discrepancies.

With automation, every deployment follows the exact same process, reducing the chances of surprises during production deployments. Furthermore, automated rollback capabilities in tools like Liquibase provide a safety net, allowing teams to quickly revert to a previous state if a deployment introduces issues. This level of consistency and reliability strengthens confidence in the deployment process, enabling organizations to deploy more frequently and with less risk, helping maintain a competitive edge and optimal working environment.

5. Boost productivity

The DBA logjam can perpetuate a backflow of delay that echoes throughout the development process. It’s quite common for both development and QA teams to spend time idle while waiting for database changes to be reviewed and deployed. Liquibase customers say that in the past, 5% to 10% of their developers’ time was spent waiting on schema changes. That’s obviously a terrible waste of productivity.

All of the above adds up to D-E-L-A-Y-S. Slowdowns in development, slowdowns in testing, and delayed releases. And applications simply can’t do what they’re meant to do — which boils down to either making money or saving money — until they’re released into production.

Whether an application is new, or it’s an upgrade of features and functionality to an existing application, it’s costly not to have that application in production.

It’s time to go faster

If you think application release cycles are shorting and starting to move at a quicker pace, you’re correct. But the pace of application release is nothing compared to what it could be when combined with database deployment automation.

Database deployment automation in conjunction with application release automation offers companies the ability to break the application release logjam created by manual database deployment processes.  In addition these combined solutions offer a great opportunity to improve productivity and performance, allowing development, test and DBA staff to focus on more important projects and initiatives while maintaining workloads at a sustainable level. Database deployment automation helps to eliminate otherwise unavoidable incidents of human error, while increasing data security and application performance and reliability. Put simply, database deployment automation helps speed the delivery of better performing applications into production more quickly, more safely and more reliably.

To learn more about the benefits of using database deployment automation and application release automation read our white paper, CI/CD for Databases: A Guide for Bringing Database Changes into your CI/CD Pipeline.