[JAVA] Fonction sans serveur avec Micronaut

Micronaut Severless Function Micronaut a la capacité de créer des fonctions sans serveur.

Serverless Functions

L'avantage par rapport à d'autres frameworks tels que Spring semble être que Micronaut dispose d'un mécanisme pour résoudre les dépendances au moment de la compilation et d'une faible empreinte mémoire.

Il semble que la fonction créée puisse être déployée sur AWS Lambda, OpenFaaS, etc.

Deploying Functions

Je voudrais essayer facilement cette fonction pour créer une fonction sans serveur de Micronaut.

environnement

L'environnement est ici.

$ mn -V
| Micronaut Version: 1.0.4
| JVM Version: 1.8.0_191

Création de projet

Créez un projet avec --profile comme function-aws.

$ mn create-app --profile function-aws --build maven hello-function
$ cd hello-function

Le profil de fonction qui peut être spécifié semble être uniquement function-aws ...

$ mn list-profiles
| Available Profiles
--------------------
  cli           The cli profile
  federation    The federation profile
  function-aws  The function profile for AWS Lambda
  kafka         The Kafka messaging profile
  profile       A profile for creating new Micronaut profiles
  service       The service profile

Si vous écrivez simplement fonction, vous vous fâcherez qu'il n'y ait pas de tel profil.

$ mn create-app --profile function --build maven hello-function
| Error Profile [function] is designed only for extension and not direct usage

Le projet résultant comprend également du code de test et plus encore.

$ find -type f
./mvnw.cmd
./.mvn/jvm.config
./.mvn/wrapper/maven-wrapper.properties
./.mvn/wrapper/MavenWrapperDownloader.java
./.mvn/wrapper/maven-wrapper.jar
./.gitignore
./mvnw
./pom.xml
./micronaut-cli.yml
./src/main/java/hello/function/HelloFunctionFunction.java
./src/main/java/hello/function/Application.java
./src/main/resources/application.yml
./src/main/resources/logback.xml
./src/test/java/hello/function/HelloFunctionFunctionTest.java
./src/test/java/hello/function/HelloFunctionClient.java

La fonction squelette ressemble à ceci.

src/main/java/hello/function/HelloFunctionFunction.java

package hello.function;

import io.micronaut.function.FunctionBean;
import java.util.function.Supplier;

@FunctionBean("hello-function")
public class HelloFunctionFunction implements Supplier<String> {

    @Override
    public String get() {
        return "hello-function";
    }
}

Il semble y avoir un moyen de définir une fonction, l'un consiste à la créer en tant que FunctionBean et l'autre à la créer en utilisant Factory.

FunctionBean

Cette fois, il est implémenté par la méthode utilisant Function Bean.

Dans ce cas, il semble que vous ayez besoin d'implémenter une interface de fonction, mais les interfaces disponibles sont comme Supplier, Consumer, BiConsumer, Function, BiFunction.

Une classe avec une méthode main ressemble à ceci.

src/main/java/hello/function/Application.java

package hello.function;

import io.micronaut.runtime.Micronaut;

public class Application {

    public static void main(String[] args) {
        Micronaut.run(Application.class);
    }
}

La fonction à exécuter est spécifiée dans le fichier de configuration. C'est le nom du «Function Bean».

src/main/resources/application.yml

micronaut:
    function:
        name: hello-function

En regardant la documentation, il semble que si vous incluez plusieurs fonctions, vous devez les définir explicitement.

Essayez d'exécuter en tant que CLI

Emballons et exécutons-le.

Functions as CLI Applications

Le résultat est renvoyé.

$ java -jar target/hello-function-0.1.jar 
12:56:07.817 [main] INFO  i.m.context.env.DefaultEnvironment - Established active environments: [function]
hello-function

Essayez d'accepter des arguments ou de DIing d'autres beans

Modifions un peu la configuration et prenons des arguments et DI d'autres beans.

Créez un bean qui ne traite que le message d'argument.

src/main/java/hello/function/MessageService.java

package hello.function;

import java.time.LocalDateTime;
import javax.inject.Singleton;

@Singleton
public class MessageService {
    public String wrap(String message) {
        return String.format("[%s] ★%s★", LocalDateTime.now(), message);
    }
}

Faisons de la fonction originale DI ce bean et recevons des arguments à l'exécution. L'interface de fonction implémente «Function».

src/main/java/hello/function/HelloFunctionFunction.java

package hello.function;

import io.micronaut.function.FunctionBean;

import java.util.function.Function;
import java.util.function.Supplier;
import javax.inject.Inject;

@FunctionBean("hello-function")
public class HelloFunctionFunction implements Function<HelloFunctionFunction.Request, HelloFunctionFunction.Response> {
    @Inject
    MessageService messageService;

    @Override
    public Response apply(Request request) {
        String replyMessage = messageService.wrap(request.getMessage());

        return new Response(replyMessage);
    }

    public static class Request {
        String message;

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }
    }

    public static class Response {
        String message;

        public Response(String message) {
            this.message = message;
        }

        public String getMessage() {
            return message;
        }
    }
}

Le code a changé, donc cette fois j'ai sauté le test et l'ai emballé.

$ ./mvnw package -DskipTests=true

Courir.

$ echo '{"message": "Bonjour le monde"}' | java -jar target/hello-function-0.1.jar 
13:00:23.558 [main] INFO  i.m.context.env.DefaultEnvironment - Established active environments: [function]
{"message":"[2019-03-05T13:00:24.185]★ Bonjour le monde ★"}

J'ai pu DI et exécuter un autre bean tout en recevant l'argument.

Il semble que cette fonction puisse également être exécutée en tant qu'application Web, mais cette fois, elle passe.

Le déploiement dans l'environnement d'exécution se fera bientôt ...