Vejledning til QuarkusIO

1. Introduktion

I dag er det meget almindeligt at skrive en applikation og implementere i skyen og ikke bekymre sig om infrastrukturen. Serverless og FaaS er blevet meget populære.

I denne type miljø, hvor forekomster oprettes og ødelægges ofte, er tiden til at starte og tid til første anmodning ekstremt vigtig, da de kan skabe en helt anden brugeroplevelse.

Sprog som JavaScript og Python er altid i fokus i denne type scenarie. Med andre ord var Java med sine fede JAR'er og lang opstartstid aldrig en topudfordrer.

I denne vejledning Vi præsenterer Quarkus og diskuterer, om det er et alternativ til at bringe Java mere effektivt til skyen.

2. QuarkusIO

QuarkusIO, det supersoniske subatomære Java, lover at levere små artefakter, ekstremt hurtig opstartstid og lavere tid til første anmodning. Når det kombineres med GraalVM, vil Quarkus kompilere før-tid (AOT).

Og da Quarkus er bygget oven på standarder, behøver vi ikke lære noget nyt. Derfor kan vi blandt andet bruge CDI og JAX-RS. Quarkus har også mange udvidelser, herunder dem, der understøtter Hibernate, Kafka, OpenShift, Kubernetes og Vert.x.

3. Vores første ansøgning

Den nemmeste måde at oprette et nyt Quarkus-projekt på er at åbne en terminal og skrive:

mvn io.quarkus: quarkus-maven-plugin: 0.13.1: Opret \ -DprojectGroupId = com.baeldung.quarkus \ -DprojectArtifactId = quarkus-projekt \ -DclassName = "com.baeldung.quarkus.HelloResource" \ -Dpath = " /Hej"

Dette vil generere projektets skelet, a HejRessource med en /Hej endpoint eksponeret, konfiguration, Maven-projekt og Dockerfiles.

Når vi først er importeret til vores IDE, har vi en struktur, der ligner den, der vises på billedet nedenfor:

Lad os undersøge indholdet af HejRessource klasse:

@Path ("/ hej") offentlig klasse HelloResource {@GET @Produces (MediaType.TEXT_PLAIN) offentlig String hej () {returner "hej"; }}

Alt ser godt ud indtil videre. På dette tidspunkt har vi en simpel applikation med et enkelt RESTEasy JAX-RS-slutpunkt. Lad os gå videre og teste det ved at åbne en terminal og køre kommandoen:

./mvnw kompilere quarkus: dev:

Vores REST-slutpunkt skal eksponeres på localhost: 8080 / hej. Lad os teste det med krølle kommando:

$ curl localhost: 8080 / hej hej

4. Varm genindlæsning

Når du kører i udviklingstilstand (./mvn kompilere kvarkus: dev), Quarkus giver mulighed for hot-reload. Med andre ord, ændringer foretaget i Java-filer eller konfigurationsfiler vil automatisk blive kompileret, når browseren opdateres. Den mest imponerende funktion her er, at vi ikke behøver at gemme vores filer. Dette kan være godt eller dårligt afhængigt af vores præference.

Vi vil nu ændre vores eksempel for at demonstrere hot-reload-kapaciteten. Hvis applikationen stoppes, kan vi bare genstarte den i dev-tilstand. Vi bruger det samme eksempel som før som vores udgangspunkt.

Først opretter vi en Hej service klasse:

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

Nu ændrer vi HejRessource klasse, indsprøjtning af Hej service og tilføje en ny metode:

@Injicer HelloService helloService; @GET @Produces (MediaType.APPLICATION_JSON) @Path ("/ høflig / {navn}") offentlig strenghilsen (@PathParam ("navn") Navn på streng) {return helloService.politeHello (navn); }

Lad os derefter teste vores nye slutpunkt:

$ curl localhost: 8080 / hej / høflig / Baeldung Hej hr. / fru Baeldung

Vi foretager en ændring mere for at demonstrere, at det samme kan anvendes på ejendomsfiler. Lad os redigere application.properties fil og tilføj endnu en nøgle:

hilsen = God morgen

Derefter ændrer vi Hej service at bruge vores nye ejendom:

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

Hvis vi udfører det samme krølle kommando, skal vi nu se:

Godmorgen Baeldung

Vi kan nemt pakke applikationen ved at køre:

./mvnw-pakke 

Dette genererer 2 jar-filer inde i mål vejviser:

  • quarkus-project-1.0-SNAPSHOT-runner.jar - en eksekverbar krukke med afhængigheder kopieret til mål / lib
  • quarkus-project-1.0-SNAPSHOT.jar - indeholder klasser og ressourcefiler

Vi kan nu køre den pakkede applikation:

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

5. Oprindeligt billede

Dernæst producerer vi et oprindeligt billede af vores applikation. Et oprindeligt billede forbedrer opstartstid og tid til første svar. Med andre ord, det indeholder alt, hvad den har brug for for at køre, inklusive den minimale JVM, der er nødvendig for at køre applikationen.

Til at begynde med skal vi have GraalVM installeret og miljøvariablen GRAALVM_HOME konfigureret.

Vi stopper nu applikationen (Ctrl + C), hvis den ikke allerede er stoppet, og kører kommandoen:

./mvnw-pakke -Pnative

Dette kan tage et par sekunder at gennemføre. Fordi oprindelige billeder forsøger at oprette al kode AOT for at starte hurtigere, som et resultat har vi længere byggetider.

Vi kan løbe ./mvnw verificere -Pnative for at kontrollere, at vores oprindelige artefakt var korrekt konstrueret:

For det andet vil vi Opret et containerbillede ved hjælp af vores oprindelige eksekverbare. Til det skal vi have en container-runtime (dvs. Docker), der kører i vores maskine. Lad os åbne et terminalvindue og udføre:

./mvnw-pakke -Pnative -Dnative-image.docker-build = sand 

Dette vil skabe en Linux 64-bit eksekverbar, så hvis vi bruger et andet OS, kan det muligvis ikke køres længere. Det er okay for nu.

Projektgenerationen skabte en Dockerfile.native for os:

FRA 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 "] 

Hvis vi undersøger filen, har vi et tip til, hvad der kommer næste gang. Først skal vi Opret et dockerbillede:

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

Nu kan vi køre containeren ved hjælp af:

docker køre -i --rm -p 8080: 8080 quarkus / quarkus-projekt

Containeren startede i en utrolig lav tid på 0,009s. Det er en af ​​styrkerne ved Quarkus.

Endelig skal vi teste vores modificerede REST for at validere vores ansøgning:

$ curl localhost: 8080 / hej / høflig / Baeldung God morgen Baeldung

6. Implementering til OpenShift

Når vi er færdige med at teste lokalt ved hjælp af Docker, distribuerer vi vores container til OpenShift. Forudsat at vi har Docker-billedet i vores registreringsdatabase, kan vi implementere applikationen ved at følge nedenstående trin:

oc new-build --binary --name = quarkus-project -l app = quarkus-project oc patch bc / quarkus-project -p '{"spec": {"strategi": {"dockerStrategy": {"dockerfilePath" : "src / main / docker / Dockerfile.native"}}}} 'oc start-build quarkus-project --from-dir =. --Følg oc new-app --image-stream = quarkus-project: seneste oc expone service quarkus-project

Nu kan vi få applikations-URL'en ved at køre:

oc få rute

Endelig får vi adgang til det samme slutpunkt (bemærk, at URL'en kan være forskellig afhængigt af vores IP-adresse):

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

7. Konklusion

I denne artikel demonstrerede vi, at Quarkus er en god tilføjelse, der kan bringe Java mere effektivt til skyen. For eksempel er det muligt nu at forestille sig Java på AWS Lambda. Quarkus er også baseret på standarder som JPA og JAX / RS. Derfor behøver vi ikke lære noget nyt.

Quarkus har fået stor opmærksomhed på det seneste, og der tilføjes mange nye funktioner hver dag. Der er flere hurtige startprojekter, som vi kan prøve Quarkus på Quarkus GitHub-lageret.

Som altid er koden til denne artikel tilgængelig på GitHub. God kodning!


$config[zx-auto] not found$config[zx-overlay] not found