As we head into 2021, we at DevOps.com wanted to highlight the most popular articles of the year. Here is the 16th episode in our Best of 2021 series.
Speed is one of the main principles of DevOps, and anything that maintains or improves speed benefits the process as a whole. However, there are still many speed bumps in the DevOps process that threaten to derail progress and slow DevOps to a crawl. One of the biggest speed bumps arises when converting legacy, monolithic applications into something more cloud-friendly – microservices.
It is clear that microservices are the future of applications developed for the cloud; search giant IDC expects that 90% Among all the new applications that will be deployed by 2022, microservice architectures will feature. IDC also notes that the primary benefits of microservices are improvements in developers’ ability to design, debug, and update, and leverage them into third-party code. Although DevOps tends to be about in-house code development, the benefits offered by the microservices architecture remain the same.
Microservices: Getting There
The transition towards a microservices architecture can be straightforward or complex, depending on the path the organization is taking and where it begins. For example, if the goal is to turn old applications into microservices, the process can be complicated and tedious. Converting legacy applications often means manually disassembling the legacy code and splitting it into independent code elements that act as microservices. This greatly complicates matters for a DevOps pipeline, where fast iteration of existing code is the rule rather than the exception.
However, there are tools coming to the market that can make the process easier. One of these tools is vFunction, which recently came out of stealth With the task of transforming monolithic Java applications into microservices.
vFunction has an interesting approach to this process. the vFunction platform Deployed locally, the vFunction Java virtual machine (JVM) agent scans legacy applications and collects data that is then collected on the vFunction server. From there, software engineers can further investigate the information collected about legacy applications, and begin designing the microservice architecture to update the code base. “Once developers are satisfied with the design, vFunction creates a service profile, which contains all the information required to build the microservice,” said vFunction CEO and Co-Function Co-founder Moti Rafalin. “This file is used by our automation engine, which scans the original code and copies the relevant artifacts to create the new service.”
Ravalin said vFunction takes advantage of supervised learning techniques, graph theory, and clustering algorithms to identify dead code and anomalies in the code that can prevent a clean crash, or “decomposition,” of a legacy application. Ultimately, vFunction has the potential to automate many of the manual steps DevOps engineers used to break monolithic applications into microservices. According to Ravalin, the vFunction function makes the process 15 times faster and can achieve 80% to 95% of automation. Currently, vFunction focuses only on Java, which it sees as the biggest opportunity today. However, the company has plans to support apps written in other languages in the future.
In addition to the newcomer vFunction, there are other ways to handle moving legacy Java applications to the cloud. One example is anthos, a managed application platform that extends Google cloud services to DevOps environments. Another is IBM Mono2Micro, which is a semi-automated AI-based toolkit to help restructure monolithic Java applications.
For those looking to build microservices-based apps from scratch, there are several tools out there. The most interesting are development environments that use Rapid Application Development (RAD) techniques and take advantage of low code models. There are dozens of RAD platforms available; Key examples WaveMaker And external systems And Agile Point.
In most cases, people who move legacy applications to the microservices model usually choose several tools, based on the particular use case. For some, it may be easier to rewrite older, smaller apps; For others, rebuilding may be the only way to get intellectual property in older applications. Either way, carefully selecting the right tools goes a long way toward maintaining speed in the DevOps realm. Maintaining this speed proves to be critical to building cloud-compatible applications on budget and on time.
“Unless one modernizes those monolithic applications to be cloud-native, they end up ordering very large machines and often end up paying more to the cloud providers,” said Ravalin. “Organizations now realize that if they want the true benefits of the cloud, they need to update these applications. This starts with embracing an architecture that includes microservices, APIs, and modern design principles.”
The lesson is to choose wisely, choosing toolkits that support scale as well as growth, and that can support the requirements of microservices.