The App Engine Standard Environment

The App Engine standard environment is based on container instances running on Google's infrastructure. Containers are preconfigured with one of several available runtimes.

The App Engine standard environment makes it easy to build and deploy an application that runs reliably even under heavy load and with large amounts of data.

Applications run in a secure, sandboxed environment, allowing App Engine standard environment to distribute requests across multiple servers, and scaling servers to meet traffic demands. Your application runs within its own secure, reliable environment that is independent of the hardware, operating system, or physical location of the server.

Instance classes

Each application running in the standard environment has an instance class, which determines its compute resources and pricing. This table summarizes the memory and CPU limits of the various instance classes. See the pricing page for billing information.

Instance Class Memory Limit CPU Limit Supported Scaling Types
F1 (default) 128 MB 600 MHz automatic
F2 256 MB 1.2 GHz automatic
F4 512 MB 2.4 GHz automatic
F4_1G 1024 MB 2.4 GHz automatic
B1 128 MB 600 MHz manual, basic
B2 (default) 256 MB 1.2 GHz manual, basic
B4 512 MB 2.4 GHz manual, basic
B4_1G 1024 MB 2.4 GHz manual, basic
B8 1024 MB 4.8 GHz manual, basic

Quotas and limits

App Engine standard environment gives you 1 GB of data storage and traffic for free, which can be increased by enabling paid applications. However, some features impose limits unrelated to quotas to protect the stability of the system. For more details on quotas, including how you can edit them to suit your needs, see the Quotas page.

Standard environment languages and runtimes

Java 7 runtime

App Engine runs your Java web application using a Java 7 JVM in a safe sandboxed environment. App Engine invokes your app's servlet classes to handle requests and prepare responses in this environment.

App Engine uses the Java Servlet standard for web applications. You provide your app's servlet classes, JavaServer Pages (JSPs), static files and data files, along with the deployment descriptor (the web.xml file) and other configuration files, in a standard WAR directory structure. App Engine serves requests by invoking servlets according to the deployment descriptor.

The secured sandbox environment isolates your application for service and security. It ensures that apps can only perform actions that do not interfere with the performance and scalability of other apps. For instance, an app cannot spawn threads in some ways, write data to the local file system or make arbitrary network connections. An app also cannot use JNI or other native code. The JVM can execute any Java bytecode that operates within the sandbox restrictions.

Java Developers Guide

Java 8 runtime
The App Engine Java 8 runtime supports all of the existing features available in the current Java 7 runtime, but with the following upgrades and enhancements:
  • Doesn't impose a security manager, as the Java 7 runtime does, which means your code won't be restricted by Java permissions issues.
  • Supports the standard public Java library, not just the whitelisted class subset available for Java 7.
  • Supports Eclipse Jetty 9
  • Supports Servlet 3.1
  • Supports gRPC based Cloud APIs, such as the Cloud Bigtable client library and the Google Cloud Java library.

    Java Developers Guide

Python runtime

App Engine standard environment executes your Python application code using a pre-loaded Python interpreter in a safe sandboxed environment. Your app receives web requests, performs work, and sends responses by interacting with this environment.

A Python web app interacts with the App Engine web server using the WSGI protocol, so apps can use any WSGI-compatible web application framework. App Engine includes a simple web application framework, called webapp2, to make it easy to get started. For larger applications, mature third-party frameworks, such as Django, work well with App Engine.

The Python interpreter can run any Python code, including Python services you include with your application, as well as the Python standard library. The interpreter cannot load Python services with C code; it is a "pure" Python environment.

The secured sandbox environment isolates your application for service and security. It ensures that apps can only perform actions that do not interfere with the performance and scalability of other apps. For instance, an app cannot write data to the local file system or make arbitrary network connections. Instead, apps use scalable services provided by App Engine to store data and communicate over the Internet. The Python interpreter raises an exception when an app attempts to import a service from the standard library known to not work within the sandbox restrictions.

Python Developers Guide

PHP runtime

The PHP runtime executes your application code in a sandboxed PHP 5.5 environment. Your app receives web requests, performs work, and sends responses by interacting with this environment. The runtime supports many of the standard PHP extensions. You cannot upload extensions written in C.

App Engine standard environment runs its own web server, which can be configured using an app.yaml file that's uploaded with your code. This file specifies how incoming HTTP requests to your application are directed to PHP scripts.

The sandbox isolates your application for reliability, scalability and security. For this reason, a small number of PHP functions are not available on App Engine, and others will raise an exception if used incorrectly. For instance, an app cannot write data to the local file system. Instead, apps can use scalable services provided by Google to store and process data and communicate over the Internet.

The PHP runtime provides a built-in Google Cloud Storage stream wrapper that allows you to use many of the standard PHP filesystem functions to access Google Cloud Storage.

PHP Developers Guide

Go runtime

App Engine standard environment runs Go version 1.9. The SDK provides an interface similar to the standard Go HTTP package; writing Go apps for App Engine is similar to writing stand-alone Go web servers.

The SDK includes the Go compiler and standard library; it has no additional dependencies. Because the Go runtime executes in a sandboxed environment, some of the standard library functions will return errors and should not be used. For example, an os.ErrPermission will occur if an app tries to write to the local file system or make arbitrary network connections. You must use App Engine's scalable services to store data and communicate over the Internet.

You never need to invoke the Go compiler yourself. Your app is automatically re-built on the server side whenever you upload new code, and if you are running the local development server the SDK automatically recompiles sources on-the-fly when you change them.

The Go runtime environment for App Engine supports goroutines, but they are scheduled on a single thread. Goroutines can run concurrently but not in parallel. An application instance can handle multiple requests. For example, if one request is waiting for a datastore API call, the instance can process another request in the meantime.

Go Developers Guide

このページは役立ちましたか?評価をお願いいたします。

フィードバックを送信...