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 las funciones de tu aplicación antes de la implementación, ejecútala en un entorno local con las herramientas de desarrollo que sueles usar.

Antes de implementar tu aplicación

Antes de implementar tu aplicación:

Implementa tu aplicación

Puedes usar cualquiera de las siguientes técnicas para implementar la app:

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

Implementa el código fuente de la app

Si usas Maven o Gradle para administrar las compilaciones locales de la app y, si todas las dependencias de la app están disponibles de forma pública, puedes ingresar el comando gcloud app deploy del directorio que contiene los archivos pom.xml o build.gradle de la app:

gcloud app deploy

El comando le indica a Cloud Build que use paquetes de compilación de App Engine para compilar la app y, luego, implementarla en App Engine.

Si usas Maven, sucede lo siguiente:

  • El paquete de compilación usa el siguiente comando de compilación: mvn clean package --batch-mode -DskipTests

  • Si el directorio raíz de la app contiene un archivo mvnw, el comando de compilación sustituye ./mvnw en lugar de mvn. A continuación, Cloud Build busca en el directorio target el archivo .jar con una entrada de manifiesto de clase principal y crea un entrypoint con el valor java -jar <jarfile>.

Si usas Gradle, sucede lo siguiente:

  • El paquete de compilación usa el siguiente comando de compilación: gradle clean assemble -x test --build-cache

  • Si el directorio raíz de la app contiene un archivo gradlew, el comando de compilación sustituye ./gradlew en lugar de gradle. A continuación, Cloud Build busca en el directorio build/libs el archivo .jar con una entrada de manifiesto de clase principal y crea un entrypoint con el valor java -jar <jarfile>.

  • Asegúrate de que no haya pom.xml en la raíz del proyecto. Los proyectos de Maven tienen prioridad sobre los proyectos de Gradle.

Cloud Build transmite registros de compilación y de implementación, y puedes verlos en la sección del historial de Cloud Build de Cloud Console.

Ten en cuenta lo siguiente sobre esta técnica de implementación:

  • Si la app tiene dependencias que solo están disponibles de forma local, Cloud Build no podrá compilar la app y la implementación fallará. En este caso, recomendamos usar el complemento de Maven de App Engine o Gradle.

  • Cuando compilas la app, usas la cuota de Cloud Build; cuando almacenas el código fuente de la app, usas la cuota de Cloud Storage. Cloud Build y Cloud Storage ofrecen cuotas gratuitas, por lo que no se generarán costos por implementar apps de App Engine hasta que las superes. Para obtener más información, consulta Precios.

  • Por el momento, no es posible especificar argumentos adicionales para el comando de compilación de Gradle. Para obtener más información, consulta la Herramienta de seguimiento de errores de Google.

Usa el complemento de App Engine para Maven o Gradle

App Engine proporciona complementos de Maven y Gradle que puedes usar para compilar y, luego, implementar la app. Por ejemplo, después de configurar el complemento de Maven de App Engine, puedes ingresar el siguiente comando desde el directorio que contiene el archivo pom.xml del proyecto:

mvn package appengine:deploy -Dapp.deploy.projectId=PROJECT_ID

Reemplaza PROJECT_ID por el ID del proyecto de Cloud. Si tu archivo pom.xml ya especifica tu ID del proyecto, no necesitas incluir la propiedad -Dapp.deploy.projectId en el comando que ejecutas.

Para obtener más información, consulta Usa Apache Maven y el complemento de App Engine o Usa Gradle y el complemento de App Engine.

Implementa un JAR ejecutable

Usa cualquier framework de compilación a fin de compilar un JAR ejecutable de forma local y, luego, realiza una de las siguientes acciones según si creaste un archivo app.yaml para la app:

  • Si creaste un archivo app.yaml, haz lo siguiente:

    1. Copia el archivo en el mismo directorio que el archivo JAR ejecutable que creaste.

    2. En el directorio que contiene el app.yaml y el JAR, ingresa el siguiente comando:

      gcloud app deploy
  • Si no creaste un archivo app.yaml, ingresa el siguiente comando:

    gcloud app deploy your-executable.jar

    gcloud app deploy creará un archivo app.yaml que contiene la configuración mínima, con todos los valores predeterminados.

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:

    mvn appengine:deploy -Dapp.deploy.projectId=PROJECT_ID -Dapp.deploy.promote=False

  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 Depurador de Cloud

Puedes usar Debugger para inspeccionar el estado de la app implementada en cualquier ubicación del código, sin detener ni ralentizar la app en ejecución.

Para usar Debugger con una app de Java 11, debes incluir la siguiente marca en el campo entrypoint del archivo app.yaml:

-agentpath:/opt/cdbg/cdbg_java_agent.so=--log_dir=/var/log

Si ya especificaste entrypoint en app.yaml, agrega la marca agentpath al comando java en el campo entrypoint.

Si no especificaste el campo entrypoint o si generas el archivo app.yaml cuando implementas la app, App Engine agrega la marca al comando que usa para iniciar la app.

Usa Cloud Profiler

Cloud Profiler es un generador de perfiles estadístico y de baja sobrecarga que recopila de manera continua información de las aplicaciones de producción sobre la asignación de memoria y el uso de la CPU. Le asigna esa información al código fuente de la app, lo que te ayuda a identificar las partes de la app que consumen más recursos y a entender mejor las características de rendimiento del código.

Para usar Cloud Profiler, configura los archivos de configuración de la app como se describe en Inicia tu programa y vuelve a implementarla.