Verwenden Sie Java 11 mit Google Cloud-Funktionen

Einführung

Im Mai 2020 unterstützten Google Cloud Functions Java 11 in der Beta. Hier In diesem Artikel wird erläutert, wie eine Java 11-Anwendung bereitgestellt wird, die durch eine HTTP-Anforderung ausgelöst wird.

Cloud Shell wird für den Vorgang verwendet.

Vorbereitung für Maven

Bereiten Sie zunächst die für Maven erforderliche POM-Datei vor. Abhängigkeiten von Funktionen-Framework-API erforderlich, um mit Cloud-Funktionen ausgeführt zu werden Beschreiben des Plug-Ins, das für die lokale Ausführung erforderlich ist.

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>example</groupId>
  <artifactId>functions-hello-world</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <properties>
    <maven.compiler.target>11</maven.compiler.target>
    <maven.compiler.source>11</maven.compiler.source>
  </properties>

  <dependencies>
    <!--Setzen Sie das Functions Framework für Java als Abhängigkeit-->
    <dependency>
      <groupId>com.google.cloud.functions</groupId>
      <artifactId>functions-framework-api</artifactId>
      <version>1.0.1</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <!--Fügen Sie das Plug-In Function Maven hinzu, um die lokale Ausführung zu ermöglichen-->
        <groupId>com.google.cloud.functions</groupId>
        <artifactId>function-maven-plugin</artifactId>
        <version>0.9.3</version>
        <configuration>
          <functionTarget>CloudFunctionsForJava</functionTarget>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Programm

Bereiten Sie als nächstes das Programm vor. Wenn Sie eine HTTP-Anforderung als Auslöser verwenden, wird die Funktionen-Framework-API "com.google.cloud.functions.HttpFunction" verwendet Sie müssen die Schnittstelle implementieren. Die einzige zu implementierende Methode ist die "service" -Methode und beschreibt den Inhalt, den Sie in dieser Methode verarbeiten möchten.

In diesem Artikel handelt es sich um eine Anwendung, die das Ergebnis zurückgibt, wenn meine Benutzer-ID mit der Qiita-API erreicht wird. Ich habe die Typinferenz für lokale Variablen so oft wie möglich verwendet, damit sie wie Java11 aussieht, und Anforderungen mit "java.net.http.HttpRequest" übersprungen.

Die Anforderungsparameter beim Aufrufen von Cloud-Funktionen werden in "com.google.cloud.functions.HttpRequest" gespeichert, was das Argument der "service" -Methode ist. In ähnlicher Weise können Sie die Antwort an den Aufrufer zurückgeben, indem Sie den Wert in den Parameter "com.google.cloud.functions.HttpResponse" schreiben.

CloudFunctionsForJava.java

import com.google.cloud.functions.HttpFunction;
import com.google.cloud.functions.HttpRequest;
import com.google.cloud.functions.HttpResponse;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;

public class CloudFunctionsForJava implements HttpFunction {

  @Override
  public void service(HttpRequest request, HttpResponse response)
      throws IOException, InterruptedException {
    
    //Bereit zum Aufrufen der Qiita-API
    var httpClient = HttpClient.newHttpClient();
    var requestFromGCF = java.net.http.HttpRequest
            .newBuilder(URI.create("https://qiita.com/api/v2/users/shuichiro"))
            .header("Content-Type", "application/json; charset=utf-8")
            .build();

    //Einen Anruf tätigen
    var responseFromQiita
        = httpClient.send(requestFromGCF,java.net.http.HttpResponse.BodyHandlers.ofString());
    
    //Content-Geben Sie die Einstellung ein, um Japanisch anzuzeigen
    response.setContentType("application/json; charset=utf-8");

    //Der von der Qiita-API erhaltene Wert wird an die Person gesendet, die die Cloud-Funktion aufgerufen hat.
    var writer = response.getWriter();
    writer.write(responseFromQiita.body());
  }
}

Der Speicherort des erstellten Programms und des POM ist wie folgt.

$ tree
.
├── pom.xml
└── src
    └── main
        └── java
            └── CloudFunctionsForJava.java

Prüfung

Zuerst kompilieren.

$ mvn compile

Es wird einige Zeit dauern, aber wenn Sie "BUILD SUCCESS" sagen, sind Sie erfolgreich. Führen Sie es nach dem Kompilieren in Ihrer lokalen Umgebung aus.

$ mvn function:run

Wenn Sie es ausführen, wird das Startprotokoll im Terminal angezeigt. Öffnen Sie also ein anderes Terminal und führen Sie Curl aus.

$ curl localhost:8080
{"description":~~~ Abkürzung ~~~~~"website_url":""}

Sie können sehen, dass das Ergebnis der Qiita-API angezeigt wird.

Bereitstellen

Schließlich tatsächlich für Cloud-Funktionen bereitstellen. Stellen Sie mit dem folgenden Befehl bereit. Der Trigger ist eine HTTP-Anforderung und kann ohne Authentifizierung ausgeführt werden.

$ gcloud functions deploy java-function --entry-point CloudFunctionsForJava --runtime java11 --trigger-http --memory 512MB --allow-unauthenticated

Nach einigen Minuten ist die Bereitstellung abgeschlossen. Klicken Sie daher auf die zum Zeitpunkt der Bereitstellung angezeigte URL.

$ curl https://us-central1-YOUR_PROJECT_ID.cloudfunctions.net/java-function 
{"description":~~~ Abkürzung ~~~~~"website_url":""}

Ich konnte bestätigen, dass die mit Java 11 erstellte Anwendung für Cloud-Funktionen bereitgestellt werden kann.