The Definitive Guide to Modernizing Applications on Google Cloud

Steve (Satish) Sangapu, Dheeraj Panyam, Jason Marston

• Publisher: Packt Publishing
• Year: 2022
• ISBN:
  9781800209022
• Edition: 1
• Topic: Commerce
• Subtopic: Business Intelligence

Get to grips with the tools, services, and functions needed for application migration to help you move from legacy applications to cloud-native on Google CloudKey Features• Discover how a sample legacy application can be transformed into a cloud-native application on Google Cloud• Learn where to start and how to apply application modernization techniques and tooling• Work with real-world use cases and instructions to modernize an application on Google CloudBook DescriptionLegacy applications, which comprise 75–80% of all enterprise applications, often end up being stuck in data centers. Modernizing these applications to make them cloud-native enables them to scale in a cloud environment without taking months or years to start seeing the benefits. This book will help software developers and solutions architects to modernize their applications on Google Cloud and transform them into cloud-native applications.This book helps you to build on your existing knowledge of enterprise application development and takes you on a journey through the six Rs: rehosting, replatforming, rearchitecting, repurchasing, retiring, and retaining. You'll learn how to modernize a legacy enterprise application on Google Cloud and build on existing assets and skills effectively. Taking an iterative and incremental approach to modernization, the book introduces the main services in Google Cloud in an easy-to-understand way that can be applied immediately to an application.By the end of this Google Cloud book, you'll have learned how to modernize a legacy enterprise application by exploring various interim architectures and tooling to develop a cloud-native microservices-based application.What you will learn• Discover the principles and best practices for building cloud-native applications• Study the six Rs of migration strategy and learn when to choose which strategy• Rehost a legacy enterprise application on Google Compute Engine• Replatform an application to use Google Load Balancer and Google Cloud SQL• Refactor into a single-page application (SPA) supported by REST services• Replatform an application to use Google Identity Platform and Firebase Authentication• Refactor to microservices using the strangler pattern• Automate the deployment process using a CI/CD pipeline with Google Cloud BuildWho this book is forThis book is for software developers and solutions architects looking to gain experience in modernizing their enterprise applications to run on Google Cloud and transform them into cloud-native applications. Basic knowledge of Java and Spring Boot is necessary. Prior knowledge of Google Cloud is useful but not mandatory.

Section 1: Cloud-Native Application Development and App Modernization in Google Cloud

On completion of Section 1, you will have gained an understanding of the cloud-native ecosystem, principles and benefits of cloud-native architecture as well as how to apply the 12-factor app principles on Google Cloud. In addition, you will get insights into the end-to-end tooling that goes into developing a cloud-native application on Google Cloud, along with a sample reference architecture. Finally, you will learn how to solve common challenges with cloud-native design patterns as well as hybrid and multi-cloud architecture recommendations.

This part of the book comprises the following chapters:

• Chapter 1, Cloud-Native Application Fundamentals
• Chapter 2, End-to-End Extensible Tooling for Cloud-Native Application Development
• Chapter 3, Cloud-Native Architecture Patterns and System Architecture Tenets

Chapter 1: Cloud-Native Application Fundamentals

Cloud computing brought about a paradigm shift in the world of software engineering and changed how we build applications. The cloud ecosystem powers some of the most powerful, largest, and most innovative applications using the same set of universal principles. However, some of these principles go against the best practices in traditional application development but are crucial to the success of a cloud-native application.

In this chapter, we are going to explore these fundamentals and core principles to help you utilize the full potential of the cloud-native ecosystem. After finishing this chapter, you'll have a clear understanding of the following topics and how they are used in day-to-day development on the cloud:

• The cloud-native ecosystem
• Benefits of cloud-native architecture
• Principles of cloud-native architecture
• Applying the 12-factor app principles on Google Cloud

The cloud-native ecosystem

The cloud-native ecosystem is a combination of three very basic elements: the cloud platform, the architecture, and, of course, the cloud-native application. Let's break them down one by one.

The cloud platform is what makes cloud-native applications possible. For instance, the virtually unlimited computing and storage capabilities of a cloud platform give cloud-native applications the following characteristics:

• Scalability, a defining characteristic.
• The pay-per-use model makes the applications cost-effective.
• Managed services that make cloud-native applications not only versatile but also very developer-friendly.

There are ample reasons why the industry is choosing cloud-native architecture as the foundation for its applications. The architecture dictates how the software is engineered and with cloud-native architecture, developers have far more control. It enables developers to adopt DevOps, containers, automation, microservices, and more. Microservices, in particular, are one of the most important components of a cloud-native architecture and they are what give cloud-native applications the rest of their defining characteristics: agility and resiliency.

An application can be considered cloud-native when it can take advantage of the cloud platform, and in order to take full advantage, it usually needs to be built on a cloud-native architecture. Therefore, a cloud-native application should be the following:

• Managed: Use the cloud platform as an infrastructure (be dependent on it to do all the computing).
• Scalable: Quickly increase or decrease resources to match the demand.
• Resilient: A single bug or crash should not take down the application.
• Loosely coupled: Parts of the application should be isolated enough for them to be altered or removed without any downtime.

If the cloud-native ecosystem were a house, the cloud platform would be the underground foundation, the architecture would be the main pillars, and the cloud applications would be the rooms.

Benefits of cloud-native applications

Cloud-native applications have many benefits that make them superior to traditional applications in many ways. These benefits are why people build cloud-native applications, but not all the benefits are innate; they're not guaranteed automatically.

Simply rehosting to a cloud platform does not mean that the time to market will decrease or that the application will be more resilient. It's up to the developer to ensure that the characteristics of the cloud platform and architecture are carried over to the end user. So, before learning how to develop cloud-native applications, it's a good idea to learn what makes cloud-native applications so powerful and popular among businesses.

Increased speed of delivery

Simply building applications isn't enough – delivering the service to the market is just as important. Bringing a new service or product to the market before competitors has a huge advantage (first-mover advantage). Similarly, timely feature updates and bug fixes are incredibly important as well.

Cloud-native applications can be built in a very short time and are generally much faster at pushing updates as well. This is possible due to the way they are architected as well as because of the approach developers take. Let's take a look at some of the architectural benefits first.

Not monolithic

A decade ago, the trend was to make everything monolithic. Today, the trend is to break the monolith into microservices. This paradigm shift was driven by the need to be more agile and resilient and monoliths were neither. The solution? Use a loosely coupled architecture that is not affected by the limitations of monolithic architecture.

Unlike a monolith, the cloud-native architecture supports an application being built in pieces and then joined together. These pieces are called microservices and they are completely isolated from each other in their own environments called containers. They communicate with each other through APIs. The popular saying breaking the monolith refers to breaking down the web of a complex and interconnected code base into neatly organized microservices that are much easier to maintain.

A popular real-world example of breaking the monolith is Netflix. By the time it turned 1 in 2008, Netflix's monolithic architecture had already become a problematic mess that caused extremely long downtimes. So, after 3 years of refactoring, Netflix's engineers were able to break down their giant monolith into 500-700 microservices, reducing cost, time to market, and downtimes.

A microservices architecture also reduces the time to fix bugs as each microservice is monitored separately and buggy microservices can be quickly identified, replaced with an older version, or completely removed without any downtime.

Independent development of microservices

Another major advantage of microservices is that because they are independent, developers can work on different microservices at once. This gives developers the ability to build and update different parts of the application at once, without constantly worrying about app-breaking updates or having to shut down the entire server for a small bug fix. Although compatibility issues haven't been completely eliminated in cloud-native applications, they are far fewer and rarer.

Amazon's two pizza policy is a great example of the independent development of microservices. The policy states that a microservice is too big if the team working on it cannot be fed by two pizzas. Although not very scientific, it illustrates just how great microservices are for small, especially remote, teams.

Independent deployment of microservices

The loosely coupled design philosophy has given rise to a new breed of applications that are modular. As microservices are usually designed with functionality in mind, they can be thought of as modular features that can be changed, replaced, or completely taken out with minimum impact on the entire application. But they can also be introduced independently. When adding a new microservice to the main code base, no major refactoring is required, which significantly reduces the time to market.

Increased scalability

Scalability is one of the key characteristics of cloud-native applications. They are extremely scalable due to the vast (unlimited as far as most businesses are concerned) hardware capabilities of modern cloud platforms. However, cloud-native applications are not scalable in the same way as traditional applications.

Historically, businesses increased their capacity to serve concurrent users by vertically scaling or scaling up. This means that they went from 2 gigabytes of memory to 8 gigabytes and from a 1 GHz CPU to a 2.4 GHz one.

Cloud-native applications, on the other hand, scale up using a different approach: horizontal scaling or scaling out. Instead of increasing the raw computing and storage capabilities of each unit, cloud platforms increase the number of units. Instead of a single stick of 8 gigabytes, they have four sticks of 2 gigabytes.

Although vertical scaling is easier, horizontal scaling opens up far more possibilities ...

Table of contents

• The Definitive Guide to Modernizing Applications on Google Cloud
• Contributors
• Preface
• Section 1: Cloud-Native Application Development and App Modernization in Google Cloud
• Chapter 1: Cloud-Native Application Fundamentals
• Chapter 2: End-to-End Extensible Tooling for Cloud-Native Application Development
• Chapter 3: Cloud-Native Architecture Patterns and System Architecture Tenets
• Section 2: Selecting the Right Google Cloud Services
• Chapter 4: Choosing the Right Compute Option
• Chapter 5: Choosing the Right Database and Storage
• Chapter 6: Implementing a Messaging and Scheduling System
• Chapter 7: Implementing Cloud-Native Security
• Section 3: Rehosting and Replatforming the Application
• Chapter 8: Introducing the Legacy Application
• Chapter 9: The Initial Architecture on Google Compute Engine
• Chapter 10: Addressing Scalability and Availability
• Chapter 11: Re-Platforming the Data Layer
• Chapter 12: Designing the Interim Architecture
• Chapter 13: Refactoring to Microservices
• Section 4: Refactoring the Application on Cloud-Native/PaaS and Serverless in Google Cloud
• Chapter 14: Refactoring the Frontend and Exposing REST Services
• Chapter 15: Handling Eventual Consistency with the Compensation Pattern
• Chapter 16: Orchestrating Your Application with Google Kubernetes Engine
• Chapter 17: Going Serverless with Google App Engine
• Chapter 18: Future Proofing Your App with Google Cloud Run
• Appendix A: Choosing the Right Migration Strategy
• Appendix B: Application Modernization Solutions
• Other Books You May Enjoy