Google App Engine Reviews

In my current company, my client is completely based on Google. They are using their domain from Google and mixing Google Cloud with AWS Cloud. When it comes to deploying our microservices or REST APIs over the cloud, I develop APIs and portals for the Service Request Development (SRD) team. There are a lot of SRD personnel involved, possibly around 1K users, with many leaders using the services globally due to my engagement with a major IT giant.

The features of Google App Engine are very valuable, as it is the same as in AWS, Beanstalk, and in Azure, where it operates similarly. Google App Engine is a complete PaaS, platform as a service. Here, we are provided two types of scaling; if we are on a standard use case, we are provided basic and automatic and manual options, and if we are on flexible users, we have access to all three types. Google App Engine is fully managed, meaning users don't need to manage resources themselves; however, management is required and is handled by Google. For the standard environment, there are two variants: the standard and the flexible environment. The standard environment works a sandbox, whereas in the flexible environment, when we click on create, it starts its VM and initializes its virtual disk and resources, which we can access using the VM. In the case of the standard environment, we can't access all the other resources.

I've noticed measurable benefits and return on investment by choosing Google App Engine. The deployment process is managed by Google, allowing me to focus on selecting our language and uploading our code, while Google manages everything else—including the provision of the VPC for flexible deployments. If choosing the flexible option, it automatically creates a VPC, whereas for standard, no VPC is provided. Essentially, I only need to make minimal choices regarding regions; other than that, I focus solely on how my code operates.

I used Google App Engine about 10 months ago. We used it to deploy frontend services and backend services. We deployed through Google App Engine using both the standard environment and the flexible environment for different end services.

Regarding integration capabilities, there were Google credentials features that made it easy to use other services from Google, such as Pub/Sub messaging service and other functionalities, which were very tightly integrated. I did not have to think about the authentication between the services as it was seamless, and I did not have to do any extra work to get the authentication part working.

We were using approximately five or six services with Google App Engine, including three backend services and a couple of frontend services. Some of them used Google's Pub/Sub messaging service and Google's Maps APIs.

What I really appreciated about Google App Engine was how simple it was to spin up new services. It took care of most tasks that would typically require manual setup when configuring a server. It functioned almost as a serverless solution.

Another beneficial aspect was the ease of creating new versions of the application. If I had a production version and wanted to experiment with something else, it was straightforward to create a new version from the command line, deploy it on Google App Engine, and use it as a different environment.

The auto-scaling feature that Google App Engine provides was particularly useful as we never had to manage how the app was scaling. We never experienced any downtimes, which demonstrates the effectiveness of the scaling capability.

The auto-scaling feature helped us significantly in our fast-paced environment where the number of users was increasing rapidly. We could improve latency for users in two ways: optimizing the application code ourselves, which we did when possible, and allowing Google to scale our services as needed. This helped us focus on fixing bugs and adding new features rather than deep optimizations.

Operationally, it was efficient because we could easily spin up new versions to demonstrate new functionality without modifying the original environment. Not having to maintain the server ourselves or worry about scaling were valuable benefits we appreciated.

My usual use case for Google App Engine is related to SaaS applications where we create applications. For this purpose, we needed Google App Engine. We had concluded between AWS, Google GCP, and Microsoft Azure. At that particular time, we decided to use GCP because of the cost effectiveness and the support. We had a tie-up with Google for that particular application.

The scalability impacts my customer's experience with Google App Engine because our system, which we designed, is microservice-based and must be scalable. We are handling around billions of data, so if the load is not scalable, then it cannot take the load we expected. We are scaling accordingly; when the CPU is already 60% full, we scale to another CPU on other Google App Engines. According to that configuration, we have around 16 to 70 systems for per single use instances.

We use Google App Engine entirely to deploy all our user interface applications, especially the applications built on top of React, ReactJS, and VueJS, which we bundle as a package and deploy as part of Google App Engine. We use it for developing and hosting web applications. We have used Google App Engine as a serverless platform and for the scalable backend deployments.

Regarding integration, for this portal, there are many microservices running behind Google Cloud, specifically Google Cloud Run and Google Cloud Kubernetes Engine (GKE). To connect Google Cloud Kubernetes Engine and Google Cloud Run, we enable VPC endpoints, and based on that, using VPC endpoints for internal communication between services, Google App Engine is capable of connecting to Kubernetes Engine to invoke all the APIs of the microservices deployed over there.

What I find most beneficial about Google App Engine is that we do not need to manage it since it's a fully managed serverless platform, allowing us to spend more time on development rather than managing and maintaining configurations. It has an automatic scaling mechanism that is very helpful in terms of scaling when new customers keep getting added. It is very cost-effective since it's a pay-as-you-go service, so we do not have to pay when we are not using it. It also focuses on more developer productivity since Google App Engine provides users with a simple user interface for developers to handle things faster.

With the automatic scalability feature of Google App Engine, it has helped our application handle variable workloads efficiently. For example, we deployed a supply chain tech analytics web portal as part of Google App Engine, where the user count was around 200 users concurrently hitting the application. When the user base grew from 200 to 700 during Black Friday, we didn't need to make any changes. Since we had already enabled Google App Engine automatic scaling, all our portals were being used by customers without downtime, and we received positive feedback.

The real-time logging feature helps us in monitoring and improving app performance with a simple UI interface where we can do monitoring and diagnostics. If there are any bottlenecks and debugging issues, they provide filters and sorting mechanisms on the same screen, allowing us to filter different types of errors. Furthermore, it connects the monitoring services to Google's notification service, so whenever there is an issue in Google App Engine, all events get notified via the notification service.

I assess the global reach and redundancy capabilities of Google App Engine as strong because currently we expose it in multiple regions including European Central, US East, and Asia Pacific regions. Across these global regions, we have extended and deployed the same Google App Engine services, enabling us to reach our platforms globally. The dynamic routing capabilities, along with its ability to handle firewalls and latencies, allow us to manage global reach when we host Google App Engine.

I am currently working in a governance team where we have created several scripts. We have developed a front end and a back end for people working with information security, along with some billing portals. All projects have been deployed on Google App Engine. We are using Cloud Scheduler for scheduling various scripts. Multiple frameworks are involved, with Python consistently used for back end development and React for front end, while deployment occurs through Google App Engine.

What I appreciate most about Google App Engine is that the deployment is significantly easier compared to a conventional Linux platform. Creating a CI/CD pipeline works seamlessly. Connecting to the command line is also an excellent feature.

Google App Engine's usage is conventionally more straightforward than normal Linux hosting that we use.

I cannot currently recall anything that could be improved in Google App Engine because it is already functioning effectively. It is more user-friendly than any other platform I have used so far.

The usual use cases for Google App Engine that I work with are mostly web applications.

The most valuable features of Google App Engine that I have found are scalability. If your applications are purely internal, we don't need to have any instance up and running, and then whenever we actually get the request, instances should start. I find this valuable in terms of saving costs.

The automatic scalability feature of Google App Engine has helped me handle variable workloads by allowing applications to go to zero scale when there are no online users, such as during night time when there might be no active users. This helps save costs for those few hours.

The seamless integration of Google App Engine with other Google Cloud services has enhanced my application capabilities by allowing us to trigger Cloud Jobs from App Engine and some cloud functions, as handling messages through Pub/Sub. We also have third-party application integrations but mostly stick to Google services such as calling cloud function endpoints or Cloud Jobs and Pub/Sub, and sometimes BigQuery and Cloud SQL.

The fully managed serverless solution of Google App Engine has helped streamline my development process by reducing DevOps efforts; we have used a fully automated deployment process.

I have used Google App Engine's real-time logging feature, and we have alert systems in place for crashes from the DB side or any file uploads, logging those events and sending alerts through GCP.

Real-time logging has assisted me in monitoring and improving application performance by allowing us to identify slowness in communication for different services by analyzing logs of connection points and execution times between logs, which helps to identify network latency.

The benefits I have seen from working with Google App Engine include its ease of use and the ability to deploy it either as code or as a Docker image, making it quite easy.