Usar o Gradle e o plug-in do App Engine

O Gradle é uma ferramenta de automação de criação de código aberto focada em flexibilidade e desempenho. O App Engine fornece um plug-in do Gradle para criar e implantar o aplicativo nessa plataforma.

Antes de começar

1. Instale o Java

2. Instalar o Gradle

3. Instale o Git

4. Se ainda não tiver feito isso, siga as etapas neste guia para fazer o download da CLI gcloud, criar seu projeto do Google Cloud e inicializar seu aplicativo do App Engine.

5. Instale o componente app-engine-java da CLI gcloud:

   gcloud components install app-engine-java
   

Crie um novo projeto do Gradle

É possível criar um novo projeto do Gradle do zero usando o shell. Como alternativa, para testar o plug-in, é possível fazer o download, executar localmente e implantar o projeto "Hello, World".

Para criar um novo projeto:

1. Crie um novo diretório e navegue até ele.

2. Para inicializar um novo projeto:

   1. Execute gradle init:

      gradle init --type java-application
      

      Você vai precisar responder a perguntas:

      • Insira a versão do Java de destino (mínima: 7, padrão: 21): 21
      • Selecione a estrutura do aplicativo: 1 para projeto de aplicativo único
      • Selecione a DSL do script de build: 2 (para Groovy)
      • Selecione a estrutura de teste: 1 (para o JUnit 4)
      • Gerar build usando novas APIs e comportamento: não

   2. Crie a pasta WEB-INF:

      mkdir -p app/src/main/webapp/WEB-INF
      

   3. Crie a pasta appengine:

      mkdir -p app/src/main/appengine
      

3. Remova os arquivos de stub gerados por gradle init:

   rm ./app/src/main/java/org/example/App.java ./app/src/test/java/org/example/AppTest.java
   

4. Adicione os seguintes elementos ao seu arquivo app/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:

   apply plugin: 'java'
   apply plugin: 'war'
   
   buildscript {
       repositories {
           // gretty plugin is in Maven Central
           mavenCentral()
       }
       dependencies {
           classpath 'com.google.cloud.tools:appengine-gradle-plugin:2.8.1'
           classpath 'org.gretty:gretty:4.1.5'
       }
   }
   apply plugin: 'org.gretty'
   apply plugin: 'com.google.cloud.tools.appengine'
   
   repositories {
       mavenCentral()
   }
   
   appengine {
       deploy {   // deploy configuration
           stopPreviousVersion = true  // default - stop the current version
           promote = true              // default - & make this the current version
           projectId = 'GCLOUD_CONFIG'
           version = 'GCLOUD_CONFIG'
       }
   }
   
   sourceSets {
       // In Gradle 8, the default location is app/src/java, which does not match
       // Maven's directory structure.
       main.java.srcDirs = ['src/main/java']
       main.resources.srcDirs = ['src/main/resources', 'src/main/webapp']
       test.java.srcDirs = ['src/test/java']
   }
   
   dependencies {
       implementation 'com.google.appengine:appengine-api-1.0-sdk:2.0.30'
       implementation 'jakarta.servlet:jakarta.servlet-api:6.1.0'
   
       // Test Dependencies
       testImplementation 'com.google.appengine:appengine-testing:2.0.30'
       testImplementation 'com.google.appengine:appengine-api-stubs:2.0.30'
       testImplementation 'com.google.appengine:appengine-tools-sdk:2.0.30'
   
       testImplementation 'com.google.truth:truth:1.1.5'
       testImplementation 'junit:junit:4.13.2'
       testImplementation 'org.mockito:mockito-core:4.11.0'
   }

5. 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):

   • app/src/main/appengine/app.yaml

   • app/src/main/docker/Dockerfile (opcional para ambientes de execução personalizados)
   • Classes Java
   • classes de teste Java

Consulte Configurar o ambiente de desenvolvimento para ter uma visão geral de um projeto Java do App Engine.

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 jettyRun
   

   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:

   :prepareInplaceWebAppFolder
   :createInplaceWebAppFolder
   :compileJava
   :processResources UP-TO-DATE
   :classes
   :prepareInplaceWebAppClasses
   :prepareInplaceWebApp
   :jettyRun
   17:40:05 INFO  Jetty 9.2.15.v20160210 started and listening on port 8080
   17:40:05 INFO   runs at:
   17:40:05 INFO    http://localhost:8080/
   

5. Veja o app em execução em http://localhost:8080.

Para saber mais sobre o plug-in do Gretty, consulte as configuração do Gretty e as tarefas do Gretty.

Implantar 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 as tarefas e propriedades do Gradle do App Engine.

Usar o wrapper do Gradle

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

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

A seguir

• Confira o código do plug-in e relate problemas no GitHub.
• Para saber como especificar propriedades de tarefas, consulte tarefas e propriedades do Gradle do App Engine.