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:

Configurar e validar o projeto do GCP

Você precisa configurar o projeto do GCP e instalar o Cloud SDK:

  1. Use o console do Google Cloud Platform para criar e configurar o projeto do GCP:

    Acessar o App Engine

    1. Selecione ou crie um novo projeto do GCP.
    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. Para ativar o faturamento do projeto, será enviada uma solicitação para criar uma nova conta de faturamento ou selecionar uma 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. Você não precisa instalar o Cloud SDK, o plug-in fará isso 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. Para adicionar as tarefas do Gradle do App Engine, os repositórios do Maven, o plug-in do Gradle para App Engine, as dependências e a configuração da tarefa, adicione ao arquivo build.gradle o elemento abaixo:

    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:1.+'    // Latest 1.x.x release
      }
    }
    
    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
    
      }
    }
    
    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 o início rápido para uma visão geral de um projeto Java do 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/getting-started-java.git
    

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

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

    cd getting-started-java-master/appengine-standard-java8/helloworld
    

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

Como depurar no servidor de desenvolvimento

Para depurar um aplicativo executado localmente, 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.

Como implantar o aplicativo

Para implantar o aplicativo:

gradle appengineDeploy

A tarefa appengineDeploy e todas as outras tarefas do Gradle têm propriedades associadas que você pode usar. 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

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Ambiente padrão do App Engine para Java 8