Leitfaden zu QuarkusIO

1. Einleitung

Heutzutage ist es sehr üblich, eine Anwendung zu schreiben und in der Cloud bereitzustellen, ohne sich um die Infrastruktur zu kümmern. Serverless und FaaS sind sehr beliebt geworden.

In dieser Art von Umgebung, in der Instanzen häufig erstellt und zerstört werden, sind die Zeit zum Booten und die Zeit zum ersten Anfordern äußerst wichtig, da sie eine völlig andere Benutzererfahrung schaffen können.

Sprachen wie JavaScript und Python stehen in solchen Szenarien immer im Mittelpunkt. Mit anderen Worten, Java mit seinen fetten JARs und seiner langen Startzeit war nie ein Top-Anwärter.

In diesem Tutorial werden wir Quarkus vorstellen und diskutieren, ob es eine Alternative ist, um Java effektiver in die Cloud zu bringen .

2. QuarkusIO

QuarkusIO, das Supersonic Subatomic Java, verspricht kleine Artefakte, eine extrem schnelle Startzeit und eine kürzere Zeit bis zur ersten Anforderung. In Kombination mit GraalVM kompiliert Quarkus vorab (AOT).

Und da Quarkus auf Standards basiert, müssen wir nichts Neues lernen. Folglich können wir unter anderem CDI und JAX-RS verwenden. Außerdem verfügt Quarkus über zahlreiche Erweiterungen, einschließlich solcher, die Hibernate, Kafka, OpenShift, Kubernetes und Vert.x unterstützen.

3. Unsere erste Bewerbung

Der einfachste Weg, ein neues Quarkus-Projekt zu erstellen, besteht darin, ein Terminal zu öffnen und Folgendes einzugeben:

mvn io.quarkus:quarkus-maven-plugin:0.13.1:create \ -DprojectGroupId=com.baeldung.quarkus \ -DprojectArtifactId=quarkus-project \ -DclassName="com.baeldung.quarkus.HelloResource" \ -Dpath="/hello"

Dadurch werden das Projektskelett, eine HelloResource mit einem / hello- Endpunkt, der Konfiguration, dem Maven-Projekt und Docker-Dateien generiert.

Nach dem Import in unsere IDE haben wir eine ähnliche Struktur wie im Bild unten:

Lassen Sie uns den Inhalt der HelloResource- Klasse untersuchen:

@Path("/hello") public class HelloResource { @GET @Produces(MediaType.TEXT_PLAIN) public String hello() { return "hello"; } }

Bisher sieht alles gut aus. Zu diesem Zeitpunkt haben wir eine einfache Anwendung mit einem einzelnen RESTEasy JAX-RS-Endpunkt. Lassen Sie uns fortfahren und es testen, indem Sie ein Terminal öffnen und den Befehl ausführen:

./mvnw compile quarkus:dev:

Unser REST-Endpunkt sollte auf localhost verfügbar gemacht werden: 8080 / hallo. Testen wir es mit dem Befehl curl :

$ curl localhost:8080/hello hello

4. Hot Reload

Im Entwicklungsmodus ( ./mvn compile quarkus: dev ) bietet Quarkus eine Hot-Reload-Funktion. Mit anderen Worten, Änderungen an Java-Dateien oder Konfigurationsdateien werden automatisch kompiliert, sobald der Browser aktualisiert wird . Das beeindruckendste Merkmal hier ist, dass wir unsere Dateien nicht speichern müssen. Dies kann je nach Präferenz gut oder schlecht sein.

Wir werden jetzt unser Beispiel ändern, um die Hot-Reload-Funktion zu demonstrieren. Wenn die Anwendung gestoppt ist, können wir sie einfach im Dev-Modus neu starten. Wir werden das gleiche Beispiel wie zuvor als Ausgangspunkt verwenden.

Zuerst erstellen wir eine HelloService- Klasse:

@ApplicationScoped public class HelloService { public String politeHello(String name){ return "Hello Mr/Mrs " + name; } }

Jetzt ändern wir die HelloResource- Klasse, fügen den HelloService ein und fügen eine neue Methode hinzu:

@Inject HelloService helloService; @GET @Produces(MediaType.APPLICATION_JSON) @Path("/polite/{name}") public String greeting(@PathParam("name") String name) { return helloService.politeHello(name); }

Als nächstes testen wir unseren neuen Endpunkt:

$ curl localhost:8080/hello/polite/Baeldung Hello Mr/Mrs Baeldung

Wir werden noch eine Änderung vornehmen, um zu demonstrieren, dass dasselbe auf Eigenschaftendateien angewendet werden kann. Bearbeiten wir die Datei application.properties und fügen einen weiteren Schlüssel hinzu:

greeting=Good morning

Danach ändern wir den HelloService , um unsere neue Eigenschaft zu verwenden:

@ConfigProperty(name = "greeting") private String greeting; public String politeHello(String name){ return greeting + " " + name; }

Wenn wir denselben Curl- Befehl ausführen , sollten wir jetzt sehen:

Good morning Baeldung

Wir können die Anwendung einfach verpacken, indem wir Folgendes ausführen:

./mvnw package 

Dadurch werden 2 JAR-Dateien im Zielverzeichnis generiert :

  • quarkus-project-1.0-SNAPSHOT-running.jar - eine ausführbare JAR-Datei, deren Abhängigkeiten nach target / lib kopiert wurden
  • quarkus-project-1.0-SNAPSHOT.jar - enthält Klassen und Ressourcendateien

Wir können jetzt die gepackte Anwendung ausführen:

java -jar target/quarkus-project-1.0-SNAPSHOT-runner.jar

5. Native Image

Als Nächstes erstellen wir ein natives Image unserer Anwendung. Ein natives Image verbessert die Startzeit und die Zeit bis zur ersten Antwort. Mit anderen Worten, es enthält alles , was zum Ausführen erforderlich ist, einschließlich der minimalen JVM, die zum Ausführen der Anwendung erforderlich ist .

Zunächst muss GraalVM installiert und die Umgebungsvariable GRAALVM_HOME konfiguriert sein.

Wir stoppen jetzt die Anwendung (Strg + C), falls nicht bereits gestoppt, und führen den folgenden Befehl aus:

./mvnw package -Pnative

Dies kann einige Sekunden dauern. Da native Images versuchen, den gesamten Code AOT zu erstellen, um schneller zu starten, haben wir längere Erstellungszeiten.

We can run ./mvnw verify -Pnative to verify that our native artifact was properly constructed:

Secondly, we'll create a container image using our native executable. For that, we must have a container runtime (i.e. Docker) running in our machine. Let's open up a terminal window and execute:

./mvnw package -Pnative -Dnative-image.docker-build=true 

This will create a Linux 64-bit executable, therefore if we're using a different OS, it might not be runnable anymore. That's okay for now.

The project generation created a Dockerfile.native for us:

FROM registry.fedoraproject.org/fedora-minimal WORKDIR /work/ COPY target/*-runner /work/application RUN chmod 775 /work EXPOSE 8080 CMD ["./application", "-Dquarkus.http.host=0.0.0.0"] 

If we examine the file, we have a hint at what comes next. First, we'll create a docker image:

docker build -f src/main/docker/Dockerfile.native -t quarkus/quarkus-project .

Now, we can run the container using:

docker run -i --rm -p 8080:8080 quarkus/quarkus-project

The container started in an incredibly low time of 0.009s. That's one of the strengths of Quarkus.

Finally, we should test our modified REST to validate our application:

$ curl localhost:8080/hello/polite/Baeldung Good morning Baeldung

6. Deploying to OpenShift

Once we're done testing locally using Docker, we'll deploy our container to OpenShift. Assuming we have the Docker image on our registry, we can deploy the application following the steps below:

oc new-build --binary --name=quarkus-project -l app=quarkus-project oc patch bc/quarkus-project -p '{"spec":{"strategy":{"dockerStrategy":{"dockerfilePath":"src/main/docker/Dockerfile.native"}}}}' oc start-build quarkus-project --from-dir=. --follow oc new-app --image-stream=quarkus-project:latest oc expose service quarkus-project

Now, we can get the application URL by running:

oc get route

Lastly, we'll access the same endpoint (note that the URL might be different, depending on our IP address):

$ curl //quarkus-project-myproject.192.168.64.2.nip.io/hello/polite/Baeldung Good morning Baeldung

7. Conclusion

In diesem Artikel haben wir gezeigt, dass Quarkus eine großartige Ergänzung ist, mit der Java effektiver in die Cloud gebracht werden kann. Zum Beispiel ist es jetzt möglich, sich Java auf AWS Lambda vorzustellen. Außerdem basiert Quarkus auf Standards wie JPA und JAX / RS. Deshalb müssen wir nichts Neues lernen.

Quarkus hat in letzter Zeit viel Aufmerksamkeit auf sich gezogen und jeden Tag werden viele neue Funktionen hinzugefügt. Es gibt mehrere Schnellstartprojekte, mit denen wir Quarkus im Quarkus GitHub-Repository testen können.

Wie immer ist der Code für diesen Artikel auf GitHub verfügbar. Viel Spaß beim Codieren!