Kuidas Quarkus ühendab MicroProfile'i ja Springi

Tere kõigile! Siin on meie kolmas postitus Quarkuse sarjast!

Java mikroteenuste arendamisel arvatakse sageli, et Eclipse MicroProfile ja Spring Boot on eraldi ja omavahel sõltumatud API-d. Vaikimisi kasutavad programmeerijad tavaliselt neid API-sid, millega nad on juba harjunud, kuna uute raamistikude ja jooksukomponentide õppimine nõuab palju aega. Täna püüame lihtsustada mõnede populaarsete MicroProfile API-de omandamist Spring-arendajatele ja näitame, kuidas saame samaaegselt kasutada Spring API ja uusi kasulikke funktsioone. Quarkus.

Kui rääkida lähemalt, siis vaatame esmalt, kuidas Quarkus toetab Spring API, et näidata Spring-arendajatele, kuidas kasutada MicroProfile API-d oma igapäevases töös. Seejärel räägime MicroProfile API-dest, mis osutuvad kasulikuks Spring-arendajatele mikroteenuste loomisel.

Miks just Quarkus? Esiteks, see võimaldab reaalajas kodeerimist (live coding), st kõikide MicroProfile API, Spring API ja teiste Java API muudatuste automaatne laadimine toimub ühe käsu abil: mvn quarkus:dev. Teiseks, meie näites käsitletud funktsioon service Person (see on kompileeritud Springi, MicroProfile'i ja JPA API-dega GraalVMi natiivse pildiga binaarfailiks) käivitub vaid 0.055 sekundi jooksul ning kasutab umbes 90 MB RAM-i (RSS) RESTful rakenduse lõpp-punktis. Samuti toimub selle kompileerimine ühe käsuga: mvn package -Pnative.

Me ei soovita süveneda MicroProfile'i detailidesse, vaid püüame aidata Spring-arendajatel mõista, kuidas Quarkus'is saab kasutada Springi API-sid koos MicroProfile'i API-dega.

Konteinerid ja Kubernetes

Kuna me ei soovi seda artiklit üle koormata, vaatame siin vaid kõrgema taseme aspekte toetuse kohta Kubernetes, kuna see on oluline mõista. Quarkus positsioneerib end kui Java-stek Kubernetes'ile, ta on loodud vähendama Java rakenduste ja teenuste mälukasutust ja käivitamise aega, ning seega suurendama nende tihedust hostis ning vähendama üldkulusid.

Quarkus toetab samuti automaatset genereerimist Kubernetes'i ressurside jaoks ja pakub juhenditest Kubernetesel ja Red Hat OpenShift'il juurutamise kohta. Lisaks genereerib Quarkus automaatselt Dockerfile.jvm (JVM pakendamine) ja Dockerfile.native (natiivne pakendamine) failid, mis on vajalikud konteinerite loomiseks.

Ja lõpuks, suunates Kubernetes'i kui sihtkeskkonda, ei kasuta Quarkus Java raamistikke, kui sarnast funktsionaalsust on võimalik rakendada Kubernetes'i platvormil. Tabelis 1 on esitatud Kubernetes'i ja tüüpiliste Java raamistike, mida Springi arendajad kasutavad, funktsionaalse vastavuse kaart.

Tabel 1. Java raamistike ja Kubernetes'i funktsionaalse vastavuse kaart.

Funktsionaalsus
Tavapärane Spring Boot
Kubernetes

Teenuse avastamine
Eureka
DNS

Konfiguratsioon
Spring Cloud Config
Config Maps / Secrets

Laotamine
Ribbon (kliendi poolel)
Service, Replication Controller (serveri poolel)

Koodi kompileerimine ja käivitamine näitest

Selles artiklis viitame näidiste projektile, kus kasutatakse koos Springi ja MicroProfile'i API-sid ning isegi seda sama Java klassi. Selle näite koodi saab kompileerida ja käivitada käsurealt, lähemalt vt faili README.md.

Spring Frameworki API-d

Sõltuvuse sisestamine

Quarkus toetab mitmeid Context and Dependency Injection (CDI) API-sid ja Spring Dependency Injection (Spring DI) API-sid. Kui töötate MicroProfile'iga, Java EE ja Jakarta EE, olete juba hästi kursis CDI-iga. Teisest küljest saavad Springi arendajad kasutada Quarkus Extension for Spring DI API-d ühilduvuse tagamiseks Spring DI-ga. Toetatud Spring DI API kasutamise näiteid on toodud tabelis 2.

V projekti näites kasutatakse nii CDI-d kui ka Springi sõltuvuste süstimist. Lisateavet ja näiteid selle kohta leiate Quarkuse juhendist, mis kannab nime Spring DI Guide.

Tabel 2. Toetatud Spring DI API-de kasutamise näited.

Toetatud Spring DI funktsioonid
Näited

Konstruktorite süstimine

public PersonSpringController(
   PersonSpringRepository personRepository,  // süstitud      
   PersonSpringMPService personService) {    // süstitud
      this.personRepository = personRepository;
      this.personService = personService;
}

Väljade süstimine
Autowired
Väärtus

@Autowired
@RestClient
SalutationRestClient salutationRestClient;

@Value("${fallbackSalutation}")
String fallbackSalutation;

Bean
@Configuration

@Configuration
public class AppConfiguration {
   @Bean(name = "capitalizeFunction")
   public StringFunction capitalizer() {
      return String::toUpperCase;
   }
}

Komponent

@Component("noopFunction")
public class NoOpSingleStringFunction implements StringFunction {
   @Override
   public String apply(String s) {
      return s;
   }
}

Teenused

@Service
public class MessageProducer {
   @Value("${greeting.message}")
   String message;

   public String getPrefix() {
      return message;
   }
}

Veebiraamistik

MicroProfile kasutajad hindavad, et Quarkus toetab JAX-RS, MicroProfile Rest Client, JSON-P ja JSON-B kui peamist veebirakenduste mudelit. Springi arendajad on meeldivalt üllatunud Quarkusesse lisandunud Spring Web API toe üle, eriti REST-iga seotud liideste osas. Nagu Spring DI puhul, on Spring Web API toe peamine eesmärk see, et Springi arendajad saaksid kasutada Spring Web API liideseid koos MicroProfile API-dega. Toetatud Spring Web API-de kasutamise näited on toodud tabelis 3 ning lisainfot ja näiteid selle kohta leiate Quarkuse juhendist, mille nimi on Spring Web Guide.

Tabel 3. Toetatud Spring Web API-de kasutamise näited.

Toetatud Spring Web funktsioonid
Näited

@RestController
@RequestMapping

@RestController
@RequestMapping("/person")
public class PersonSpringController {
   ...
   ...
   ...
}

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (osaline)

@GetMapping(path = "/greet/{id}",
   produces = "text/plain")
   public String greetPerson(
   @PathVariable(name = "id") long id) {
   ...
   ...
   ...
}

Spring Data JPA

MicroProfilei kasutajatele meeldib ka see, et Quarkus toetab JPA-d Hibernate ORM-i abil. Head uudised on ka Spring-arendajatele: Quarkus toetab levinud Spring Data JPA annotatsioone ja tüüpe. Tabelis 4 on toodud näited toetatud Spring Data JPA API-de kasutamisest.
V projekti näites kasutatakse Spring Data JPA API-sid ja lisainformatsioon on saadaval Quarkuse juhendis, mille pealkiri on Spring Data JPA juhend.

Tabel 4. Näited toetatud Spring Data JPA API-de kasutamisest.

Toetatud funktsioonid Spring Data JPA
Näited

CrudRepository

public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}

Repository
JpaRepository
PagingAndSortingRepository

public class PersonRepository extends 

    Repository {

    Person save(Person entity);

    Optional findById(Person entity);
}

Repository Fragments

public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}

Deriveeritud päringumeetodid

public interface PersonRepository extends CrudRepository {

    List findByName(String name);
    
    Person findByNameBySsn(String ssn);
    
    Optional 
       findByNameBySsnIgnoreCase(String ssn);

    Boolean existsBookByYearOfBirthBetween(
            Integer start, Integer end);
}

Kasutaja määratud päringud

public interface MovieRepository
         extends CrudRepository {

    Movie findFirstByOrderByDurationDesc();

    @Query("select m from Movie m where m.rating = ?1")
    Iterator findByRating(String rating);

    @Query("from Movie where title = ?1")
    Movie findByTitle(String title);
}

MicroProfile API-d

Vea taluvus (Fault tolerance)

Talitõrje konstruktsioonid on üliolulised, et vältida kaskaadset pärandit ja luua usaldusväärseid mikroteenuste arhitektuure. Springi arendajad on juba aastaid kasutanud talitõrjet millestki circuit-breaker. Hystrix. Kuid Hystrix pole juba pikka aega uuendatud, samas kui MicroProfile'i talitõrje on aktiivselt arenenud ja sellel on juba mitme aasta tootmisest saadud kogemus. Seetõttu soovitatakse Quarkuses teenuste usaldusväärsuse tõstmiseks kasutada MicroProfile'i talitõrje API-sid, mille kasutamise näiteid on toodud tabelis 5. Täiendavaid üksikasju leiate Quarkuse juhendist. Talitõrje juhend.

Tabel 5. Toetatud MicroProfile'i talitõrje API-de kasutamise näidised.

MicroProfile'i talitõrje funktsioonid
Kirjeldus
Näited

@Asynchronous

Loogika täitmine eraldi lõimes

@Asynchronous
@Retry
public Future getSalutation() {
   ...
   return future;
}

@Bulkhead

Samaaegsete päringute arvu piiramine

@Bulkhead(5)
public void fiveConcurrent() {
   makeRemoteCall(); //...
}

@CircuitBreaker

Ahned tõrgete käsitlemine ja taastumine

@CircuitBreaker(delay=500   // milliseconds
   failureRatio = .75,
   requestVolumeThreshold = 20,
   successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

@Fallback

Alternatiivse loogika kutsumine tõrke korral

@Timeout(500) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

public String fallback() {
   return "hello";
}

Uuesti

Taaskatsumine tõrke korral

@Retry(maxRetries=3)
public String getSalutation() {
   makeRemoteCall(); //...
}

Ooteaeg

Tõrke korral kontrolliaeg

@Timeout(value = 500) // milliseconds
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

Teenuste kontroll (Service Health)

Kubernetes platvormid jälgivad konteinerite tervislikkust spetsiaalsete teenuste abil. Alusplatvorm peab teenuseid jälgima, seetõttu kasutavad Spring-arendajad tavaliselt kohandatud HealthIndicator ja Spring Boot Actuator. Quarkus'e puhul saab seda teha MicroProfile Health abil, mis vaikimisi teostab töövõimekuse kontrolli (liveness check), kuid saab samuti seadistada nii töövõimekuse kui ka valmisoleku (readiness) samaaegseks kontrollimiseks. Toetatud MicroProfile Health API-de kasutamise näited on esitatud tabelis 6, lisainformatsioon on toodud Quarkus'i juhendis. Tervisejuhend.

Tabel 6. Toetatud MicroProfile Health API-de kasutamise näited.

MicroProfile Health funktsioonid
Kirjeldus
Näited

@Liveness

Platvorm taaskäivitab rikkis konteineriseeritud rakendused
Lõpp-punkt:
host:8080/health/live

@Elulekus
public class MyHC implements HealthCheck {
  public HealthCheckResponse call() {

   ...
   return HealthCheckResponse
     .named("myHCProbe")
     .status(ready ? true:false)
     .withData("mydata", data)
     .build();  
}

@Valmidus

Platvorm ei suuna liiklust konteineriseeritud rakendustele, kui need ei ole valmis.
Lõpp-punkt:
host:8080/health/ready

@Valmidus
public class MyHC implements HealthCheck {
  public HealthCheckResponse call() {

   ...
   return HealthCheckResponse
     .named("myHCProbe")
     .status(live ? true:false)
     .withData("mydata", data)
     .build();  
}

Mõõdikud

Rakendused provisioniseerivad mõõdikute või operatiivsetes eesmärkides (SLA tulemuslikkuse jälgimiseks) või mitteoperatiivsetes (äritulemuste SLA). Spring-arendajad provisioniseerivad mõõdikuid Spring Boot Actuatori ja Micrometer'i abil. Quarkus omakorda kasutab MicroProfile Metrics'i, et provisioniseerida põhimeetriad (JVM ja operatsioonisüsteem), müügi-mõõdikud (Quarkus) ja rakenduse mõõdikud. MicroProfile Metrics nõuab, et rakendus toetaks väljundiformaate JSON ja OpenMetrics (Prometheus). Näited MicroProfile Metrics API kasutamisest on toodud tabelis 7.

V projekti näites MicroProfile Metrics'i kasutatakse rakenduse mõõdikute provisioniseerimiseks. Täiendavat teavet leiate Quarkus juhendist. Mõõdikute juhend.

Tabel 7. MicroProfile Metrics API-de näidiste kasutamine.

MicroProfile Metrics funktsioonid
Kirjeldus
Näited

@Counted

Tähistab count-eriteavitus, mis loendab märgistatud objekti kutsumise arvu.

@Counted(name = "fallbackCounter", 
  displayName = "Fallback Counter", 
  description = "Fallback Counter")
public String salutationFallback() {
   return fallbackSalutation;
}

@ConcurrentGauge

Tähistab gauge-eriala, mis loendab märgistatud objekti paralleelseid kutsungeid.

@ConcurrentGuage(
  name = "fallbackConcurrentGauge", 
  displayName="Fallback Concurrent", 
  description="Fallback Concurrent")
public String salutationFallback() {
   return fallbackSalutation;
}

@Gauge

Tähistab gauge-eriala, mis mõõdab märgistatud objekti väärtust.

@Metered(name = "FallbackGauge",
   displayName="Fallback Gauge",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

@Metered

Tähistab meter-eriala, mis jälgib märgistatud objekti kutsumise sagedust.

@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

Mõõdik

Annotatsioon, mis sisaldab metaandmeid, kui esitatakse mõõdikute loomise või muutmise päring.

@Metric
@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

Ajastatud

Mõõdab ajastust, mis jälgib annotatiivse objekti kestust

@Timed(name = "TimedFallback",
   displayName="Ajastatud tagastus",
   description="Tagastamise viivitus")
public String salutationFallback() {
   return fallbackSalutation;
}

Mõõdikute lõpp-punktid (Metrics Endpoints)

Rakenduse mõõdikud localhost:8080/metrics/application
Põhimõõdikud localhost:8080/metrics/base
Tehase mõõdikud localhost:8080/metrics/vendor
Kõik mõõdikud localhost:8080/metrics

Rest-klient MicroProfile

Mikroteenused pakuvad sageli RESTful lõpp-punkte, millega toimetamiseks on vajalikud vastavad kliendi API-d. Springi arendajad kasutavad tavaliselt RestTemplate'i, kuid Quarkus pakub selle jaoks MicroProfile Rest Client API liideseid, mille kasutamise näidised on tabelis 8.

V projekti näites RESTful lõpp-punktide kasutamine toimub MicroProfile Rest Client abil. Lisainfot ja näiteid selle kohta leiate Quarkuse juhendist. Rest Klientide Juhend.

Tabel 8. Näited MicroProfile Rest Client API liideste kasutamisest.

MicroProfile Rest Client funktsioonid
Kirjeldus
Näited

@RegisterRestClient

Registreerib tüübitud Java liidese REST kliendina

@RegisterRestClient
@Path("/")
public interface MyRestClient {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String getSalutation();
}

@RestClient

Tähistab tüübistatud REST-klientliidese eksemplari rakendamist

@Autowired // või @Inject
@RestClient
MyRestClient restClient;

Kutse

Kutsed REST-lõpp-punkti

System.out.println(
   restClient.getSalutation());

mp-rest/url

Määrab REST-lõpp-punkti

application.properties:
org.example.MyRestClient/mp-rest/url=
   http://localhost:8081/myendpoint

Kokkuvõte

Selles blogis, mis on eelkõige kasulik Spring arendajatele, vaatame lühidalt, kuidas Quarkus'is kasutada Spring'iga seotud API-liideseid koos MicroProfile'i API-liidestega, et arendada Java mikroteenuseid ja seejärel kompileerida neid natiivseks binaarkoodiks, mis säästab sadu megabait mälu ja käivitub mõne millisekundi jooksul.

Nagu te juba aru saite, on täiendavat teavet Spring'i ja MicroProfile'i API-liideste toetamise kohta ning hulgaliselt muud kasulikku teavet saadaval Quarkusi käsiraamatutes.

Allikas: habr.com