Ambiente de execução do Java

O ambiente de execução do Java é a pilha de software responsável por instalar o código do aplicativo e as dependências e, em seguida, executar esse aplicativo no ambiente flexível.

Versões do Java

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

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.

Para usar uma versão compatível do Java, é necessário:

  • Instalar a versão 420.0.0 ou mais recente da CLI gcloud. É possível atualizar as ferramentas da CLI executando o gcloud components update comando. Para conferir a versão instalada, execute o gcloud version comando.

  • Para implantar usando o Maven, adicione 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.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 25 no Ubuntu 24:

      runtime: java
env: flex

runtime_config:
    operating_system: "ubuntu24"
    runtime_version: "25"

    • Para especificar a versão mais recente do Java com suporte no Ubuntu 24:

        runtime: java
  env: flex

  runtime_config:
      operating_system: "ubuntu24"

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

Suporte para outros ambientes de execução Java

Se você precisa usar uma versão do Java que não tem suporte, crie um ambiente de execução personalizado e selecione uma imagem de base válida com a versão 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 emulados Google Cloud, em vez de serviços remotos Google Cloud . 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.gradlee use o comando:

gradle jettyRun

implantar o aplicativo

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 seu Google Cloud projeto. 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