Veiledning til QuarkusIO

1. Introduksjon

I dag er det veldig vanlig å skrive en applikasjon og distribuere til skyen og ikke bekymre deg for infrastrukturen. Serverless og FaaS har blitt veldig populære.

I denne typen miljø, hvor forekomster blir opprettet og ødelagt ofte, er tid til oppstart og tid til første forespørsel ekstremt viktig, da de kan skape en helt annen brukeropplevelse.

Språk som JavaScript og Python er alltid i søkelyset i denne typen scenarier. Med andre ord, Java med sine fete JAR og lang oppstartstid var aldri en topp konkurrent.

I denne veiledningen, Vi presenterer Quarkus og diskuterer om det er et alternativ for å bringe Java mer effektivt til skyen.

2. QuarkusIO

QuarkusIO, det supersoniske subatomære Java, lover å levere små gjenstander, ekstremt rask oppstartstid og lavere tid til første forespørsel. Når det kombineres med GraalVM, vil Quarkus kompilere på forhånd (AOT).

Siden Quarkus er bygget på standard, trenger vi ikke lære noe nytt. Derfor kan vi blant annet bruke CDI og JAX-RS. Quarkus har også mange utvidelser, inkludert de som støtter Hibernate, Kafka, OpenShift, Kubernetes og Vert.x.

3. Vår første søknad

Den enkleste måten å lage et nytt Quarkus-prosjekt på er å åpne en terminal og skrive:

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

Dette vil generere prosjektskjelettet, a HelloResource med en /Hallo endepunkt eksponert, konfigurasjon, Maven-prosjekt og Dockerfiles.

Når vi er importert til IDE, har vi en struktur som ligner den som vises i bildet nedenfor:

La oss undersøke innholdet i HelloResource klasse:

@Path ("/ hallo") offentlig klasse HelloResource {@GET @Produces (MediaType.TEXT_PLAIN) offentlig String hei () {return "hallo"; }}

Alt ser bra ut så langt. På dette tidspunktet har vi en enkel applikasjon med et enkelt RESTEasy JAX-RS-sluttpunkt. La oss gå videre og teste det ved å åpne en terminal og kjøre kommandoen:

./mvnw kompilere kvarkus: dev:

REST-endepunktet vårt skal eksponeres på localhost: 8080 / hei. La oss teste det med krølle kommando:

$ curl localhost: 8080 / hallo hei

4. Hot Reload

Når du kjører i utviklingsmodus (./mvn kompilere kvarkus: dev), Gir Quarkus en funksjon for varmelading. Med andre ord, endringer som er gjort i Java-filer eller i konfigurasjonsfiler blir automatisk kompilert når nettleseren er oppdatert. Den mest imponerende funksjonen her er at vi ikke trenger å lagre filene våre. Dette kan være bra eller dårlig, avhengig av hva vi foretrekker.

Vi vil nå modifisere eksemplet vårt for å demonstrere muligheten for hot-reload. Hvis applikasjonen stoppes, kan vi bare starte den på nytt i dev-modus. Vi bruker det samme eksemplet som før som utgangspunkt.

Først oppretter vi en HelloService klasse:

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

Nå skal vi endre HelloResource klasse, injisere HelloService og legge til en ny metode:

@Injiser HelloService helloService; @GET @Produces (MediaType.APPLICATION_JSON) @Path ("/ høflig / {navn}") offentlig strenghilsen (@PathParam ("navn") strengnavn) {retur helloService.politeHello (navn); }

La oss deretter teste vårt nye endepunkt:

$ curl localhost: 8080 / hei / høflig / Baeldung Hei Mr / Mrs Baeldung

Vi vil gjøre en endring til for å demonstrere at det samme kan brukes på eiendomsfiler. La oss redigere application.properties fil og legg til en nøkkel til:

hilsen = God morgen

Etter det endrer vi HelloService å bruke vår nye eiendom:

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

Hvis vi utfører det samme krølle kommando, skal vi nå se:

God morgen Baeldung

Vi kan enkelt pakke applikasjonen ved å kjøre:

./mvnw-pakke 

Dette genererer to jar-filer inne i mål katalog:

  • quarkus-project-1.0-SNAPSHOT-runner.jar - en kjørbar krukke med avhengighetene kopiert til mål / lib
  • quarkus-project-1.0-SNAPSHOT.jar - inneholder klasser og ressursfiler

Vi kan nå kjøre den pakkede applikasjonen:

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

5. Innfødt bilde

Deretter vil vi produsere et eget bilde av applikasjonen vår. Et opprinnelig bilde vil forbedre oppstartstid og tid til første respons. Med andre ord, det inneholder alt den trenger for å kjøre, inkludert minimal JVM som er nødvendig for å kjøre applikasjonen.

Til å begynne med må vi ha GraalVM installert og miljøvariabelen GRAALVM_HOME konfigurert.

Vi stopper nå applikasjonen (Ctrl + C), hvis ikke allerede stoppet, og kjører kommandoen:

./mvnw-pakke -Native

Dette kan ta noen sekunder å fullføre. Fordi innfødte bilder prøver å lage all kode AOT for å starte raskere, vil vi få lengre byggetider.

Vi kan løpe ./mvnw verifisere -Pnative for å verifisere at vår opprinnelige gjenstand var riktig konstruert:

For det andre vil vi lage et containerbilde ved hjelp av vår opprinnelige kjørbare. For det må vi ha en container kjøretid (dvs. Docker) som kjører i maskinen vår. La oss åpne et terminalvindu og utføre:

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

Dette vil opprette en Linux 64-bit kjørbar, så hvis vi bruker et annet operativsystem, kan det hende det ikke kan kjøres lenger. Det er greit for nå.

Prosjektgenerasjonen skapte en Dockerfile.native for oss:

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øker filen, har vi et hint om hva som kommer videre. Først skal vi lage et dockerbilde:

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

Nå kan vi kjøre containeren ved hjelp av:

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

Containeren startet på en utrolig lav tid på 0,009s. Det er en av styrkene til Quarkus.

Til slutt bør vi teste vår modifiserte REST for å validere søknaden vår:

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

6. Distribuere til OpenShift

Når vi er ferdig med å teste lokalt ved hjelp av Docker, distribuerer vi containeren vår til OpenShift. Forutsatt at vi har Docker-bildet i registret vårt, kan vi distribuere applikasjonen ved å følge trinnene nedenfor:

oc nybygg - binær - navn = quarkus-prosjekt -l app = quarkus-prosjekt 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 ny app - image-stream = quarkus-prosjekt: siste oc eksponere tjeneste quarkus-prosjekt

Nå kan vi få applikasjons-URL ved å kjøre:

oc få rute

Til slutt får vi tilgang til samme endepunkt (merk at URL-en kan være forskjellig, avhengig av IP-adressen vår):

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

7. Konklusjon

I denne artikkelen demonstrerte vi at Quarkus er et flott tillegg som kan bringe Java mer effektivt til skyen. For eksempel er det mulig nå å forestille seg Java på AWS Lambda. Quarkus er også basert på standarder som JPA og JAX / RS. Derfor trenger vi ikke lære noe nytt.

Quarkus har fått mye oppmerksomhet i det siste, og mange nye funksjoner blir lagt til hver dag. Det er flere hurtigstartprosjekter for oss å prøve Quarkus på Quarkus GitHub-depot.

Som alltid er koden for denne artikkelen tilgjengelig på GitHub. God koding!


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