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 Cloud

Configure seu projeto do Cloud e instale a CLI gcloud:

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

    Acessar o App Engine

    1. Selecione ou crie um novo projeto do 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:

    appengine-java8/helloworld/build.gradle 
    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.4.3' // 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.3'
  testImplementation 'org.mockito:mockito-all:1.10.19'

  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. Também é necessário adicionar os seguintes arquivos ao projeto 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. Com o servidor iniciado e o aplicativo em execução, 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. Veja 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