Google App Engine; An Introduction

 

App Engine is GCP's original platform-as-a-service (PaaS) offering. App Engine is designed to allow developers to focus on application development while minimizing their need to support the infrastructure that runs their applications.

App Engine has two versions:

1. App Engine Standard.

2. App Engine Flexible.

App Engine Standard is a platform for running applications in a language-specific serverless environment. Currently, App Engine Standard supports Go, Java, PHP, Node.js, and Python, but the set of supported languages may have changed by the time you read this. App Engine Standard is available in two forms: first generation and second generation. Second-generation services offer more memory and more runtime options.

Each application running in App Engine Standard has an instance class that determines the amount of available CPU and memory. Resources in instance classes currently run from 256 MB of memory and a 600 MHz CPU up to 2048 MB of memory and a 4.8 GHz CPU.

App Engine Flexible runs Docker containers. This allows developers to customize their runtime environments in ways not available in App Engine Standard. For example, developers can start with custom Docker images, install additional libraries and packages, and then deploy container instances based on that image. App Engine Flexible also provides health checks and automatically patches the underlying operating system.

App Engine Standard is a good option when your application is developed in one of the supported languages and needs to scale up and down based on workload. App Engine Flexible is a good option when you want to have the advantages of a PaaS as well as the ability to customize your runtime environment.

Modern software systems have become increasing complex. Cloud platforms have helped tame some of the complexity by providing both managed and unmanaged services. So it's no surprise that companies have shifted workloads to cloud platforms. As cloud platforms continue to grow, knowing when and how to use these services is important for developers.

Google App Engine is one of the fully managed, serverless solutions provided by Google Cloud Platform. It allows users to build monolithic server-side rendered websites, and it supports popular development languages with a range of developer tools. It takes care of the server and deployment management so the user can focus on the code.

Google App Engine is best suited for applications that are designed using a microservice architecture. It provides the user with two different environments: standard and flexible. The standard environment run applications in a sandbox, using specific runtimes. The flexible environment runs applications on Docker containers using any version of the languages supported by App Engine.

When to use App Engine

Google App Engine is designed to provide nearly limitless scalability, which is a good option for applications that are expected to grow fast in traffic. It is also a good call for applications that are written in one of the supported languages: Python, Java, Node.js, Go, Ruby, PHP, or .NET.

Additionally, the most things to consider when deciding which platform to use are the team's skills in relation to managing servers and monitoring tools. In the case of App Engine, these skills are not strictly necessary. It also has a free tier, which can be a very attractive feature.

How we implemented it:

For this solution we used a terraform project that declares the following resources:

1. A VPC with a subnet to connect Redis and CloudRun.

2. A redis instance to store data.

3. A CloudRun service that runs the application.

The project contains a simple Counter Application consuming a Redis Memory Store.

Main Components:

Redis: here is a Terraform block declaring the Redis instance.

 

Connector

Here we declare the connector that will be used to allow the application to access the Redis instance.

 

App Engine application:

In the App Engine application we set two Terraform resources: the application and its standard version. In the standard version resource, we can set parameters like region, image, and the application environment variables, among other details.

App Engine vs Compute Engine: Which Google Service Should You Use for Your Deployment?

For many customers just getting started on their cloud modernization journey, the dizzying array of options available can be overwhelming. As software engineers and platform operators evaluate their options, it's not uncommon for them to struggle to choose the "right" path. The truth is that there is no single path that is best for every organization.

In this article, we discuss two options available with Google Cloud Platform: App Engine vs Compute Engine.

Both of these products offer distinct advantages for application developers and platform operators - and they're both widely used in cloud-native applications today.

Google's App Engine offering alone more than 350 billion requests per day. At their core, though, they're in fundamentally different categories of products. Google Compute Engine (GCE) is an Infrastructure-as-a-Service (IaaS) solution, whereas Google App Engine is a Platform-as-a-Service solution.

IaaS and PaaS Defined

In an IaaS model, cloud providers handle the physical server hardware, storage and networking components traditionally found in on-premises data centers. They also provide the virtualization or hypervisor layer that allows customers to create their own virtual machines that will ultimately host applications. Customers have the ability to define specific attributes of each virtual machine and to install and manage its own platform.

In a PaaS model, the cloud provider not only handles the physical infrastructure components and virtualization layers of traditional data centers, but the provider also delivers the application hosting software platform. This allows customers to focus on developing custom applications, rather than having to focus on infrastructure management and application hosting or platform concerns.