Google App Engine (GAE)

Google App Engine is a fully-managed platform that enables developers to build and deploy web applications and mobile backends without worrying about managing the underlying infrastructure. App Engine provides a scalable, reliable, secure environment for building applications and supports various programming languages and frameworks.

With App Engine, developers can focus on building the application logic and leave the infrastructure management to Google. App Engine automatically scales the application up or down based on traffic and resource needs, so developers can be confident that their applications will remain performant even as usage fluctuates. Additionally, App Engine provides features like automatic load balancing, traffic splitting, and built-in security controls to help developers quickly deploy and manage their applications.

What Languages Does GAE Support?

App Engine supports various programming languages, including Java, Python, Node.js, PHP, Ruby, and Go, and popular web frameworks like Flask, Django, and Spring. It also integrates with other Google Cloud Platform services like Cloud SQL, Storage, and BigQuery, building powerful applications that easily leverage these services.

Overall, Google App Engine is an ideal platform for developers who want to build and deploy web applications quickly and easily without worrying about the underlying infrastructure or having to manage servers themselves.

Google App Engine is a fully managed microservices platform available in standard and flexible offerings. It is a :

• Serverless Environment
• Supports all main languages like Java, PHP, Node.js, Python, C#, .Net, Ruby and Go
• Open Platform
• Fully Managed Service
• Monitoring, logging, Diagnosis
• Application Versioning
• Elastic Computer
• Auto-scaling

How to Deploy GAE

Deployment is from the Google SDK or Cloud shell using:

Gcloud init
Gcloud auth login
Gcloud app deploy

To deploy an application to Google App Engine (GAE), you will need to follow these general steps:

1. Prepare your code: Ensure that your code is structured correctly and meets the requirements for GAE, such as including an app.yaml file that defines the runtime environment and application settings.
2. Create a project and enable the App Engine API: If you haven’t already done so, create a new project in the Google Cloud Console and enable the App Engine API.
3. Install and configure the gcloud SDK: Install the Google Cloud SDK, which includes the gcloud command-line tool, and configure it to use your project.
4. Deploy your application: Use the gcloud app deploy command to deploy your application to GAE. You can also specify additional deployment settings such as version names, traffic splitting, and service names.
5. Verify your deployment: Once your application has been deployed, you can verify that it is working correctly by visiting the URL for your application.

Here is an example command for deploying a Python application to GAE using the gcloud command-line tool:

This command deploys the application using the settings specified in the app.yaml file and creates a new version named 1. You can then visit your application’s URL to ensure it is working correctly.

Traffic Splitting

GAE traffic splitting is a feature that allows you to test and deploy new versions of your application without affecting all your users simultaneously. With traffic splitting, you can direct a percentage of your incoming traffic to a new version of your application while the remaining traffic is directed to the current version.

This allows you to test new features, updates, or bug fixes on a small percentage of your user traffic before rolling it out to all users. You can gradually increase the percentage of traffic going to the new version over time, allowing you to monitor its performance and ensure it works correctly before making it the default version.

Traffic splitting is easy to configure using the App Engine console or the gcloud command-line tool. When you deploy a new application version, you can specify the percentage of traffic that should go to the new version using the --traffic-split flag. For example, to split traffic evenly between two versions of an application, you would use the following command:

This command deploys the application’s version and directs 50% of incoming traffic to it, while the other 50% goes to the current default version.

• Works with LB
• Split traffic to different versions

GAE Microservices

Google App Engine (GAE) microservices are small, independent services that work together to create a larger application. Each microservice is designed to perform a specific function or task and communicates with other microservices using well-defined APIs and protocols.

Microservices can be written in different programming languages and can run independently of each other, allowing for greater scalability and flexibility. They can also be deployed and managed separately, allowing for easier testing and updating of individual services without affecting the entire application.

GAE microservices are typically designed to be stateless, meaning that they do not store data or maintain a state between requests. This allows them to be more easily scaled horizontally, adding more service instances as needed.

GAE Scaling

Google App Engine (GAE) scaling is the process of dynamically adjusting the number of computing resources allocated to an application in response to changes in traffic and usage patterns. GAE allows you to configure different scaling types depending on the needs of your application.

The two main types of scaling in GAE are:

1. Automatic scaling: This type of scaling allows GAE to automatically adjust the number of instances (i.e., virtual machines) running your application in response to changes in traffic. When traffic increases, GAE will automatically spin up new instances to handle the load and will scale back down when traffic decreases. With automatic scaling, you can set a minimum and maximum number of instances, and GAE will scale between these limits based on demand.
2. Manual scaling: With manual scaling, you can set a fixed number of instances to run your application, and GAE will not automatically adjust this number based on traffic. This type of scaling is useful for applications with consistent traffic patterns or applications requiring a specific number of instances for performance or availability reasons.

In addition to these scaling types, GAE also allows you to configure other settings, such as instance class (i.e., the size and power of each virtual machine), idle instances (i.e., instances that are kept running to handle incoming traffic), and scaling thresholds (i.e., the criteria used to determine when to spin up or down instances).

• Manual scaling
• Auto-scaling – due to latency, CPU etc
• Scaling controlled by app. yaml

GAE Limits

Certain limits and quotas are in place to prevent abuse, ensure fair usage, and maintain system performance. These limits apply to your application’s various resources, including CPU usage, memory usage, storage, network bandwidth, and API calls.

Here are some examples of GAE limits:

1. CPU and memory usage: GAE limits the amount of CPU and memory that your application can use. The exact limits depend on the instance class and scaling type you choose.
2. Storage limits: GAE limits the amount of data that your application can store in its file system and datastore. The exact limits depend on the storage type and pricing plan you choose.
3. Network bandwidth limits: GAE limits the amount of network bandwidth that your application can use. The exact limits depend on the instance class and scaling type you choose.
4. API call limits: GAE limits the number of API calls your application can make daily. The exact limits depend on the API and pricing plan you choose.

It’s important to note that these limits can change over time and may differ depending on your GAE environment (e.g., standard environment vs flexible environment). You can view your current usage and quota limits in the GAE console and can request additional quota if needed.

• Max services per application = 5
• Maximum versions per application =5
• Maximum instances per vision with manual scaling = 20

GAE Engine Types

Flexible environment

• Dockerized container images
• Docker Image or docker file
• Infrastructure customization
• Custom Libraries
• SSH for debugging
• Deploy OWN docker containers
• High Performance and can customize compute specs
• Instances are health checked
• Automatic locates to geography
• Underline infrastructure managed by google
• Always have ROOT access to VM instances

Standard environment

• Pre-defined runtime
• Libraries that support App Engine API
• Cannot customise the environment
• Auto-scaling for demand – not able to customize

GAE Features

Figure 7- https://cloud.google.com/appengine/docs/the-appengine-environments