Three common approaches to app modernization
We’ll explore the three most common patterns you’ll find along your app modernization journey
In previous posts one and two (and in our field guide to application modernization on IBM Power Systems™) we help you get started by exploring some steps you can take right now to modernize at your own pace. Becoming familiar with some common strategies can help you to minimize complexity along the way. So, let’s explore three common app modernization patterns and use cases to propel your modernization effort forward.
Case 1: Embrace containers and surround existing enterprise applications
Containers give you all sorts of technological benefits. You can isolate individual components, refactor and test them, redeploy and scale as needed without disrupting or updating the entire app. Plus, containers carry common sets of standards and security as they travel across your hybrid cloud. They’re lightweight, quick to start, and have consistent and portable app runtime. Now, developers can easily share these assets with each other, reducing the time to build.
To that end, containers give you an easier way to approach app modernization, which is to continue running existing traditional apps while you incrementally surround them with new and innovative cloud-native services.
For example, imagine that you’re a bank that wants to create a new mobile front-end interface or leverage cloud-based location services to find the nearest ATM using a banking app. Containers provide an approachable low-risk path that won’t disrupt your existing apps, yet also pave the way for innovation and skill development with new programming languages and development methodologies.
Case 2: Transition to containers
As your app modernization journey advances further and you grow comfortable with the technology, tools and practices involved, you can evaluate packaging apps inside containers, paving a path to more
portable applications across the cloud and more frequent software updates by leveraging DevOps practices.
Assuming your apps are based on portable technology (Java, for example), this is a fairly straightforward process. You usually do not have to make many changes to the app itself to reap the operational, management and monitoring benefits of containers paired with Red Hat OpenShift. For apps running native IBM AIX or IBM i technology (RPG or COBOL, for example), consider leaving them as-is and focusing on the “surround with containers” approach described previously. This provides a path to maximize innovation with new technologies while eliminating the large risk and expense of re-platforming.
Case 3: Rearchitect to cloud-native, microservices and API-first architecture
As described, the second step to application modernization is to transition your apps into containers. That does not necessarily mean those apps are truly cloud native. Each cloud-native application has a set of microservices representing each logical capability. Each microservice also has a well-defined API that sits on top of it to expose its capability. Because this approach typically requires changes to the application, it can take longer to complete than just moving your app into containers. With that in mind, taking an iterative approach to the process will keep things manageable.
Leveraging these approaches as part of your modernization journey will open doors to tremendous benefits. These include a quicker time to market, increased developer efficiency, app deployment flexibility, seamless integration with DevOps automation and access to the latest technology innovations.
For more guidance along your enterprise application modernization journey, check out our field guides.