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 previos

  • Antes de empezar a desarrollar, descarga la última versión del SDK de Google Cloud o actualízalo 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.2.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-appenine/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 Valor predeterminado
DBG_ENABLE Cloud Debugger booleano 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 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 el entorno local, se recomienda que uses 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 el SDK de Google Cloud 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 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.