Apache Maven und das (Google Cloud CLI-basierte) App Engine-Plug-in verwenden

Auf dieser Seite wird erläutert, wie Sie ein App Engine-Projekt für Ihre Cloud Endpoints Frameworks API mithilfe von Apache Maven verwalten. Apache Maven ist ein Tool zum Verwalten und Nachvollziehen von Softwareprojekten, mit dem WAR-Dateien (Web Application Archive) für die Bereitstellung in App Engine erstellt werden können. Google stellt ein Plug-in und Maven-Archetypen zur Verfügung, die von Maven 3.3.9 oder höher unterstützt werden.

Maven lädt die Java-Bibliotheken aus dem App Engine SDK herunter. Sie können Maven verwenden, um Ihre Anwendung lokal zu testen und in App Engine bereitzustellen.

Hinweise

Verwenden Sie die Google Cloud Console, um Ihr Google Cloud-Projekt zu erstellen und einzurichten:

Zu App Engine
1. Wählen Sie ein Google Cloud-Projekt aus oder erstellen Sie ein neues.
2. Wenn Sie eine App Engine-Anwendung für Ihr Projekt erstellen müssen, wählen Sie an der entsprechenden Eingabeaufforderung eine Region aus, in der sich Ihre App Engine-Anwendung befinden soll.
Laden Sie die gcloud CLI herunter, installieren Sie sie und initialisieren Sie dann die Google Cloud CLI.
Wenn die Google Cloud CLI bereits installiert ist und für eine andere Google Cloud-Projekt-ID konfiguriert werden soll, als Sie bei der Initialisierung der Befehlszeile angegeben haben, lesen Sie gcloud CLI-Konfigurationen verwalten.
Installieren Sie die app-engine-java-Komponente der gcloud CLI:
```
gcloud components install app-engine-java
```
Hinweis: Führen Sie gcloud components update aus, um zu prüfen, ob die neueste Version der gcloud CLI für Java installiert ist.
Laden Sie Java herunter und installieren und konfigurieren Sie es, sofern nicht bereits geschehen.

Setzen Sie die Java-Compiler-Flags im pom.xml Ihres Projekts, um den Java 8-Bytecode anzugeben:

<properties>
  <maven.compiler.source>1.8</maven.compiler.source>
  <maven.compiler.target>1.8</maven.compiler.target>
</properties>

Es muss Apache Maven 3.3.9 oder höher installiert sein. Führen Sie den folgenden Befehl aus, um Ihre Maven-Version zu ermitteln:
```
 mvn -v
```
Falls nicht die richtige Version von Maven installiert ist, gehen Sie so vor:
1. Laden Sie Maven 3.3.9 oder höher von der Maven-Website herunter.
2. Installieren Sie Maven auf Ihrem lokalen Rechner.
  Hinweis: Linux-Nutzer müssen möglicherweise Maven herunterladen, anstatt apt-get install zu verwenden.

Maven-Plug-in für App Engine in ein vorhandenes Projekt aufnehmen (optional)

Damit Sie das Maven-Plug-in für App Engine in einem vorhandenen Maven-Projekt verwenden können, fügen Sie Folgendes in den Abschnitt plugins der Projektdatei pom.xml ein:

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

App Engine-Archetyp auswählen

Mit Maven-Archetypen können Nutzer Maven-Projekte mit Vorlagen erstellen, die allgemeine Szenarien abdecken. App Engine verwendet dieses Maven-Feature, um einige nützliche App Engine-Archetypen auf Maven Central zur Verfügung zu stellen. Wählen Sie einen geeigneten App Engine-Archetypen für Ihre Anwendung aus:

Anwendungstyp	Artefakt	Beschreibung
Endpoints Frameworks für App Engine	`endpoints-skeleton-archetype`	Generiert ein neues, leeres Back-End-API-Projekt für Endpoints Frameworks für App Engine, das die erforderlichen Dateien und Verzeichnisse bereits enthält und für Ihre eigenen Klassen und Ressourcen einsatzbereit ist.
Endpoints Frameworks für App Engine	`hello-endpoints-archetype`	Generiert ein Back-End-API-Startprojekt für Endpoints Frameworks für App Engine, das sofort erstellt und ausgeführt werden kann.

Neues Projekt mit Maven erstellen

Bei der Projekterstellung werden Sie von Maven aufgefordert, groupId, artifactId, version und das package für das Projekt anzugeben.

Begriff	Bedeutung
`groupId`	Ein Namespace in Maven, um Ihre Artefakte zu erfassen. Wenn Nutzer Ihr Projekt in ihrem eigenen Maven-Projekt verwenden, dient dies als Attribut für das abhängige Objekt, das der Nutzer letztendlich angibt.
`artifactId`	Der Name Ihres Projekts in Maven. Er wird auch von Nutzern Ihres Projekts angegeben, wenn ihre eigenen Maven-Projekte von Ihrem Projekt abhängig sind.
`version`	Die ursprüngliche Maven-Version, mit der Ihr Projekt generiert werden soll. Es empfiehlt sich, `version` mit dem Suffix `-SNAPSHOT` zu versehen, da dies im Maven-Release-Plug-in Unterstützung für Versionen bietet, die sich in der Entwicklung befinden. Weitere Informationen finden Sie in der Maven-Anleitung zur Verwendung des Release-Plug-ins.
`package`	Das während der Generierung erstellt Java-Paket.

Neue Endpoints Frameworks-Anwendung erstellen

In diesem Abschnitt wird beschrieben, wie Sie ein neues Projekt für Endpoints Frameworks Version 2.0 erstellen.

Das Beispiel hello-endpoints-archetype zeigt die Verwendung von Plug-ins, darunter das Maven-Plug-in für App Engine und das Maven-Plug-in für Endpoints Frameworks.

hello-endpoints-archetype generiert mithilfe von Endpoints Frameworks Version 2.0 die Beispiel-API "Greetings". Es dient auch als Beispiel für die Migration Ihrer mit Endpoints Frameworks Version 1.0 erstellten Anwendungen zu Endpoints Frameworks Version 2.0.

Die mit dem Archetyp generierte README.md gibt darüber Auskunft, wo die Migration stattgefunden hat.

So erstellen Sie ein Back-End-API-Archetypprojekt für Endpoints Frameworks für App Engine:

Wechseln Sie in das Verzeichnis, in dem Sie das Projekt erstellen möchten.
Führen Sie den folgenden Maven-Befehl aus:
```
mvn archetype:generate -Dgoogle-cloud-project=[YOUR-PROJECT-ID] -Dappengine-plugin=2.7.0 -Dendpoints-frameworks=2.1.0 -Dendpoints-plugin=1.0.2 -Dappengine-sdk=1.9.98 -Dfilter=com.google.appengine.archetypes:
```
Wobei:
- -Dgoogle-cloud-project ist Ihre Projekt-ID.
- -Dappengine-plugin ist die neueste Version des Maven-Plug-ins für App Engine.
- -Dendpoints-frameworks ist die neueste Version von Endpoints Frameworks für App Engine für Maven-Abhängigkeiten.
- -Dendpoints-plugin ist die neueste Version des Maven-Plug-ins für Endpoints Frameworks für App Engine.
Hinweis: Die Archetypen von Endpoints Frameworks for App Engine unterstützen Gradle und verwenden die neueste Version jeder Abhängigkeit.
Geben Sie die Nummer an, die hello-endpoints-archetype entspricht.

Hinweis: Wenn Sie ein leeres Projekt erstellen möchten, das die erforderliche Verzeichnisstruktur und die erforderlichen Dateien für Ihre eigenen Klassen enthält, geben Sie die Nummer an, die endpoints-skeleton-archetype entspricht.
Wählen Sie die neueste Version aus der angezeigten Liste der verfügbaren Archetypversionen aus.
Geben Sie bei der Aufforderung Define value for property 'groupId' den Namespace für Ihre Anwendung an, beispielsweise den Wert com.example.helloendpoints.
Geben Sie bei der Aufforderung Define value for property 'artifactId' den Namespace für Ihre Anwendung an, beispielsweise den Wert helloendpoints.
Übernehmen Sie den Standardwert (Define value for property 'version'), wenn Sie zur Bestätigung Ihrer Auswahl aufgefordert werden.
Übernehmen Sie den Standardwert (Define value for property 'package'), wenn Sie zur Bestätigung Ihrer Auswahl aufgefordert werden.
Wenn Sie zur Bestätigung Ihrer Auswahl aufgefordert werden, akzeptieren Sie den Standardwert durch Eingabe von Y.
Warten Sie, bis das Projekt fertig generiert ist. Wechseln Sie dann in das neue Projektverzeichnis, z. B. helloendpoints/.
Erstellen Sie das Projekt:
```
mvn clean package
```

Warten Sie, bis das Projekt erstellt ist. Wenn das Projekt erfolgreich abgeschlossen wurde, wird eine Meldung wie diese angezeigt:

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4.062 s
[INFO] Finished at: 2017-02-28T00:28:03-08:00
[INFO] Final Memory: 27M/485M
[INFO] ------------------------------------------------------------------------

Um das Projekt lokal zu testen und in der App Engine-Standardumgebung bereitzustellen, lesen Sie die Informationen unter Maven-Projekt verwalten, testen und bereitstellen.
Außerdem können Sie mithilfe des Maven-Plug-ins für Endpoints Frameworks Java-Clientbibliotheken für die Greetings API generieren:
```
mvn endpoints-framework:clientLibs
```

Das folgende Diagramm zeigt das grundlegende Projektlayout der Greetings API:

Maven-Projektlayout

README.md enthält Informationen zum generierten Beispiel.
Greetings.java enthält eine API-Definition für die Beispiel-API "Greetings".
Constants.java enthält Konstanten, die in der Beispiel-API "Greetings" verwendet werden.
HelloGreeting.java enthält einen Container für Nachrichten, die von der Beispiel-API "Greetings" empfangen und gesendet wurden.
index.html enthält eine einfache Benutzeroberfläche zum Aufrufen der Back-End-API "Begrüßungs-API".
base.js enthält das erforderliche JavaScript für die Benutzeroberfläche zum Senden von Back-End-Anfragen.
Wenn build.gradle einmal generiert wurde, unterstützt das Beispiel auch Gradle und liefert weitere Informationen zu dieser Funktion in der Datei README.md.

Anwendung kompilieren und erstellen

So erstellen Sie eine Anwendung, die mit App Engine-Maven-Archetypen generiert wurde:

Wechseln Sie zum Hauptverzeichnis des Projekts, beispielsweise guestbook/.
Führen Sie Maven aus:
```
mvn clean package
```
Warten Sie, bis das Projekt erstellt ist. Wenn das Projekt erfolgreich abgeschlossen wurde, wird eine Meldung wie diese angezeigt:
```
BUILD SUCCESS
 Total time: 10.724s
 Finished at: 2016-08-04T16:18:24-07:00
 Final Memory: 24M/213M
```

Anwendung mit dem Entwicklungsserver testen

Sie können Ihre Anwendung in der Entwicklungsphase jederzeit auf dem Entwicklungsserver ausführen und testen. Dazu rufen Sie das Maven-Plug-in für App Engine auf.

So testen Sie Ihre Endpoints Frameworks für App Engine-Anwendung:

Erstellen Sie Ihre Anwendung, wenn nicht bereits geschehen:
```
mvn clean package
```

Führen Sie das Beispiel lokal aus:

mvn appengine:run

Warten Sie, bis der Server gestartet wurde. Wenn er vollständig gestartet wurde und Ihre Anwendung ausgeführt wird, sehen Sie eine Nachricht wie diese:

[INFO] GCLOUD: INFO ### devappserver2.py:764] Skipping SDK update check.
[INFO] GCLOUD: INFO ### api_server.py:268] Starting API server at: http://localhost:34199
[INFO] GCLOUD: INFO ### dispatcher.py:199] Starting module "default" running at: http://localhost:8080
[INFO] GCLOUD: INFO ### admin_server.py:116] Starting admin server at: http://localhost:8000
[INFO] GCLOUD: ### com.google.appengine.tools.development.SystemPropertiesManager setSystemProperties

Rufen Sie mit Ihrem Browser http://localhost:8080/ auf, um auf Ihre Anwendung zuzugreifen.
Beenden Sie die Anwendung und den Entwicklungsserver mit Control+C.

Port für lokale Tests angeben

Wenn Sie Ihre Anwendung auf dem lokalen Entwicklungsserver ausführen, ist der Standardport 8080. Sie können diese Standardeinstellung ändern, wenn Sie den Plug-in-Eintrag für appengine-maven-plugin anpassen. Sie können beispielsweise den Port und die Adresse in der Datei pom.xml festlegen, die sich in Ihrem Anwendungsverzeichnis befindet:

<plugins>
   <plugin>
     <groupId>com.google.cloud.tools</groupId>
     <artifactId>appengine-maven-plugin</artifactId>
     <version>2.7.0</version>
     <configuration>
       <devserver.host>0.0.0.0</devserver.host>
       <devserver.port>8181</devserver.port>
     </configuration>
  </plugin>
</plugins>

In diesem Beispiel wird der Port mit <devserver.port> auf 8181 anstatt auf den Standardport festgelegt und als Adresse 0.0.0.0 angegeben. Das bedeutet, dass der Entwicklungsserver Anfragen entgegennimmt, die vom lokalen Netzwerk kommen.

Das Präfix devserver ist optional. Sie können stattdessen <port>8181</port> verwenden.

Debugging auf dem Entwicklungsserver

Wenn Sie Fehler in einer lokal ausgeführten Anwendung debuggen möchten, legen Sie das Attribut jvmFlags in der Plug-in-Konfiguration so fest, dass das Debugging in der zugrunde liegenden JVM aktiviert wird. Beispiel:

<configuration>
  <jvmFlags>
    <jvmFlag>-Xdebug</jvmFlag>
    <jvmFlag>-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005</jvmFlag>
  </jvmFlags>
</configuration>

Anwendung bereitstellen

So stellen Sie Ihre Anwendung bereit:

mvn appengine:deploy

Das Ziel appengine:deploy und alle anderen Ziele im Maven-Plug-in für App Engine haben zugehörige Parameter, die Sie verwenden können. Eine vollständige Liste der Ziele und Parameter finden Sie unter Ziele und Parameter des Maven-Plug-ins für App Engine.

Nächste Schritte

Code des Maven-Plug-ins für App Engine durchgehen und GitHub
Parameter für Ziele unter Zuhilfenahme von Ziele und Parameter des Maven-Plug-ins für App Engine angeben
Code des Maven-Plug-ins für Endpoints Frameworks durchgehen und GitHub
Parameter für Ziele unter Zuhilfenahme des Maven-Plug-ins für Cloud Endpoints Frameworks angeben