ક્વાર્કસ કેવી રીતે માઇક્રોપ્રોફાઇલ અને સ્પ્રિંગને જોડે છે

દરેકને નમસ્કાર, અહીં ક્વાર્કસ શ્રેણીની ત્રીજી પોસ્ટ છે!

જાવા માઇક્રોસર્વિસીસનો વિકાસ કરતી વખતે, તે ઘણીવાર માનવામાં આવે છે ગ્રહણ માઇક્રોપ્રોફાઇલ и વસંત બૂટ અલગ અને સ્વતંત્ર API છે. મૂળભૂત રીતે, પ્રોગ્રામર્સ એપીઆઈનો ઉપયોગ કરવાનું વલણ ધરાવે છે જેનો તેઓ પહેલેથી ઉપયોગ કરે છે, કારણ કે નવા ફ્રેમવર્ક અને રનટાઇમ ઘટકો શીખવામાં ઘણો સમય લાગે છે. આજે આપણે કેટલાક લોકપ્રિયના વિકાસને સરળ બનાવવાનો પ્રયાસ કરીશું વસંત વિકાસકર્તાઓ માટે માઇક્રોપ્રોફાઇલ API અને તમને બતાવે છે કે કેવી રીતે એકસાથે સ્પ્રિંગ API અને નવી ઉપયોગી સુવિધાઓનો ઉપયોગ કરવો ક્વાર્કસ.

થોડી વધુ વિગતમાં, અમે સૌપ્રથમ સ્પ્રિંગ ડેવલપર્સને તેમના રોજિંદા કામમાં માઇક્રોપ્રોફાઇલ API નો ઉપયોગ કેવી રીતે કરવો તે બતાવવા માટે ક્વાર્કસ સ્પ્રિંગ API ને કેવી રીતે સપોર્ટ કરે છે તેના અવકાશ અને વિગતો જોઈશું. પછી અમે માઇક્રોપ્રોફાઇલ API ને આવરી લઈશું, જે માઇક્રોસર્વિસ બનાવતી વખતે વસંત વિકાસકર્તાઓ માટે ઉપયોગી છે.

શા માટે ક્વાર્કસ? સૌપ્રથમ, આ લાઇવ કોડિંગ છે, એટલે કે, માઇક્રોપ્રોફાઇલ API, સ્પ્રિંગ API અને અન્ય જાવા API માં કોઈપણ ફેરફારોનું ઓટોમેટિક રીલોડિંગ, જે માત્ર એક આદેશ સાથે કરવામાં આવે છે: mvn quarkus:dev. બીજું, માં ગણવામાં આવે છે અમારા ઉદાહરણમાં વ્યક્તિ સેવા (જે સ્પ્રિંગ, માઇક્રોપ્રોફાઇલ અને JPA API ને મૂળ GraalVM ઇમેજનો ઉપયોગ કરીને બાઈનરીમાં કમ્પાઇલ કરે છે) માત્ર 0.055 સેકન્ડમાં શરૂ થાય છે અને RESTful એપ્લિકેશન એન્ડપોઇન્ટ પર લગભગ 90 MB RAM (RSS) લે છે. વધુમાં, તેનું સંકલન પોતે માત્ર એક આદેશ સાથે કરવામાં આવે છે: mvn package -Pnative.

અમે માઈક્રોપ્રોફાઈલ વિશે વિગતમાં જઈશું નહીં, સ્પ્રિંગ ડેવલપર્સને સમજવામાં મદદ કરવા સિવાય કે તેઓ ક્વાર્કસમાં માઇક્રોપ્રોફાઈલ API સાથે સ્પ્રિંગ API નો ઉપયોગ કેવી રીતે કરી શકે છે.

કન્ટેનર અને કુબરનેટ્સ

આ લેખને સરળ રાખવા માટે, અમે અહીં માત્ર સમર્થનના ઉચ્ચ-સ્તરના પાસાઓને આવરી લઈશું. ક્યુબર્નેટિસ, કારણ કે તે સમજવું મહત્વપૂર્ણ છે. ક્વાર્કસ કુબરનેટ્સ માટે જાવા સ્ટેક તરીકે સ્થિત છે, તે જાવા એપ્લિકેશન્સ અને સેવાઓના મેમરી વપરાશ અને સ્ટાર્ટઅપ સમયને ઘટાડવા અને પરિણામે, હોસ્ટ પર તેમની ઘનતામાં વધારો કરવા અને એકંદર ખર્ચ ઘટાડવા માટે રચાયેલ છે.

ક્વાર્કસ પણ ઓટો જનરેશનને સપોર્ટ કરે છે Kubernetes સંસાધનો અને ઑફર્સ માર્ગદર્શિકાઓ Kubernetes અને Red Hat OpenShift પ્લેટફોર્મ પર જમાવટ માટે. વધુમાં, ક્વાર્કસ કન્ટેનર બનાવવા માટે જરૂરી Dockerfile.jvm (JVM પેકેજિંગ) અને Dockerfile.native (મૂળ બાઈનરી પેકેજિંગ) ફાઈલો આપમેળે જનરેટ કરે છે.

અંતે, લક્ષ્ય જમાવટ પર્યાવરણ તરીકે કુબરનેટ્સ પર ધ્યાન કેન્દ્રિત કરીને, ક્વાર્કસ એવા કિસ્સાઓમાં જાવા ફ્રેમવર્કનો ઉપયોગ કરતું નથી કે જ્યાં કુબરનેટ્સ પ્લેટફોર્મના સ્તરે સમાન કાર્યક્ષમતા લાગુ કરવામાં આવી હોય. કોષ્ટક 1 કુબરનેટ્સ અને સ્પ્રિંગ ડેવલપર્સ દ્વારા ઉપયોગમાં લેવાતા લાક્ષણિક જાવા ફ્રેમવર્ક વચ્ચેના કાર્યાત્મક પત્રવ્યવહારનો નકશો પ્રદાન કરે છે.

કોષ્ટક 1. જાવા ફ્રેમવર્ક અને કુબરનેટ્સ વચ્ચેના કાર્યાત્મક પત્રવ્યવહારનો નકશો.

કાર્યાત્મક
પરંપરાગત વસંત બુટ
ક્યુબર્નેટિસ

સેવા શોધ
યુરેકા
DNS

રૂપરેખાંકન
વસંત મેઘ રૂપરેખા
રૂપરેખા નકશા/રહસ્યો

લોડ બેલેન્સિંગ
રિબન (ક્લાયન્ટ બાજુ)
સેવા, પ્રતિકૃતિ નિયંત્રક (સર્વર બાજુ)

ઉદાહરણમાંથી કોડનું સંકલન અને ચલાવવું

આ લેખમાં આપણે ઉલ્લેખ કરીએ છીએ ઉદાહરણ પ્રોજેક્ટ, જ્યાં સ્પ્રિંગ અને માઇક્રોપ્રોફાઇલ API અને તે જ Java વર્ગનો એકસાથે ઉપયોગ થાય છે. આ ઉદાહરણમાંનો કોડ કમાન્ડ લાઇનમાંથી કમ્પાઇલ અને રન કરી શકાય છે, વિગતો માટે README.md ફાઇલ જુઓ.

વસંત ફ્રેમવર્ક API

નિર્ભરતા ઇન્જેક્શન

ક્વાર્કસ શ્રેણીને સપોર્ટ કરે છે સંદર્ભો અને નિર્ભરતા ઇન્જેક્શન (CDI) APIs અને સ્પ્રિંગ ડિપેન્ડન્સી ઈન્જેક્શન (સ્પ્રિંગ ડીઆઈ) એપીઆઈ. જો તમે માઇક્રોપ્રોફાઇલ સાથે કામ કરી રહ્યા છો, જાવા EE અને જકાર્તા EE, તો પછી તમે પહેલેથી જ CDI થી ખૂબ પરિચિત છો. બીજી તરફ, સ્પ્રિંગ ડેવલપર્સ સ્પ્રિંગ ડીઆઈ સાથે સુસંગતતા હાંસલ કરવા માટે સ્પ્રિંગ ડીઆઈ API માટે ક્વાર્કસ એક્સ્ટેંશનનો ઉપયોગ કરી શકે છે. સપોર્ટેડ સ્પ્રિંગ DI API નો ઉપયોગ કરવાના ઉદાહરણો કોષ્ટક 2 માં આપવામાં આવ્યા છે.

В અમારા ઉદાહરણમાંથી પ્રોજેક્ટ સીડીઆઈ અને સ્પ્રિંગ ડિપેન્ડન્સી ઈન્જેક્શન બંનેનો ઉપયોગ કરે છે. આ વિષય પર વધુ માહિતી અને ઉદાહરણો માટે, કવાર્કસ માર્ગદર્શિકા જુઓ વસંત DI માર્ગદર્શિકા.

કોષ્ટક 2. સપોર્ટેડ સ્પ્રિંગ DI API નો ઉપયોગ કરવાના ઉદાહરણો.

સપોર્ટેડ સ્પ્રિંગ ડીઆઈ ફીચર્સ
ઉદાહરણો

કન્સ્ટ્રક્ટર ઇન્જેક્શન

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

ફીલ્ડ ઈન્જેક્શન
ઓટોવાયર્ડ
ભાવ

@Autowired
@RestClient
SalutationRestClient salutationRestClient;

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

બીન
@ રૂપરેખાંકન

@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;
   }
}

વેબ ફ્રેમવર્ક

માઇક્રોપ્રોફાઇલ વપરાશકર્તાઓને ગમશે કે ક્વાર્કસ પ્રાથમિક વેબ પ્રોગ્રામિંગ મોડલ તરીકે JAX-RS, માઇક્રોપ્રોફાઇલ રેસ્ટ ક્લાયંટ, JSON-P અને JSON-B ને સપોર્ટ કરે છે. સ્પ્રિંગ ડેવલપર્સ સ્પ્રિંગ વેબ API માટે ક્વાર્કસના તાજેતરના સમર્થનથી ખુશ થશે, ખાસ કરીને REST ઇન્ટરફેસમાં. સ્પ્રિંગ ડીઆઈની જેમ જ, સ્પ્રિંગ વેબ API સપોર્ટનો મુખ્ય ધ્યેય સ્પ્રિંગ ડેવલપર્સને માઇક્રોપ્રોફાઇલ API સાથે જોડાણમાં સ્પ્રિંગ વેબ API નો ઉપયોગ કરવા સક્ષમ બનાવવાનો છે. સપોર્ટેડ સ્પ્રિંગ વેબ API નો ઉપયોગ કેવી રીતે કરવો તેના ઉદાહરણો કોષ્ટક 3 માં આપવામાં આવ્યા છે, અને આ વિષય પર વધુ માહિતી અને ઉદાહરણો ક્વાર્કસ ટ્યુટોરીયલમાં મળી શકે છે. વસંત વેબ માર્ગદર્શિકા.

કોષ્ટક 3. સપોર્ટેડ સ્પ્રિંગ વેબ API નો ઉપયોગ કરવાના ઉદાહરણો.

સપોર્ટેડ સ્પ્રિંગ વેબ સુવિધાઓ
ઉદાહરણો

@RestController
@RequestMapping

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

@GetMapping
@પોસ્ટમેપિંગ
@પુટમેપિંગ
@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

માઇક્રોપ્રોફાઇલ વપરાશકર્તાઓ એ પણ પ્રશંસા કરશે કે ક્વાર્કસ હાઇબરનેટ ORM નો ઉપયોગ કરીને JPA ને સપોર્ટ કરે છે. વસંત વિકાસકર્તાઓ માટે પણ સારા સમાચાર છે: ક્વાર્કસ સામાન્ય સ્પ્રિંગ ડેટા JPA એનોટેશન અને પ્રકારોને સપોર્ટ કરે છે. સપોર્ટેડ સ્પ્રિંગ ડેટા JPA API નો ઉપયોગ કરવાના ઉદાહરણો કોષ્ટક 4 માં આપવામાં આવ્યા છે.
В અમારા ઉદાહરણમાંથી પ્રોજેક્ટ સ્પ્રિંગ ડેટા JPA API નો ઉપયોગ કરવામાં આવે છે અને ક્વાર્કસ ટ્યુટોરીયલમાં વધુ માહિતી ઉપલબ્ધ છે વસંત ડેટા JPA માર્ગદર્શિકા.

કોષ્ટક 4. સપોર્ટેડ સ્પ્રિંગ ડેટા JPA API નો ઉપયોગ કરવાના ઉદાહરણો.

સપોર્ટેડ સ્પ્રિંગ ડેટા JPA સુવિધાઓ
ઉદાહરણો

CrudRepository

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

રીપોઝીટરી
JpaRepository
પેજીંગ અને સોર્ટિંગ રીપોઝીટરી

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);
}

માઇક્રોપ્રોફાઇલ API

સહનશીલતા દોષ

કાસ્કેડિંગ નિષ્ફળતાઓને રોકવા અને વિશ્વસનીય માઇક્રોસર્વિસ આર્કિટેક્ચર્સ બનાવવા માટે ફોલ્ટ સહિષ્ણુતા રચનાઓ ખૂબ જ મહત્વપૂર્ણ છે. સ્પ્રિંગ ડેવલપર્સ ઘણા વર્ષોથી ફોલ્ટ ટોલરન્સ માટે સર્કિટ બ્રેકર્સનો ઉપયોગ કરી રહ્યા છે. હાયસ્ટ્રિક્સ. જો કે, Hystrix લાંબા સમયથી અપડેટ કરવામાં આવ્યું નથી, પરંતુ માઇક્રોપ્રોફાઇલની ફોલ્ટ ટોલરન્સ હવે સક્રિય રીતે વિકાસ કરી રહી છે અને તેની પાછળ ઘણા વર્ષોનો ઉત્પાદન ઉપયોગ છે. તેથી, ક્વાર્કસમાં સેવાઓની વિશ્વસનીયતા સુધારવા માટે, માઇક્રોપ્રોફાઇલ ફોલ્ટ ટોલરન્સ API નો ઉપયોગ કરવાની ભલામણ કરવામાં આવે છે, જેનાં ઉદાહરણો કોષ્ટક 5 માં વપરાયેલ છે. આ અંગે વધુ માહિતી માટે, ક્વાર્કસ મેન્યુઅલ જુઓ દોષ સહિષ્ણુતા માર્ગદર્શિકા.

કોષ્ટક 5. સમર્થિત માઇક્રોપ્રોફાઇલ ફોલ્ટ ટોલરન્સ API નો ઉપયોગ કરવાના ઉદાહરણો.

માઇક્રોપ્રોફાઇલ ફોલ્ટ ટોલરન્સ ફીચર્સ
વર્ણન
ઉદાહરણો

@અસિંક્રોનસ

એક અલગ થ્રેડમાં તર્કનો અમલ

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

@બલ્કહેડ

એક સાથે વિનંતીઓની સંખ્યા મર્યાદિત કરો

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

@સર્કિટબ્રેકર

સ્માર્ટ નિષ્ફળતાનું સંચાલન અને નિષ્ફળતાઓમાંથી પુનઃપ્રાપ્તિ

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

@ફોલબેક

નિષ્ફળતાના કિસ્સામાં વૈકલ્પિક તર્કને કૉલ કરવો

@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 પ્લેટફોર્મ ખાસ સેવાઓનો ઉપયોગ કરીને કન્ટેનરના સ્વાસ્થ્ય પર નજર રાખે છે. અંતર્ગત પ્લેટફોર્મને સેવાઓનું નિરીક્ષણ કરવાની મંજૂરી આપવા માટે, સ્પ્રિંગ ડેવલપર્સ સામાન્ય રીતે કસ્ટમ હેલ્થ ઈન્ડિકેટર અને સ્પ્રિંગ બૂટ એક્ટ્યુએટરનો ઉપયોગ કરે છે. ક્વાર્કસમાં, આ માઇક્રોપ્રોફાઇલ હેલ્થનો ઉપયોગ કરીને કરી શકાય છે, જે ડિફૉલ્ટ રૂપે જીવંતતા તપાસ કરે છે, પરંતુ એક સાથે જીવંતતા અને તત્પરતા તપાસવા માટે ગોઠવી શકાય છે. સપોર્ટેડ માઇક્રોપ્રોફાઇલ હેલ્થ API નો ઉપયોગ કેવી રીતે કરવો તેના ઉદાહરણો કોષ્ટક 6 માં આપવામાં આવ્યા છે, અને વધારાની માહિતી ક્વાર્કસ મેન્યુઅલમાં આપવામાં આવી છે. આરોગ્ય માર્ગદર્શન.

કોષ્ટક 6: સમર્થિત માઇક્રોપ્રોફાઇલ હેલ્થ API ના ઉપયોગના ઉદાહરણો.

માઇક્રોપ્રોફાઇલ આરોગ્ય સુવિધાઓ
વર્ણન
ઉદાહરણો

@જીવંત

પ્લેટફોર્મ રીબૂટ નિષ્ફળ કન્ટેનરાઇઝ્ડ એપ્લિકેશન્સ
અંતિમ બિંદુ:
હોસ્ટ: 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();  
}

મેટ્રિક્સ

એપ્લિકેશનો ઓપરેશનલ હેતુઓ (પ્રદર્શન SLAsનું નિરીક્ષણ કરવા માટે) અથવા બિન-ઓપરેશનલ હેતુઓ (વ્યવસાયિક SLA) માટે મેટ્રિક્સ પ્રદાન કરે છે. સ્પ્રિંગ ડેવલપર્સ સ્પ્રિંગ બૂટ એક્ટ્યુએટર અને માઇક્રોમીટરનો ઉપયોગ કરીને મેટ્રિક્સ પ્રદાન કરે છે. બદલામાં, ક્વાર્કસ બેઝલાઇન મેટ્રિક્સ (JVM અને ઓપરેટિંગ સિસ્ટમ), વેન્ડર મેટ્રિક્સ (ક્વાર્કસ) અને એપ્લિકેશન મેટ્રિક્સ પ્રદાન કરવા માટે માઇક્રોપ્રોફાઇલ મેટ્રિક્સનો ઉપયોગ કરે છે. માઇક્રોપ્રોફાઇલ મેટ્રિક્સ માટે જરૂરી છે કે અમલીકરણ JSON અને OpenMetrics (પ્રોમિથિયસ) આઉટપુટ ફોર્મેટને સપોર્ટ કરે. માઇક્રોપ્રોફાઇલ મેટ્રિક્સ API નો ઉપયોગ કરવાના ઉદાહરણો કોષ્ટક 7 માં આપવામાં આવ્યા છે.

В અમારા ઉદાહરણમાંથી પ્રોજેક્ટ માઇક્રોપ્રોફાઇલ મેટ્રિક્સનો ઉપયોગ એપ્લિકેશન મેટ્રિક્સ પ્રદાન કરવા માટે થાય છે. વધુ માહિતી માટે, ક્વાર્કસ મેન્યુઅલ જુઓ મેટ્રિક્સ માર્ગદર્શિકા.

કોષ્ટક 7. માઇક્રોપ્રોફાઇલ મેટ્રિક્સ API નો ઉપયોગ કરવાના ઉદાહરણો.

માઇક્રોપ્રોફાઇલ મેટ્રિક્સ સુવિધાઓ
વર્ણન
ઉદાહરણો

@ગણતરી

એક કાઉન્ટર કાઉન્ટર સૂચવે છે જે ટીકા કરેલ ઑબ્જેક્ટને કેટલી વખત કૉલ કરવામાં આવ્યો છે તેની ગણતરી કરે છે

@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;
}

@ગેજ

એક ગેજ સેન્સર સૂચવે છે જે ટીકા કરેલ ઑબ્જેક્ટના મૂલ્યને માપે છે

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

@મીટર

મીટર સેન્સર સૂચવે છે જે ટીકા કરેલ ઑબ્જેક્ટની કૉલ આવર્તનનું નિરીક્ષણ કરે છે

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

મેટ્રિક

જ્યારે મેટ્રિક દાખલ કરવા અથવા બનાવવાની વિનંતી પ્રાપ્ત થાય છે ત્યારે મેટાડેટા વિશેની માહિતી ધરાવતી ટીકા

@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;
}

મેટ્રિક્સ એન્ડપોઇન્ટ્સ

એપ્લિકેશન મેટ્રિક્સ લોકલહોસ્ટ:8080/મેટ્રિક્સ/એપ્લિકેશન
મૂળભૂત મેટ્રિક્સ લોકલહોસ્ટ:8080/મેટ્રિક્સ/બેઝ
વિક્રેતા મેટ્રિક્સ લોકલહોસ્ટ:8080/મેટ્રિક્સ/વેન્ડર
બધા મેટ્રિક્સ લોકલહોસ્ટ:8080/મેટ્રિક્સ

માઇક્રોપ્રોફાઇલ રેસ્ટ ક્લાયન્ટ

માઈક્રોસર્વિસ ઘણી વખત RESTful એન્ડપોઈન્ટ પ્રદાન કરે છે જેની સાથે કામ કરવા માટે અનુરૂપ ક્લાયંટ API ની જરૂર પડે છે. RESTful એન્ડપોઇન્ટનો ઉપયોગ કરવા માટે, વસંત વિકાસકર્તાઓ સામાન્ય રીતે RestTemplate નો ઉપયોગ કરે છે. ક્વાર્કસ આ સમસ્યાને ઉકેલવા માટે માઇક્રોપ્રોફાઇલ રેસ્ટ ક્લાયન્ટ API ઓફર કરે છે, જેનાં ઉપયોગનાં ઉદાહરણો કોષ્ટક 8 માં આપેલ છે.

В અમારા ઉદાહરણમાંથી પ્રોજેક્ટ RESTful એન્ડપોઇન્ટનો ઉપયોગ માઇક્રોપ્રોફાઇલ રેસ્ટ ક્લાયન્ટનો ઉપયોગ કરીને કરવામાં આવે છે. આ વિષય પર વધુ માહિતી અને ઉદાહરણો ક્વાર્કસ મેન્યુઅલમાં મળી શકે છે બાકીના ગ્રાહક માર્ગદર્શિકા.

કોષ્ટક 8. માઇક્રોપ્રોફાઇલ રેસ્ટ ક્લાયન્ટ API નો ઉપયોગ કરવાના ઉદાહરણો.

માઇક્રોપ્રોફાઇલ રેસ્ટ ક્લાયન્ટ સુવિધાઓ
વર્ણન
ઉદાહરણો

@RegisterRestClient

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

પરિણામો

આ બ્લોગમાં, મુખ્યત્વે સ્પ્રિંગ ડેવલપર્સને લક્ષ્યમાં રાખીને, અમે જાવા માઇક્રોસર્વિસિસ વિકસાવવા માટે ક્વાર્કસમાં માઇક્રોપ્રોફાઇલ API સાથે સ્પ્રિંગ API નો ઉપયોગ કેવી રીતે કરવો અને પછી તેને મૂળ દ્વિસંગી કોડમાં કમ્પાઇલ કરવું કે જે સેંકડો મેગાબાઇટ્સ RAM બચાવે છે અને તેમાં લોન્ચ થાય છે તેના પર એક ઝડપી નજર નાખી. મિલિસેકન્ડની બાબત.

જેમ તમે પહેલાથી જ સમજી ગયા છો, સ્પ્રિંગ અને માઇક્રોપ્રોફાઇલ API માટે સમર્થન વિશે વધુ માહિતી તેમજ અન્ય ઘણી ઉપયોગી માહિતી, આમાં મળી શકે છે. ક્વાર્કસ મેન્યુઅલ.

સોર્સ: www.habr.com