Usa Gradle y el complemento de App Engine

Puedes usar Gradle, un sistema de automatización de compilación flexible que es declarativo y se usa para automatizar la compilación, las pruebas, la publicación y la implementación. En esta página, se explica cómo usar Gradle con un proyecto de App Engine en el entorno estándar.

Antes de comenzar

Instala y configura los siguientes requisitos previos:

Configura y valida tu proyecto de Cloud

Debes configurar tu proyecto de Cloud y, luego, instalar el SDK de Cloud:

  1. Usa Google Cloud Console para crear y configurar tu proyecto de Cloud:

    Ir a App Engine

    1. Selecciona o crea un proyecto de Cloud nuevo.
    2. Sigue las indicaciones para asegurarte de que exista una aplicación de App Engine y de que la facturación esté habilitada:
      1. Si necesitas crear una aplicación de App Engine para tu proyecto, se te solicitará que selecciones la región donde quieres que se ubique tu aplicación de App Engine.
      2. Sigue las instrucciones para crear una cuenta de facturación nueva o seleccionar una existente.
    3. El Panel se abrirá después de crear la aplicación de App Engine y de habilitar la facturación de tu proyecto.
  2. No es necesario que instales el SDK de Cloud porque el complemento lo instala de manera automática cuando es necesario.

Crea un proyecto de Gradle nuevo

Puedes crear un proyecto de Gradle nuevo desde cero con el shell. O bien, si quieres probar el complemento, puedes descargar, ejecutar de forma local y, luego, implementar el proyecto de Hello World.

  1. Crea un directorio nuevo y, luego, ingrésalo.

  2. Para inicializar un proyecto nuevo, sigue estos pasos:

    gradle init --type java-library;
    mkdir -p src/main/webapp/WEB-INF;
    rm src/main/java/Library.java src/test/java/LibraryTest.java
    
  3. Agrega el siguiente comando a tu archivo build.gradle para agregar las tareas y el complemento de App Engine Gradle, los repositorios de Maven, las dependencias y la configuración de las tareas.

    buildscript {    // Configuration for building
      repositories {
        jcenter()    // Bintray's repository - a fast Maven Central mirror & more
        mavenCentral()
      }
      dependencies {
        classpath 'com.google.cloud.tools:appengine-gradle-plugin:2.2.0' // If a newer version is available, use it
      }
    }
    
    repositories {   // repositories for Jar's you access in your code
      maven {
        url 'https://oss.sonatype.org/content/repositories/snapshots' // SNAPSHOT repository (if needed)
      }
      mavenCentral()
      jcenter()
    }
    
    apply plugin: 'java'                              // standard Java tasks
    apply plugin: 'war'                               // standard Web Archive plugin
    apply plugin: 'com.google.cloud.tools.appengine'  // App Engine tasks
    
    dependencies {
      compile 'com.google.appengine:appengine-api-1.0-sdk:+'  // Latest App Engine Api's
      providedCompile 'javax.servlet:javax.servlet-api:3.1.0'
    
      compile 'jstl:jstl:1.2'
    
    // Add your dependencies here.
    //  compile 'com.google.cloud:google-cloud:+'   // Latest Cloud API's http://googlecloudplatform.github.io/google-cloud-java
    
      testCompile 'junit:junit:4.12'
      testCompile 'com.google.truth:truth:0.33'
      testCompile 'org.mockito:mockito-all:1.10.19'
    
      testCompile 'com.google.appengine:appengine-testing:+'
      testCompile 'com.google.appengine:appengine-api-stubs:+'
      testCompile 'com.google.appengine:appengine-tools-sdk:+'
    }
    
    // Always run unit tests
    appengineDeploy.dependsOn test
    appengineStage.dependsOn test
    
    appengine {  // App Engine tasks configuration
      deploy {   // deploy configuration
        projectId = System.getenv('GOOGLE_CLOUD_PROJECT')
        version = '1'
      }
    }
    
    test {
      useJUnit()
      testLogging.showStandardStreams = true
      beforeTest { descriptor ->
         logger.lifecycle("test: " + descriptor + "  Running")
      }
    
      onOutput { descriptor, event ->
         logger.lifecycle("test: " + descriptor + ": " + event.message )
      }
      afterTest { descriptor, result ->
        logger.lifecycle("test: " + descriptor + ": " + result )
      }
    }
    
    group   = "com.example.appenginej8"        // Generated output GroupId
    version = "1.0-SNAPSHOT"       // Version in generated output
    
    sourceCompatibility = 1.8     // App Engine Flexible uses Java 8
    targetCompatibility = 1.8     // App Engine Flexible uses Java 8
  4. También debes agregar los siguientes archivos a tu proyecto mediante un editor de texto o un entorno de desarrollo integrado (IDE):

Consulta Archivos de configuración para obtener una descripción general de un proyecto de App Engine en Java.

Descarga la app de Hello World

  1. Clona el repositorio de la app de muestra Hello World a la máquina local:

    git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
    

    De manera opcional, puedes descargar la muestra como un archivo zip y extraerla.

  2. Ve al directorio que contiene el código de muestra:

    cd java-docs-samples/appengine-java8/helloworld
    

Prueba tu aplicación con el servidor de desarrollo

  1. Si deseas acceder a los recursos de Google desde tu proyecto cuando ejecutas de forma local, usa el siguiente comando para configurar las credenciales predeterminadas de la aplicación:

    gcloud auth application-default login
    
  2. Cambia a la raíz del directorio de tu aplicación.

  3. Durante la fase de desarrollo, puedes invocar Gradle para ejecutar y probar tu aplicación en cualquier momento en el servidor de desarrollo:

    gradle appengineRun
    

    También tienes la opción de ejecutar Gradle sin instalarlo si usas el wrapper de Gradle.

  4. Espera a que inicie el servidor. El servidor se inicia mientras tu aplicación está en ejecución, y ves un mensaje como el siguiente:

    :compileJava
    :processResources NO-SOURCE
    :classes
    :war
    :explodeWar
    :assemble
    :appengineRun
    2018-06-05 22:50:46.231:INFO::main: Logging initialized @321ms
    Jun 06, 2018 2:50:49 AM com.google.appengine.tools.development.AbstractModule startup
    INFO: Module instance default is running at http://localhost:8080/
    Jun 06, 2018 2:50:49 AM com.google.appengine.tools.development.AbstractModule startup
    INFO: The admin console is running at http://localhost:8080/_ah/admin
    Jun 05, 2018 10:50:49 PM com.google.appengine.tools.development.DevAppServerImpl doStart
    INFO: Dev App Server is now running
    
  5. Observa cómo se ejecuta tu app en http://127.0.0.1:8080.

Depura en el servidor de desarrollo

Para depurar una aplicación que se ejecuta de manera local, configura la propiedad jvmFlags a fin de habilitar la depuración en la JVM subyacente, por ejemplo:

    appengine {
      run {
        jvmFlags = ['-Xdebug', '-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005']
      }
    }

Habilita la carga en caliente de la aplicación

Carga en caliente es la capacidad de actualizar una o más clases en una aplicación que se está ejecutando actualmente sin detener el entorno. Para habilitar la carga en caliente, sigue estos pasos:

  • Debes indicarle al servidor local que analice los cambios:

    appengine {
      run {
        automaticRestart = true
      }
    }
    
  • Mientras tu app se está ejecutando, ejecuta la tarea explodeWar para copiar los cambios directamente en la aplicación explotada y propagar los cambios en la aplicación en ejecución.

Implementa tu aplicación

Para implementar tu aplicación:

gradle appengineDeploy

La tarea appengineDeploy, al igual que las otras tareas de Gradle, tienen propiedades asociadas que puedes usar. Si deseas obtener una lista completa de tareas y propiedades, consulta Tareas y propiedades de Gradle para App Engine.

Usa el wrapper de Gradle

Gradle proporciona un mecanismo para descargar y ejecutar la versión que se requiere sin instalación:

Linux/macOS

./gradlew appengineRun

Windows

gradlew.bat appengineRun

Puedes encontrar información adicional sobre Gradle en Tareas y propiedades de Gradle para App Engine.

Qué sigue