Java 11-Laufzeitumgebung

Die Java 11-Laufzeit ist der Software-Stack für die Installation des Codes Ihres Webdienstes und der zugehörigen Abhängigkeiten sowie für die Ausführung des Dienstes.

Die Java 11-Laufzeit für App Engine in der Standardumgebung wird in der Datei app.yaml so deklariert:

runtime: java11

Hinweis

Laden Sie die neueste Version des Cloud SDK herunter oder aktualisieren Sie Ihr Cloud SDK auf die aktuelle Version:
```
gcloud components update
```
Für die Bereitstellung mithilfe von Maven müssen Sie das App Engine-Maven-Plug-in in die Datei pom.xml aufnehmen:
```
<plugin>
   <groupId>com.google.cloud.tools</groupId>
   <artifactId>appengine-maven-plugin</artifactId>
   <version>2.2.0</version>
</plugin>
```
Die Bereitstellung ist außerdem über den Befehl gcloud app deploy und über das Gradle-Plug-in für App Engine möglich.
Befolgen Sie die Anleitung für Ihr Anwendungsframework, um den Build einer ausführbaren JAR-Datei zu konfigurieren.

Framework-Kompatibilität

Mit der Java 11-Laufzeit von App Engine können Sie ausführbare JAR-Dateien bereitstellen. Die Laufzeit enthält kein Web-Serving-Framework, das heißt, Sie sind nicht auf die Verwendung von Servlet-basierten Frameworks oder Bibliotheken beschränkt. Sie können also Ihre nativen Abhängigkeiten oder Netzwerk-Stacks wie die Netty-Bibliothek nutzen.

Das GitHub-Repository von Google Cloud enthält hello world-Beispiele, die gängige Java-Web-Frameworks verwenden:

Sie sind nicht auf diese Frameworks beschränkt und können Ihre bevorzugten Frameworks wie Grails, Blade oder Play! nutzen. Vaadin oder jHipster

Maven-Quellprojekte in der Java 11-Laufzeit bereitstellen

Sie können Ihr Maven-Projekt als Quellcode bereitstellen und mithilfe von App Engine-Buildpacks erstellen sowie bereitstellen.

Um ein Maven-Projekt als Quellcode bereitzustellen, wechseln Sie zum obersten Verzeichnis Ihres Projekts und geben Sie Folgendes ein:

gcloud app deploy pom.xml

Es werden Build- und Bereitstellungslogs gestreamt. Die ausführlichen Logs finden Sie im Abschnitt für den Cloud Build-Verlauf in der Cloud Console.

Ausführbare GraalVM-Dateien verwenden

Die standardmäßige Java 11-Laufzeit von App Engine unterstützt native ausführbare GraalVM-Image-Dateien. Nachdem Sie Ihre Java 11-Anwendung mit einem nativen GraalVM-Image kompiliert haben, können Sie mit der Einstellung entrypoint in der app.yaml-Datei auf die ausführbare Datei verweisen.

Eine ausführbare Datei mit dem Dateinamen myexecutable kann beispielsweise die folgende Konfigurationsdatei app.yaml haben:

runtime: java11
entrypoint: ./myexecutable

Java-Version

Die Java 11-Laufzeitumgebung verwendet die neueste stabile Version von Java 11. App Engine wird automatisch auf neue Nebenversionen aktualisiert. Die Aktualisierung der Hauptversion erfolgt jedoch nicht automatisch.

Beispiel: Ihre Anwendung wird möglicherweise unter Java 11.0.4 bereitgestellt und bei einer späteren Bereitstellung der verwalteten Plattform automatisch auf die Version Java 11.0.5 aktualisiert, aber nicht automatisch auf Java 12 aktualisiert.

Open-JDK-Umgebung der Laufzeit

App Engine führt Java 11-Anwendungen in einem durch gVisor gesicherten Container auf einer aktuellen Ubuntu 18.04-Linux-Distribution und dem unterstützten Paket openjdk-11-jdk aus. App Engine verwaltet das Basis-Image und aktualisiert das OpenJDK 11-Paket, ohne dass Sie Ihre Anwendung noch einmal bereitstellen müssen.

Die bereitgestellte Anwendung befindet sich im Verzeichnis /workspace der Laufzeit. Sie kann auch über einen symbolischen Link unter /srv aufgerufen werden.

Abhängigkeiten

Weitere Informationen zum Deklarieren und Verwalten von Abhängigkeiten finden Sie unter Abhängigkeiten angeben.

Anwendungsstart

Frameworks wie Spring Boot, Micronaut, Ktor erstellen standardmäßig eine ausführbare Uber-JAR. Wenn Ihre Maven- oder Gradle-Build-Datei eine ausführbare Uber-JAR-Datei erzeugt, startet die Laufzeit Ihre Anwendung durch Ausführen einer Uber-JAR-Anwendung.

Alternativ verwendet App Engine den Inhalt des optionalen Feldes entrypoint in Ihrer app.yaml-Datei. Beispiel:

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

Die Beispiel-JAR-Datei YOUR-ARTIFACT.jar muss:

Sich im Stammverzeichnis Ihrer Datei app.yaml befinden.
Einen Main-Class-Eintrag in der META-INF/MANIFEST.MF-Metadatendatei enthalten.
Optional einen Class-Path-Eintrag mit einer Liste relativer Pfade zu anderen abhängigen JAR-Dateien enthalten. Diese werden automatisch mit der Anwendung hochgeladen.

Damit Ihre Anwendung HTTP-Anfragen empfängt, sollte durch den Einstiegspunkt ein Webserver gestartet werden, der den von der Umgebungsvariablen PORT angegebenen Port überwacht.

Mit einem benutzerdefinierten Einstiegspunkt können Sie Ihre Anwendung als schmale JAR-Datei erstellen und verpacken, die nur Ihren Anwendungscode und direkte Abhängigkeiten enthält. Wenn Sie Ihre Anwendung bereitstellen, lädt das App Engine-Plug-in nur die Dateien hoch, die sich geändert haben, und nicht das gesamte Uber-JAR-Paket.

Achten Sie darauf, die PORT-Umgebungsvariable zu verwenden

Wenn in Ihren Anwendungslogdateien die Warnungen zu Port 8080 und NGINX angezeigt werden, überwacht der Webserver Ihrer Anwendung den Standardport 8080. Dadurch wird verhindert, dass App Engine mit der NGINX-Ebene HTTP-Antworten komprimiert. Es empfiehlt sich, den Webserver so zu konfigurieren, dass er auf HTTP-Anfragen an dem von der Umgebungsvariablen PORT angegebenen Port antwortet, in der Regel 8081. Beispiel:

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

Auf GitHub ansehen

/*
 * 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();
  }
}

Kompatibilität mit früheren Java-Versionen

Nutzer können auf die folgenden Funktionen aus früheren Java-Versionen zugreifen:

Erweiterte Typableitung mit dem Keyword var.
Mit unveränderlichen Sammlungen können Sie ganz einfach Listen oder Karten erstellen.
Rufen Sie Remote-Hosts mit dem abgestuften HttpClient auf.
Verwenden Sie das JPMS-Modulsystem.
Verwenden Sie alternative JVM-Sprachen wie Apache Groovy, Kotlin oder Scala.

Umgebungsvariablen

Folgende Umgebungsvariablen werden durch die Laufzeit festgelegt:

Umgebungsvariable	Beschreibung
`GAE_APPLICATION`	ID der App Engine-Anwendung. Diese ID hat das Präfix „`region code`~”, z. B. „e~” für Anwendungen, die in Europa bereitgestellt werden.
`GAE_DEPLOYMENT_ID`	ID der aktuellen Bereitstellung.
`GAE_ENV`	App Engine-Umgebung. Legen Sie `standard` fest.
`GAE_INSTANCE`	ID der Instanz, auf der Ihr Dienst gerade ausgeführt wird.
`GAE_MEMORY_MB`	Größe des für den Anwendungsprozess verfügbaren Speichers in MB
`GAE_RUNTIME`	Laufzeit, die in der Datei `app.yaml` angegeben ist.
`GAE_SERVICE`	Dienstname, der in der Datei `app.yaml` angegeben ist. Wenn kein Dienstname angegeben ist, wird als Wert `default` festgelegt.
`GAE_VERSION`	Aktuelle Versionsbezeichnung Ihres Dienstes.
`GOOGLE_CLOUD_PROJECT`	Cloud-Projekt-ID, die der Anwendung zugeordnet ist.
`PORT`	Port, der HTTP-Anfragen empfängt.

Sie können zusätzliche Umgebungsvariablen in Ihrer app.yaml-Datei definieren. Die oben genannten Werte können jedoch nicht überschrieben werden.

HTTPS- und Weiterleitungs-Proxys

App Engine beendet HTTPS-Verbindungen am Load-Balancer und leitet Anfragen an die Anwendung weiter. Einige Anwendungen müssen die ursprüngliche Anfrage-IP-Adresse und das Protokoll bestimmen. Die IP-Adresse des Nutzers ist im Standardheader X-Forwarded-For verfügbar. Bei Anwendungen, die diese Informationen benötigen, sollte das Web-Framework so konfiguriert werden, dass dem Proxy vertraut wird.

Dateisystemzugriff

Die Laufzeit enthält das beschreibbare Verzeichnis /tmp. Alle anderen Verzeichnisse sind schreibgeschützt. Beim Schreiben in /tmp wird Systemspeicher belegt.

Metadatenserver

Jede Instanz einer Anwendung kann mit dem App Engine-Metadatenserver Informationen über die Instanz und das Projekt abfragen.

Sie können auf den Metadatenserver über die folgenden Endpunkte zugreifen:

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

In der folgenden Tabelle sind die Endpunkte aufgeführt, an die Sie HTTP-Anfragen für bestimmte Metadaten senden können:

Metadatenendpunkt	Beschreibung
`/computeMetadata/v1/project/numeric-project-id`	Projektnummer, die Ihrem Projekt zugewiesen ist.
`/computeMetadata/v1/project/project-id`	Projekt-ID, die Ihrem Projekt zugewiesen ist.
`/computeMetadata/v1/instance/zone`	Zone, in der die Instanz ausgeführt wird.
`/computeMetadata/v1/instance/service-accounts/default/aliases`
`/computeMetadata/v1/instance/service-accounts/default/email`	E-Mail-Adresse des Standarddienstkontos, die Ihrem Projekt zugewiesen ist.
`/computeMetadata/v1/instance/service-accounts/default/`	Listet alle Standarddienstkonten für Ihr Projekt auf.
`/computeMetadata/v1/instance/service-accounts/default/scopes`	Listet alle unterstützten Bereiche für die Standarddienstkonten auf.
`/computeMetadata/v1/instance/service-accounts/default/token`	Gibt das Authentifizierungstoken zurück, mit dem Ihre Anwendung gegenüber anderen Google Cloud APIs authentifiziert werden kann.

Wenn Sie z. B. Ihre Projekt-ID abrufen möchten, senden Sie eine Anfrage an http://metadata.google.internal/computeMetadata/v1/project/project-id.