Converting monolith applications to Micro services based applications

 Converting monolith applications to Micro services based applications

Legacy applications are difficult to maintain, challenging to add new features to, cumbersome and time consuming to test and, finally, risky and problematic to deploy. Simply put, the process is not as fast as a modern business requires. They lack engineering velocity and business agility. 

Organizations can truly utilize the full power of digital transformation when a majority of their legacy applications have migrated to cloud native architectures. Cloud has not only transformed the way data is stored and managed but it has also had a profound impact on the application development architecture and vice-versa. There is almost a symbiotic co- existence of cloud and microservices.

With the advent of microservices architecture, monolithic applications have seen gradual decline. This is not a singular phenomenon as efficiency in cloud demands distributed deployments and probably a move towards stateless applications in the future.

Research giant IDC predicts that 90% of all new apps deployed by 2022 will feature microservices architectures. IDC also notes the primary benefits of microservices are the improvements to developers’ ability to design, debug, update and leverage third-party code.

However, what should we do with the huge installed base of the critical monolithic applications? Could we transform the monolithic applications into micro services based applications? Yes, we can. However, it is easier said than done. We need tools to help us and the good news is that we have good tools already emerging that help us in this endeavor.

 Vfunction, Calinfonia based startup has created a system to transform monolithic Java applications into microservices, using what it claims is a scalable, repeatable factory model. It combines dynamic and static code analysis, data science, and automation to transform Java applications to cloud-native architecture.

How does it work?

vFunction says that the platform can automatically assess the modernization complexity of all legacy Java apps – measuring across multiple dimensions including dependencies, number of identified microservices, and volume of Java resources and classes.

The process- Analyze and Breakdown the monoliths and then Automate micro service formation

VFunction works on-premises and the VFunction server is installed locally. An on-premises vFunction Java virtual machine (JVM) agent installed on the application server performs a dynamic analysis on the running legacy application. vFunction also performs a static analysis on the application binary and, combining both, identifies individual services. The data gathered is collected on the vFunction server.

From there, software architects can further examine the collected information about the legacy applications, and start designing a microservices architecture to modernize the codebase. After vFunction generates a service specification file, which contains all the information required to create the microservice. That file is used by our automation engine, which scans the original code and copies the relevant artifacts to create the new service.

vFunction leverages supervised learning techniques, graph theory and clustering algorithms to identify dead code and code anomalies that could prevent a clean breakdown, or “decomposition,” of the legacy application. Ultimately, vFunction has the potential to automate many of the manual steps that DevOps engineers used to perform to break monolithic applications into microservices.

vFunction then automates the creation of the individual microservices, copying the necessary source code and automating their creation. It puts everything into a directory, which can then be uploaded separately to a repository. As for the deployment of the code, vFunction is agnostic, and the microservices can be deployed on any Kubernetes or cloud native platform.

vFunction dashboards provide an executive summary of the progress of all applications being refactored, throughout the full end-to-end process. With a modernization factory you can kick off multiple assessments, drill into each application, view service creation progress, and track microservices creation results.

Expected Outcome

vFunction provides an automated, self-service modernization factory that can be applied across all your Java applications. Application cycle times accelerate, deployments become more frequent, licensing costs decrease, and development teams can tap into the most modern tools, devops patterns, CI/CD pipelines, and corporate architectural standards.

According to Rafalin, Founder and CEO of vFunction, the platform makes the process as much as 15 times faster and can achieve somewhere between 80% to 95% automation.

Scope of market for the vfunction platform

Currently, vFunction is focused solely on Java, which it deems the biggest opportunity today. However, the company has plans to support applications written in other languages in the future.

There are more than 21 billion Java virtual machines today running predominantly monolithic applications. Many could take advantage of cloud native architectures, but rebuilding them for this new environment would be complex, time-consuming, and could require taking employees from other, more value-adding tasks.

“The market opportunity is enormous on the Java side,” said Rafalin. “It’s basically the backbone of most enterprises, so there’s plenty to do there, but the algorithms and our technology works at a very fundamental level. It is definitely transferable to other languages.”

Source: vFunction website, IBM