REGION_ID is an abbreviated code that Google assigns
based on the region you select when you create your app. The code does not
correspond to a country or province, even though some region IDs may appear
similar to commonly used country and province codes. For apps created after
REGION_ID.r is included in
App Engine URLs. For existing apps created before this date, the
region ID is optional in the URL.
Learn more about region IDs.
This document describes how your App Engine application receives requests and sends responses. For more details, see the Request Headers and Responses reference.
If your application uses services, you can address requests to a specific service or a specific version of that service. For more information about service addressability, see How Requests are Routed.
Your application is responsible for starting a webserver and handling requests. You can use any web framework that is available for your development language.
App Engine runs multiple instances of your application, and each
instance has its own web server for handling requests. Any request can be routed
to any instance, so consecutive requests from the same user are not necessarily
sent to the same instance. An instance can handle multiple requests
concurrently. The number of instances can be adjusted automatically as traffic
You can also change the number of concurrent requests an instance can handle
by setting the
element in your app.yaml file.
The server determines which PHP handler script to run by comparing the URL of
the request to the URL patterns in the app's
configuration file. It then runs the script populated with the request data. The
server puts the request data in environment variables and the standard input
stream. The script performs actions appropriate to the request, then prepares a
response and puts it on the standard output stream.
The following example is a PHP script that responds to any HTTP request with the message 'Hello World!'
<?php echo 'Hello, World!';
Quotas and limits
App Engine automatically allocates resources to your application as traffic increases. However, this is bound by the following restrictions:
App Engine reserves automatic scaling capacity for applications with low latency, where the application responds to requests in less than one second.
Applications that are heavily CPU-bound may also incur some additional latency in order to efficiently share resources with other applications on the same servers. Requests for static files are exempt from these latency limits.
Each incoming request to the application counts toward the Requests limit. Data sent in response to a request counts toward the Outgoing Bandwidth (billable) limit.
Both HTTP and HTTPS (secure) requests count toward the Requests, Incoming Bandwidth (billable), and Outgoing Bandwidth (billable) limits. The Cloud Console Quota Details page also reports Secure Requests, Secure Incoming Bandwidth, and Secure Outgoing Bandwidth as separate values for informational purposes. Only HTTPS requests count toward these values. For more information, see the Quotas page.
The following limits apply specifically to the use of request handlers:
|Request size||32 megabytes|
|Response size||32 megabytes|
|Request timeout||Depends on the type of scaling your app uses|
|Maximum total number of files (app files and static files)||10,000 total
1,000 per directory
|Maximum size of an application file||32 megabytes|
|Maximum size of a static file||32 megabytes|
|Maximum total size of all application and static files||First 1 gigabyte is free
$ 0.026 per gigabyte per month after first 1 gigabyte
|Pending request timeout||10 seconds|
|Maximum size of a single request header field||8 kilobytes for second-generation runtimes in the standard environment. Requests to these runtimes with header fields exceeding 8 kilobytes will return HTTP 400 errors.|
All HTTP/2 requests will be translated into HTTP/1.1 requests when forwarded to the application server.
Dynamic responses are limited to 32 MB. If a script handler generates a response larger than this limit, the server sends back an empty response with a 500 Internal Server Error status code. This limitation does not apply to responses that serve data from Cloud Storage.
The response header limit is 8 KB for second-generation runtimes. Response headers that exceed this limit will return HTTP 502 errors, with logs showing
upstream sent too big header while reading response header from upstream.
An incoming HTTP request includes the HTTP headers sent by the client. For security purposes, some headers are sanitized or amended by intermediate proxies before they reach the application.
For more information, see the Request headers reference.
Handling request timeouts
App Engine is optimized for applications with short-lived requests, typically those that take a few hundred milliseconds. An efficient app responds quickly for the majority of requests. An app that doesn't will not scale well with App Engine's infrastructure. To ensure this level of performance, there is a system-imposed maximum request timeout that every app must respond by.If a PHP script exceeds this deadline, the
TIMEOUTbit on the connection status bitfield is set. Your script will then have a short second deadline to clean up any long running tasks and return a response to the user.
If your script hasn't returned a response by the second deadline, the handler is stopped and a default error response is returned.
ResponsesApp Engine calls the script with the
$_REQUESTarray populated, buffers any output from the script, and when the script completes execution, sends the buffered output to the end user.
There are size limits that apply to the response you generate, and the response may be modified before it is returned to the client.For more information, see the Request responses reference.
App Engine does not support streaming responses where data is sent in incremental chunks to the client while a request is being processed. All data from your code is collected as described above and sent as a single HTTP response.
Response compressionApp Engine does its best to serve compressed (gzipped) content to clients that support it. To determine if content should be compressed, App Engine does the following when it receives a request:
Confirms if the client can reliably receive compressed responses by viewing both the
User-Agentheaders in the request. This approach avoids some well-known bugs with gzipped content in popular browsers.
Confirms if compressing the content is appropriate by viewing the
Content-Typeheader that you have configured for the response handler. In general, compression is appropriate for text-based content types, and not for binary content types.
Note the following:
A client can force text-based content types to be compressed by setting both of the
User-Agentrequest headers to
If a request doesn't specify
Accept-Encodingheader, App Engine will not compress the response data.
The Google Frontend caches responses from App Engine static file and directory handlers. Depending on a variety of factors, such as which type of response data is cached first, which
Varyheaders you have specified in the response, and which headers are included in the request, a client could request compressed data but receive uncompressed data, and the other way around. For more information, see Response caching.
The Google Frontend, and potentially the user's browser and other intermediate caching proxy servers, will cache your app's responses as instructed by standard caching headers that you specify in the response. You can specify these response headers either through your framework, directly in your code, or through App Engine static file and directory handlers.
In the Google Frontend, the cache key is the full URL of the request.
Caching static content
To ensure that clients always receive updated static content as soon as it is
published, we recommend that you serve static content from versioned
directories, such as
css/v1/styles.css. The Google Frontend will not validate
the cache (check for updated content) until the cache expires. Even after the
cache expires, the cache will not be updated until the content at the request
The following response headers that you can
influence how and when the Google Frontend caches content:
Cache-Controlshould be set to
publicfor the Google Frontend to cache content; it may also be cached by the Google Frontend unless you specify a
no-storedirective. If you don't set this header in
app.yaml, App Engine automatically adds it for all responses handled by a static file or directory handler. For more information, see Headers added or replaced.
Vary: To enable the cache to return different responses for a URL based on headers that are sent in the request, set one or more of the following values in the
Due to the potential for high cardinality, data will not be cached for other
You specify the following response header:
You app receives a request that contains the
Accept-Encoding: gzipheader. App Engine returns a compressed response and the Google Frontend caches the gzipped version of the response data. All subsequent requests for this URL that contain the
Accept-Encoding: gzipheader will receive the gzipped data from the cache until the cache becomes invalidated (due to the content changing after the cache expires).
Your app receives a request that does not contain the
Accept-Encodingheader. App Engine returns an uncompressed response and Google Frontend caches the uncompressed version of the response data. All subsequent requests for this URL that do not contain the
Accept-Encodingheader will receive the compressed data from the cache until the cache becomes invalidated.
If you do not specify a
Varyresponse header, the Google Frontend creates a single cache entry for the URL and will use it for all requests regardless of the headers in the request. For example:
- You do not specify the
Vary: Accept-Encodingresponse header.
- A request contains the
Accept-Encoding: gzipheader, and the gzipped version of the response data will be cached.
- A second request does not contain the
Accept-Encoding: gzipheader. However, because the cache contains a gzipped version of the response data, the response will be gzipped even though the client requested uncompressed data.
The headers in the request also influence caching:
- If the request contains an
Authorizationheader, the content will not be cached by the Google Frontend.
By default, the caching headers that App Engine static file and directory handlers add to responses instruct clients and web proxies such as the Google Frontend to expire the cache after 10 minutes.
After a file is transmitted with a given expiration time, there is generally no way to clear it out of web-proxy caches, even if the user clears their own browser cache. Re-deploying a new version of the app will not reset any caches. Therefore, if you ever plan to modify a static file, it should have a short (less than one hour) expiration time. In most cases, the default 10-minute expiration time is appropriate.
You can change the default expiration for all static file and directory handlers
by specifying the
element in your
file. To set specific expiration times for individiual
element within the handler element in your
The value you specify in the expiration elements time will be used to
Expires HTTP response headers.
App cachingThe PHP runtime environment includes the OPcache which can cache PHP intermediate code and significantly improve your application's response time. You can disable OPcache caching by setting
opcache.enabled = "0"in the application's php.ini file.
LoggingThe App Engine web server captures everything the handler script writes to the standard output stream for the response to the web request. It also captures everything the handler script writes to the standard error stream, and stores it as log data. Log data for your application can be viewed in the Cloud Console using Cloud Logging.
Forcing HTTPS connections
For security reasons, all applications should encourage clients to connect over
https. To instruct the browser to prefer
http for a given page
or entire domain, set the
Strict-Transport-Security header in your responses.
To set this header for any static content that is served by your app, add the header to your app's static file and directory handlers.
Strict-Transport-Security: max-age=31536000; includeSubDomains
Handling asynchronous background work
Background work is any work that your app performs for a request after you have delivered your HTTP response. Avoid performing background work in your app, and review your code to make sure all asynchronous operations finish before you deliver your response.
For long-running jobs, we recommend using Cloud Tasks. With Cloud Tasks, HTTP requests are long-lived and return a response only after any asynchronous work ends.