streamalism.org

1. Inleiding

Tegenwoordig is het heel gebruikelijk om een ​​applicatie te schrijven en deze in de cloud te implementeren en je geen zorgen te maken over de infrastructuur. Serverless en FaaS zijn erg populair geworden.

In dit soort omgevingen, waar instanties vaak worden gemaakt en vernietigd, zijn de tijd om op te starten en de tijd tot het eerste verzoek uiterst belangrijk, omdat ze een compleet andere gebruikerservaring kunnen creëren.

Talen als JavaScript en Python staan ​​altijd in de schijnwerpers in dit soort scenario's. Met andere woorden, Java met zijn dikke JAR's en lange opstarttijd was nooit een grote kanshebber.

In deze tutorial we zullen Quarkus presenteren en bespreken of het een alternatief is om Java effectiever naar de cloud te brengen.

2. QuarkusIO

QuarkusIO, het supersonische subatomaire Java, belooft kleine artefacten, een extreem snelle opstarttijd en een kortere tijd tot het eerste verzoek te leveren. In combinatie met GraalVM zal Quarkus van tevoren compileren (AOT).

En aangezien Quarkus op de beste normen is gebouwd, hoeven we niets nieuws te leren. Hierdoor kunnen we onder andere CDI en JAX-RS gebruiken. Quarkus heeft ook veel extensies, waaronder extensies die Hibernate, Kafka, OpenShift, Kubernetes en Vert.x ondersteunen.

3. Onze eerste toepassing

De eenvoudigste manier om een ​​nieuw Quarkus-project te maken, is door een terminal te openen en te typen:

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

Dit zal het projectskelet genereren, een HalloResource met een /Hallo eindpunt blootgesteld, configuratie, Maven-project en Dockerfiles.

Eenmaal geïmporteerd in onze IDE, hebben we een structuur die lijkt op die in de onderstaande afbeelding:

Laten we de inhoud van het HalloResource klasse:

@Path ("/ hallo") openbare klasse HelloResource {@GET @Produces (MediaType.TEXT_PLAIN) openbare tekenreeks hallo () {retourneer "hallo"; }}

Alles ziet er tot nu toe goed uit. Op dit moment hebben we een eenvoudige applicatie met een enkel RESTEasy JAX-RS-eindpunt. Laten we doorgaan en het testen door een terminal te openen en de opdracht uit te voeren:

./mvnw compileer quarkus: dev:

Ons REST-eindpunt moet worden weergegeven op localhost: 8080 / hallo. Laten we het testen met de krullen opdracht:

$ curl localhost: 8080 / hallo hallo

4. Heet herladen

Bij gebruik in ontwikkelingsmodus (./mvn compileer quarkus: dev), Biedt Quarkus een hot-reload-mogelijkheid. Met andere woorden, Wijzigingen in Java-bestanden of configuratiebestanden worden automatisch gecompileerd zodra de browser wordt vernieuwd. De meest indrukwekkende functie hier is dat we onze bestanden niet hoeven op te slaan. Dit kan goed of slecht zijn, afhankelijk van onze voorkeur.

We zullen nu ons voorbeeld aanpassen om de hot-reload-mogelijkheid te demonstreren. Als de applicatie is gestopt, kunnen we deze eenvoudig opnieuw opstarten in dev-modus. We zullen hetzelfde voorbeeld als hiervoor gebruiken als ons uitgangspunt.

Eerst maken we een HalloService klasse:

@ApplicationScoped openbare klasse HelloService {openbare tekenreeks politeHello (tekenreeksnaam) {retourneer "Hallo heer / mevrouw" + naam; }}

Nu gaan we het HalloResource klasse, het injecteren van de HalloService en het toevoegen van een nieuwe methode:

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

Laten we vervolgens ons nieuwe eindpunt testen:

$ curl localhost: 8080 / hallo / beleefd / Baeldung Hallo meneer / mevrouw Baeldung

We zullen nog een wijziging aanbrengen om aan te tonen dat hetzelfde kan worden toegepast op eigenschappenbestanden. Laten we het application.properties bestand en voeg nog een sleutel toe:

groet = Goedemorgen

Daarna zullen we het HalloService om ons nieuwe pand te gebruiken:

@ConfigProperty (name = "groet") privé String-begroeting; openbare tekenreeks politeHello (tekenreeksnaam) {retourgroet + "" + naam; }

Als we hetzelfde uitvoeren krullen commando, we zouden nu moeten zien:

Goedemorgen Baeldung

We kunnen de applicatie eenvoudig verpakken door:

./mvnw pakket 

Dit genereert 2 jar-bestanden in het doelwit directory:

• quarkus-project-1.0-SNAPSHOT-runner.jar - een uitvoerbare jar waarnaar de afhankelijkheden zijn gekopieerd target / lib
• quarkus-project-1.0-SNAPSHOT.jar - bevat klassen en bronbestanden

We kunnen nu de verpakte applicatie uitvoeren:

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

5. Native afbeelding

Vervolgens maken we een native image van onze applicatie. Een native image verbetert de opstarttijd en de tijd tot de eerste reactie. Met andere woorden, het bevat alles wat het nodig heeft om te draaien, inclusief de minimale JVM die nodig is om de applicatie uit te voeren.

Om te beginnen moeten we GraalVM hebben geïnstalleerd en de omgevingsvariabele GRAALVM_HOME geconfigureerd.

We stoppen nu de applicatie (Ctrl + C), als deze nog niet is gestopt, en voeren de opdracht uit:

./mvnw pakket -Pnative

Dit kan enkele seconden duren. Omdat native images proberen alle code AOT te maken om sneller op te starten, hebben we daardoor langere bouwtijden.

We kunnen rennen ./mvnw verifiëren -Pnative om te verifiëren dat ons oorspronkelijke artefact correct is geconstrueerd:

Ten tweede zullen we maak een containerimage met behulp van ons native uitvoerbare bestand. Daarvoor moeten we een containerruntime (d.w.z. Docker) op onze computer hebben uitgevoerd. Laten we een terminalvenster openen en uitvoeren:

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

Dit zal een Linux 64-bits uitvoerbaar bestand maken, dus als we een ander besturingssysteem gebruiken, is het mogelijk niet meer uitvoerbaar. Dat is oké voor nu.

De projectgeneratie creëerde een Dockerfile.native voor ons:

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

Als we het bestand onderzoeken, hebben we een hint over wat er daarna komt. Ten eerste zullen we maak een docker-afbeelding:

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

Nu kunnen we de container uitvoeren met behulp van:

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

De container startte in een ongelooflijk lage tijd van 0,009 seconden. Dat is een van de sterke punten van Quarkus.

Ten slotte moeten we onze gewijzigde REST testen om onze applicatie te valideren:

$ curl localhost: 8080 / hallo / beleefd / Baeldung Goedemorgen Baeldung

6. Implementeren naar OpenShift

Zodra we klaar zijn met het lokaal testen met Docker, implementeren we onze container op OpenShift. Ervan uitgaande dat we de Docker-image in ons register hebben, kunnen we de applicatie implementeren door de onderstaande stappen te volgen:

oc nieuwbouw --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: laatste oc onthult service quarkus-project

Nu kunnen we de applicatie-URL krijgen door het volgende uit te voeren:

oc route ophalen

Ten slotte hebben we toegang tot hetzelfde eindpunt (merk op dat de URL kan verschillen, afhankelijk van ons IP-adres):

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

7. Conclusie

In dit artikel hebben we aangetoond dat Quarkus een geweldige toevoeging is die Java effectiever naar de cloud kan brengen. Het is nu bijvoorbeeld mogelijk om Java voor te stellen op AWS Lambda. Quarkus is ook gebaseerd op standaarden zoals JPA en JAX / RS. Daarom hoeven we niets nieuws te leren.

Quarkus heeft de laatste tijd veel aandacht getrokken en er worden elke dag veel nieuwe functies toegevoegd. Er zijn verschillende quickstart-projecten waarmee we Quarkus kunnen uitproberen in de Quarkus GitHub-repository.

Zoals altijd is de code voor dit artikel beschikbaar op GitHub. Veel plezier met coderen!