Python 3.9 ahora está disponible a nivel general.

Implementa y prueba tu aplicación

ID de región

REGION_ID es un código abreviado que Google asigna en función de la región que seleccionas cuando creas la app. El código no corresponde a un país ni a una provincia, aunque algunos ID de región puedan parecer similares a los códigos de país y provincia que se suelen usar. Incluir REGION_ID.r en las URL de App Engine es opcional en el caso de las apps existentes, y pronto será obligatorio para todas las apps nuevas.

A fin de garantizar una transición sin problemas, estamos actualizando App Engine de forma paulatina para usar los ID de región. Si aún no actualizamos tu proyecto de Google Cloud, no verás un ID de región para la app. Dado que el ID es opcional en las apps existentes, no es necesario que actualices las URL ni realices otros cambios una vez que el ID de región esté disponible en las apps existentes.

Obtén más información acerca de los ID de región.

Aprende cómo ejecutar tu aplicación de forma local, implementarla y probarla en App Engine.

Ejecuta de manera local

Para probar la funcionalidad antes de la implementación, ejecuta tu aplicación en un entorno local con las herramientas de desarrollo que sueles usar. Te recomendamos que uses las herramientas estándar de Python, como virtualenv, para crear entornos aislados y pytest a fin de ejecutar pruebas de unidades y pruebas de integración, en lugar de depender de dev_appserver, el servidor de desarrollo local que se proporciona con el SDK de Google Cloud.

Por ejemplo, para ejecutar una aplicación Flask con el servidor de desarrollo de Flask, por lo general, puedes usar lo siguiente:

python main.py

Las aplicaciones Django se pueden iniciar de la siguiente manera:

python manage.py runserver

Para simular un entorno de producción de App Engine, puedes ejecutar todo el servidor de la interfaz de puerta de enlace del servidor web (WSGI) de manera local. Para hacerlo, usa el mismo comando que se especifica como punto de entrada en tu app.yaml, por ejemplo:

gunicorn -b :$PORT main:app

Antes de implementar tu aplicación

Antes de implementar tu aplicación:

Implementa tu aplicación

Implementa la aplicación en App Engine mediante el comando gcloud app deploy.

Durante la implementación, el servicio Cloud Build compila una imagen de contenedor de la aplicación para ejecutar en el entorno estándar de App Engine. Obtén más información en la documentación Administra imágenes de compilación.

Para implementar tus apps de manera programática, usa la API de Administrador.

Implementa un servicio

Para implementar tu aplicación en App Engine, debes implementar versiones de sus servicios y cada uno de sus archivos de configuración.

Para implementar una versión del servicio de la aplicación, ejecuta el siguiente comando desde el directorio donde se encuentra ubicado el archivo app.yaml del servicio:

gcloud app deploy

Si no especificas los archivos con el comando, solo se implementará el archivo app.yaml en el directorio actual. De forma predeterminada, el comando deploy genera un ID único para la versión que implementas, implementa la versión en el proyecto de Google Cloud en el que configuraste la herramienta de línea de comandos de gcloud y enruta todo el tráfico a la versión nueva.

Puedes cambiar el comportamiento predeterminado del comando si orientas los archivos específicos o incluyes parámetros adicionales:

  • Para implementar los otros archivos de configuración de tu servicio, debes orientar y, luego, implementar cada archivo por separado. Por ejemplo:
    gcloud app deploy cron.yaml
    gcloud app deploy dispatch.yaml
    gcloud app deploy index.yaml
    
  • Para especificar un ID de versión personalizada, usa el marcador --version.
  • Para evitar que el tráfico se enrute de manera automática a la versión nueva, usa la marca --no-promote.
  • Para implementar en un proyecto de Google Cloud específico, usa la marca --project.

Por ejemplo, para implementar el servicio que define el archivo app.yaml en un proyecto específico de Google Cloud, asígnale un ID de versión personalizado y evita que el tráfico se enrute a la versión nueva:

gcloud app deploy --project PROJECT_ID --version VERSION_ID --no-promote

Para obtener más información sobre este comando, consulta la referencia de gcloud app deploy.

Implementa varios servicios

Puedes usar el mismo comando de implementación para implementar o actualizar varios de los servicios que conforman tu aplicación.

Para implementar varios servicios, implementa cada archivo app.yaml del servicio por separado. Puedes especificar varios archivos con un solo comando de gcloud app deploy:

gcloud app deploy service1/app.yaml service2/app.yaml

Requisitos para implementar varios servicios

  • Primero debes implementar una versión de la aplicación en el servicio default antes de poder crear y, luego, implementar los servicios posteriores.
  • El ID de cada uno de los servicios se debe especificar en los archivos de configuración app.yaml correspondientes. Para especificar el ID de servicio, incluye la definición del elemento service en cada archivo de configuración. De forma predeterminada, si se excluye la definición de este elemento del archivo de configuración, se implementa la versión en el servicio default.

Omite archivos

Puedes usar un archivo .gcloudignore para especificar los archivos y directorios que no se subirán a App Engine cuando implementes los servicios. Esto es útil para ignorar artefactos de compilación y otros archivos que no necesitan subirse con tu implementación.

Administra imágenes

Cada vez que implementas una versión nueva, se crea una imagen de contenedor con el servicio Cloud Build. Esa imagen de contenedor luego se ejecuta en el entorno estándar de App Engine.

Las imágenes de contenedor compiladas se guardan en la carpeta app-engine en Container Registry. Puedes descargar estas imágenes para mantenerlas o ejecutarlas en otro lugar. Una vez que se complete la implementación, App Engine no necesitará las imágenes de contenedor. Ten en cuenta que no se borran de forma automática, por lo que puedes borrar con seguridad cualquier imagen que no necesites para no alcanzar tu cuota de almacenamiento. Para obtener más información sobre cómo administrar imágenes en Container Registry, consulta la documentación de Container Registry.

Visualiza tu aplicación

Una vez que implementes la aplicación en App Engine, puedes ejecutar el siguiente comando para iniciar el navegador y visualizarla en https://PROJECT_ID.REGION_ID.r.appspot.com:

gcloud app browse

Prueba en App Engine antes de desviar el tráfico

Antes de configurar una nueva versión para recibir tráfico, puedes probarla en App Engine. Por ejemplo, para probar una versión nueva del servicio default, sigue estos pasos:

  1. Implementa tu versión nueva, pero evita que el tráfico se enrute de forma automática a ella:

    gcloud app deploy --no-promote

  2. Accede a la versión nueva desde la siguiente URL:

    https://VERSION_ID-dot-default-dot-PROJECT_ID.REGION_ID.r.appspot.com

    Ahora puedes probar tu versión nueva en el entorno de ejecución de App Engine. Puedes depurar tu aplicación si miras los registros. Para obtener más información, consulta Escribe registros de aplicaciones.

    En App Engine, las solicitudes enviadas a https://PROJECT_ID.REGION_ID.r.appspot.com se enrutan a la versión que se configuró antes para recibir tráfico.

  3. Cuando desees enviar tráfico a la nueva versión, usa Cloud Console para migrar el tráfico:

    Administra versiones

    Selecciona la versión que acabas de implementar y haz clic en Migrar tráfico.

Puedes usar el mismo proceso para probar las versiones nuevas de otros servicios si reemplazas default en la URL por el nombre del servicio:

https://VERSION_ID-dot-SERVICE_ID-dot-PROJECT_ID.REGION_ID.r.appspot.com

Para obtener más información sobre cómo orientar versiones y servicios específicos, consulta Enruta solicitudes.

Usa variables de entorno de compilación

También puedes configurar variables de entorno de compilación para entornos de ejecución que admitan paquetes de compilación.

Las variables de entorno de compilación son pares clave-valor implementados junto con una app que te permite pasar la información de configuración a los paquetes de compilación. Por ejemplo, puede que quieras personalizar las opciones del compilador. Puedes agregar o quitar estas variables de entorno de compilación si configuras el campo build_env_variables en tu archivo app.yaml.

Usa el servidor de desarrollo local

El SDK de Google Cloud incluye un servidor de desarrollo local llamado dev_appserver que puedes ejecutar de manera local para simular cómo se ejecuta la aplicación en producción en App Engine. Este servidor de desarrollo simula de forma parcial el entorno en el que se ejecuta tu aplicación.

Ejecuta el servidor de desarrollo local

Una vez creado el archivo de configuración app.yaml de la app, puedes iniciar el servidor de desarrollo local con el comando dev_appserver.py para ejecutar la aplicación de manera local.

  1. Para iniciar el servidor de desarrollo local, sigue estos pasos:

    Ejecuta el comando dev_appserver.py desde la raíz del directorio del proyecto. Especifica el ID del proyecto y la ruta de acceso al archivo app.yaml:

    dev_appserver.py --application=PROJECT_ID app.yaml

    Para cambiar el puerto, incluye la opción --port:

    dev_appserver.py --application=PROJECT_ID app.yaml --port=9999

    Para obtener más información sobre las opciones del comando dev_appserver.py, consulta Opciones del servidor de desarrollo local.

  2. Cuando se inicia el servidor de desarrollo local, se configura un entorno de desarrollo que instala de manera previa las dependencias en el archivo requirements.txt.

  3. El servidor de desarrollo local ahora ejecuta y recibe solicitudes. Visita http://localhost:8080/ en tu navegador web para ver la aplicación en acción.

    Si especificaste un puerto personalizado con la opción --port, recuerda abrir el navegador en ese puerto.

  4. Para detener el servidor local desde la línea de comandos, presiona Control-C en tu teclado.

Detecta el entorno de ejecución de la aplicación

Para determinar si tu código se ejecuta en producción o en el servidor de desarrollo local, puedes verificar la variable de entorno GAE_ENV:

if os.getenv('GAE_ENV', '').startswith('standard'):
  # Production in the standard environment
else:
  # Local execution.

Usa el servidor de desarrollo local con los servicios de Google Cloud

Puedes integrar dev_appserver con otros componentes de Google Cloud.

Bibliotecas cliente de Cloud

Muchas bibliotecas cliente de Google Cloud dependen de la presencia de la variable de entorno GOOGLE_CLOUD_PROJECT, que debería ser el ID de tu proyecto de Cloud. Para encontrar su valor, ejecuta el comando gcloud config list project o consulta la página de tu proyecto en Google Cloud Console.

Para asegurarte de que esta variable de entorno se configure de manera correcta durante el desarrollo local, inicializa dev_appserver mediante el parámetro --application=PROJECT_ID, como se muestra en el ejemplo anterior.

Emuladores de Cloud

Puedes probar la aplicación con emuladores para Cloud Datastore, Cloud Bigtable y Cloud Pub/Sub.

Vuelve a cargar de forma automática los cambios de requirements.txt y app.yaml

El servidor de desarrollo local instala de manera automática las dependencias en el archivo requirements.txt. dev_appserver también te permite probar la funcionalidad que se configura a través de app.yaml. Por ejemplo, puedes probar la habilidad de tu aplicación para entregar archivos estáticos. Cuando se ejecuta dev_appserver, cualquier cambio en requirements.txt y app.yaml reinicia de manera automática la aplicación para reflejar estos cambios. Esto podría generar una demora temporal a medida que se descargan y se instalan las dependencias.

Enrutamiento y administración de instancias en el servidor de desarrollo

Descubre direcciones de instancias

En el servidor de desarrollo local se crean todas las instancias de ajuste de escala manual en el inicio. Las instancias para los servicios de ajuste de escala automático y básico se administran de manera dinámica. El servidor asigna un puerto a cada servicio y los clientes pueden confiar en el servidor para balancear la carga y seleccionar una instancia de manera automática. Las asignaciones de puerto para darle una dirección a cada servicio aparecen en el flujo de mensajes de registro del servidor.

Estos son los puertos para una aplicación que define tres servicios:

INFO Starting module "default" running at: http://localhost:8084
INFO Starting module "service1" running at: http://localhost:8082
INFO Starting module "service2" running at: http://localhost:8083

Cuando usas la dirección de un servicio, por ejemplo http://localhost:8082/, el servidor crea o selecciona una instancia del servicio y envía la solicitud a esa instancia.

El servidor asigna puertos únicos a cada instancia de un servicio. Puedes usar el servidor de administración para descubrir estos puertos. Existe un puerto único para el servidor de administración, que aparece en el registro de mensajes:

INFO Starting admin server at: http://localhost:8000

Esta dirección te lleva a la consola del servidor de administración. Haz clic en Instancias para ver el estado dinámico de las instancias de tu app.

Aparece una entrada individual para cada instancia básica y manual. Los números de instancia son vínculos con direcciones de puerto únicas para cada instancia. Haz clic en el vínculo para enviar una solicitud directamente a esa instancia.

Archivos de envío

Si la aplicación incluye un archivo dispatch.yaml, la transmisión de mensajes de registro incluirá un puerto de despachador:

INFO Starting dispatcher running at: http://localhost:8080

Las solicitudes a este puerto se enrutan según las reglas del archivo de envío. El servidor no es compatible con las reglas del archivo dispatch.yaml, que incluye nombres de host, por ejemplo, url: "customer1.myapp.com/*". Las reglas con patrones de ruta de acceso relativos (url: "*/fun") funcionan, por lo que puedes usar URL como http://localhost/fun/mobile para alcanzar las instancias. El servidor informa un error en la transmisión de registro si intentas iniciar una aplicación con un archivo dispatch.yaml que contiene reglas basadas en el host.