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

  • Antes de empezar a desarrollar, descarga la última versión del SDK de Google Cloud o actualiza tu SDK de Cloud a la versión actual:

    gcloud components update
    
  • A fin de realizar la implementación mediante Maven, deberás agregar el complemento de Maven de App Engine a tu pom.xml:

    <plugin>
       <groupId>com.google.cloud.tools</groupId>
       <artifactId>appengine-maven-plugin</artifactId>
       <version>2.2.0</version>
    </plugin>

    Otras opciones de implementación incluyen el uso del comando de gcloud app deploy o el complemento de App Engine Gradle.

  • Sigue las instrucciones del framework de la aplicación para configurar la compilación de un archivo 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 así:

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-appenine/openjdk:8 se selecciona automáticamente 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 para buscar una alternativa o argumentos ejecutables correspondientes al comando predeterminado (java).

Si el primer argumento para la imagen no es un archivo 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 un archivo ejecutable, como bash, ejecutará ese comando.

Por ejemplo, puedes ejecutar un 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 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 Default
DBG_ENABLE Depurador de Cloud boolean true
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 size Establecido por Google App Engine o /proc/meminfo-400 millones
HEAP_SIZE_RATIO Memoria para la pila porcentaje 80
HEAP_SIZE_MB Pila disponible size ${HEAP_SIZE_RATIO}% de ${GAE_MEMORY_MB}
JAVA_HEAP_OPTS Argumentos de pila 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 configura de forma explícita, JAVA_OPTS se establece de forma predeterminada en JAVA_OPTS:=-showversion \ ${JAVA_TMP_OPTS} \ ${DBG_AGENT} \ ${JAVA_HEAP_OPTS} \ ${JAVA_GC_OPTS} \ ${JAVA_USER_OPTS}.

Efectivamente, la línea de comandos ejecutada es (donde $@ representa los argumentos que pasan al punto de entrada del docker):

java $JAVA_OPTS "$@"

Pruebas locales

Puedes compilar la aplicación con lo siguiente:

mvn package

Y ejecutarla con la línea de comandos de java:

java -jar target/myjar.jar

O bien, sigue las instrucciones para el marco de trabajo 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 Bigtable. Usa el comando gcloud para iniciarlos antes de ejecutar tu app:

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

Implementa tu app

Después de completar las configuraciones, puedes usar el SDK de Google Cloud para implementar este directorio que contiene los archivos app.yaml y JAR con:

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 aplicación:

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

Reemplaza PROJECT_ID por el ID de tu proyecto de 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 tu aplicación:

gradle appengineDeploy

Personalizar Java Runtime 8

No necesitas un Dockerfile para implementar la aplicación en Java Runtime 8. Pero si tu aplicación exige una configuración adicional, de manera explícita, puedes proporcionar un Dockerfile 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 Compilar entornos de ejecución personalizados.