Esta página foi traduzida pela API Cloud Translation.

Usar o Apache Maven e o plug-in do App Engine (baseado na CLI Google Cloud)

Esta página explica como gerir um projeto do App Engine para a sua API Cloud Endpoints Frameworks através do Apache Maven. O Apache Maven é uma ferramenta de gestão e compreensão de projetos de software capaz de criar ficheiros de arquivo de aplicações Web (WAR) para implementação no App Engine. A Google disponibiliza um plug-in e arquétipos do Maven suportados pelo Maven 3.3.9 ou superior.

O Maven transfere as bibliotecas Java do SDK do App Engine. Pode usar o Maven para testar a sua app localmente e implementá-la no App Engine.

Antes de começar

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. Se precisar de criar uma aplicação do App Engine para o seu projeto, siga as instruções para selecionar a região onde quer que a sua aplicação do App Engine esteja localizada.
Transfira e instale a CLI gcloud e, em seguida, inicialize a CLI Google Cloud.
Se já tiver a CLI gcloud instalada e quiser configurá-la para usar um ID do projeto diferente do que usou para a inicializar, consulte o artigo Gerir configurações da CLI gcloud. Google Cloud
Instale o componente app-engine-java da CLI gcloud:
```
gcloud components install app-engine-java
```
Nota: para se certificar de que tem a versão mais recente da CLI gcloud para Java, execute gcloud components update.
Se não tiver o Java, transfira-o, instale-o e configure-o.

Defina as flags do compilador Java no ficheiro pom.xml do projeto para especificar o código de bytes Java 8:

<properties>
  <maven.compiler.source>1.8</maven.compiler.source>
  <maven.compiler.target>1.8</maven.compiler.target>
</properties>

Tem de ter a versão 3.3.9 ou superior do Apache Maven instalada. Para determinar a sua versão do Maven, execute o seguinte comando:
```
 mvn -v
```
Se não tiver a versão adequada do Maven instalada:
1. Transfira a versão 3.3.9 ou superior do Maven a partir do Website do Maven.
2. Instale o Maven na sua máquina local.
  Nota: os utilizadores do Linux podem ter de transferir o Maven em vez de usar o apt-get install.

Adicionar o plug-in do Maven do App Engine a um projeto existente (opcional)

Para usar o App Engine Maven plugin num projeto Maven existente, adicione o seguinte à secção plugins no ficheiro pom.xml do projeto:

<plugin>
   <groupId>com.google.cloud.tools</groupId>
   <artifactId>appengine-maven-plugin</artifactId>
   <version>2.8.1</version>
</plugin>

Escolher um arquétipo do App Engine

Os arquétipos do Maven permitem que os utilizadores criem projetos do Maven através de modelos que abrangem cenários comuns. O App Engine tira partido desta funcionalidade do Maven para fornecer alguns arquétipos do App Engine úteis no Maven Central. Selecione um arquétipo do App Engine adequado para a sua app:

Tipo de aplicação	Artefacto	Descrição
Frameworks de Endpoints para o App Engine	`endpoints-skeleton-archetype`	Gera um novo projeto de API de back-end do Endpoints Frameworks para o App Engine vazio, pronto para as suas próprias classes e recursos, com os ficheiros e os diretórios necessários.
Frameworks de Endpoints para o App Engine	`hello-endpoints-archetype`	Gera um projeto de API de back-end do Endpoints Frameworks para App Engine inicial, pronto para ser criado e executado.

Criar um novo projeto através do Maven

Durante a criação do projeto, o Maven pede-lhe que forneça o groupId, o artifactId, o version e o package do projeto.

Vigência	Significado
`groupId`	Um espaço de nomes no Maven para monitorizar os seus artefactos. Quando as pessoas consomem o seu projeto no respetivo projeto Maven, este funciona como um atributo da dependência que acabam por especificar.
`artifactId`	O nome do seu projeto no Maven. Também é especificado pelos consumidores do seu projeto quando dependem de si nos respetivos projetos Maven.
`version`	A versão inicial do Maven com a qual quer que o seu projeto seja gerado. É recomendável que o nome da versão `version` tenha o sufixo `-SNAPSHOT`, uma vez que isto oferece suporte no plug-in de lançamento do Maven para versões que estão em desenvolvimento. Para mais informações, consulte o guia do Maven sobre a utilização do plug-in de lançamento.
`package`	O pacote Java criado durante a geração.

Criar uma nova app Endpoints Frameworks

Esta secção descreve a criação de um novo projeto do Endpoints Frameworks versão 2.0.

O hello-endpoints-archetype oferece um exemplo de utilização de plug-ins, incluindo o plug-in do App Engine Maven e o plug-in do Endpoints Frameworks Maven.

O hello-endpoints-archetype gera um exemplo da API Greetings através da versão 2.0 dos Frameworks de Endpoints. Também funciona como exemplo para migrar as suas aplicações da versão 1.0 do Endpoints Frameworks para a versão 2.0 do Endpoints Frameworks.

O README.md gerado com o arquétipo fornece informações sobre o local onde a migração ocorreu.

Para criar um projeto de arquétipo da API de back-end do Endpoints Frameworks para App Engine:

Altere o diretório para um diretório onde quer criar o projeto.
Execute o seguinte comando Maven:
```
mvn archetype:generate -Dgoogle-cloud-project=[YOUR-PROJECT-ID] -Dappengine-plugin=2.8.1 -Dendpoints-frameworks=2.1.0 -Dendpoints-plugin=1.0.2 -Dappengine-sdk=1.9.98 -Dfilter=com.google.appengine.archetypes:
```
Onde:
- -Dgoogle-cloud-project está definido como o ID do seu projeto.
- -Dappengine-plugin está definido para a versão mais recente do plug-in do App Engine Maven.
- -Dendpoints-frameworks está definido para a versão mais recente dos Frameworks de Endpoints para o App Engine para dependências do Maven.
- -Dendpoints-plugin está definido para a versão mais recente do Endpoints Frameworks for App Engine Maven Plugin.
Nota: os arquétipos dos Frameworks de Endpoints para o App Engine têm suporte do Gradle e usam a versão mais recente de cada dependência.
Indique o número correspondente a hello-endpoints-archetype.

Nota: para criar um projeto vazio com a estrutura de diretórios e os ficheiros necessários prontos para as suas próprias classes, indique o número correspondente a endpoints-skeleton-archetype.
Selecione a versão mais recente na lista apresentada de versões de arquétipos disponíveis.
Quando lhe for pedido que Define value for property 'groupId', indique o espaço de nomes da sua app; por exemplo, indique o valor com.example.helloendpoints.
Quando lhe for pedido Define value for property 'artifactId', indique o nome do projeto. Por exemplo, indique o valor helloendpoints.
Quando lhe for pedido que Define value for property 'version', aceite o valor predefinido.
Quando lhe for pedido que Define value for property 'package', aceite o valor predefinido.
Quando lhe for pedido para confirmar as suas escolhas, aceite o valor predefinido introduzindo Y.
Aguarde que o projeto termine a geração. Em seguida, altere os diretórios para o diretório do novo projeto, por exemplo, helloendpoints/.
Crie o projeto.
```
mvn clean package
```

Aguarde pela compilação do projeto. Quando o projeto termina com êxito, é apresentada uma mensagem semelhante à seguinte:

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4.062 s
[INFO] Finished at: 2017-02-28T00:28:03-08:00
[INFO] Final Memory: 27M/485M
[INFO] ------------------------------------------------------------------------

Para testar localmente e implementar o projeto no ambiente padrão do App Engine, reveja o artigo Gerir, testar e implementar um projeto Maven.
Além disso, pode gerar bibliotecas cliente Java para a API Greeting usando o Endpoints Frameworks Maven Plugin:
```
mvn endpoints-framework:clientLibs
```

O diagrama seguinte mostra o esquema básico do projeto da API Greetings:

Esquema do projeto Maven

README.md contém informações sobre o exemplo gerado.
Greetings.java contém uma definição de API para uma API Greetings de exemplo.
Constants.java contém constantes usadas no exemplo da API Greetings.
HelloGreeting.java contém um contentor para mensagens recebidas e enviadas a partir da API Greetings de exemplo.
index.html contém uma IU simples para chamar a API Greetings de back-end.
base.js contém o JavaScript necessário para que a IU faça pedidos de back-end.
build.gradle Depois de gerado, o exemplo também suporta o Gradle e mais informações sobre esta funcionalidade no README.md.

Compilar e criar a sua aplicação

Para criar uma aplicação criada com os arquétipos do App Engine do Maven:

Mude para o diretório principal do seu projeto, por exemplo, guestbook/.
Executar Maven:
```
mvn clean package
```
Aguarde pela compilação do projeto. Quando o projeto termina com êxito, é apresentada uma mensagem semelhante à seguinte:
```
BUILD SUCCESS
 Total time: 10.724s
 Finished at: 2016-08-04T16:18:24-07:00
 Final Memory: 24M/213M
```

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

Durante a fase de desenvolvimento, pode executar e testar a sua aplicação em qualquer altura no servidor de desenvolvimento executando o plug-in do App Engine Maven.

Para testar a sua app Endpoints Frameworks for App Engine:

Se ainda não o fez, crie a sua app:
```
mvn clean package
```

Execute o exemplo localmente:

mvn appengine:run

Aguarde que o servidor seja iniciado. Quando o servidor é iniciado completamente com a sua aplicação em execução, é apresentada uma mensagem semelhante à seguinte:

[INFO] GCLOUD: INFO ### devappserver2.py:764] Skipping SDK update check.
[INFO] GCLOUD: INFO ### api_server.py:268] Starting API server at: http://localhost:34199
[INFO] GCLOUD: INFO ### dispatcher.py:199] Starting module "default" running at: http://localhost:8080
[INFO] GCLOUD: INFO ### admin_server.py:116] Starting admin server at: http://localhost:8000
[INFO] GCLOUD: ### com.google.appengine.tools.development.SystemPropertiesManager setSystemProperties

Use o navegador para aceder a http://localhost:8080/ e aceder à sua app.
Encerre a aplicação e o servidor de desenvolvimento premindo Control+C.

Especificar uma porta para testes locais

Quando executa a aplicação no servidor de desenvolvimento local, a porta predefinida é 8080. Pode alterar esta predefinição modificando a entrada do plug-in para appengine-maven-plugin. Por exemplo, pode especificar a porta e o endereço no ficheiro pom.xml do diretório da aplicação:

<plugins>
   <plugin>
     <groupId>com.google.cloud.tools</groupId>
     <artifactId>appengine-maven-plugin</artifactId>
     <version>2.8.1</version>
     <configuration>
       <devserver.host>0.0.0.0</devserver.host>
       <devserver.port>8181</devserver.port>
     </configuration>
  </plugin>
</plugins>

Neste exemplo, o elemento <devserver.port> define a porta como 8181 em vez da predefinição, e o endereço 0.0.0.0 é especificado, o que significa que o servidor de desenvolvimento escuta os pedidos provenientes da rede local.

O prefixo devserver é opcional. Em alternativa, pode usar <port>8181</port>.

Depuração no servidor de programação

Para depurar uma aplicação em execução local, defina jvmFlags na configuração do plug-in para ativar a depuração na JVM subjacente, por exemplo:

<configuration>
  <jvmFlags>
    <jvmFlag>-Xdebug</jvmFlag>
    <jvmFlag>-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005</jvmFlag>
  </jvmFlags>
</configuration>

Implementar a sua aplicação

Para implementar a sua aplicação:

mvn appengine:deploy

O objetivo appengine:deploy e todos os outros objetivos no plug-in do App Engine Maven têm parâmetros associados que pode usar. Para ver uma lista completa de objetivos e parâmetros, consulte o artigo Objetivos e parâmetros do plug-in do App Engine Maven.

O que se segue?

Explore o código do plug-in do App Engine Maven e comunique problemas no GitHub.
Saiba como especificar parâmetros para objetivos consultando o artigo Objetivos e parâmetros do App Engine Maven.
Explore o código do plug-in do Maven do Endpoints Frameworks e comunique problemas no GitHub.
Saiba como especificar parâmetros para objetivos consultando o plug-in do Maven do Cloud Endpoints Frameworks.