როგორ აერთიანებს Quarkus MicroProfile და Spring

მოგესალმებით ყველას, აი, მესამე პოსტი Quarkus-ის სერიაში!

Java მიკროსერვისების შემუშავებისას ხშირად სჯერათ, რომ დაბნელების მიკროპროფილი и საგაზაფხულო ჩექმა არის ცალკე და დამოუკიდებელი API. ნაგულისხმევად, პროგრამისტები იყენებენ API-ებს, რომლებსაც უკვე მიჩვეულები არიან, რადგან ახალი ჩარჩოების და გაშვების კომპონენტების სწავლას დიდი დრო სჭირდება. დღეს ჩვენ შევეცდებით გავამარტივოთ ზოგიერთი პოპულარული განვითარება MicroProfile API გაზაფხულის დეველოპერებისთვის და გაჩვენებთ, თუ როგორ გამოიყენოთ ერთდროულად Spring API და ახალი სასარგებლო ფუნქციები კვარკუსი.

ცოტა უფრო დეტალურად, ჩვენ პირველ რიგში განვიხილავთ სფეროს და დეტალებს იმის შესახებ, თუ როგორ უჭერს მხარს Quarkus Spring API-ებს, რათა Spring დეველოპერებს ვაჩვენოთ, თუ როგორ გამოიყენონ MicroProfile API თავიანთ ყოველდღიურ მუშაობაში. შემდეგ ჩვენ გავაშუქებთ MicroProfile API-ებს, რომლებიც სასარგებლოა Spring დეველოპერებისთვის მიკროსერვისების შექმნისას.

რატომ Quarkus? პირველ რიგში, ეს არის ცოცხალი კოდირება, ანუ MicroProfile API, Spring API და სხვა Java API-ებში ნებისმიერი ცვლილების ავტომატური გადატვირთვა, რომელიც შესრულებულია მხოლოდ ერთი ბრძანებით: mvn quarkus:dev. მეორეც, განხილული იყო ჩვენს მაგალითში პიროვნების სერვისი (რომელიც გროვდება Spring, MicroProfile და JPA API-ებიდან ბინარში GraalVM სურათის გამოყენებით) იწყება სულ რაღაც 0.055 წამში და იკავებს დაახლოებით 90 მბ RAM-ს (RSS) RESTful აპლიკაციის ბოლო წერტილზე. უფრო მეტიც, მისი შედგენა თავად ხდება მხოლოდ ერთი ბრძანებით: mvn პაკეტი -Pnative.

ჩვენ არ განვიხილავთ დეტალებს MicroProfile-ის შესახებ, გარდა იმისა, რომ დავეხმაროთ Spring დეველოპერებს იმის გაგებაში, თუ როგორ შეუძლიათ გამოიყენონ Spring API-ები MicroProfile API-ებით Quarkus-ში.

კონტეინერები და კუბერნეტები

ამ სტატიის მარტივი შესანარჩუნებლად, აქ მხოლოდ მაღალი დონის მხარდაჭერის ასპექტებს განვიხილავთ. კუბერნეტები, რადგან მნიშვნელოვანია გაგება. Quarkus პოზიციონირებულია როგორც ჯავის დასტა Kubernetes-ისთვის, ის შექმნილია იმისთვის, რომ მინიმუმამდე დაიყვანოს მეხსიერების მოხმარება და Java აპლიკაციებისა და სერვისების გაშვების დრო და, შედეგად, გაზარდოს მათი სიმკვრივე ჰოსტზე და შეამციროს საერთო ხარჯები.

კვარკუსიც მხარს უჭერს ავტო გენერაციას Kubernetes რესურსები და შეთავაზებები სახელმძღვანელო Kubernetes და Red Hat OpenShift პლატფორმებზე განლაგებისთვის. გარდა ამისა, Quarkus ავტომატურად წარმოქმნის Dockerfile.jvm (JVM შეფუთვა) და Dockerfile.native (მშობლიური ბინარული შეფუთვა) ფაილებს, რომლებიც საჭიროა კონტეინერების შესაქმნელად.

დაბოლოს, Kubernetes-ზე, როგორც სამიზნე განლაგების გარემოზე ფოკუსირებით, Quarkus არ იყენებს Java Framework-ებს იმ შემთხვევებში, როდესაც მსგავსი ფუნქციონირება ხორციელდება თავად Kubernetes პლატფორმის დონეზე. ცხრილში 1 მოცემულია ფუნქციური კორესპონდენციის რუკა Kubernetes-სა და ტიპურ ჯავას ჩარჩოებს შორის, რომლებსაც იყენებენ Spring დეველოპერები.

ცხრილი 1. ჯავის ჩარჩოებსა და კუბერნეტებს შორის ფუნქციური კორესპონდენციის რუკა.

ფუნქციონალობა
ტრადიციული საგაზაფხულო ჩექმა
კუბერნეტები

სერვისის აღმოჩენა
Eureka
DNS

კონფიგურაცია
Spring Cloud Config
რუქების/საიდუმლოების კონფიგურაცია

Დატვირთვის დაბალანსება
ლენტი (კლიენტის მხარე)
სერვისი, რეპლიკაციის კონტროლერი (სერვერის მხარე)

კოდის შედგენა და გაშვება მაგალითიდან

ამ სტატიაში ჩვენ მივმართავთ პროექტის მაგალითი, სადაც Spring და MicroProfile API და თუნდაც ერთი და იგივე Java კლასი გამოიყენება ერთად. ამ მაგალითში კოდის შედგენა და გაშვება შესაძლებელია ბრძანების ხაზიდან, დეტალებისთვის იხილეთ README.md ფაილი.

Spring Framework API-ები

დამოკიდებულების ინექცია

Quarkus მხარს უჭერს დიაპაზონს Contexts and Dependency Injection (CDI) API-ები და Spring Dependency Injection (Spring DI) API-ები. თუ თქვენ მუშაობთ MicroProfile-თან, Java EE და Jakarta EE, მაშინ თქვენ უკვე კარგად იცნობთ CDI-ს. მეორეს მხრივ, Spring დეველოპერებს შეუძლიათ გამოიყენონ Quarkus Extension Spring DI API-სთვის Spring DI-თან თავსებადობის მისაღწევად. მხარდაჭერილი Spring DI API-ების გამოყენების მაგალითები მოცემულია ცხრილში 2.

В პროექტი ჩვენი მაგალითიდან იყენებს როგორც CDI, ასევე გაზაფხულზე დამოკიდებულების ინექციას. დამატებითი ინფორმაციისთვის და მაგალითებისთვის ამ თემაზე იხილეთ Quarkus-ის სახელმძღვანელო ე.წ საგაზაფხულო DI გზამკვლევი.

ცხრილი 2. მხარდაჭერილი Spring DI API-ების გამოყენების მაგალითები.

მხარდაჭერილი Spring DI ფუნქციები
მაგალითები

კონსტრუქტორის ინექცია

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

საველე ინექცია
ავტომატური გაყვანილობა
ღირებულება

@Autowired
@RestClient
SalutationRestClient salutationRestClient;

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

Bean
@კონფიგურაცია

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

კომპონენტი

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

სამსახურის

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

   public String getPrefix() {
      return message;
   }
}

ვებ ჩარჩო

MicroProfile მომხმარებლებს მოეწონებათ, რომ Quarkus მხარს უჭერს JAX-RS, MicroProfile Rest Client, JSON-P და JSON-B, როგორც ვებ პროგრამირების პირველად მოდელს. საგაზაფხულო დეველოპერები კმაყოფილი იქნებიან Quarkus-ის ბოლო მხარდაჭერით Spring Web API, კერძოდ REST ინტერფეისებისთვის. Spring DI-ის მსგავსად, Spring Web API-ის მხარდაჭერის მთავარი მიზანია Spring დეველოპერებს საშუალება მისცეს გამოიყენონ Spring Web API MicroProfile API-ებთან ერთად. მხარდაჭერილი Spring Web API-ების გამოყენების მაგალითები მოცემულია ცხრილში 3 და მეტი ინფორმაცია და მაგალითები ამ თემაზე შეგიძლიათ იხილოთ Quarkus-ის სახელმძღვანელოში ე.წ. საგაზაფხულო ვებ გზამკვლევი.

ცხრილი 3. მხარდაჭერილი Spring Web API-ების გამოყენების მაგალითები.

მხარდაჭერილი საგაზაფხულო ვებ ფუნქციები
მაგალითები

@RestController
@RequestMapping

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

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (ნაწილობრივ)

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

საგაზაფხულო მონაცემები JPA

MicroProfile მომხმარებლები ასევე დააფასებენ, რომ Quarkus მხარს უჭერს JPA-ს Hibernate ORM-ის გამოყენებით. ასევე არის კარგი სიახლე Spring დეველოპერებისთვის: Quarkus მხარს უჭერს გაზაფხულის მონაცემთა JPA-ს საერთო ანოტაციებსა და ტიპებს. მხარდაჭერილი Spring Data JPA API-ების გამოყენების მაგალითები მოცემულია ცხრილში 4.
В პროექტი ჩვენი მაგალითიდან გამოიყენება Spring Data JPA API-ები და მეტი ინფორმაცია ხელმისაწვდომია Quarkus-ის სახელმძღვანელოში ე.წ Spring Data JPA გზამკვლევი.

ცხრილი 4. მხარდაჭერილი Spring Data JPA API-ების გამოყენების მაგალითები.

მხარდაჭერილი Spring Data JPA ფუნქციები
მაგალითები

CrudRepository

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

საცავი
JpaRepository
PagingAndSorting Repository

public class PersonRepository extends 

    Repository {

    Person save(Person entity);

    Optional findById(Person entity);
}

საცავის ფრაგმენტები

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

მიღებული შეკითხვის მეთოდები

public interface PersonRepository extends CrudRepository {

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

    Boolean existsBookByYearOfBirthBetween(
            Integer start, Integer end);
}

მომხმარებლის მიერ განსაზღვრული მოთხოვნები

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-ები

შეცდომის ტოლერანტობა

ხარვეზების ტოლერანტობის კონსტრუქციები ძალიან მნიშვნელოვანია კასკადური ჩავარდნების თავიდან ასაცილებლად და საიმედო მიკროსერვისის არქიტექტურის შესაქმნელად. საგაზაფხულო დეველოპერები მრავალი წლის განმავლობაში იყენებდნენ ამომრთველებს შეცდომების ტოლერანტობისთვის. ჰისტრიქსი. თუმცა, Hystrix დიდი ხანია არ განახლებულა, მაგრამ MicroProfile's Fault Tolerance ახლა აქტიურად ვითარდება და მის უკან რამდენიმე წლიანი საწარმოო გამოყენებაა. ამიტომ, Quarkus-ში სერვისების სანდოობის გასაუმჯობესებლად, რეკომენდებულია MicroProfile Fault Tolerance API-ების გამოყენება, რომელთა მაგალითები გამოიყენება ცხრილში 5. ამის შესახებ დამატებითი ინფორმაციისთვის იხილეთ Quarkus-ის სახელმძღვანელო. შეცდომების ტოლერანტობის სახელმძღვანელო.

ცხრილი 5. მხარდაჭერილი MicroProfile Fault Tolerance API-ების გამოყენების მაგალითები.

მიკროპროფილის შეცდომის ტოლერანტობის მახასიათებლები
აღწერა
მაგალითები

@ასინქრონული

ლოგიკის შესრულება ცალკე თემაში

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

@Bulkhead

შეზღუდეთ ერთდროული მოთხოვნების რაოდენობა

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

@CircuitBreaker

ჭკვიანური წარუმატებლობის მართვა და წარუმატებლობისგან აღდგენა

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

@Fallback

მარცხის შემთხვევაში ალტერნატიული ლოგიკის გამოძახება

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

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

გაიმეორეთ

ხელახლა სცადეთ მოთხოვნის წარუმატებლობის შემთხვევაში

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

Დროის ამოწურვა

წარუმატებლობის კონტროლის დრო ამოიწურა

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

სერვისების შემოწმება (სერვისის ჯანმრთელობა)

Kubernetes პლატფორმები აკონტროლებენ კონტეინერების ჯანმრთელობას სპეციალური სერვისების გამოყენებით. იმისათვის, რომ ფუძემდებლური პლატფორმა მომსახუროს სერვისების მონიტორინგისთვის, Spring დეველოპერები ჩვეულებრივ იყენებენ მორგებულ HealthIndicator-ს და Spring Boot Actuator-ს. Quarkus-ში ეს შეიძლება გაკეთდეს MicroProfile Health-ის გამოყენებით, რომელიც ნაგულისხმევად ახორციელებს სიცოცხლისუნარიანობის შემოწმებას, მაგრამ შეიძლება კონფიგურირებული იყოს სიცოცხლისა და მზადყოფნის ერთდროულად შესამოწმებლად. მხარდაჭერილი MicroProfile Health API-ების გამოყენების მაგალითები მოცემულია ცხრილში 6 და დამატებითი ინფორმაცია მოცემულია Quarkus-ის სახელმძღვანელოში. ჯანმრთელობის გზამკვლევი.

ცხრილი 6: მხარდაჭერილი MicroProfile Health API-ების გამოყენების მაგალითები.

MicroProfile ჯანმრთელობის მახასიათებლები
აღწერა
მაგალითები

@Liveness

პლატფორმა გადატვირთავს წარუმატებელ კონტეინერიზებულ აპლიკაციებს
საბოლოო წერტილი:
მასპინძელი:8080/ჯანმრთელობა/ცოცხალი

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

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

@მზადობა

პლატფორმა არ გაუგზავნის ტრაფიკს კონტეინერულ აპლიკაციებში, თუ ის მზად არ არის
საბოლოო წერტილი:
მასპინძელი:8080/ჯანმრთელობა/მზადაა

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

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

მეტრიკა

აპლიკაციები უზრუნველყოფენ მეტრიკას როგორც საოპერაციო მიზნებისთვის (ეფექტურობის SLA-ების მონიტორინგისთვის) ან არაოპერაციული მიზნებისთვის (ბიზნესის SLA). საგაზაფხულო დეველოპერები უზრუნველყოფენ მეტრიკას Spring Boot Actuator-ისა და Micrometer-ის გამოყენებით. თავის მხრივ, Quarkus იყენებს MicroProfile Metrics-ს საბაზისო მეტრიკის (JVM და ოპერაციული სისტემა), გამყიდველის მეტრიკის (Quarkus) და აპლიკაციის მეტრიკის უზრუნველსაყოფად. MicroProfile Metrics მოითხოვს, რომ განხორციელებამ მხარი დაუჭიროს JSON და OpenMetrics (Prometheus) გამომავალი ფორმატებს. MicroProfile Metrics API-ის გამოყენების მაგალითები მოცემულია ცხრილში 7.

В პროექტი ჩვენი მაგალითიდან MicroProfile Metrics გამოიყენება აპლიკაციის მეტრიკის უზრუნველსაყოფად. დამატებითი ინფორმაციისთვის იხილეთ Quarkus-ის სახელმძღვანელო მეტრიკის გზამკვლევი.

ცხრილი 7. MicroProfile Metrics API-ების გამოყენების მაგალითები.

MicroProfile Metrics მახასიათებლები
აღწერა
მაგალითები

@დათვლილი

აღნიშნავს მრიცხველს, რომელიც ითვლის რამდენჯერ იქნა გამოძახებული ანოტირებული ობიექტი

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

@ConcurrentGauge

აღნიშნავს ლიანდაგს, რომელიც ითვლის ანოტირებულ ობიექტზე თანმხლები ზარების რაოდენობას

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

@Gauge

აღნიშნავს ლიანდაგის სენსორს, რომელიც ზომავს ანოტირებული ობიექტის მნიშვნელობას

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

@Metered

აღნიშნავს მრიცხველის სენსორს, რომელიც აკონტროლებს ანოტირებული ობიექტის ზარის სიხშირეს

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

Metric

ანოტაცია, რომელიც შეიცავს ინფორმაციას მეტამონაცემების შესახებ, როდესაც მიიღება მოთხოვნა მეტრიკის შეყვანის ან წარმოების შესახებ

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

დროულად

მიუთითებს ტაიმერზე, რომელიც აკონტროლებს ანოტირებული ობიექტის ხანგრძლივობას

@Timed(name = "TimedFallback",
   displayName="Timed Fallback",
   description="Fallback delay")
public String salutationFallback() {
   return fallbackSalutation;
}

მეტრიკის საბოლოო წერტილები

განაცხადის მეტრიკა localhost:8080/მეტრიკა/აპლიკაცია
ძირითადი მეტრიკა localhost:8080/მეტრიკა/ბაზა
გამყიდველის მეტრიკა localhost:8080/მეტრიკა/მიმწოდებელი
ყველა მეტრიკა localhost:8080/მეტრიკა

MicroProfile Rest კლიენტი

მიკროსერვისები ხშირად უზრუნველყოფენ RESTful საბოლოო წერტილებს, რომლებზეც საჭიროა შესაბამისი კლიენტის API-ები. RESTful ბოლო წერტილების გამოსაყენებლად გაზაფხულის დეველოპერები ჩვეულებრივ იყენებენ RestTemplate-ს. Quarkus გთავაზობთ MicroProfile Rest Client API-ებს ამ პრობლემის გადასაჭრელად, რომელთა გამოყენების მაგალითები მოცემულია ცხრილში 8.

В პროექტი ჩვენი მაგალითიდან RESTful ბოლო წერტილების გამოყენება ხდება MicroProfile Rest Client-ის გამოყენებით. დამატებითი ინფორმაცია და მაგალითები ამ თემაზე შეგიძლიათ იხილოთ Quarkus-ის სახელმძღვანელოში დასვენების კლიენტის გზამკვლევი.

ცხრილი 8. MicroProfile Rest Client API-ების გამოყენების მაგალითები.

MicroProfile Rest Client-ის მახასიათებლები
აღწერა
მაგალითები

@RegisterRestClient

არეგისტრირებს აკრეფილ Java ინტერფეისს REST კლიენტად

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

@RestClient

აღნიშნავს აკრეფილი REST კლიენტის ინტერფეისის ინსტანციის განხორციელებას

@Autowired // or @Inject
@RestClient
MyRestClient restClient;

შემოწირულობა

უწოდებს REST ბოლო წერტილს

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

mp-rest/url

განსაზღვრავს REST ბოლო წერტილს

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

შედეგები

ამ ბლოგში, რომელიც ძირითადად გამიზნულია Spring დეველოპერებისთვის, ჩვენ გადავხედეთ, თუ როგორ გამოვიყენოთ Spring API-ები MicroProfile API-ებით Quarkus-ში ჯავის მიკროსერვისების გასავითარებლად და შემდეგ მათი შედგენის ბუნებრივ ბინარულ კოდში, რომელიც დაზოგავს ასობით მეგაბაიტს ოპერატიული მეხსიერებას და გაშვებას მილიწამების საკითხი.

როგორც უკვე მიხვდით, დამატებითი ინფორმაცია Spring და MicroProfile API-ების მხარდაჭერის შესახებ, ისევე როგორც ბევრი სხვა სასარგებლო ინფორმაცია, შეგიძლიათ იხილოთ აქ Quarkus-ის სახელმძღვანელოები.

წყარო: www.habr.com