Micronaut Severless Function Micronaut kann serverlose Funktionen erstellen.
Der Vorteil gegenüber anderen Frameworks wie Spring besteht darin, dass Micronaut über einen Mechanismus zum Auflösen von Abhängigkeiten beim Kompilieren und einen geringen Speicherbedarf verfügt.
Es scheint, dass die erstellte Funktion für AWS Lambda, OpenFaaS usw. bereitgestellt werden kann.
Ich möchte diese Funktion einfach ausprobieren, um eine serverlose Funktion von Micronaut zu erstellen.
Die Umwelt ist hier.
$ mn -V
| Micronaut Version: 1.0.4
| JVM Version: 1.8.0_191
Erstellen Sie ein Projekt mit --profile als function-aws.
$ mn create-app --profile function-aws --build maven hello-function
$ cd hello-function
Das Profil von function, das angegeben werden kann, scheint nur function-aws zu sein ...
$ 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
Wenn Sie nur "Funktion" schreiben, werden Sie wütend, dass es kein solches Profil gibt.
$ mn create-app --profile function --build maven hello-function
| Error Profile [function] is designed only for extension and not direct usage
Das resultierende Projekt enthält auch Testcode und mehr.
$ 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
Die Skelettfunktion sieht so aus.
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";
}
}
Es scheint eine Möglichkeit zu geben, eine Funktion zu definieren. Eine besteht darin, sie als "FunctionBean" zu erstellen, und die andere darin, sie mit "Factory" zu erstellen.
Dieses Mal wird es von der Methode mit Function Bean implementiert.
In diesem Fall müssen Sie anscheinend eine Funktionsschnittstelle implementieren, aber die verfügbaren Schnittstellen sind wie "Lieferant", "Verbraucher", "BiConsumer", "Funktion", "BiFunktion".
Eine Klasse mit einer Hauptmethode sieht so aus.
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);
}
}
Die auszuführende Funktion ist in der Konfigurationsdatei angegeben. Dies ist der Name der Function Bean.
src/main/resources/application.yml
micronaut:
function:
name: hello-function
In der Dokumentation scheint es, dass Sie mehrere Funktionen explizit festlegen müssen, wenn Sie sie einschließen.
Lassen Sie es uns packen und ausführen.
Das Ergebnis wird zurückgegeben.
$ 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
Lassen Sie uns die Konfiguration ein wenig ändern und Argumente und DI andere Beans nehmen.
Erstellen Sie eine Bean, die nur die Argumentnachricht verarbeitet.
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);
}
}
Lassen Sie uns die ursprüngliche Funktion DI dieser Bean machen und zur Laufzeit Argumente empfangen. Die Funktionsschnittstelle implementiert 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;
}
}
}
Der Code hat sich geändert, daher habe ich diesmal den Test übersprungen und verpackt.
$ ./mvnw package -DskipTests=true
Lauf.
$ echo '{"message": "Hallo Welt"}' | 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]★ Hallo Welt ★"}
Ich konnte DI ausführen und eine weitere Bean ausführen, während ich das Argument erhielt.
Es scheint, dass die Funktion auch als Webanwendung ausgeführt werden kann, diesmal jedoch.
Die Bereitstellung in der Ausführungsumgebung erfolgt in Kürze ...
Recommended Posts