Java 8 Runtime

O Java 8 Runtime não inclui nenhuma biblioteca de veiculação na Web. O único requisito é que o aplicativo deve escutar e responder na porta 8080. O código de exemplo aqui mostra como adicionar biblioteca própria, como Spring Boot, ao Java 8 Runtime.

Pré-requisitos

Antes de começar a desenvolver, faça o download da versão mais recente da Google Cloud CLI ou atualize a CLI gcloud para a versão atual:
```
gcloud components update
```
Para implantar usando maven, você precisará adicionar o Plug-in Maven do App Engine para 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 uso do comando gcloud app deploy ou do plug-in do Gradle para o App Engine.
Siga as instruções da estrutura do aplicativo para configurar a compilação de um arquivo JAR executável. Esse JAR precisa ser executado via java -jar app.jar. Para ver exemplos, consulte a documentação de Spring Boot.

Organizar os arquivos

A hierarquia de arquivos de desenvolvimento deve ser assim:

MyDir/
  pom.xml
  [index.yaml]
  [cron.yaml]
  [dispatch.yaml]
  src/main/
    appengine/
      app.yaml
    docker/
      Dockerfile
    java/
      com.example.mycode/
        MyCode.java

`app.yaml`

Um arquivo app.yaml é obrigatório. Defina um arquivo que tenha a seguinte aparência:

runtime: java
env: flex

Ao especificar runtime: java, a imagem de tempo de execução gcr.io/google-appengine/openjdk:8 é selecionada automaticamente quando você implanta um arquivo JAR (*.jar).

Para selecionar uma versão do JDK, use o campo runtime_config.jdk.

runtime: java
env: flex
runtime_config:
  jdk: openjdk8

Você pode encontrar outras configurações do app.yaml em Como usar o app.yaml.

Arquivos opcionais

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

Coloque esses arquivos no nível superior de MyDir. Se você usar esses arquivos, precisará implantá-los separadamente com o comando gcloud app deploy.

Ponto de entrada padrão

O ponto de entrada para a imagem do OpenJDK 8 é docker-entrypoint.bash, que processa argumentos de linha de comando passados para procurar uma alternativa executável ou argumentos para o comando padrão (java).

Se o primeiro argumento da imagem não for um executável, o comando java será adicionado implicitamente. Exemplo:

$ docker run openjdk -jar /usr/share/someapplication.jar

Se o primeiro argumento para a imagem for um executável, como bash, ele executará esse comando.

Por exemplo, execute um shell com:

> docker run -it --rm openjdk bash
root@c7b35e88ff93:/#

Variáveis de ambiente

Use a tecla env_variables no arquivo app.yaml para definir as variáveis de ambiente. Exemplo:

env_variables:
   MY_VAR_COLOR: 'blue'

A tabela a seguir lista as variáveis de ambiente que você usa para ativar, desativar ou configurar recursos.

Variável de ambiente	Descrição	Tipo	Padrão
`TMPDIR`	Diretório temporário	dirname
`JAVA_TMP_OPTS`	Argumentos tmpdir do JVM	Argumentos do JVM	`-Djava.io.tmpdir=${TMPDIR}`
`GAE_MEMORY_MB`	Memória disponível	size	Definido pelo Google App Engine ou `/proc/meminfo` - 400 milhões
`HEAP_SIZE_RATIO`	Memória da pilha	percentual	80
`HEAP_SIZE_MB`	Pilha disponível	size	`${HEAP_SIZE_RATIO}`% de `${GAE_MEMORY_MB}`
`JAVA_HEAP_OPTS`	Argumentos de pilha do JVM	Argumentos do JVM	`-Xms${HEAP_SIZE_MB}M -Xmx${HEAP_SIZE_MB}M`
`JAVA_GC_OPTS`	Argumentos GC do JVM	Argumentos do JVM	`-XX:+UseG1GC` mais a configuração
`JAVA_USER_OPTS`	Outros argumentos do JVM	Argumentos do JVM
`JAVA_OPTS`	Argumentos do JVM	Argumentos do JVM	Consulte abaixo
`SHUTDOWN_LOGGING_THREAD_DUMP`	Despejo de thread de desligamento	booleano	`false`
`SHUTDOWN_LOGGING_HEAP_INFO`	Informações de pilha de desligamento	booleano	`false`
`SHUTDOWN_LOGGING_SAMPLE_THRESHOLD`	Amostragem de desligamento	percentual	100

Se não estiver definido explicitamente, JAVA_OPTS assumirá como padrão: JAVA_OPTS:=-showversion \ ${JAVA_TMP_OPTS} \ ${DBG_AGENT} \ ${JAVA_HEAP_OPTS} \ ${JAVA_GC_OPTS} \ ${JAVA_USER_OPTS}

A linha de comando é executada efetivamente (onde $@ são os argumentos passados para o ponto de entrada do docker):

java $JAVA_OPTS "$@"

Teste local

Crie o aplicativo usando:

mvn package

Execute-o usando a linha de comando java:

java -jar target/myjar.jar

Ou siga as instruções da biblioteca de aplicativos sobre como executar o aplicativo localmente.

Ao testar no ambiente local, prefira usar serviços de nuvem emulados do Google, em vez de serviços de nuvem remotos do Google. Há emuladores para armazenamento de dados, Pub/Sub e 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

Implantar o app

Depois de concluir as configurações, use a Google Cloud CLI para implantar esse diretório que contém o arquivo app.yaml e o JAR usando:

gcloud app deploy app.yaml

Se você estiver usando 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 o aplicativo:

gradle appengineDeploy

Como personalizar o Java 8 Runtime

Você não precisa de um Dockerfile para implantar o aplicativo no Java 8 Runtime. Mas, se o aplicativo precisar de configuração adicional, forneça explicitamente um Dockerfile para personalizar o tempo de execução do Java.

Se você quiser usar a imagem como base para um ambiente de execução personalizado, especifique runtime: custom no arquivo app.yaml e grave o Dockerfile da seguinte maneira:

FROM gcr.io/google-appengine/openjdk:8
COPY your-application.jar $APP_DESTINATION

Essas linhas adicionam o JAR ao local correto para o contêiner do Docker.

Adicione outras diretivas ao Dockerfile para personalizar o tempo de execução do Java. Consulte Como criar tempos de execução personalizados.