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

Você pode usar 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 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 os avisos para verificar se existe um aplicativo do App Engine e se o faturamento está ativado:
      1. Se precisar criar um aplicativo do App Engine para o projeto, você verá uma solicitação para selecionar a região em que o aplicativo do App Engine ficará localizado.
      2. Se precisar ativar o faturamento para o projeto, você verá uma solicitação para criar uma nova conta de faturamento ou selecionar uma existente.
    3. O Painel será aberto após a criação do aplicativo do App Engine e a ativação do faturamento no projeto.
  2. Instale e inicialize o Google Cloud SDK.

    Se você já tiver a ferramenta gcloud instalada e quiser configurá-la para usar um código de projeto do GCP diferente do inicializado, consulte Como gerenciar configurações do Cloud SDK.

  3. Instale o SDK do App Engine para Java:

    gcloud components install app-engine-java
    

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 o seguinte trecho ao arquivo build.gradle para adicionar tarefas do Gradle do App Engine, repositórios do Maven, o plug-in Gradle do App Engine, dependências e a configuração da tarefa:

    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. Você também precisa 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
    

Como testar o aplicativo com o servidor de desenvolvimento

  1. Para acessar os recursos do Google do projeto durante a execução local, defina 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, você pode 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 {
        jvmFlags = ["-Dappengine.fullscan.seconds=5"]
      }
    }
    
  • 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.

Próximas etapas

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

Enviar comentários sobre…

Ambiente padrão do App Engine para Java