Ambiente de execução do Java 11

O ambiente de execução do Java 11 é a pilha de software responsável por instalar o código do serviço da Web e as dependências dele, além de executar o serviço.

O ambiente de execução do Java 11 para o App Engine no ambiente padrão é declarado no arquivo app.yaml:

runtime: java11

Antes de começar

  1. Faça o download da versão mais recente do SDK do Cloud ou atualize seu SDK para a versão atual:

    gcloud components update
    
  2. Para implantar usando o Maven, você precisará adicionar o Plug-in do Maven para o App Engine ao arquivo 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 uso do comando gcloud app deploy ou do plug-in do Gradle para o App Engine.

  3. Siga as instruções do framework do seu aplicativo para configurar o build de um arquivo JAR executável.

Compatibilidade do framework

Com o ambiente de execução do Java 11 para o App Engine, é possível implantar arquivos JAR executáveis. O ambiente de execução não inclui nenhum framework de exibição na Web, o que significa que você não está limitado a usar bibliotecas ou frameworks baseados em servlet. Use suas dependências nativas ou pilhas de rede, como a biblioteca Netty (em inglês).

Há amostras de hello world que usam os conhecidos frameworks da Web em Java no repositório do GitHub do Google Cloud:

Você não precisa usar apenas esses frameworks. Recomendamos que você teste outras opções, como Grail, Blade, Pixel, Play!, Vaadin ou jHipster (em inglês).

Implantar projetos de origem do Maven no ambiente de execução do Java 11

É possível implantar seu projeto do Maven como código-fonte e fazer com que ele seja criado e implantado usando o App Engine Buildpacks.

Para implantar um projeto do Maven como código-fonte, acesse o diretório de nível superior do projeto e digite:

gcloud app deploy pom.xml

Os registros de criação e implantação serão transmitidos, e você poderá ver os registros detalhados na seção de histórico do Cloud Build no Console do Cloud.

Como usar executáveis do GraalVM

O ambiente de execução padrão do Java 11 para o App Engine é compatível com executáveis de imagens nativas do GraalVM. Depois de compilar o app em Java 11 usando uma imagem nativa do GraalVM, use a configuração entrypoint no arquivo app.yaml para apontar para o executável.

Por exemplo, um executável com o nome de arquivo myexecutable pode ter o seguinte arquivo de configuração app.yaml:

runtime: java11
entrypoint: ./myexecutable

Versão do Java

O ambiente de execução do Java 11 usa a versão estável mais recente do Java 11. As versões secundárias do App Engine são atualizadas automaticamente. No entanto, a versão principal precisa ser atualizada manualmente.

Por exemplo, seu aplicativo pode ser implantado em Java 11.0.4 e atualizado automaticamente para a versão Java 11.0.5 em uma implantação posterior da plataforma gerenciada, mas não será atualizado automaticamente para Java 12.

O ambiente Open JDK do ambiente de execução

O App Engine executa apps Java 11 em um contêiner protegido pelo gVisor em uma distribuição do Linux atualizada do Ubuntu 18.04 e no pacote openjdk-11-jdk compatível. O App Engine mantém a imagem base e atualiza o pacote OpenJDK 11 sem exigir que você reimplante o aplicativo.

O app implantado está localizado no diretório /workspace do ambiente de execução. Ele também pode ser acessado por meio de um link simbólico em /srv.

Dependências

Para ver mais informações sobre como declarar e gerenciar dependências, consulte Como especificar dependências.

Inicialização do aplicativo

Frameworks, como Spring Boot, Micronaut e Ktor, criam um JAR uber executável por padrão. Se o arquivo de build do Maven ou do Gradle produzir um Uber JAR executável, o ambiente de execução iniciará seu aplicativo executando um aplicativo Uber JAR.

Como alternativa, o App Engine usará o conteúdo do campo entrypoint opcional no arquivo app.yaml. Por exemplo:

runtime: java11
entrypoint: java -Xmx64m -jar YOUR-ARTIFACT.jar

Em que o jar YOUR-ARTIFACT.jar do aplicativo precisa:

  • estar no diretório raiz com o arquivo app.yaml;
  • conter uma entrada Main-Class no arquivo de metadados META-INF/MANIFEST.MF;
  • (opcional) conter uma entrada Class-Path com uma lista de caminhos relativos a outros jars dependentes. Eles serão enviados automaticamente com o aplicativo.

Para que o app receba solicitações HTTP, seu ponto de entrada precisa iniciar um servidor da Web que atenda na porta especificada pela variável de ambiente PORT.

Com um ponto de entrada personalizado, é possível construir e empacotar seu aplicativo como um arquivo JAR thin, que contém apenas o código do aplicativo e as dependências diretas. Ao implantar o aplicativo, o plug-in do App Engine fará upload apenas dos arquivos que foram alterados, em vez de todo o pacote uber JAR.

Certifique-se de usar a variável de ambiente PORT

Se você vir os avisos sobre a porta 8080 e o NGINX nos arquivos de registro do seu app, isso significará que o servidor da Web do aplicativo está atendendo na porta 8080 padrão. Isso impede que o App Engine use a camada NGINX para compactar as respostas HTTP. Recomendamos que você configure seu servidor da Web para responder a solicitações HTTP na porta especificada pela variável de ambiente PORT, normalmente 8081. Por exemplo:

/*
 * Copyright 2019 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.example.appengine;

import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

public class Main {

  public static void main(String[] args) throws IOException {
    // Create an instance of HttpServer bound to port defined by the
    // PORT environment variable when present, otherwise on 8080.
    int port = Integer.parseInt(System.getenv().getOrDefault("PORT", "8080"));
    HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);

    // Set root URI path.
    server.createContext("/", (var t) -> {
      byte[] response = "Hello World!".getBytes();
      t.sendResponseHeaders(200, response.length);
      try (OutputStream os = t.getResponseBody()) {
        os.write(response);
      }
    });

    // Create a second URI path.
    server.createContext("/foo", (var t) -> {
      byte[] response = "Foo!".getBytes();
      t.sendResponseHeaders(200, response.length);
      try (OutputStream os = t.getResponseBody()) {
        os.write(response);
      }
    });

    server.start();
  }
}

Compatibilidade com as versões anteriores do Java

Os usuários podem acessar os seguintes recursos das versões anteriores do Java:

  • Inferência de tipo avançada com a palavra-chave var
  • Criação fácil de listas ou mapas com coleções imutáveis
  • Chamada de hosts remotos usando o HttpClient graduado
  • Uso do sistema do módulo JPMS
  • Use as linguagens JVM alternativas, como Apache GRoovy, Kotlin ou Scala (links em inglês).

Variáveis de ambiente

As seguintes variáveis de ambiente são definidas pelo ambiente de execução:

Variável de ambiente Descrição
GAE_APPLICATION O ID do aplicativo do App Engine. Esse ID tem o prefixo "region code~", como "e~" para aplicativos implantados na Europa.
GAE_DEPLOYMENT_ID O ID da implantação atual.
GAE_ENV O ambiente do App Engine. Defina como standard.
GAE_INSTANCE O ID da instância em que o serviço é executado no momento.
GAE_MEMORY_MB A quantidade de memória disponível para o processo do aplicativo em MB.
GAE_RUNTIME O ambiente de execução especificado no seu arquivo app.yaml.
GAE_SERVICE O nome do serviço especificado no seu arquivo app.yaml. Se nenhum nome de serviço for especificado, ele será definido como default.
GAE_VERSION O rótulo da versão atual do serviço.
GOOGLE_CLOUD_PROJECT O código do projeto do Cloud associado ao aplicativo.
PORT A porta que recebe solicitações HTTP.

É possíveldefinir outras variáveis de ambiente no arquivo app.yaml, mas os valores acima não podem ser modificados.

HTTPS e proxies de encaminhamento

O App Engine encerra as conexões HTTPS no balanceador de carga e encaminha as solicitações para o aplicativo. Em alguns aplicativos, é necessário determinar o protocolo e o IP de solicitação originais. O endereço IP do usuário está disponível no cabeçalho X-Forwarded-For padrão. Os aplicativos que precisam dessa informação devem configurar o framework da Web para confiar no proxy.

Acesso ao sistema de arquivos

O ambiente de execução inclui um diretório /tmp gravável, e todos os outros diretórios têm acesso somente de leitura. A gravação em /tmp ocupa a memória do sistema.

Servidor de metadados

Cada instância do aplicativo pode usar o servidor de metadados do App Engine para consultar informações sobre a instância e o projeto.

É possível acessar o servidor de metadados por meio dos endpoints a seguir:

  • http://metadata
  • http://metadata.google.internal

A tabela a seguir lista os endpoints em que é possível fazer solicitações HTTP para metadados específicos.

Endpoint de metadados Descrição
/computeMetadata/v1/project/numeric-project-id Número do projeto atribuído ao seu projeto.
/computeMetadata/v1/project/project-id ID do projeto atribuído ao seu projeto.
/computeMetadata/v1/instance/zone Zona em que a instância está em execução.
/computeMetadata/v1/instance/service-accounts/default/aliases
/computeMetadata/v1/instance/service-accounts/default/email E-mail da conta de serviço padrão atribuído ao seu projeto.
/computeMetadata/v1/instance/service-accounts/default/ Lista todas as contas de serviço padrão do seu projeto.
/computeMetadata/v1/instance/service-accounts/default/scopes Lista todos os escopos compatíveis com as contas de serviço padrão.
/computeMetadata/v1/instance/service-accounts/default/token Retorna o token de autenticação que pode ser usado para autenticar o aplicativo em outras Google Cloud APIs.

Por exemplo, para recuperar o ID do projeto, envie uma solicitação para http://metadata.google.internal/computeMetadata/v1/project/project-id.