Checklist to Get Legacy Applications Ready for the CloudJune 13, 2018
When you’re moving applications to the cloud, it can be tempting to take the fastest route and merely rehost the application as is. Maybe you’re under a tight timeline and don’t have the bandwidth to update applications as you migrate. Or you’re getting resistance from users around tweaking an application that already works well.
The thing is, legacy applications that run well from an onsite data-center don’t always run as well in the cloud. That’s because they’re designed in ways that will cause them to slow down or even fail more in the cloud. They might have integration points or database calls that could bog things down. Or they might even be written in a language your cloud provider doesn’t natively support.
“For existing applications to take advantage of the promises of cloud computing, you need to take a systematic approach to assessing their architecture and identifying what needs to change.” – Gartner 2017
To really benefit from the key reasons to move to the cloud—like agility, scalability, resilience, and cost—it’s not enough to merely move the applications. You need to refresh them, too. Try to get each application as close as possible to cloud-native functionality. This means your applications should:
- Use a dynamic, shared, and virtual infrastructure
- Offer services in an on-demand, self-service model
- Scale rapidly and elastically
- Meter consumption
- Stay available across common networks
For each application, you should:
- Do an inventory of what functionality needs to change
- Scope out how much it needs to change
- Estimate how much time, effort, cost, and resources it will take
Here’s a quick checklist of things to look for across five key areas.
1. Assess the application architecture
The first step is to look at how the overall application is designed. To run in the cloud, applications need to run differently, too. They need to work in an environment with ephemeral systems, lack of dedicated storage, and horizontal rather than vertical scalability.
To figure out if your architecture is ready for the cloud, here are some things to look for:
- Languages or runtimes your cloud provider doesn’t support
- Direct code-to-runtime relationships that won’t translate to the cloud
- Improper state management where you rely on complex server clusters for replication
- Monolithic design and deployment, which won’t support the agility you need for the cloud
- Single points of failure where the entire application will fail if a single component fails
- Bottlenecks where requests are routed through a single component that might experience latency
2. Look for gotchas in your application code
Things to look for:
- Hardcoded values deep in your source code, which can range from IP addresses to usernames
- Memory locks where you try to control the order of requests, as these will often fail in the cloud when the same code is running across many machines
- Blocking calls, which can cause applications to hang or gradually slow down over time
- Siloed logging where you’re not writing log files to a useful place or aggregating them
- Nonrestartable components that won’t respond gracefully if the cloud provider reboots its systems
3. Find where the application integrates with others
Your applications likely talk to many other applications, businesses, data sources, services, third parties, feeds, back-end systems, and legacy systems. When you move applications to the cloud, these integration points are often what cause the application to run more slowly or even fail. So before you move the application, you should optimize these various touch points.
Things to look for:
- Chatty interactions that need excessive round trips to do a single task
- Network calls to any external applications
- Complex call graphs, which are where a service delivers a message to many consumers, who in turn pass the message on to more consumers
- Third-party libraries and APIs, which can be black boxes you don’t have control over
4. Look at the data persistence
Most legacy applications rely on databases that are super consistent and reliable. But this might not always be the case in the fluid environment of the cloud. That’s why legacy database calls often become a bottleneck for applications in the cloud.
To mitigate, you should look for these types of things:
- Multiphase commits, where you affect multiple servers at once
- Monolithic databases that try to solve every problem the application might face
- Use of select statements and wildcards in SQL statements, which can bring back more data than you need and hog resources
- Developer-crafted SQL statements, which can be unpredictable and not optimized for your databases
5. Make it easier to update the application
Last up, you should look for ways to simplify your entire process to develop, test, manage, monitor, and troubleshoot the application. The goal is to reduce the time it takes for you deploy new code to the cloud.
Some common issues to look for here:
- Manual configuration updates
- Manual builds and deployments
- Inability to be containerized
- Inability to roll back releases
- Lack of failure injection testing
How Binary Tree can help
To get their applications to the cloud faster, many organizations choose to partner with a migration expert. We at Binary Tree are experts at modernizing Domino applications to the Microsoft cloud. Specifically, we can help you:
- Assess your software and systems and get them ready to migrate
- Take care of the migration for you—or train you how to do it yourself
- Be on hand to fix any issues that come up during the migration
- Drive user adoption through training and onboarding
- Train your IT team to manage email and applications in the cloud
We’d be happy to talk more with you about what you need and how we can help! To get started, get in touch.
Source: Gartner. How to Assess Your Application to Adopt Cloud-Native Architecture. October 2017