El entorno de ejecución de Java 8

Java Runtime 8 no incluye ningún marco de trabajo de entrega web. El único requisito es que la aplicación debe detectar y responder en el puerto 8080. El código de muestra que aparece aquí te explica cómo puedes agregar tu propio marco de trabajo, como Spring Boot, a Java Runtime 8.

Requisitos previos

Antes de empezar a desarrollar, descarga la última versión de Google Cloud CLI o actualiza tu CLI de gcloud a la versión actual:
```
gcloud components update
```
A fin de implementar mediante Maven, deberás agregar el complemento Maven de App Engine a tu pom.xml:
```
<plugin>
   <groupId>com.google.cloud.tools</groupId>
   <artifactId>appengine-maven-plugin</artifactId>
   <version>2.7.0</version>
</plugin>
```
Entre otras opciones de implementación, se incluye el uso del comando gcloud app deploy o el complemento Gradle de App Engine.
Sigue las instrucciones para que el framework de tu aplicación configure la compilación de un JAR ejecutable. Este JAR ejecutable debe ejecutarse a través de java -jar app.jar. Por ejemplo, consulta la documentación de Spring Boot.

Organizar tus archivos

La jerarquía de archivos de desarrollo debería verse de la siguiente manera:

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

`app.yaml`

Se requiere un archivo app.yaml. Define un archivo que tenga este aspecto:

runtime: java
env: flex

Si especificas runtime: java, la imagen del entorno de ejecución gcr.io/google-appengine/openjdk:8 se selecciona de forma automática cuando implementas un archivo JAR (*.jar).

Para seleccionar una versión de JDK, usa el campo runtime_config.jdk.

runtime: java
env: flex
runtime_config:
  jdk: openjdk8

Puedes encontrar otra configuración de app.yaml en Usa app.yaml.

Archivos opcionales

Estos archivos de configuración son opcionales:

Coloca estos archivos en el nivel superior de MyDir. Si usas alguno de estos archivos, debes implementarlos por separado con el comando gcloud app deploy.

Punto de entrada predeterminado

El punto de entrada para la imagen de OpenJDK 8 es docker-entrypoint.bash, que procesa los argumentos de línea de comandos aprobados con el fin de buscar una alternativa o argumentos ejecutables correspondientes al comando predeterminado (java).

Si el primer argumento para la imagen no es ejecutable, el comando java se agrega de manera implícita. Por ejemplo:

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

Si el primer argumento para la imagen es ejecutable, como bash, se ejecutará ese comando.

Por ejemplo, puedes ejecutar una shell con lo siguiente:

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

Variables de entorno

Usa la clave env_variables en el archivo app.yaml para establecer las variables de entorno. Por ejemplo:

env_variables:
   MY_VAR_COLOR: 'blue'

En la tabla siguiente, se enumeran las variables del entorno que puedes usar para habilitar, inhabilitar o configurar características.

Variable del entorno	Descripción	Tipo	Predeterminado
`TMPDIR`	Directorio temporal	dirname
`JAVA_TMP_OPTS`	Argumentos de directorio temporal de JVM	argumentos de JVM	`-Djava.io.tmpdir=${TMPDIR}`
`GAE_MEMORY_MB`	Memoria disponible	tamaño	Establecido por Google App Engine o `/proc/meminfo`-400M
`HEAP_SIZE_RATIO`	Memoria para el montón	porcentaje	80
`HEAP_SIZE_MB`	Pila disponible	tamaño	`${HEAP_SIZE_RATIO}`% de `${GAE_MEMORY_MB}`
`JAVA_HEAP_OPTS`	Argumentos del montón de JVM	argumentos de JVM	`-Xms${HEAP_SIZE_MB}M -Xmx${HEAP_SIZE_MB}M`
`JAVA_GC_OPTS`	Argumentos de JVM GC	Argumentos de JVM	`-XX:+UseG1GC` más la configuración
`JAVA_USER_OPTS`	Otros argumentos de JVM	argumentos de JVM
`JAVA_OPTS`	Argumentos de JVM	argumentos de JVM	Ver a continuación
`SHUTDOWN_LOGGING_THREAD_DUMP`	Volcado de conversaciones de cierre	booleano	`false`
`SHUTDOWN_LOGGING_HEAP_INFO`	Información de pila de cierre	booleano	`false`
`SHUTDOWN_LOGGING_SAMPLE_THRESHOLD`	Muestreo de cierre	porcentaje	100

Si no se establece de forma explícita, el valor predeterminado de JAVA_OPTS es JAVA_OPTS:=-showversion \ ${JAVA_TMP_OPTS} \ ${DBG_AGENT} \ ${JAVA_HEAP_OPTS} \ ${JAVA_GC_OPTS} \ ${JAVA_USER_OPTS}.

La línea de comandos ejecutada es efectiva ($@ representa los argumentos que se pasan al punto de entrada del docker):

java $JAVA_OPTS "$@"

Pruebas locales

Puedes compilar la app mediante el siguiente comando:

mvn package

Ejecútala mediante la línea de comandos de java:

java -jar target/myjar.jar

O bien, sigue las instrucciones para el framework de tu aplicación sobre cómo ejecutar la aplicación de manera local.

Cuando realices pruebas en tu entorno local, preferirás usar los servicios emulados de Google Cloud en lugar de los servicios remotos de Google Cloud. Hay emuladores para Datastore, Pub/Sub y Cloud Bigtable. Usa el comando de gcloud a fin de iniciarlos antes de ejecutar la app:

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

Implementa tu app

Después de completar los parámetros de configuración, puedes usar Google Cloud CLI para implementar este directorio que contiene el archivo app.yaml y el JAR mediante el siguiente comando:

gcloud app deploy app.yaml

Si usas alguno de los archivos de configuración opcionales (index.yaml, cron.yaml y dispatch.yaml) asegúrate de implementarlos por separado con el comando de gcloud. Por ejemplo:

gcloud app deploy cron.yaml

Maven

Usa Maven para implementar tu app:

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

Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud. Si tu archivo pom.xml ya especifica tu ID del proyecto, no necesitas incluir la propiedad -Dapp.deploy.projectId en el comando que ejecutas.

Gradle

Usa Gradle para implementar la aplicación:

gradle appengineDeploy

Personalizar Java Runtime 8

No necesitas un Dockerfile para implementar la aplicación en Java Runtime 8. Pero si tu app exige una configuración adicional, puedes proporcionar un Dockerfile de manera explícita para personalizar el entorno de ejecución de Java.

Si quieres usar la imagen como base para un entorno de ejecución personalizado, puedes especificar runtime: custom en tu archivo app.yaml y, luego, escribir el Dockerfile de esta manera:

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

Estas líneas agregan el archivo JAR a la ubicación correcta para el contenedor de Docker.

Puedes agregar directivas adicionales a Dockerfile para personalizar el entorno de ejecución de Java. Consulta Compila entornos de ejecución personalizados.