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.

Versões do Java

O Java 21 usa buildpacks. Eles ajudam você a criar e configurar contêineres que podem ser implantados no Google Cloud.

Para conferir 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.

Para usar uma versão compatível do Java, é preciso:

  • Instalar a versão da CLI gcloud 420.0.0 ou posterior do Google Analytics. É 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, adicione o plug-in do Maven para App Engine ao pom.xml:

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

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

  • Incluir as configurações runtime_config e operating_system no arquivo app.yaml para especificar um sistema operacional.

  • 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:

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 ambiente 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

Suporte a outros ambientes de execução Java

Se você precisa usar uma versão do Java que não é compatível, crie um ambiente de execução personalizado e selecione uma imagem de base válida com a versão do Java necessária.

Para imagens de base fornecidas pelo Google ou imagens de base do Docker Java, consulte Como criar ambientes de execução personalizados.

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]

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:

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. Por 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