Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cloud.google.com/appengine/docs/standard/python3/runtime below:

Python 3 Runtime Environment | Google App Engine standard environment docs

Stay organized with collections Save and categorize content based on your preferences.

The Python runtime is the software stack responsible for installing your web service's code and its dependencies and running your App Engine service.

The Python runtime for App Engine in the standard environment is declared in the app.yaml file:

runtime: pythonVERSION

Where VERSION is the Python MAJOR and MINOR version numbers. For example, to use the latest Python version, Python 3.13, specify 313.

For other supported Python versions, and the corresponding Ubuntu version for your Python version, see the Runtime support schedule.

The latest supported Python version is 3.13. The Python runtime uses the latest stable release of the version that is specified in your app.yaml file. App Engine automatically updates to new patch versions, but it does not automatically update the minor version.

For example, your application might be deployed at Python 3.7.0 and later automatically updated to Python 3.7.1, but it will not be automatically updated to the next minor version Python 3.8.0.

If you're new to Google Cloud, create an account to evaluate how App Engine performs in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

App Engine runs Python apps in a container secured by gVisor on an up-to-date Ubuntu Linux distribution.

During deployment, App Engine uses the Python package manager pip to install dependencies defined in the requirements.txt metadata file located in your project's root directory. You do not need to upload dependencies as App Engine performs a fresh install.

Dependency specification using the Pipfile/Pipfile.lock standard is currently not supported and your project must not have these files present.

The runtime starts your app by running the command you specify in the entrypoint field in your app.yaml file. If you have configured a Gunicorn web server entrypoint in the app.yaml file, you must also add gunicorn to your requirements.txt file.

The entrypoint should start a web server that listens on the port specified by the PORT environment variable. For example:

entrypoint: gunicorn -b :$PORT main:app

The web framework that your app uses is responsible for routing requests to the appropriate handlers in your app.

If your app meets the following requirements, App Engine will start your app with the gunicorn web server if you don't specify the entrypoint field:

• The root of your app directory contains a main.py file with a WSGI-compatible object called app.

• Your app does not contain Pipfile or Pipfile.lock files.

If you do not specify an entrypoint for the Python 3 runtime, App Engine configures and starts the default Gunicorn web server.

• Ensure the Python module required to run the specified entrypoint in app.yaml is present in the requirements.txt file. Add gunicorn to the requirements.txt file only if a gunicorn endpoint is explicitly specified in the app.yaml file.

• For the best performance, the entrypoint should be lightweight because it runs whenever a new instance of your application is created.

• You can use the entrypoint field to tune the performance of your app. For example, if you use gunicorn as your web server, you can use the --workers flag in the entrypoint field to configure the number of workers serving your app.

  The number of workers you specify should match the instance class of your App Engine app:

  Instance class Workers F1 2 F2 4 F4 8 F4_1G 8 B1 2 B2 4 B4 8 B4_1G 8 B8 8

  This guidance serves as a starting point for selecting the number of workers. You may need to use a different number of workers depending on your app's performance characteristics. The example below shows an App Engine deployment that uses two gunicorn workers for serving apps:

  entrypoint: gunicorn -b :$PORT -w 2 main:app
  

• We recommend that you configure your web server to listen and respond to HTTP requests on the port specified by your $PORT environment variable. Using the default port 8080 prevents App Engine from using its NGINX layer to compress HTTP responses. Note that if you use port 8080, warnings about port 8080 and NGINX will show in your app's log files.

In addition to Django and Flask, you can use other web frameworks with App Engine, such as uwsgi and Tornado. The following example shows how to use uwsgi with App Engine:

The following environment variables are set by the runtime:

You can define additional environment variables in your app.yaml file, but the above values cannot be overridden, except for NODE_ENV.

App Engine terminates HTTPS connections at the load balancer and forwards requests to your application. Some applications need to determine the original request IP and protocol. The user's IP address is available in the standard X-Forwarded-For header. Applications that require this information should configure their web framework to trust the proxy.

The runtime includes a full filesystem. The filesystem is read-only except for the location /tmp, which is a virtual disk storing data in your App Engine instance's RAM.

Each instance of your application can use the App Engine metadata server to query information about the instance and your project.

You can access the metadata server through the following endpoints:

• http://metadata
• http://metadata.google.internal

Requests sent to the metadata server must include the request header Metadata-Flavor: Google. This header indicates that the request was sent with the intention of retrieving metadata values.

The following table lists the endpoints where you can make HTTP requests for specific metadata:

For example, to retrieve your project ID, send a request to http://metadata.google.internal/computeMetadata/v1/project/project-id.

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.

Last updated 2025-07-02 UTC.

[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Hard to understand","hardToUnderstand","thumb-down"],["Incorrect information or sample code","incorrectInformationOrSampleCode","thumb-down"],["Missing the information/samples I need","missingTheInformationSamplesINeed","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2025-07-02 UTC."],[[["The Python runtime for App Engine's standard environment is specified in the `app.yaml` file using the format `runtime: python\u003cVERSION\u003e`, where VERSION represents the major and minor Python version numbers."],["App Engine automatically updates to new patch versions of Python, but minor version updates (e.g., from 3.7 to 3.8) are not automatic and need manual configuration."],["During deployment, App Engine uses `pip` to install dependencies listed in the `requirements.txt` file, and dependency specification using `Pipfile` or `Pipfile.lock` is not supported."],["The `entrypoint` field in `app.yaml` specifies the command to start your app, and if unspecified, App Engine will start the app with `gunicorn` if it meets certain conditions, such as having a `main.py` file with a WSGI-compatible object called `app`."],["App Engine sets various environment variables like `PORT`, `GAE_APPLICATION`, and `GAE_VERSION`, and allows defining additional custom environment variables within the `app.yaml` file, excluding overriding the built-in ones."]]],[]]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4