El entorno de ejecución de Python es la pila de software encargada de instalar el código y las dependencias de tu aplicación y, luego, ejecutarla en el entorno flexible.
La versión
3.8
y las versiones posteriores se compilan a través de buildpacks, que requieren que elijas un sistema operativo en el archivoapp.yaml
. Por ejemplo, para usar Python 3.12, debes especificar Ubuntu 22 como el sistema operativo.La versión
3.7
y anteriores se compilan mediante Docker.
Para obtener la lista completa de las versiones de Python compatibles y sus versiones correspondientes de Ubuntu, consulta el programa de asistencia del entorno de ejecución.
Versiones nuevas del entorno de ejecución
Para la versión 3.8 y posteriores del entorno de ejecución de Python, debes incluir la configuración de runtime_config
y operating_system
en tu archivo app.yaml
para especificar un sistema operativo.
Para usar los nuevos entornos de ejecución, debes instalar la versión 420.0.0 o posterior de la CLI de gcloud
. Puedes actualizar las herramientas de la CLI si ejecutas el comando gcloud components update
.
Para ver la versión instalada, ejecuta el comando gcloud version
.
Opcional: Puedes especificar una versión del entorno de ejecución si incluyes la configuración runtime_version
en tu archivo app.yaml
. De forma predeterminada, se usa la última versión de Python si no se especifica la configuración runtime_version
.
Ejemplos
Para especificar Python 3.12 en Ubuntu 22, haz lo siguiente:
runtime: python env: flex entrypoint: gunicorn -b :$PORT main:app runtime_config: operating_system: "ubuntu22" runtime_version: "3.12"
Para especificar la última versión de Python compatible en Ubuntu 22, sigue estos pasos:
runtime: python env: flex entrypoint: gunicorn -b :$PORT main:app runtime_config: operating_system: "ubuntu22"
See the app.yaml
reference page for more information.
Versiones anteriores del entorno de ejecución
Para las versiones 3.7 y anteriores de Python, debes especificar una versión con la configuración de runtime_config
y python_version
en el archivo app.yaml
de tu aplicación.
Ejemplo
runtime: python
env: flex
entrypoint: gunicorn -b :$PORT main:app
runtime_config:
python_version: 3.7
En las versiones de Python 3.7 y anteriores, el intérprete predeterminado es Python 2.7.12 si se omite runtime_config
o python_version
. Por ejemplo, puedes usar el entorno de ejecución predeterminado si especificas runtime: python
en tu archivo app.yaml
:
runtime: python
env: flex
Consulta la página de referencia de app.yaml
para obtener más información.
Los intérpretes que se implementan para cada configuración se muestran en la siguiente tabla:
Configuración python_version |
Intérprete implementado | ID de entorno de ejecución | Ejemplo app.yaml |
---|---|---|---|
2 (predeterminada) |
2.7.12 | python2 |
runtime_config: python_version: 2 |
3.4 |
3.4.8 | python34 |
runtime_config: python_version: 3.4 |
3.5 |
3.5.9 | python35 |
runtime_config: python_version: 3.5 |
3 o 3.6 |
3.6.10 | python36 |
runtime_config: python_version: 3 |
3.7 |
3.7.9 | python37 |
runtime_config: python_version: 3.7 |
Otra compatibilidad con el entorno de ejecución de Python
Si la versión de Python deseada no aparece en la lista, hay varias opciones:
- Entorno flexible de App Engine: Crea un entorno de ejecución personalizado y selecciona una imagen base válida con la versión de Python que necesites.
- Entorno estándar de App Engine: Admite Python 3.7, 3.8, 3.9, 3.10 y 3.11.
- Cloud Functions: Admite Python 3.7, 3.8, 3.9 y 3.10.
- Cloud Run: Aloja tu aplicación en un contenedor según la imagen de contenedor de la versión de Python que necesitas (consulta la Guía de inicio rápido de Python). Como las imágenes de Python 3.10 ya están disponibles, puedes implementar esa versión hoy mismo.
Para el entorno flexible de App Engine o Cloud Run, consulta Compila entornos de ejecución personalizados a fin de obtener imágenes base proporcionadas por Google o imágenes base de Docker para Python para imágenes de Python disponibles actualmente, incluida la información de imágenes de Python 2.
Si deseas investigar más a fondo el alojamiento de apps de App Engine en contenedores para Cloud Run, consulta el codelab y el contenido de video que abarcan el alojamiento en contenedores con Docker o sin Docker. Ten en cuenta que, por el momento, este contenido solo abarca el entorno estándar de App Engine para las migraciones de Cloud Run.
Dependencias
El entorno de ejecución busca un archivo requirements.txt
en el directorio fuente de tu aplicación y usa pip
para instalar cualquier dependencia antes de iniciar la aplicación. Para obtener más información acerca de cómo declarar y administrar los paquetes, consulta Cómo usar las bibliotecas de Python.
Si tu aplicación requiere dependencias privadas, debes usar un entorno de ejecución personalizado basado en el entorno de ejecución de Python para instalar los paquetes adecuados.
Usar bibliotecas C con Python
Para habilitar el uso de paquetes de Python que requieren extensiones C, los encabezados de la versión de Python actual y los siguientes paquetes de Ubuntu vienen preinstalados en el sistema:
build-essential
ca-certificates
curl
gfortran
git
libatlas-dev
libblas-dev
libcurl4-openssl-dev
libffi-dev
libfreetype6-dev
libjpeg-dev
liblapack-dev
libmemcached-dev
libmysqlclient-dev
libpng12-dev
libpq-dev
libquadmath0
libsasl2-2
libsasl2-dev
libsasl2-modules
libsqlite3-dev
libssl-dev
libxml2-dev
libxslt1-dev
libz-dev
mercurial
netbase
pkg-config
sasl2-bin
swig
wget
zlib1g-dev
Estos paquetes permiten la instalación de las bibliotecas más populares de Python. Si la aplicación requiere otras dependencias del nivel del sistema operativo, deberás usar un entorno de ejecución personalizado basado en este entorno de ejecución para instalar los paquetes adecuados.
Inicio de la aplicación
El entorno de ejecución inicia tu aplicación mediante el entrypoint
definido en tu archivo app.yaml
. El punto de entrada debería iniciar un proceso que responda a solicitudes HTTP en el puerto definido por la variable de entorno PORT
.
La mayoría de las aplicaciones web usan un servidor WSGI, como Gunicorn, uWSGI o Waitress.
Antes de que puedas usar uno de estos servidores, debes agregarlos como una dependencia en el archivo requirements.txt
de tu aplicación.
Si usas gunicorn
para tu aplicación de Flask, asegúrate de que la versión de Python de tu aplicación sea compatible con gunicorn
.
El entorno de ejecución garantiza que todas las dependencias estén instaladas antes de que se llame al entrypoint.
Flask==2.0.2
gunicorn==20.1.0
Este es un ejemplo de un entrypoint que usa gunicorn para una aplicación Flask:
entrypoint: gunicorn -b :$PORT main:app
Este es un ejemplo de un entrypoint que usa gunicorn para una aplicación Django:
entrypoint: gunicorn -b :$PORT mydjangoapp:wsgi
Gunicorn es el servidor WSGI recomendado, pero es completamente posible utilizar cualquier otro servidor WSGI. Por ejemplo, el siguiente es un entrypoint que usa uWSGI con Flask:
entrypoint: uwsgi --http :$PORT --wsgi-file main.py --callable app
Para las aplicaciones que pueden controlar solicitudes sin un servidor WSGI, puedes simplemente ejecutar una secuencia de comandos de Python:
entrypoint: python main.py
Configuración recomendada para Gunicorn
Los ejemplos básicos de entrypoint antes mencionados pretenden ser puntos de partida y pueden funcionar para tus aplicaciones web. Sin embargo, la mayoría de las aplicaciones necesitarán configurar aún más el servidor WSGI. En lugar de especificar todas las configuraciones en el entrypoint, crea un archivo gunicorn.conf.py
en el directorio raíz de tu proyecto, donde se encuentra tu archivo app.yaml
, y especifícalo en el entrypoint:
entrypoint: gunicorn -c gunicorn.conf.py -b :$PORT main:app
Puedes leer sobre todos los valores de configuración de Gunicorn en la documentación.
Trabajadores
Gunicorn utiliza trabajadores para controlar las solicitudes. De manera predeterminada, Gunicorn utiliza trabajadores de sincronización. Esta clase de trabajadores es compatible con todas las aplicaciones web, pero cada trabajador puede controlar solamente una solicitud a la vez. De manera predeterminada, gunicorn solo usa uno de estos trabajadores. A menudo, esto puede hacer que no se utilicen correctamente tus instancias y aumentar la latencia en aplicaciones con cargas importantes.
Te recomendamos configurar una cantidad de trabajadores equivalente a de 2 a 4 veces la cantidad de núcleos de CPU para tu instancia, más uno. Puedes especificar esto en gunicorn.conf.py
de la siguiente manera:
import multiprocessing
workers = multiprocessing.cpu_count() * 2 + 1
Además, algunas aplicaciones web que están mayormente vinculadas a la E/S pueden registrar una mejora en el rendimiento si utilizan una clase diferente de trabajadores.
Si tu clase de trabajador requiere dependencias adicionales, como gevent o tornado, esas dependencias deberán declararse en el requirements.txt
de tu aplicación.
Proxies HTTPS y de reenvío
App Engine finaliza la conexión HTTPS en el balanceador de cargas y reenvía la solicitud a la aplicación. La mayoría de las aplicaciones no necesitan saber si la solicitud se envió a través de HTTPS o no, pero en aquellas que se necesita esta información, se debe configurar Gunicorn para que confíe en el proxy de App Engine en su gunicorn.conf.py
:
forwarded_allow_ips = '*'
secure_scheme_headers = {'X-FORWARDED-PROTO': 'https'}
Gunicorn ahora garantizará que wsgi.url_scheme
sea 'https'
, que la mayoría de los frameworks usarán como un indicador de la solicitud. Si tu servidor o framework WSGI no es compatible, verifica el valor del encabezado X-Forwarded-Proto
de forma manual.
Algunas aplicaciones también necesitan verificar la dirección IP del usuario. Esta está disponible en el encabezado estándar X-Forwarded-For
.
Ten en cuenta que la configuración secure_scheme_headers
en gunicorn.conf.py
debe estar en mayúscula, como X-FORWARDED-PROTO
, pero los encabezados que tu código puede leer en mayúsculas y minúsculas, como X-Forwarded-Proto
.
Extiende el tiempo de ejecución
El entorno de ejecución de Python del entorno flexible se puede usar para crear un entorno de ejecución personalizado. Consulta Personaliza Python para obtener más información.
Variables de entorno
Las siguientes variables del entorno se configuran mediante el entorno de ejecución:
Variable del entorno | Descripción |
---|---|
GAE_INSTANCE |
El nombre de la instancia actual. |
GAE_MEMORY_MB |
La cantidad de memoria disponible para el proceso de la aplicación. |
GAE_SERVICE |
El nombre del servicio especificado en el archivo app.yaml de la aplicación; si no se especifica ningún nombre, se configura como default . |
GAE_VERSION |
La etiqueta de versión de la aplicación actual. |
GOOGLE_CLOUD_PROJECT |
El ID del proyecto asociado con la aplicación, que se puede ver en la consola de Google Cloud. |
PORT |
El puerto que recibirá las solicitudes HTTP. |
Puedes establecer variables de entorno adicionales en el archivo app.yaml
.
Servidor de metadatos
Cada instancia de la aplicación puede usar el servidor de metadatos de Compute Engine para consultar información acerca de la instancia, incluidos el nombre del host, la dirección IP externa, el ID de la instancia, los metadatos personalizados y la información de la cuenta de servicio. App Engine no permite establecer metadatos personalizados para cada instancia; sin embargo, puedes establecer metadatos personalizados de todo el proyecto y leerlos desde las instancias de App Engine y Compute Engine.
Esta función de ejemplo usa el servidor de metadatos para obtener la dirección IP externa de la instancia: