Of the three major cloud service providers, Google Cloud Platform (GCP) lags behind Amazon Web Services (AWS) and Microsoft Azure in terms of market share. But GCP is charging hard—its current 10% market share represents a 2% gain in just a couple of years. One reason for that momentum is that GCP offers a wide range of developer-friendly tools and fully managed services that make application modernization much easier than it otherwise would be.
That’s critically important for companies trying to keep ahead of their competition. With legacy applications currently being used for 75 to 80% of enterprise workloads, it’s no wonder that application modernization is a high priority for many organizations.
The Problem with Monoliths in the Cloud
The problem is that the traditional monolithic applications many companies depend on for some of their most business-critical processing are usually ill-suited to participate in the cloud ecosystem where so much of today’s technological innovation occurs. GCP provides a suite of services designed to remove most infrastructure management tasks from the shoulders of developers, allowing them to focus on cloud-enabling their legacy software without worrying about setting up and maintaining the cloud environment in which those apps run.
That’s why it’s important for companies to be aware of the modernization services GCP offers, such as those related to container management, Kubernetes, databases, APIs, and security management. Companies should closely examine these tools to understand how each can be applied to modernizing legacy apps.
But before focusing on the tools, we need to understand what legacy application modernization aims to achieve.
From Monoliths to Microservices
Most legacy apps were designed as stand-alone programs, with few facilities for interoperating with other applications. Yet an ability to interoperate is indispensable for integration into the cloud ecosystem.
Even more problematic is the fact that most legacy applications are structured as monoliths, meaning that the codebase is essentially a single unit that has function implementations and dependencies interwoven throughout.
Monolithic apps are extremely difficult to update with new or upgraded features to meet rapidly evolving marketplace requirements—a change to any part of the design has the potential to ripple throughout the codebase in unexpected ways, potentially causing the entire application to fail.
That’s why the focus of application modernization is to restructure monolithic codebases into a cloud-native, microservices architecture. Microservices are small units of code that perform a single task and operate autonomously. They can be deployed and updated independently of one another, allowing individual functions to be quickly and easily updated without impacting other portions of the application. Restructuring a legacy app into microservices makes upgrading it far easier.
Modernization vs Migration
A trap that companies often fall into is thinking that by simply migrating a legacy app from the data center to the cloud, they’ve accomplished a significant degree of modernization. However, that approach, often called a “lift and shift” operation, delivers far less than it promises. The problem is that while moving an app to the cloud as-is (rehosting) or with minimal alterations (replatforming) may allow it to take advantage of some cloud benefits, the app itself remains essentially unchanged—if it was monolithic before being migrated, it’s still monolithic afterward, with all the disadvantages of that architecture.
For that reason, the first step of true modernization is normally to refactor the app into microservices. Once that’s done, further upgrades become far easier to make.
Related: Four Advantages of Refactoring That Java Architects Love
The Google Cloud Hosting Platform
A distinguishing feature of the Google Cloud is that it is designed as an environment in which refactoring applications from monoliths to microservices is natural and easy. For example, Scott Carey, a Managing Editor at Computerworld, notes that,
“Google also often stands out for its deep expertise around open source technologies, especially containers, thanks to its central role in the development of Kubernetes for orchestration and the Istio service mesh, which are quickly becoming industry standard technologies.”
As we’ll see, both Kubernetes, which was originally developed by Google, and service mesh are seminal technologies for creating and deploying microservices. Many of the services available to developers in the Google Cloud fit that mold. Let’s take a look.
Google Compute Engine (GCE)
Google Compute Engine is an IaaS compute service that lets you create and run virtual machines on the GCP platform. That makes it a natural destination for migrating applications from data center servers to the cloud. There’s even a specialized platform, called Migrate for Compute Engine, that’s designed specifically for that purpose.
Google Container Registry (GCR)
According to Danish Suhail, Google Cloud Engineer at Royal Cyber,
“Containerization is the crucial process for effectively developing the microservices approach.”
Google Container Registry is a service for storing, managing, and sharing container images. A container image includes the operating system and all the files, libraries, dependencies, settings, and code needed for an application to run. GCR, which essentially acts as a source code control system for container images, allows developers to more easily manage a large portfolio of containerized microservices.
Google Kubernetes Engine (GKE)
Google Kubernetes Engine is the GCP Kubernetes management and orchestration service. Kubernetes is the premier open-source system for deploying, managing, and scaling containerized applications, and is particularly important in creating and deploying microservices. As Ankit Kumar, Marketing Manager for SPEC INDIA notes,
“Kubernetes works natively with microservices, and is a good way to deploy basic, and even more complex microservices architectures without too much of a hassle.”
GKE, which reduces the complexity of managing Kubernetes clusters, has been described as a “managed, hosted staging environment for implementing microservices.”
Related: Start Your App Modernization Journey with Kubernetes for Legacy Java Applications
Cloud Run
Cloud Run is a serverless, managed compute platform that lets you run stateless containers directly on top of Google’s infrastructure. It’s especially useful for running already built applications in the cloud. Cloud Run allows you to deploy microservices (as well as full-featured applications) without worrying about provisioning resources or managing infrastructure.
Cloud Functions
Cloud Functions allows you to run your code in the cloud without having to manage servers or containers. Google describes it as “a scalable, pay-as-you-go functions as a service (FaaS) product to help you build and connect event driven services with simple, single purpose code.” Cloud Functions allows you to surface your microservices via HTTP APIs.
Cloud Spanner / AlloyDB for PostgreSQL
Cloud Spanner is a fully managed relational database service intended for use with mission-critical applications. It provides both transactional consistency and automatic, synchronous replication to ensure high availability, even though these traits were previously considered to be incompatible with one another. Cloud Spanner exhibits both SQL and NoSQL traits and is offered as an alternative to other relational databases such as IBM DB2, Oracle, MySQL, and PostgreSQL.
AlloyDB for PostgreSQL is a fully managed PostgreSQL-compatible database-as-a-service (DBaaS) offering that provides superior performance, availability, and scale. It automatically handles administrative functions such as patching, replication, backups, and capacity management. AlloyDB, which has been described as “a PostgreSQL service on steroids,” handles transactional workloads more than 4X faster than standard PostgreSQL and is up to 100X faster for analytical queries.
Database Migration Service (DMS)
Database Migration Service is designed to be the simplest and quickest way to migrate databases to the Google Cloud. In fact, with its highly intuitive user interface, customers may not even need documentation. DMS supports the migration of MySQL, PostgreSQL, and SQL Server databases to Cloud SQL.
Anthos (Anthos Configuration Manager, Anthos Service Mesh)
Anthos is an application management platform that “enables you to manage GKE clusters and workloads running on virtual machines across environments.”
Anthos Config Management allows users to define and enforce uniform configuration, usage, and security policies across Kubernetes clusters or on GKE, without having expert Kubernetes skills. With it, you can create a common configuration across your entire infrastructure, whether on premises or in the cloud.
Anthos Service Mesh is designed to simplify microservices management. When monolithic apps are refactored into a large number of microservices, managing the API interactions between those microservices can become quite complex. Anthos Service Mesh enables tracing, monitoring, and logging of your microservices, and allows you to control traffic flows and API calls between services.
Google Cloud Build
Google Cloud Build is a managed service that can import source code from repositories such as GitHub or Bitbucket, and automatically build, test, and deploy containers on GCP.
Google API Management (Apigee)
Apigee manages the lifecycle of the APIs your microservices (and applications) use to communicate with one another. Makers of APIs must manage them carefully in terms of documentation, availability, compatibility, and security. Apigee allows you to securely design, publish, and monitor your APIs. As Google puts it,
Apigee “gives you precise control over what portions of your legacy systems you expose and how you expose them. It also lets you seamlessly refactor the implementation of an API (that is, moving from a legacy service to a microservice) without impacting the consumers of the API.”
How vFunction Helps You Modernize Your Monolithic Apps
Refactoring a monolithic legacy app to microservices can be extremely difficult when performed manually. What’s needed are automation technologies that can accelerate the process. And that’s exactly what vFunction provides.
The AI-enabled vFunction platform intelligently and automatically transforms complex monolithic Java apps into microservices. It uses static analysis, dynamic analysis, and data science to analyze your entire application estate and then delivers a scalable and repeatable process for cloud-native modernization.If you’d like to experience first-hand how vFunction can help you modernize your monolithic legacy applications, please schedule a demo today.
