Usar o Gradle e o App Engine Plugin

Pode usar o Gradle, um sistema de automatização de compilação flexível que é declarativo e usado para automatizar a compilação, os testes, a publicação e a implementação. Esta página explica 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 seu Google Cloud projeto

Tem de configurar o seu Google Cloud projeto e instalar a CLI gcloud:

  1. Use a Google Cloud consola para criar e configurar o seu Google Cloud projeto:

    Aceder ao App Engine

    1. Selecione ou crie um novo Google Cloud projeto.
    2. Siga as instruções para garantir que existe uma aplicação do App Engine e que a faturação está ativada:
      1. Se precisar de criar uma aplicação do App Engine para o seu projeto, é-lhe pedido que selecione a região onde quer que a aplicação do App Engine esteja localizada.
      2. Siga as instruções para criar uma nova conta de faturação ou selecionar uma conta existente.
    3. O Painel de controlo é aberto depois de a aplicação do App Engine ter sido criada e a faturação ter sido ativada no seu projeto.

  2. Não tem de instalar a CLI gcloud porque o plug-in instala automaticamente o SDK quando necessário.

Criar um novo projeto do Gradle

Pode criar um novo projeto Gradle do zero através da shell. Em alternativa, para experimentar o plug-in, pode transferir, executar localmente e implementar o projeto Hello World.

  1. Criar e introduzir 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 ao ficheiro build.gradle para adicionar tarefas do App Engine Gradle, repositórios Maven, o plug-in Gradle do App Engine, dependências e 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. Também tem de adicionar os seguintes ficheiros ao seu projeto através de um editor de texto ou de um ambiente de programação integrado (IDE):

Consulte os ficheiros de configuração para uma vista geral de um projeto do Java App Engine.

Transferir a app Hello World

  1. Clone o repositório da app de exemplo Hello World para a sua máquina local:

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

    Em alternativa, pode transferir o exemplo como um ficheiro ZIP e extraí-lo.

  2. Altere para o diretório que contém o código de exemplo:

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

Testar a sua aplicação com o servidor de desenvolvimento

  1. Para aceder aos recursos Google a partir do seu projeto quando executado localmente, defina as credenciais predefinidas da aplicação executando:

    gcloud auth application-default login

  2. Altere para a raiz do diretório da aplicação.

  3. Durante a fase de desenvolvimento, pode executar e testar a sua aplicação em qualquer altura no servidor de desenvolvimento invocando o Gradle:

    gradle appengineRun

    Em alternativa, pode executar o Gradle sem o instalar usando o wrapper do Gradle.

  4. Aguarde que o servidor seja iniciado. O servidor é iniciado com a sua aplicação em execução quando 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 a sua app em execução em http://127.0.0.1:8080.

Depuração no servidor de programação

Para depurar uma aplicação executada 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 recarga rápida da aplicação

O recarregamento rápido é a capacidade de atualizar uma ou mais classes numa aplicação que está atualmente em execução sem parar o ambiente. Para ativar a recarga rápida:

  • Tem de indicar ao servidor local que procure alterações:

    appengine {
  run {
    automaticRestart = true
  }
}

  • Enquanto a app está em execução, execute a tarefa explodeWar para copiar as alterações diretamente para a app expandida e propagar as alterações para a aplicação em execução.

Implementar a sua aplicação

Para implementar a sua aplicação:

gradle appengineDeploy

A tarefa appengineDeploy e todas as outras tarefas do Gradle têm propriedades associadas que pode usar. Para ver uma lista completa de tarefas e propriedades, consulte o artigo Tarefas e propriedades do Gradle do App Engine.

Usar o wrapper do Gradle

O Gradle oferece um mecanismo para transferir e executar a versão necessária do Gradle sem instalação:

Linux/macOS

./gradlew appengineRun

Windows

gradlew.bat appengineRun

Pode encontrar informações adicionais sobre o Gradle em Tarefas e propriedades do Gradle do App Engine.

O que se segue?