Ambiente de execução do Java

O ambiente de execução do Java é a pilha de software responsável por instalar o código e as dependências do aplicativo e executá-lo no ambiente flexível.

• A versão 11 e as mais recentes são criadas com buildpacks, que exigem a escolha de um sistema operacional no arquivo app.yaml. Por exemplo, para usar o Java 21, é necessário especificar o Ubuntu 22 como o sistema operacional.

• O ambiente de execução do Java 8 / Jetty 9 fornece OpenJDK 8 e Eclipse Jetty 9 compatível com a especificação do Java Servlet 3.1. A imagem Jetty herda da imagem OpenJDK.

Para ver a lista completa de versões Java com suporte e a versão correspondente do Ubuntu, consulte a Programação de suporte ao ambiente de execução.

Pré-requisitos

Para usar o ambiente de execução do Java:

• É necessário instalar a CLI gcloud versão 420.0.0 ou posterior. É possível atualizar as ferramentas da CLI executando o comando gcloud components update. Para conferir a versão instalada, execute o comando gcloud version.

• 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.7.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]

Escolher uma versão do Java

Novas versões de ambiente de execução

Para o ambiente de execução do Java versão 11 e posterior, é necessário incluir as configurações runtime_config e operating_system no seu arquivo app.yaml para especificar um sistema operacional.

Observação: os ambientes de execução do Java 11/17 são compatíveis apenas com a implantação de arquivos JAR executáveis. Esses novos ambientes de execução não contêm frameworks de disponibilização da Web que limitam o uso de bibliotecas ou frameworks baseados em servlet.

Como alternativa, é possível especificar uma versão de ambiente de execução incluindo a configuração runtime_version em app.yaml. Por padrão, a versão mais recente do Java será usada se a configuração runtime_version não for especificada.

Exemplos

• Para especificar o Java 21 no Ubuntu 22:

  runtime: java
  env: flex
  
  runtime_config:
      operating_system: "ubuntu22"
      runtime_version: "21"
  

• Para especificar a versão mais recente compatível do Java no Ubuntu 22:

    runtime: java
    env: flex
  
    runtime_config:
        operating_system: "ubuntu22"
  

Versões anteriores do ambiente de execução

Para Java 8, especifique as configurações runtime_config e jdk no arquivo app.yaml.

O Java 8 é compatível com:

• O ambiente de execução Eclipse Jetty 9 executa o Jetty 9 usando o Servlet 3.1.
• o próprio código de servidor que detecta na porta 8080 como parte do aplicativo. Esse recurso permite usar frameworks de microsserviço, como SparkJava e Spring-Boot.

Exemplos

• Como especificar o Jetty versão 9 (padrão/opcional):

    runtime_config:
      jdk: openjdk8
      server: jetty9
  

• Como especificar o Java versão 8:

    runtime_config:
      jdk: openjdk8
  

• Exemplo de app.yaml para Java 8:

  runtime: java
  env: flex
  
  handlers:
  - url: /.*
    script: this field is required, but ignored

Consulte pom.xml para configurar o Maven e build.gradle para configurar o Gradle.

Arquivos opcionais

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

• index.yaml

• cron.yaml

• dispatch.yaml

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.

web.xml é opcional e necessário apenas se você não estiver usando 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.

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 do Google Cloud, em vez de serviços remotos. Use os seguintes emuladores:

• Datastore

• Pub/Sub

• Bigtable

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 localmente, 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 a Google Cloud CLI, execute:

gcloud init

Depois de concluir as configurações, você pode usar a Google Cloud CLI 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 Google Cloud. Se o arquivo pom.xml já especificar 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 . Adicione outras diretivas ao Dockerfile para personalizar o tempo de execução do Java. Consulte Como criar tempos de execução personalizados.

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