Utiliser Java 11 avec Google Cloud Functions

introduction

En mai 2020, Google Cloud Functions a pris en charge Java 11 en version bêta. Ici Cet article explique comment déployer réellement une application Java 11 déclenchée par une requête HTTP.

Cloud Shell est utilisé pour l'opération.

Se préparer pour Maven

Tout d'abord, préparez le fichier pom requis pour Maven. Dépendances sur functions-framework-api requises pour s'exécuter avec Cloud Functions Décrivez le plug-in requis pour s'exécuter localement.

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>
    <!--Mettre Functions Framework for Java en tant que dépendance-->
    <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>
        <!--Incluez le plug-in Function Maven pour permettre une exécution locale-->
        <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>

programme

Ensuite, préparez le programme. Lors de l'utilisation d'une requête HTTP comme déclencheur, la fonction functions-framework-api com.google.cloud.functions.HttpFunction Vous devez implémenter l'interface. La seule méthode à implémenter est la méthode service, et décrivez le contenu que vous souhaitez traiter dans cette méthode.

Dans cet article, c'est une application qui retourne le résultat en frappant mon ID utilisateur avec l'API Qiita. J'ai utilisé autant que possible l'inférence de type pour les variables locales pour le faire ressembler à Java11, et j'ai ignoré les requêtes en utilisant java.net.http.HttpRequest.

Les paramètres de requête lors de l'appel de Cloud Functions sont stockés dans com.google.cloud.functions.HttpRequest, qui est l'argument de la méthode service. De même, en écrivant la valeur dans le paramètre com.google.cloud.functions.HttpResponse, vous pouvez renvoyer la réponse à l'appelant.

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 {
    
    //Prêt à appeler l'API Qiita
    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();

    //Passer un coup de téléphone
    var responseFromQiita
        = httpClient.send(requestFromGCF,java.net.http.HttpResponse.BodyHandlers.ofString());
    
    //Content-Paramètre de type, pour afficher le japonais
    response.setContentType("application/json; charset=utf-8");

    //La valeur obtenue à partir de l'API Qiita est envoyée à la personne qui a appelé la fonction Cloud.
    var writer = response.getWriter();
    writer.write(responseFromQiita.body());
  }
}

L'emplacement du programme créé et du pom est le suivant.

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

tester

Tout d'abord, compilez.

$ mvn compile

Cela prendra du temps, mais si vous dites «CONSTRUIRE LE SUCCÈS», vous réussissez. Une fois compilé, exécutez-le dans votre environnement local.

$ mvn function:run

Lorsque vous l'exécutez, le journal de démarrage sera affiché dans le terminal, alors ouvrez un autre terminal et exécutez curl.

$ curl localhost:8080
{"description":~~~ Abréviation ~~~~~"website_url":""}

Vous pouvez voir que le résultat de l'API Qiita est affiché.

Déployer

Enfin, déployez-le sur Cloud Functions. Déployez avec la commande suivante. Le déclencheur est une requête HTTP et il peut être exécuté sans authentification.

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

Après quelques minutes, le déploiement sera terminé, alors cliquez sur l'URL affichée au moment du déploiement.

$ curl https://us-central1-YOUR_PROJECT_ID.cloudfunctions.net/java-function 
{"description":~~~ Abréviation ~~~~~"website_url":""}

J'ai pu confirmer que l'application créée avec Java 11 pouvait être déployée sur Cloud Functions.