Aviso: En los próximos meses, reorganizaremos el sitio de documentación de App Engine para facilitar la búsqueda de contenido y alinearlo mejor con el resto de los productos de Google Cloud. El mismo contenido estará disponible, pero la navegación ahora coincidirá con el resto de los productos de Cloud.

Java 17 ahora está disponible de forma general.

Entorno de ejecución de Java 11/17

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

El entorno de ejecución de Java es la pila de software encargada de instalar el código de tu servicio web y sus dependencias, y de ejecutar el servicio.

A fin de especificar Java 11/17 para el entorno estándar de App Engine, declara el entorno de ejecución en el archivo app.yaml. Por ejemplo:

Java 17

runtime: java17

Java 11

runtime: java11

Antes de comenzar

  1. Descarga la última versión de Google Cloud CLI o actualiza tu CLI de gcloud a la versión actual:

    gcloud components update
    
  2. A fin de implementar mediante Maven, deberás agregar el complemento de Maven de App Engine a tu archivo pom.xml:

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

    Entre otras opciones de implementación, se incluye el uso del comando gcloud app deploy o el complemento Gradle de App Engine.

  3. Sigue las instrucciones para que el framework de tu aplicación configure la compilación de un archivo JAR ejecutable.

Compatibilidad con el framework

Con los entornos de ejecución de Java 11/17 de App Engine, puedes implementar archivos JAR ejecutables. Los entornos de ejecución no incluyen ningún framework de entrega web, lo que significa que no estás limitado a usar bibliotecas o frameworks basados en servlets. Usa tus dependencias nativas o pilas de herramientas de redes, como la biblioteca de Netty.

Hay muestras de hello world que usan frameworks web populares de Java en el repositorio de GitHub de Google Cloud:

No estás limitado a estos frameworks y te recomendamos que pruebes el que prefieras, como Grails, Blade, Play!, Vaadin o jHipster.

Implementa proyectos fuente de Maven en los entornos de ejecución de Java 11/17

Puedes implementar tu proyecto de Maven como el código fuente y hacer que se compile y se implemente mediante Paquetes de compilación de App Engine.

Para implementar un proyecto de Maven como el código fuente, ve al directorio de nivel superior de tu proyecto y escribe lo siguiente:

gcloud app deploy pom.xml

Se transmitirán los registros de compilación y de implementación, y podrás ver los registros detallados en la sección historial de Cloud Build en Cloud Console.

Usa ejecutables de GraalVM

El entorno de ejecución de Java del entorno estándar de App Engine admite ejecutables de imágenes nativas de GraalVM. Una vez que compiles tu app de Java 11/17 mediante una imagen nativa de GraalVM, puedes usar la configuración entrypoint en tu archivo app.yaml para que apunte al ejecutable.

Por ejemplo, un ejecutable con el nombre de archivo myexecutable podría tener el siguiente archivo de configuración app.yaml:

runtime: java17 # or another supported runtime
entrypoint: ./myexecutable

Las bibliotecas cliente de Google Cloud se pueden usar para compilar aplicaciones como una imagen nativa de GraalVM. Para obtener más información, consulta la documentación sobre cómo compilar imágenes nativas.

Versión de Java

Los entornos de ejecución de Java 11/17 usan la última versión estable de la versión que se especifica en tu archivo app.yaml. App Engine se actualiza de forma automática a las nuevas versiones de actualización de parche, pero no se actualizará automáticamente a las versiones secundarias.

Por ejemplo, tu aplicación podría implementarse en Java 11.0.4 y actualizarse de forma automática a la versión Java 11.0.5 en una implementación posterior de la plataforma administrada, pero no se actualizará a Java 12 de manera automática.

El entorno de Open JDK del entorno de ejecución

App Engine ejecuta apps de Java 11/17 en un contenedor protegido por gVisor en una distribución de Linux de Ubuntu actualizada y su entorno de ejecución compatible openjdk-11-jdk para Java 11 u openjdk-17-jdk para Java 17.

  • Java 11 se ejecuta en Ubuntu 18.04
  • Java 17 se ejecuta en Ubuntu 22.04

App Engine mantiene la imagen base y actualiza el paquete de OpenJDK 11 y OpenJDK 17, sin necesidad de que vuelvas a implementar tu app.

Tu app implementada se ubica en el directorio /workspace del entorno de ejecución. También se puede acceder a ella a través de un vínculo simbólico en /srv.

Versiones de Java de App Engine

Todos los artefactos publicados que comienzan con la versión 2.x.x usan el mecanismo de actualización de código abierto. Los artefactos publicados que comienzan con la versión 1.9.9xx o anteriores usan el sistema de compilación interno. Consulta el repositorio de GitHub para obtener más detalles.

Dependencias

Para obtener más información sobre la declaración y la administración de dependencias, consulta Especifica dependencias.

Inicio de la aplicación

Los frameworks como Spring Boot, Micronaut y Ktor compilan un uber ejecutable JAR de forma predeterminada. Si tu archivo de compilación de Maven o Gradle genera un Uber JAR ejecutable, el entorno de ejecución inicia la aplicación mediante la ejecución de una aplicación Uber JAR.

Como alternativa, App Engine usará el contenido del campo opcional entrypoint en el archivo app.yaml. Por ejemplo:

runtime: java17 # or another supported runtime
entrypoint: java -Xmx64m -jar YOUR-ARTIFACT.jar

En el ejemplo anterior del jar de la aplicación YOUR-ARTIFACT.jar, se debe cumplir lo siguiente:

  • Estar en el directorio raíz con el archivo app.yaml
  • Contener una entrada Main-Class en el archivo de metadatos META-INF/MANIFEST.MF
  • De manera opcional, contener una entrada Class-Path con una lista de rutas de acceso relativas a otros jar dependientes. Estos se subirán con la aplicación de forma automática.

Para que la app reciba solicitudes HTTP, el punto de entrada debe iniciar un servidor web que escuche en el puerto que especificó la variable de entorno PORT. El entorno de entrega de App Engine configura el valor de la variable de entorno PORT de forma dinámica. Este valor no se puede establecer en la sección env_variables del archivo app.yaml.

Con un punto de entrada personalizado, puedes construir y empaquetar tu aplicación como un archivo JAR delgado que solo contiene el código de la aplicación y las dependencias directas. Cuando implementas la aplicación, el complemento de App Engine solo subirá los archivos que cambiaron, en lugar de todo el paquete Uber JAR.

Asegúrate de usar la variable de entorno PORT

Si ves las advertencias sobre el puerto 8080 y NGINX en los archivos de registro de la app, el servidor web de la app escucha en el puerto 8080 predeterminado. Esto evita que App Engine use su capa NGINX para comprimir las respuestas HTTP. Te recomendamos que configures tu servidor web para que responda a las solicitudes HTTP en el puerto que especificó la variable de entorno PORT, por lo general, 8081. Por ejemplo:

/*
 * Copyright 2019 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.example.appengine;

import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

public class Main {

  public static void main(String[] args) throws IOException {
    // Create an instance of HttpServer bound to port defined by the
    // PORT environment variable when present, otherwise on 8080.
    int port = Integer.parseInt(System.getenv().getOrDefault("PORT", "8080"));
    HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);

    // Set root URI path.
    server.createContext("/", (var t) -> {
      byte[] response = "Hello World!".getBytes();
      t.sendResponseHeaders(200, response.length);
      try (OutputStream os = t.getResponseBody()) {
        os.write(response);
      }
    });

    // Create a second URI path.
    server.createContext("/foo", (var t) -> {
      byte[] response = "Foo!".getBytes();
      t.sendResponseHeaders(200, response.length);
      try (OutputStream os = t.getResponseBody()) {
        os.write(response);
      }
    });

    server.start();
  }
}

Compatibilidad con versiones anteriores de Java

Para conocer las diferencias entre los entornos de ejecución de Java 8 y Java 11/17, consulta Diferencias clave entre los entornos de ejecución de Java 8 y Java 11/17.

Variables de entorno

El entorno de ejecución configura las siguientes variables del entorno:

Variable del entorno Descripción
GAE_APPLICATION ID de tu aplicación de App Engine. Este ID tiene el prefijo “region code~”, como “e~”, para aplicaciones implementadas en Europa.
GAE_DEPLOYMENT_ID ID de la implementación actual.
GAE_ENV Entorno de App Engine. Se define en standard.
GAE_INSTANCE ID de la instancia en la que se está ejecutando tu servicio.
GAE_MEMORY_MB Cantidad de memoria disponible para el proceso de la aplicación, en MB.
GAE_RUNTIME Entorno de ejecución especificado en el archivo app.yaml.
GAE_SERVICE Nombre de servicio especificado en el archivo app.yaml. Si no se especifica un nombre de servicio, se asigna default.
GAE_VERSION Etiqueta de la versión actual de tu servicio.
GOOGLE_CLOUD_PROJECT ID del proyecto de Cloud asociado a tu aplicación.
PORT Puerto que recibe las solicitudes HTTP.

Puedes definir variables de entorno adicionales en tu archivo app.yaml, pero los valores anteriores no se pueden anular.

Proxies HTTPS y de reenvío

App Engine finaliza las conexiones HTTPS en el balanceador de cargas y reenvía las solicitudes a tu aplicación. Algunas aplicaciones deben determinar la IP y el protocolo de la solicitud original. La dirección IP del usuario está disponible en el encabezado X-Forwarded-For estándar. Las aplicaciones que necesitan esta información deben configurar sus frameworks web para que confíen en el proxy.

Acceso al sistema de archivos

El entorno de ejecución incluye un directorio /tmp que admite escritura, y todos los demás directorios tienen acceso de solo lectura. Escribir en /tmp ocupa memoria del sistema.

Servidor de metadatos

Cada instancia de tu aplicación puede usar el servidor de metadatos de App Engine para consultar información acerca de la instancia y del proyecto.

Puedes acceder al servidor de metadatos a través de los siguientes extremos:

  • http://metadata
  • http://metadata.google.internal

Las solicitudes enviadas al servidor de metadatos deben incluir el encabezado de solicitud Metadata-Flavor: Google. Este encabezado indica que la solicitud se envió con la intención de recuperar valores de metadatos.

La siguiente tabla enumera los extremos en los que puedes realizar solicitudes HTTP para metadatos específicos:

Extremo de metadatos Descripción
/computeMetadata/v1/project/numeric-project-id El número de proyecto asignado a tu proyecto.
/computeMetadata/v1/project/project-id El ID del proyecto asignado a tu proyecto.
/computeMetadata/v1/instance/zone La zona en la que se está ejecutando la instancia.
/computeMetadata/v1/instance/service-accounts/default/aliases
/computeMetadata/v1/instance/service-accounts/default/email El correo electrónico de la cuenta de servicio predeterminada asignado a tu proyecto.
/computeMetadata/v1/instance/service-accounts/default/ Enumera todas las cuentas de servicio predeterminadas para tu proyecto.
/computeMetadata/v1/instance/service-accounts/default/scopes Enumera todos los alcances compatibles para las cuentas de servicio predeterminadas.
/computeMetadata/v1/instance/service-accounts/default/token Muestra el token de autenticación que puede usarse para autenticar tu aplicación en otras API de Google Cloud.

Por ejemplo, para recuperar tu ID del proyecto, envía una solicitud a http://metadata.google.internal/computeMetadata/v1/project/project-id.