Note: SomePython runtimes have reachedend of support. You cannot re-deployversions that use runtimes after their end of support date. We recommend thatyouupgrade your appto use the latest version of Python.

The Python runtime is the software stack responsible forinstalling your application code and dependencies, and then running thatapplication in the flexible environment.

Python versions

Python 3.14 (preview) usesbuildpacks. For the full list of supportedPython versions, and their corresponding Ubuntuversion, see theRuntime support schedule.

To use asupportedPython version, you must:

• Include theruntime_config andoperating_system settings in yourapp.yaml file tospecify an operating system.

• Installgcloud CLI version420.0.0 or later. You can update your CLItooling by running thegcloud components updatecommand. To view your installed version, run thegcloud version command.

• Optionally, you can specify a runtime version by including theruntime_versionsetting in yourapp.yaml file. By default, the latest Python version is used iftheruntime_version setting is not specified.

Examples

• To specify Python 3.14 (preview) on Ubuntu 24:

  runtime:pythonenv:flexentrypoint:gunicorn -b :$PORT main:appruntime_config:operating_system:"ubuntu24"runtime_version:"3.14"

• To specify the latest supported Python version on Ubuntu 24:

  runtime:pythonenv:flexentrypoint:gunicorn -b :$PORT main:appruntime_config:operating_system:"ubuntu24"

See theapp.yamlreference page for more information.

Previous runtime versions

For Pythonversion 3.7 and earlier, you specify a version using theruntime_config andpython_version settings in your application'sapp.yamlfile.

Example

runtime:pythonenv:flexentrypoint:gunicorn-b:$PORTmain:appruntime_config:python_version:3.7

For Python versions 3.7 and earlier, the default interpreter isPython 2.7.12 ifruntime_config orpython_version are omitted. For example, you can usethe default runtime by specifyingruntime: python in yourapp.yaml file:

runtime:pythonenv:flex

See theapp.yamlreference page for more information.

The interpreters that are deployed for each version setting are shown in thefollowing table:

Support for other Python runtimes

If you need to use a Python version that isn'tsupported, you can create acustom runtime and select avalid base image with the Python version you need.

For Google-supplied base images orDocker Python base images,seeBuilding custom runtimes.

To further investigate containerizing App Engine apps forCloud Run, see themigration guide.

Dependencies

The runtime looks for arequirements.txtfile in your application's source directory and usespipto install any dependencies before starting your application. For moreinformation on declaring and managing packages, seeUsing Python Libraries.

If your app requires private dependencies, you need to use acustom runtime based on the Pythonruntime to install the appropriate packages.

Application startup

The runtime starts your application using theentrypoint defined in yourapp.yaml file. The entrypointshould start a process that responds to HTTP requests on the port defined by theenvironment variablePORT.

Most web applications use aWSGI server such asGunicorn,uWSGI orWaitress.

Before you can use one of these servers, you must add them as a dependency in your application'srequirements.txt.If you usegunicorn for your Flask application, ensure that your application'sPython version iscompatible withgunicorn.

The runtime ensures that all dependencies are installed before your entrypoint is called.

Flask==2.0.2gunicorn==20.1.0

An example entrypoint using gunicorn for a Flask application:

entrypoint:gunicorn-b:$PORTmain:app

An example entrypoint using gunicorn for a Django application:

entrypoint:gunicorn-b:$PORTmydjangoapp:wsgi

Gunicorn is the recommended WSGI server, but it's completely possible to use any other WSGI server. For example, here is an entrypoint that uses uWSGI with Flask:

entrypoint:uwsgi--http:$PORT--wsgi-filemain.py--callableapp

For applications that can handle requests without a WSGI server, you can just execute a Python script:

entrypoint:pythonmain.py

Recommended Gunicorn configuration

The basic entrypoint examples shown above are intended to be starting pointsand may work for your web applications. Most applications, however, will need tofurther configure the WSGI server. Instead of specifying all of the settings onthe entrypoint, create agunicorn.conf.py file in your project root directory,where yourapp.yaml file is located, and specify it in your entrypoint:

entrypoint:gunicorn-cgunicorn.conf.py-b:$PORTmain:app

You can read about all of Gunicorn's configuration values in itsdocumentation.

Workers

Gunicorn uses workers to handle requests. By default, Gunicorn usessync workers. This worker class is compatible with all web applications, but each worker can only handle one request at a time. By default, gunicorn only uses one of these workers. This can often cause your instances to be underutilized and increase latency in applications under high load.

We recommend setting the number of workers to 2-4 times the number of CPU cores for your instance plus one. You can specify this ingunicorn.conf.py as:

importmultiprocessingworkers=multiprocessing.cpu_count()*2+1

Additionally, some web applications that are mostly I/O bound can see aperformance improvement by using adifferent worker class.If your worker class requires additional dependencies such as gevent or tornado, those dependencies will need to be declared in your application'srequirements.txt.

HTTPS and forwarding proxies

App Engine terminates the HTTPS connection at the load balancer and forwards therequest to your application. Most applications do not need to know if therequest was sent over HTTPS or not, but applications that do need thisinformation should configure Gunicorn to trust the App Engine proxy in theirgunicorn.conf.py:

forwarded_allow_ips='*'secure_scheme_headers={'X-FORWARDED-PROTO':'https'}

Gunicorn will now ensure that thewsgi.url_scheme to'https', which most webframeworks will use as indication of the request is secure. If your WSGI serveror framework doesn't support this, just check the value of theX-Forwarded-Proto header manually.

Some applications also need to ascertain the user's IP address. This isavailable in theX-Forwarded-For header.

Note that thesecure_scheme_headers setting ingunicorn.conf.py should beupper case, likeX-FORWARDED-PROTO, but the headers that your code can readwill be in mixed case, likeX-Forwarded-Proto.

Extending the runtime

The flexible environment Python runtime can be used to create a custom runtime.SeeCustomizing the Pythonfor more information.

Environment variables

The following environment variables are set by the runtime environment:

You can set additional environment variables in theapp.yaml file.

Metadata server

Each instance of your application can use theCompute Engine metadata server to query information about theinstance, including its host name, external IP address, instance ID, custommetadata, and service account information. App Engine does not allow you to setcustom metadata for each instance, but you can setproject-wide custom metadata and read it from yourApp Engine and Compute Engine instances.

This example function uses the metadata server to get the external IP address of the instance:

METADATA_NETWORK_INTERFACE_URL=("http://metadata/computeMetadata/v1/instance/network-interfaces/0/""access-configs/0/external-ip")defget_external_ip():"""Gets the instance's external IP address from the Compute Engine metadata    server.    If the metadata server is unavailable, it assumes that the application is running locally.    Returns:        The instance's external IP address, or the string 'localhost' if the IP address        is not available.    """try:r=requests.get(METADATA_NETWORK_INTERFACE_URL,headers={"Metadata-Flavor":"Google"},timeout=2,)returnr.textexceptrequests.RequestException:logging.info("Metadata server could not be reached, assuming local.")return"localhost"