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. Including
REGION_ID.r in App Engine URLs is optional for
existing apps and will soon be required for all new apps.
To ensure a smooth transition, we are slowly updating App Engine to use region IDs. If we haven't updated your Google Cloud project yet, you won't see a region ID for your app. Since the ID is optional for existing apps, you don't need to update URLs or make other changes once the region ID is available for your existing apps.
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.
require "sinatra" get "/" do "Hello world!" end
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 with very high latency, such as over one second per request for many requests, and high throughput require Silver, Gold, or Platinum support. Customers with this level of support can request higher throughput limits by contacting their support representative.
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
Dynamic responses are limited to 32MB. 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 the Blobstore or Cloud Storage .
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.
Specifying a request deadline
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.All requests to your app must return a response within the maximum request timeout. If your app doesn't respond by the timeout, App Engine interrupts the request handler.
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 compressionFor responses that are returned by your code, App Engine compresses data in the response if both of the following conditions are true:
- The request contains the
Accept-Encodingheader that includes
gzipas a value.
For responses that are returned by an App Engine static file or directory handler, response data is compressed if all of the following conditions are true:
- The request includes
gzipas one of its values.
- The client is capable of receiving the response data in a compressed format.
The Google Frontend maintains a list of clients that are known to have
problems with compressed responses. These clients will not receive compressed
data from static handlers in your app, even if the request headers contain
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-Controlmust be set to
publicfor the Google Fontend to cache content. 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.
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
Strict-Transport-Security is enabled by default for responses that are
generated from your code. For more information, see the
config.force_ssl configuration method.