Como usar o Gradle e o plug-in do App Engine

Use o Gradle, um sistema de automação de versão flexível e declarativo, para automatizar as etapas de criação, teste, publicação e implantação. Nesta página, explicamos como usar o Gradle com um projeto do App Engine no ambiente padrão.

Antes de começar

Instale e configure os seguintes pré-requisitos:

Como configurar e validar seu projeto do Google Cloud

Configure seu projeto do Google Cloud e instale a CLI gcloud:

  1. Use o Console do Google Cloud para criar e configurar seu projeto do Google Cloud:

    Acessar o App Engine

    1. Selecione ou crie um projeto do Google Cloud.
    2. Siga as instruções para certificar-se de que há um aplicativo do App Engine e de que o faturamento está ativado:
      1. Para criar um aplicativo do App Engine para o projeto, será enviada uma instrução para selecionar a região em que o aplicativo ficará localizado.
      2. Siga as instruções para criar uma nova conta de faturamento ou selecione uma conta atual.
    3. O Painel será aberto após a criação do aplicativo do App Engine e a ativação do faturamento no projeto.
  2. Não é necessário instalar a CLI gcloud porque o plug-in instala o SDK automaticamente quando necessário.

Como criar um novo projeto do Gradle

É possível criar um novo projeto do Gradle do zero usando o shell. Outra opção para testar o plug-in é fazer o download, a execução local e a implantação do projeto “Hello World”.

  1. Crie e insira um novo diretório.

  2. Para inicializar um novo projeto:

    gradle init --type java-library;
    mkdir -p src/main/webapp/WEB-INF;
    rm src/main/java/Library.java src/test/java/LibraryTest.java
    
  3. Adicione os seguintes elementos ao seu arquivo build.gradle para adicionar tarefas do Gradle do App Engine, repositórios Maven, o plug-in do Gradle do App Engine, dependências e a configuração de tarefas:

    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.5.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 {
      implementation 'com.google.appengine:appengine-api-1.0-sdk:+'  // Latest App Engine Api's
      providedCompile 'javax.servlet:javax.servlet-api:3.1.0'
    
      implementation 'jstl:jstl:1.2'
    
    // Add your dependencies here.
    //  implementation 'com.google.cloud:google-cloud:+'   // Latest Cloud API's http://googlecloudplatform.github.io/google-cloud-java
    
      testImplementation 'junit:junit:4.13.2'
      testImplementation 'com.google.truth:truth:1.1.5'
      testImplementation 'org.mockito:mockito-core:4.11.0'
    
      testImplementation 'com.google.appengine:appengine-testing:+'
      testImplementation 'com.google.appengine:appengine-api-stubs:+'
      testImplementation '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. Você também precisa adicionar ao projeto os arquivos abaixo, usando um editor de texto ou um ambiente de desenvolvimento integrado (IDE, na sigla em inglês):

Consulte Arquivos de configuração para ter uma visão geral de um projeto do Java App Engine.

Como fazer o download do app Hello World

  1. Clone o repositório do app de amostra Hello World na máquina local:

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

    Também é possível fazer o download da amostra como um arquivo zip e extraí-lo.

  2. Acesse o diretório que contém o código de amostra:

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

Como testar o aplicativo com o servidor de desenvolvimento

  1. Em seu projeto, para acessar os recursos do Google durante a execução local, configure as credenciais padrão do aplicativo executando:

    gcloud auth application-default login
    
  2. Mude para a raiz do diretório do aplicativo.

  3. Durante a fase de desenvolvimento, é possível executar e testar o aplicativo a qualquer momento no servidor de desenvolvimento invocando o Gradle:

    gradle appengineRun
    

    Você também pode executar o Gradle sem instalá-lo, basta usar o wrapper do Gradle.

  4. Aguarde a inicialização do servidor. O servidor é iniciado com o aplicativo em execução, quando você vê uma mensagem semelhante a esta:

    :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. Acesse seu app em execução em http://127.0.0.1:8080.

Como depurar no servidor de desenvolvimento

Para depurar um aplicativo em execução local, defina a propriedade jvmFlags para ativar a depuração na JVM subjacente, por exemplo:

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

Ativar a atualização a quente do aplicativo

Atualização a quente é a capacidade de atualizar uma ou mais classes em um aplicativo atualmente em execução sem interromper o ambiente. Para ativar a atualização a quente:

  • Você precisa instruir o servidor local a procurar alterações:

    appengine {
      run {
        automaticRestart = true
      }
    }
    
  • Com o aplicativo em execução, execute a tarefa explodeWar para copiar as alterações no aplicativo explodido diretamente e propagá-las no aplicativo em execução.

Implantar o aplicativo

Para implantar o aplicativo:

gradle appengineDeploy

A tarefa appengineDeploy e todas as outras tarefas do Gradle têm propriedades associadas que podem ser usadas. Para uma lista completa de tarefas e propriedades, consulte Tarefas e propriedades do Gradle do App Engine.

Como usar o wrapper do Gradle

O Gradle oferece um mecanismo para download e execução da versão obrigatória dele sem instalação:

Linux/macOS

./gradlew appengineRun

Windows

gradlew.bat appengineRun

Informações extras sobre o Gradle podem ser encontradas em Tarefas e propriedades do Gradle do App Engine.

A seguir