O tempo de execução do Java

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

Versões do Java

O Java 21 usa buildpacks. Os buildpacks ajudam a criar e configurar contentores que pode implementar no Google Cloud.

Para ver a lista completa de versões Java suportadas e a respetiva versão do Ubuntu, consulte a Programação de suporte de tempo de execução.

Para usar uma versão do Java suportada, tem de:

  • Instale a versão 420.0.0 ou posterior da CLI gcloud. Pode atualizar as ferramentas da CLI executando o comando gcloud components update. Para ver a versão instalada, pode executar o comando gcloud version.

  • Para implementar através do Maven, tem de adicionar o App Engine Maven Plugin 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 implementação incluem o comando gcloud app deploy ou o App Engine Gradle plugin.

  • Inclua as definições runtime_config e operating_system no ficheiro app.yaml para especificar um sistema operativo.

  • Opcionalmente, pode especificar uma versão do tempo de execução incluindo a definição runtime_version no ficheiro app.yaml. Por predefinição, é usada a versão mais recente do Java se a definiçã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 do Java mais recente suportada no Ubuntu 22:

        runtime: java
  env: flex

  runtime_config:
      operating_system: "ubuntu22"

Versões de tempo de execução anteriores

Para o Java 8, especifique as definições runtime_config e jdk no ficheiro app.yaml.

O Java 8 suporta:

  • O tempo de execução do Eclipse Jetty 9 e executa o Jetty 9 através do Servlet 3.1.

  • O seu próprio código de servidor que escuta na porta 8080 como parte da sua aplicação. Esta funcionalidade permite-lhe usar frameworks de microsserviços como o SparkJava e o Spring-Boot.

Exemplos

  • Especificar a versão 9 do Jetty (predefinição / opcional):

      runtime_config:
    jdk: openjdk8
    server: jetty9

  • Especificar a versão 8 do Java:

      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.

Ficheiros opcionais

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

Coloque estes ficheiros no nível superior de MyDir. Se usar algum destes ficheiros, tem de implementá-los separadamente com o comando gcloud app deploy.

web.xml é opcional e só é necessário se não estiver a usar anotações do Servlet 3.x.

Pode colocar conteúdo Web estático, bem como as suas páginas JavaServer, no diretório webapp/. O Jetty 9, que o ambiente flexível do App Engine usa como contentor de servlets, usa o Apache Jasper como implementação de JSP predefinida e inclui taglibs JSTL.

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

Ativar a compressão gzip

O controlador gzip está incluído no Jetty, mas não está ativado por predefinição. Para ativar este módulo, defina a variável de ambiente JETTY_MODULES_ENABLE=gzip no ficheiro app.yaml:

env_variables:
  JETTY_MODULES_ENABLE: 'gzip'

Usar o início rápido

O Jetty pode acelerar o tempo de início da sua aplicação pré-analisando o respetivo conteúdo e gerando ficheiros de configuração. Se estiver a usar uma imagem expandida pode ativar o início rápido executando /scripts/jetty/quickstart.sh no seu Dockerfile, depois de adicionar o WAR da aplicação.

Variáveis de ambiente

Pode definir as seguintes variáveis de ambiente opcionais específicas do tempo de execução do Java 8/Jetty 9. Também pode definir variáveis de ambiente do OpenJDK 8.

Para definir variáveis de ambiente, use a chave env_variables no ficheiro app.yaml.

Var. amb. Maven Prop Valor/comentário
JETTY_PROPERTIES Lista de pares name=value separados por vírgulas anexados a $JETTY_ARGS
JETTY_MODULES_ENABLE Lista de módulos separados por vírgulas a ativar anexando a $JETTY_ARGS
JETTY_MODULES_DISABLE Lista de módulos separados por vírgulas a desativar removendo-os de $JETTY_BASE/start.d
JETTY_ARGS Argumentos transmitidos ao start.jar do Jetty. Todos os argumentos usados para a configuração personalizada do Jetty devem ser transmitidos aqui.
JAVA_OPTS Argumentos de tempo de execução da JVM

Cloud Logging melhorado (beta)

Quando executado no ambiente flexível do App Engine, pode configurar o Java Util Logging para enviar registos para o Cloud Logging definindo a variável de ambiente JETTY_ARGS. Por exemplo:

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

Tem de fornecer um ficheiro logging.properties que configure um LoggingHandler da seguinte forma:

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 tempos de execução Java

Se precisar de usar uma versão do Java que não seja suportada, pode criar um tempo de execução personalizado e selecionar uma imagem base válida com a versão do Java de que precisa.

Para imagens base fornecidas pela Google ou imagens base do Docker Java, consulte o artigo Criar tempos de execução personalizados.

Organizar os seus ficheiros

A sua árvore de origem deve ter o seguinte aspeto:

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]

Testes locais

Quando testar no seu ambiente local, pode usar serviços Google Cloud emulados, em vez de serviços Google Cloud remotos. Pode usar os seguintes emuladores:

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

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

Maven

Adicione estas linhas no ficheiro maven pom.xml para adicionar o Jetty 9 Maven Plugin:

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

Para executar a sua app localmente, use o comando Maven:

mvn jetty:run-exploded

Gradle

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

gradle jettyRun

Implemente a sua app

Para inicializar a CLI Google Cloud, execute o seguinte comando:

gcloud init

Após concluir as configurações, pode usar a Google Cloud CLI para implementar este diretório que contém os ficheiros app.yaml e WAR através do seguinte comando:

gcloud app deploy app.yaml

Se estiver a usar algum dos ficheiros de configuração opcionais (index.yaml, cron.yaml e dispatch.yaml), implemente-os separadamente com o comando gcloud. Por exemplo:

gcloud app deploy cron.yaml

Maven

Use o Maven para implementar a sua app:

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

Substitua PROJECT_ID pelo ID do seu Google Cloud projeto. Se o seu ficheiro pom.xml já especificar o seu ID do projeto, não precisa de incluir a propriedade -Dapp.deploy.projectId no comando que executar.

Gradle

Use o Gradle para implementar a sua app:

gradle appengineDeploy