In diesem Dokument wird beschrieben, wie Sie eine Java 8-Anwendung als JAR-Datei neu verpacken, um sie in einer unterstützten Java-Laufzeit auszuführen. Wenn Sie eine unterstützte Java-Laufzeit verwenden möchten, können Sie entweder einen Server wie Jetty einbetten oder Ihre Anwendung mit Docker für eine benutzerdefinierte Laufzeit containerisieren, ohne die Anwendung vollständig neu schreiben zu müssen. Sie können Ihre vorhandenen WAR-Anwendungen auf modernen Java-Plattformen oder in flexiblen Cloud-Umgebungen ausführen. Wählen Sie die Methode aus, die am besten zu Ihrer Bereitstellungsstrategie und Infrastruktur passt:
- Dockerfiles zum Bereitstellen Ihrer Anwendung verwenden (empfohlen)
- Eingebettete Java-Laufzeit (Jetty) verwenden
Java 8-Webanwendung (WAR-Datei) vorbereiten
Bevor Sie Ihre Java 8-Anwendung als unterstützte JAR-Datei neu verpacken, müssen Sie eine WAR-Datei erstellen. In diesem Abschnitt finden Sie eine Beispielanwendung für Java 8, mit der eine WAR-Datei erstellt wird. Folgen Sie der Anleitung zum Erstellen einer Java 8-hello-world
-Anwendung:
Erstellen Sie eine
HelloServlet.java
-Datei in Ihrem Quellverzeichnis:Erstellen Sie eine
web.xml
-Bereitstellungsdeskriptordatei, um Ihre Webanwendung zu konfigurieren:Erstelle eine Landingpage
index.jsp
:Fügen Sie der Datei
pom.xml
den folgenden Code hinzu, um den Build für Ihre Java 8-Anwendung zu definieren:Konfiguration für das Verpacken von WAR-Dateien:
<groupId>com.example</groupId> <artifactId>HelloWorldApp</artifactId> <version>1.0</version> <packaging>war</packaging>
maven-war-plugin
-Plug-in mit der Quellemaven.compiler
und dem Ziel1.8
:<properties> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> <java.version>8</java.version> </properties>
javax.servlet-api
-Abhängigkeit:<dependencies> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> <scope>provided</scope> </dependency> </dependencies>
Maven-Konfiguration:
<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <source>${maven.compiler.source}</source> <target>${maven.compiler.target}</target> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-war-plugin</artifactId> <version>3.3.2</version> </plugin> </plugins> </build>
Ihr Projektverzeichnis sollte in etwa so aussehen:
├── pom.xml └── src └── main ├── java │ └── com │ └── example │ └── HelloServlet.java └── webapp ├── WEB-INF │ └── web.xml └── index.jsp
Führen Sie
mvn install
im Projektverzeichnis Ihrer Anwendung aus, um die WAR-DateiHelloWorldApp-1.0.war
im Zielverzeichnis zu generieren.
Dockerfiles zum Bereitstellen Ihrer Anwendung verwenden (empfohlen)
Benutzerdefinierte Laufzeiten eignen sich für Plattformen, die benutzerdefinierte Container unterstützen, z. B. benutzerdefinierte App Engine-Laufzeiten. Benutzerdefinierte Laufzeiten bieten Flexibilität, da Sie die Laufzeitumgebung konfigurieren können. Ein Beispiel für die Bereitstellung benutzerdefinierter Laufzeiten finden Sie unter Benutzerdefinierte Laufzeitanwendung in der flexiblen App Engine-Umgebung erstellen.
In der folgenden Anleitung wird beschrieben, wie Sie Ihre Java 8-Anwendung mit einer Dockerfile in einen Container packen:
- Java 8-Webanwendung (WAR-Datei) vorbereiten
- Container-Image erstellen und per Push an Artifact Registry übertragen
- Anwendung bereitstellen
Container-Image erstellen und per Push an Artifact Registry übertragen
In diesem Abschnitt wird beschrieben, wie Sie mit Cloud Build ein Docker-Image erstellen und in ein Artifact Registry-Repository verschieben. So erstellen Sie ein Container-Image Ihrer Anwendung:
Erstellen Sie eine
cloudbuild.yaml
-Datei in Ihrem Quellverzeichnis, um das Docker-Image zu erstellen und in Artifact Registry zu übertragen:steps: # Step 1: Build the Docker image - name: "gcr.io/cloud-builders/docker" args: - "build" - "-t" - "$LOCATION-docker.pkg.dev/$PROJECT/$REPOSITORY/SERVICE:VERSION" - "." # Step 2: Push the Docker image to Artifact Registry - name: "gcr.io/cloud-builders/docker" args: - "push" - "$LOCATION-docker.pkg.dev/$PROJECT/$REPOSITORY/SERVICE:VERSION" images: - "$LOCATION-docker.pkg.dev/$PROJECT/$REPOSITORY/SERVICE:VERSION"
Ersetzen Sie:
- LOCATION durch die Google Cloud Region, in der Sie Ihre App bereitstellen.
- PROJECT durch Ihre Google Cloud Projekt-ID.
- Ersetzen Sie REPOSITORY durch den Namen Ihres Artifact Registry-Repositorys.
- IMAGE durch die URL Ihres Container-Images.
- TAG durch das Tag Ihres Container-Images.
Erstellen Sie ein Dockerfile mit der folgenden Konfiguration:
Laden Sie Docker herunter und installieren Sie es, um die Beispielanwendung zu testen und den Hello World-Container auf Ihrem lokalen Computer auszuführen.
Erstellen Sie das Container-Image und übertragen Sie es per Push in die Artifact Registry:
gcloud builds submit .
Anwendung bereitstellen
So stellen Sie Ihre App Engine-Anwendung bereit:
Konfigurieren Sie die Datei
app.yaml
so, dass eine benutzerdefinierte Laufzeit im Quellverzeichnis verwendet wird:Ihr Projektverzeichnis sollte in etwa so aussehen:
├── Dockerfile ├── README.md ├── app.yaml ├── cloudbuild.yaml ├── pom.xml └── src └── main ├── java │ └── com │ └── example │ └── HelloServlet.java └── webapp ├── WEB-INF │ └── web.xml └── index.jsp
Stellen Sie die Anwendung mit dem Befehl
gcloud app deploy
bereit:gcloud app deploy --image-url=REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE:tag
Ersetzen Sie:
- LOCATION durch die Google Cloud Region, in der Sie Ihre App bereitstellen.
- PROJECT durch Ihre Google Cloud Projekt-ID.
- Ersetzen Sie REPOSITORY durch den Namen Ihres Artifact Registry-Repositorys.
- IMAGE durch die URL Ihres Container-Images.
- TAG durch das Tag Ihres Container-Images.
Eingebettete Java-Laufzeit verwenden
In der folgenden Anleitung wird gezeigt, wie Sie eine App Engine Java 8-Anwendung mit einem eingebetteten Server (Jetty) neu verpacken, damit sie als eigenständiges JAR in einer unterstützten Java-Laufzeit ausgeführt werden kann:
- Eingebetteten Jetty-Server erstellen
- Java 8-Webanwendung (WAR-Datei) vorbereiten
- WAR-Datei mit eingebettetem Jetty ausführen und Anwendung bereitstellen
Eingebetteten Jetty-Server erstellen
So bündeln Sie die WAR-Datei Ihrer Anwendung mit einem eingebetteten Jetty-Server:
Erstellen Sie eine
Main
-Klasse, um den Jetty-Server zu initialisieren und zu konfigurieren, damit Ihre WAR-Datei ausgeführt werden kann. Mit der KlasseMain
wird der Serverport eingerichtet, der standardmäßig auf8080
festgelegt ist. Sie können den Quellcode auch so ändern, dass ein Port verwendet wird, der in der UmgebungsvariablePORT
angegeben ist. Die KlasseMain
konfiguriert denWebAppContext
-Handler für die Bereitstellung Ihrer WAR-Datei:Erstellen Sie die Maven-Projektdatei
pom.xml
und fügen Sie die folgende Konfiguration hinzu:Legen Sie die Attribute
maven.compiler.source
undmaven.compiler.target
auf eine unterstützte Java-Laufzeit fest:Fügen Sie Abhängigkeiten für Jetty hinzu:
Konfigurieren Sie das Attribut
maven-assembly-plugin
für Paketabhängigkeiten:
Ihr Projektverzeichnis sollte in etwa so aussehen:
├─src │ └─main │ └─java │ └─jetty │ └─Main.java └─pom.xml
Führen Sie den Befehl
mvn install
im Projektverzeichnis des Jetty-Runners aus. Dadurch wird diejetty-jar-with-dependencies.jar
in Ihrem Zielverzeichnis generiert.Folgen Sie der Anleitung im Abschnitt Java 8-Webanwendung (WAR-Datei) vorbereiten, um eine WAR-Datei zu erstellen.
WAR-Datei mit eingebettetem Jetty ausführen und Anwendung bereitstellen
In diesem Abschnitt wird beschrieben, wie Sie Ihre Anwendung in einer ausführbaren JAR-Datei verpacken. So verpacken und stellen Sie Ihre Anwendung bereit:
Platzieren Sie die generierte Jetty-Runner-JAR-Datei
jetty-jar-with-dependencies.jar
und die WAR-Datei Ihrer AnwendungHelloWorldApp-1.0.war
im selben Verzeichnis.Führen Sie die Anwendung mit einer unterstützten Java-Laufzeit aus:
java -jar jetty-jar-with-dependencies.jar HelloWorldApp-1.0.war
- Rufen Sie in Ihrem Webbrowser http://localhost:8080 auf. Sie sollten die Begrüßungsseite Ihrer Anwendung sehen.
Erstellen Sie ein
entrypoint
-Element in Ihrerapp.yaml
-Datei, um diejetty-jar-with-dependencies
-Datei aufzurufen, und übergeben Sie die WAR-Datei als Argument. Die Version, die Sie in der WAR-Datei angeben, muss mit der Version in der Dateipom.xml
übereinstimmen:Stellen Sie die Anwendung mit dem Befehl
gcloud app deploy
bereit.