Se usó la API de Cloud Translation para traducir esta página.

El entorno de ejecución de Java

El entorno de ejecución de Java es la pila de software encargada de instalar el código y las dependencias de tu aplicación y, luego, ejecutarla en el entorno flexible.

Versiones de Java

Java 21 usa buildpacks. Los paquetes de compilación te ayudan a compilar y configurar contenedores que puedes implementar en Google Cloud.

Para obtener la lista completa de las versiones de Java compatibles y su versión de Ubuntu correspondiente, consulta el programa de asistencia del entorno de ejecución.

Para usar una versión de Java compatible, debes hacer lo siguiente:

Instala la versión 420.0.0 o posterior de la CLI de gcloud. Puedes actualizar las herramientas de la CLI si ejecutas el comando gcloud components update. Para ver la versión instalada, puedes ejecutar el comando gcloud version.
Para implementar con Maven, debes agregar el complemento de Maven para App Engine a tu pom.xml:
```
<plugin>
   <groupId>com.google.cloud.tools</groupId>
   <artifactId>appengine-maven-plugin</artifactId>
   <version>2.8.1</version>
</plugin>
```
Entre otras opciones de implementación, se incluye el uso del comando gcloud app deploy o el complemento Gradle de App Engine.
Incluye la configuración runtime_config y operating_system en el archivo app.yaml para especificar un sistema operativo.

Nota: Los entornos de ejecución de Java admitidos solo admiten la implementación de archivos JAR ejecutables. Los entornos de ejecución de Java compatibles no incluyen ningún framework de entrega web que te limite a usar bibliotecas o frameworks basados en servlets.
Opcional: Puedes especificar una versión del entorno de ejecución si incluyes la configuración runtime_version en tu archivo app.yaml. De forma predeterminada, se usa la última versión de Java si no se especifica la configuración de runtime_version.

Ejemplos
- Para especificar Java 21 en Ubuntu 22, haz lo siguiente:
```
runtime: java
env: flex

runtime_config:
    operating_system: "ubuntu22"
    runtime_version: "21"
```
- Para especificar la última versión de Python compatible en Ubuntu 22, sigue estos pasos:
```
  runtime: java
  env: flex

  runtime_config:
      operating_system: "ubuntu22"
```

Versiones anteriores del entorno de ejecución

Para Java 8, especifica la configuración de runtime_config y jdk en tu archivo app.yaml.

Java 8 es compatible con lo siguiente:

El entorno de ejecución de Eclipse Jetty 9 y ejecuta Jetty 9 con el Servlet 3.1.
Tu propio código de servidor que escucha en el puerto 8080 como parte de tu aplicación. Esta función te permite usar frameworks de microservicios, como SparkJava y Spring-Boot.

Ejemplos

Especifica la versión 9 de Jetty (configuración predeterminada/opcional):
```
  runtime_config:
    jdk: openjdk8
    server: jetty9
```
Especifica la versión 8 de Java:
```
  runtime_config:
    jdk: openjdk8
```

Muestra de app.yaml para Java 8:

runtime: java
env: flex

handlers:
- url: /.*
  script: this field is required, but ignored

Consulta pom.xml para configurar Maven y build.gradle para configurar Gradle.

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.

web.xml es opcional y solo se necesita si no usas las anotaciones de Servlet 3.x.

Puedes colocar contenido web estático, así como tus páginas de JavaServer, en el directorio webapp/. Jetty 9, que se usa en el entorno flexible de App Engine como contenedor de Servlet, usa Apache Jasper como la implementación predeterminada de JSP y, además, incluye la biblioteca de etiquetas de JSTL.

El archivo Dockerfile es opcional y se usa para personalizar el entorno de ejecución de Java.

Habilita la compresión Gzip

El controlador gzip se incluye con Jetty, pero no está activado de forma predeterminada. Para activar este módulo, configura la variable de entorno, JETTY_MODULES_ENABLE=gzip, en el archivo app.yaml:

env_variables:
  JETTY_MODULES_ENABLE: 'gzip'

Usa la guía de inicio rápido

Jetty puede acelerar el tiempo de inicio de tu aplicación con un análisis previo de su contenido y la generación de archivos de configuración. Si usas una imagen extendida, puedes activar la guía de inicio rápido mediante la ejecución de /scripts/jetty/quickstart.sh en tu Dockerfile, después de agregar el WAR de la aplicación.

Variables de entorno

Puedes establecer las siguientes variables opcionales del entorno que son específicas del entorno de ejecución de Java 8 o Jetty 9. También puedes establecer las variables del entorno de OpenJDK 8.

Para configurar variables de entorno, usa la clave env_variables en el archivo app.yaml.

Variable del entorno	Propiedades de Maven	Valor o comentario
`JETTY_PROPERTIES`		Lista de pares de `name=value` separados por comas anexos a `$JETTY_ARGS`
`JETTY_MODULES_ENABLE`		Lista de módulos separados por comas que se deben habilitar mediante la incorporación a `$JETTY_ARGS`
`JETTY_MODULES_DISABLE`		Lista de módulos separados por comas que se deben inhabilitar mediante la eliminación desde `$JETTY_BASE/start.d`
`JETTY_ARGS`		Argumentos pasados al `start.jar` de Jetty Cualquier argumento que se usa para la configuración personalizada de Jetty se debe transferir aquí.
`JAVA_OPTS`		Argumentos del entorno de ejecución de JVM.

Cloud Logging mejorado (beta)

Cuando se ejecuta en el entorno flexible de App Engine, puedes configurar Java Util Logging para enviar registros a Cloud Logging mediante la configuración de la variable de entorno JETTY_ARGS. Por ejemplo:

 env_variables:
   JETTY_ARGS: -Djava.util.logging.config.file=WEB-INF/logging.properties

Debes proporcionar un archivo logging.properties que configure un LoggingHandler de la siguiente manera:

handlers=com.google.cloud.logging.LoggingHandler

# Optional configuration
.level=INFO
com.google.cloud.logging.LoggingHandler.level=FINE
com.google.cloud.logging.LoggingHandler.log=gae_app.log
com.google.cloud.logging.LoggingHandler.formatter=java.util.logging.SimpleFormatter
java.util.logging.SimpleFormatter.format=%3$s: %5$s%6$s

Compatibilidad con otros entornos de ejecución de Java

Si necesitas usar una versión de Java que no es compatible, puedes crear un entorno de ejecución personalizado y seleccionar una imagen base válida con la versión de Java que necesites.

Para las imágenes base proporcionadas por Google o las imágenes base de Docker para Java, consulta Compila entornos de ejecución personalizados.

Organizar tus archivos

El árbol fuente debería verse así:

MyDir/
  [pom.xml]
  [build.gradle]
  [index.yaml]
  [cron.yaml]
  [dispatch.yaml]
  src/main/
    appengine/
      app.yaml
    docker/
      [Dockerfile]
    java/
      com.example.mycode/
        MyCode.java
    webapp/
      [index.html]
      [jsp.jsp]
      WEB-INF/
        [web.xml]

Pruebas locales

Cuando realices pruebas en tu entorno local, puedes usar los servicios emulados de Google Cloud en lugar de los servicios remotos de Google Cloud. Puedes usar los siguientes emuladores:

Usa el comando gcloud para iniciarlos antes de ejecutar la aplicación:

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

Maven

Agrega las siguientes líneas al archivo pom.xml de Maven para agregar el complemento de Jetty 9 para Maven:

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <version>9.4.2.v20170220</version>
</plugin>

Para ejecutar tu aplicación de forma local, usa el siguiente comando de Maven:

mvn jetty:run-exploded

Gradle

Sigue las instrucciones en la página sobre cómo crear un nuevo proyecto de Gradle para agregar el complemento de Gretty Gradle a tu build.gradle y, luego, usa este comando:

gradle jettyRun

Implementa tu app

Para inicializar el SDK de Google Cloud, debes ejecutar lo siguiente:

gcloud init

Después de completar la configuración, puedes usar Google Cloud CLI para implementar este directorio que contiene los archivos app.yaml y WAR mediante este comando:

gcloud app deploy app.yaml

Si usas alguno de los archivos de configuración opcionales (index.yaml, cron.yaml y dispatch.yaml), impleméntalos por separado mediante el comando 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 tu aplicación:

gradle appengineDeploy