Java-Laufzeitumgebung

Die Java-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-Laufzeit wird für die App Engine-Standardumgebung in der Datei app.yaml deklariert. Beispiel:

runtime: javaVERSION

Dabei ist VERSION die Java-MAJOR-Versionsnummer. Java 21 verwendet beispielsweise 21.

Informationen zu anderen unterstützten Java-Versionen und zur entsprechenden Ubuntu-Version für Ihre Java-Version finden Sie im Zeitplan für den Laufzeitsupport.

Hinweise

Laden Sie die neueste Version der Google Cloud CLI herunter oder aktualisieren Sie Ihre gcloud CLI 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.7.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-Laufzeit von App Engine können Sie ausführbare JAR-Dateien bereitstellen. Die Laufzeiten enthalten kein Web-Serving-Framework, das heißt, Sie sind nicht auf die Verwendung von Servlet-basierten Frameworks oder Bibliotheken beschränkt. Verwenden Sie Ihre nativen Abhängigkeiten oder Netzwerkstacks wie die Netty-Bibliothek.

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-Laufzeit bereitstellen

Sie können Ihr Maven-Projekt als Quellcode bereitstellen und mithilfe der Buildpacks von Google Cloud erstellen und 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 Java-Laufzeit der App Engine-Standardumgebung unterstützt ausführbare native GraalVM-Image-Dateien. Nachdem Sie Ihre Java-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: java17 # or another supported runtime
entrypoint: ./myexecutable

Google Cloud-Clientbibliotheken können zum Kompilieren von Anwendungen als natives GraalVM-Image verwendet werden. Weitere Informationen finden Sie in der Dokumentation zum Kompilieren nativer Images.

Java-Version

Die Java-Laufzeit verwendet den neuesten stabilen Release der Version, die in der Datei app.yaml angegeben ist. App Engine wird automatisch auf neue Patchrelease-Versionen aktualisiert. Die Nebenversion wird jedoch nicht automatisch aktualisiert.

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.

Informationen zum Upgrade Ihrer Java-Version finden Sie unter Vorhandene Anwendung aktualisieren.

Open-JDK-Umgebung der Laufzeit

App Engine führt Java-Anwendungen in einem durch gVisor gesicherten Container auf einer aktuellen Ubuntu Linux-Distribution und ihrer unterstützten openjdk-11-jdk für Java 11- oder openjdk-17-jdk für Java 17-Laufzeit.

Informationen zu unterstützten Ubuntu-Versionen für Ihre Java-Version finden Sie im Zeitplan für den Laufzeitsupport.

App Engine verwaltet das Basis-Image und aktualisiert die Pakete OpenJDK 11 und OpenJDK 17, 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.

App Engine-Java-Releases

Alle freigegebenen Artefakte, die mit Version 2.x.x beginnen, verwenden den Releasemechanismus Open Source. Freigegebene Artefakte, die mit Version 1.9.9xx oder früher beginnen, verwenden das interne Build-System. Weitere Informationen finden Sie im GitHub-Repository.

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: java21 # or another supported runtime
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. Der Wert der Umgebungsvariable PORT wird dynamisch von der App Engine-Bereitstellungsumgebung festgelegt. Dieser Wert kann nicht im Abschnitt env_variables der Datei app.yaml festgelegt werden.

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:

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

Informationen zu Unterschieden zwischen Java 8 und der neuesten unterstützten Java-Version finden Sie unter Wichtige Unterschiede zwischen den Java 8- und Java 11+-Laufzeiten.

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`	Google Cloud-Projekt-ID, die der Anwendung zugeordnet ist.
`PORT`	Port, der HTTP-Anfragen empfängt.
`NODE_ENV` (nur in der Node.js-Laufzeit verfügbar)	Erhält den Wert `production`, wenn der Dienst bereitgestellt wird.

Sie können in der Datei app.yaml weitere Umgebungsvariablen definieren. Die oben angegebenen Werte können aber mit Ausnahme von NODE_ENV nicht überschrieben werden.

HTTPS und Weiterleitungsproxys

App Engine terminiert 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

An den Metadatenserver gesendete Anfragen müssen den Anfrageheader Metadata-Flavor: Google enthalten. Dieser Header gibt an, dass die Anfrage zum Abrufen von Metadatenwerten gesendet wurde.

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/region`	Region, 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.