Java 8 / Jetty 9 Runtime

O ambiente de execução do Eclipse Jetty 9 usa o OpenJDK 8 e o Jetty 9, além de ser compatível com a especificação Servlet Java 3.1.

Pré-requisitos

  • Faça o download da versão mais recente do Google Cloud SDK ou atualize o Cloud SDK para a versão atual:

    gcloud components update
    
  • Para implantar usando o Maven, você precisará adicionar o plug-in do Maven do App Engine ao seu pom.xml:

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

    Outras opções de implantação incluem o gcloud app deploy comando ou o plug-in Gradle do Google App Engine.

Organizar os arquivos

Sua árvore de código-fonte deve ter a seguinte aparência:

MyDir/
  [pom.xml]
  [build.gradle]
  [index.yaml]
  [cron.yaml]
  [dispatch.yaml]
  src/main/
    appengine/
      app.yaml
    docker/
      [Dockerfile]
    java/
      com.example.mycode/
        MyCode.java
    webapp/
      [index.html]
      [jsp.jsp]
      WEB-INF/
        [web.xml]

app.yaml

Um arquivo app.yaml é obrigatório. Defina um arquivo que tenha a seguinte aparência:

runtime: java
env: flex

handlers:
- url: /.*
  script: this field is required, but ignored

A imagem de tempo de execução gcr.io/google-appengine/jetty é selecionada automaticamente quando você implanta um WAR (arquivo *.war).

Se você quiser usar essa imagem como base para um ambiente de execução personalizado, especifique runtime: custom no arquivo app.yaml e grave o Dockerfile assim:

FROM gcr.io/google-appengine/jetty
ADD your-application.war $APP_DESTINATION

Essas linhas adicionam o WAR no local correto do contêiner do Docker.

Outras configurações de app.yaml são descritas em Using app.yaml.

O arquivo pom.xml é usado para configurar o Maven e o build.gradle, para configurar o Gradle.

Arquivos opcionais

Estes arquivos de configuração são opcionais:

Coloque esses arquivos no nível superior do MyDir. Se você usar algum desses arquivos, precisará implantá-los separadamente com o comando gcloud app deploy.

O web.xml é opcional. Ele apenas será necessário se você não estiver usando as anotações do Servlet 3.x.

Você pode colocar conteúdo da Web estático, bem como suas páginas JavaServer, no diretório webapp/. O Jetty 9, que é usado pelo ambiente flexível do App Engine como contêiner do Servlet, usa o Apache Jasper como implementação padrão do JSP e inclui taglibs JSTL.

O arquivo Dockerfile é opcional e é usado para personalizar o tempo de execução do Java.

Como habilitar a compactação Gzip

O gerenciador gzip é incluído no Jetty, mas não é ativado por padrão. Para ativar esse módulo, defina a variável de ambiente JETTY_MODULES_ENABLE=gzip no arquivo app.yaml:

env_variables:
  JETTY_MODULES_ENABLE: 'gzip'

Como usar o guia de início rápido

Como o Jetty verifica seu conteúdo previamente e gera os arquivos de configuração, ele pode acelerar o tempo de inicialização do aplicativo. Se você estiver usando uma imagem estendida, poderá ativar o início rápido executando /scripts/jetty/quickstart.sh no Dockerfile, depois que o WAR do aplicativo for adicionado.

FROM launcher.gcr.io/google/jetty
ADD your-application.war $JETTY_BASE/webapps/root.war

# generate quickstart-web.xml
RUN /scripts/jetty/quickstart.sh

Variáveis de ambiente

Você pode definir as seguintes variáveis de ambiente opcionais específicas para o Java 8 / Jetty 9 Runtime. Também é possível definir as variáveis de ambiente do OpenJDK 8.

Para definir variáveis de ambiente, use a tecla env_variables no arquivo app.yaml.

Variável de ambiente Objeto do Maven Valor/Comentário
JETTY_PROPERTIES Lista separada por vírgulas de pares name=value anexados a $JETTY_ARGS
JETTY_MODULES_ENABLE Lista separada por vírgulas de módulos para ativar anexando a $JETTY_ARGS
JETTY_MODULES_DISABLE Lista separada por vírgula de módulos a serem desativados por remoção de $JETTY_BASE/start.d
JETTY_ARGS Argumentos passados para start.jar do Jetty. Qualquer argumento usado para a configuração personalizada do Jetty deve ser transmitido para essa variável.
JAVA_OPTS Argumentos de tempo de execução do JVM.

Cloud Logging aprimorado (Beta)

Ao executar no ambiente flexível do App Engine, é possível configurar o Java Util Logging para enviar registros ao Cloud Logging definindo a variável de ambiente JETTY_ARGS. Exemplo:

 env_variables:
   JETTY_ARGS: -Djava.util.logging.config.file=WEB-INF/logging.properties

É preciso fornecer um arquivo logging.properties que configure um LoggingHandler da seguinte maneira:

handlers=com.google.cloud.logging.LoggingHandler

# Optional configuration
.level=INFO
com.google.cloud.logging.LoggingHandler.level=FINE
com.google.cloud.logging.LoggingHandler.log=gae_app.log
com.google.cloud.logging.LoggingHandler.formatter=java.util.logging.SimpleFormatter
java.util.logging.SimpleFormatter.format=%3$s: %5$s%6$s

Teste local

Ao fazer testes no seu ambiente local, você pode usar serviços simulados de nuvem do Google, em vez de serviços remotos. Use os seguintes emuladores:

Use o comando gcloud para iniciá-los antes de executar o aplicativo:

gcloud beta emulators datastore start
gcloud beta emulators pubsub start
gcloud beta emulators bigtable start

Maven

Adicione estas linhas ao arquivo pom.xml do Maven para adicionar o plug-in do Maven para Jetty 9:

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <version>9.4.2.v20170220</version>
</plugin>

Para executar seu app na máquina local, use o seguinte comando do Maven:

mvn jetty:run-exploded

Gradle

Siga as instruções em Como criar um novo projeto do Gradle para adicionar o plug-in Gretty Gradle ao seu build.gradle e use o comando:

gradle jettyRun

Implantar o app

Para inicializar o Google Cloud SDK, execute:

gcloud init

Depois de concluir as configurações, você pode usar o Google Cloud SDK para implantar esse diretório contendo os arquivos app.yaml e WAR usando:

gcloud app deploy app.yaml

Se você estiver usando qualquer um dos arquivos de configuração opcionais (index.yaml, cron.yaml e dispatch.yaml), implante-os separadamente com o comando gcloud. Exemplo:

gcloud app deploy cron.yaml

Maven

Use o Maven para implantar o aplicativo:

mvn package appengine:deploy -Dapp.deploy.projectId=PROJECT_ID

Substitua PROJECT_ID pelo ID do projeto do Cloud. Se seu arquivo pom.xmlespecificar o ID do projeto, não será necessário incluir a propriedade -Dapp.deploy.projectId no comando executado.

Gradle

Use o Gradle para implantar seu app:

gradle appengineDeploy

Como personalizar o Java 8 / Jetty 9 Runtime

Você não precisa de um Dockerfile para implantar seu app no Java 8/Jetty 9 Runtime. Se seu app precisar de configuração adicional, forneça explicitamente um Dockerfile para personalizar o tempo de execução do Java. O Dockerfile precisa incluir a imagem base gcr.io/google-appengine/jetty. Adicione outras diretivas ao Dockerfile para personalizar o tempo de execução do Java. Consulte Como criar tempos de execução personalizados.

Seu Dockerfile precisa começar da seguinte maneira:

FROM gcr.io/google-appengine/jetty
ADD your-application.war $APP_DESTINATION
# YOUR DOCKER COMMANDS

Nesse caso, your-application.war é o nome do arquivo WAR criado no diretório target/ (maven) ou build/staged-app/ (gradle).