Entorno de ejecución de Java 11

Python 2.7/3 |Java 8/11 |PHP 5/7 |Ruby |Go 1.11/1.12+ |Node.js

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

El entorno de ejecución de Java 11 para App Engine en el entorno estándar se declara en el archivo app.yaml:

runtime: java11

Antes de comenzar

1. Descarga la última versión del SDK de Cloud o actualiza tu SDK de Cloud a la versión actual:

   gcloud components update
   

2. A fin de realizar la implementación 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.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.

3. Sigue las instrucciones del framework de la aplicación para configurar la compilación de un archivo JAR ejecutable.

Compatibilidad con el framework

Con el entorno de ejecución de Java 11 de App Engine, puedes implementar archivos JAR ejecutables. El entorno de ejecución no incluye ningún marco de trabajo de entrega web, lo que significa que no estás limitado a usar frameworks o bibliotecas 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:

• Spring Boot
• Vert.x
• SparkJava
• Ktor
• Micronaut
• Quarkus

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

Implementa proyectos de origen de Maven en el entorno de ejecución de Java 11

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 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 archivos ejecutables de GraalVM

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

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

runtime: java11
entrypoint: ./myexecutable

Nota: Algunas bibliotecas cliente de Google Cloud necesitan una configuración adicional para funcionar con una imagen nativa de GraalVM. Para obtener más información, consulta Configuración del agente de GraalVM.

Versión de Java

El entorno de ejecución de Java 11 usa la última versión estable de Java 11. App Engine se actualiza de forma automática a nuevas revisiones menores luego de la implementación, sin embargo, no actualizará la versión principal de forma automática.

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

El entorno de Open JDK del entorno de ejecución

App Engine ejecuta apps de Java 11 en un contenedor protegido por gVisor en una distribución de Linux de Ubuntu 18.04 actualizada y su paquete compatible de openjdk-11-jdk. App Engine mantiene la imagen base y actualiza el paquete de OpenJDK 11, sin necesidad de que vuelvas a implementar tu app.

Tu app implementada se ubica en el directorio /srv del entorno de ejecución.

Dependencias

Para obtener más información sobre la declaración y 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 JAR Uber ejecutable, el entorno de ejecución inicia la aplicación mediante la ejecución de una aplicación JAR Uber.

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

runtime: java11
entrypoint: java -Xmx64m -jar YOUR-ARTIFACT.jar

En el ejemplo, el archivo jar de la aplicación YOUR-ARTIFACT.jar debe cumplir con lo siguiente:

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

Para que tu 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.

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 tu aplicación, el complemento de App Engine solo subirá los archivos que cambiaron, en lugar de todo el paquete JAR uber.

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 tu app, el servidor web de la app esté escuchando 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 especificado por la variable de entorno PORT, por lo general, 8081. Por ejemplo:

appengine-java11/http-server/src/main/java/com/example/appengine/Main.java

Ver en GitHub

/*
 * 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

Los usuarios pueden acceder a las siguientes funciones de versiones anteriores de Java:

• Inferencia de tipo avanzada con la palabra clave var.
• Crea listas o mapas con facilidad con colecciones inmutables.
• Llama a hosts remotos mediante el HttpClient graduado.
• Usa el sistema de módulos JPMS.
• Usa lenguajes JVM alternativos, como Apache Groovy, Kotlin o Scala.

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	El 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 marcos de trabajo 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 la 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 de tu proyecto.

Nota: Los metadatos personalizados no son compatibles con el entorno de ejecución de Java 11 en el entorno estándar.

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

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

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.