क्वार्कस, कोटलिन और ग्रैडल पर एक माइक्रो सर्विस बनाना

परिचय

पिछले लेख में, हमने संक्षेप में आधुनिक JVM चौखटे पर एक microservice बनाने की प्रक्रिया का वर्णन किया, साथ ही साथ उनकी तुलना भी की। इस आलेख में हाल ही में जारी किए गए क्वार्कस में उल्लेखित प्रौद्योगिकियों का उपयोग करके एक माइक्रोसेवा बनाने और मुख्य लेख में निर्दिष्ट आवश्यकताओं के अनुसार विस्तार से चर्चा की जाएगी। परिणामी एप्लिकेशन निम्नलिखित माइक्रोसर्विस आर्किटेक्चर का हिस्सा बन जाएगा:

परियोजना का स्रोत कोड, हमेशा की तरह, GitHub पर उपलब्ध है ।

एक परियोजना के साथ काम शुरू करने से पहले, निम्नलिखित स्थापित किया जाना चाहिए:

• Jdk 13
• कौंसल

एक नया प्रोजेक्ट बनाएं

एक नया प्रोजेक्ट बनाने के लिए, वेब स्टार्टर या मावेन का उपयोग करें ( मावेन प्रोजेक्ट या ग्रैडल प्रोजेक्ट बनाने के लिए)। यह ध्यान देने योग्य है कि रूपरेखा जावा, कोटलिन और स्काला भाषाओं का समर्थन करती है।

zavismosti

इस परियोजना में, ग्रैडल कोटलिन डीएसएल का निर्माण प्रणाली के रूप में किया जाता है। बिल्ड स्क्रिप्ट में होना चाहिए:

• प्लग-इन
  लिस्टिंग 1. build.gradle.kts

  
  

  plugins { kotlin("jvm") kotlin("plugin.allopen") id("io.quarkus") } 

  
  

  प्लगइन संस्करण संकल्प settings.gradle.kts में किया जाता है।

  
  

• पर निर्भर करता है
  लिस्टिंग 2. build.gradle.kts

  
  

   dependencies { ... implementation(enforcedPlatform("io.quarkus:quarkus-bom:$quarkusVersion")) implementation("io.quarkus:quarkus-resteasy-jackson") implementation("io.quarkus:quarkus-rest-client") implementation("io.quarkus:quarkus-kotlin") implementation("io.quarkus:quarkus-config-yaml") testImplementation("io.quarkus:quarkus-junit5") ... } 

  
  

  Maven BOM के आयात की जानकारी ग्रैडल प्रलेखन में उपलब्ध है।

  
  

आपको कुछ कोटलिन कक्षाएं open की भी आवश्यकता है (वे डिफ़ॉल्ट रूप से final हैं, क्वार्कस क्लैमलिन में ग्रेड को कॉन्फ़िगर करने के बारे में अधिक जानकारी:

लिस्टिंग 3. build.gradle.kts

 allOpen { annotation("javax.enterprise.context.ApplicationScoped") } 

का विन्यास

फ्रेमवर्क संपत्तियों और YAML फ़ाइलों का उपयोग करके कॉन्फ़िगरेशन का समर्थन करता है
( क्वार्कस कॉन्फिग गाइड में अधिक)। कॉन्फ़िगरेशन फ़ाइल resources फ़ोल्डर में स्थित है और इस तरह दिखता है:

लिस्टिंग 4. application.yaml

 quarkus: http: host: localhost port: 8084 application-info: name: quarkus-service framework: name: Quarkus release-year: 2019 

इस कोड के टुकड़े में, microservice के मानक और कस्टम पैरामीटर कॉन्फ़िगर किए गए हैं। उत्तरार्द्ध को इस तरह पढ़ा जा सकता है:

लिस्टिंग 5. रीडिंग कस्टम एप्लिकेशन पैरामीटर ( स्रोत कोड )

 import io.quarkus.arc.config.ConfigProperties @ConfigProperties(prefix = "application-info") class ApplicationInfoProperties { lateinit var name: String lateinit var framework: FrameworkConfiguration class FrameworkConfiguration { lateinit var name: String lateinit var releaseYear: String } } 

बीना

इससे पहले कि आप कोड के साथ काम करना शुरू करें, यह ध्यान दिया जाना चाहिए कि क्वार्कस एप्लिकेशन के स्रोत कोड में कोई मुख्य विधि नहीं है (हालांकि यह प्रकट हो सकता है)।

पिछले लिस्टिंग से @ConfigProperties बीन को दूसरी बीन में @Inject करना @Inject एनोटेशन का उपयोग करके किया जाता है:

लिस्टिंग 6. @ConfigProperties बीन ( स्रोत ) को लागू करना

 @ApplicationScoped class ApplicationInfoService( @Inject private val applicationInfoProperties: ApplicationInfoProperties, @Inject private val serviceClient: ServiceClient ) { ... } 

ApplicationInfoService बीन द्वारा @ApplicationScoped , बदले में, निम्नानुसार लागू किया जाता है:

लिस्टिंग 7. @ApplicationScoped को @ApplicationScoped बीन ( स्रोत )

 class ApplicationInfoResource( @Inject private val applicationInfoService: ApplicationInfoService ) 

क्वार्कस सीडीआई गाइड में कॉनटेक्स और डिपेंडेंसी इंजेक्शन पर अधिक जानकारी।

अन्य नियंत्रक

स्प्रिंग फ्रेमवर्क या जावा EE के साथ काम करने वालों के लिए REST कंट्रोलर में कुछ भी असामान्य नहीं है:

लिस्टिंग 8. बाकी नियंत्रक ( स्रोत )

 @Path("/application-info") @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) class ApplicationInfoResource( @Inject private val applicationInfoService: ApplicationInfoService ) { @GET fun get(@QueryParam("request-to") requestTo: String?): Response = Response.ok(applicationInfoService.get(requestTo)).build() @GET @Path("/logo") @Produces("image/png") fun logo(): Response = Response.ok(applicationInfoService.getLogo()).build() } 

अन्य ग्राहक

क्वार्कस माइक्रोसवर्क आर्किटेक्चर में काम करने के लिए, एक सेवा को अन्य सेवाओं के लिए अनुरोधों को पूरा करने में सक्षम होना चाहिए। चूंकि सभी सेवाओं में समान एपीआई है, इसलिए यह कॉमन कोड के लिए एक एकल इंटरफ़ेस बनाने के लिए समझ में आता है और आरईएसटी ग्राहकों का एक समूह इसे विरासत में देता है:

लिस्टिंग 9. अन्य ग्राहकों ( स्रोत कोड )

 @ApplicationScoped @Path("/") interface ExternalServiceClient { @GET @Path("/application-info") @Produces("application/json") fun getApplicationInfo(): ApplicationInfo } @RegisterRestClient(baseUri = "http://helidon-service") interface HelidonServiceClient : ExternalServiceClient @RegisterRestClient(baseUri = "http://ktor-service") interface KtorServiceClient : ExternalServiceClient @RegisterRestClient(baseUri = "http://micronaut-service") interface MicronautServiceClient : ExternalServiceClient @RegisterRestClient(baseUri = "http://quarkus-service") interface QuarkusServiceClient : ExternalServiceClient @RegisterRestClient(baseUri = "http://spring-boot-service") interface SpringBootServiceClient : ExternalServiceClient 

जैसा कि आप देख सकते हैं, अन्य सेवाओं के लिए एक REST क्लाइंट बनाना, संबंधित JAX-RS और MicroProfile के साथ एक इंटरफ़ेस बनाना है।

सेवा खोज

जैसा कि आपने पिछले अनुभाग में देखा था, baseUri पैरामीटर baseUri सेवाओं के नाम हैं। लेकिन अब तक, क्वार्कस के पास सेवा डिस्कवरी ( यूरेका ) के लिए अंतर्निहित समर्थन नहीं है या यह काम नहीं करता है ( कंसल ), क्योंकि रूपरेखा मुख्य रूप से क्लाउड वातावरण में काम करने के उद्देश्य से है। इसलिए, सेवा डिस्कवरी पैटर्न जावा लाइब्रेरी के लिए कौंसल क्लाइंट का उपयोग करके लागू किया जाता है।

कौंसल के लिए क्लाइंट में दो विधियाँ शामिल हैं, register और getServiceInstance (राउंड-रॉबिन एल्गोरिथ्म का उपयोग करके):

लिस्टिंग 10. ग्राहक को कौंसल ( स्रोत )

 @ApplicationScoped class ConsulClient( @ConfigProperty(name = "application-info.name") private val serviceName: String, @ConfigProperty(name = "quarkus.http.port") private val port: Int ) { private val consulUrl = "http://localhost:8500" private val consulClient by lazy { Consul.builder().withUrl(consulUrl).build() } private var serviceInstanceIndex: Int = 0 fun register() { consulClient.agentClient().register(createConsulRegistration()) } fun getServiceInstance(serviceName: String): Service { val serviceInstances = consulClient.healthClient().getHealthyServiceInstances(serviceName).response val selectedInstance = serviceInstances[serviceInstanceIndex] serviceInstanceIndex = (serviceInstanceIndex + 1) % serviceInstances.size return selectedInstance.service } private fun createConsulRegistration() = ImmutableRegistration.builder() .id("$serviceName-$port") .name(serviceName) .address("localhost") .port(port) .build() } 

सबसे पहले आपको आवेदन पंजीकृत करने की आवश्यकता है:

लिस्टिंग 11. कंसल ( स्रोत ) के साथ पंजीकरण

 @ApplicationScoped class ConsulRegistrationBean( @Inject private val consulClient: ConsulClient ) { fun onStart(@Observes event: StartupEvent) { consulClient.register() } } 

अगला, आपको सेवाओं के नाम को वास्तविक स्थान पर बदलने की आवश्यकता है। ऐसा करने के लिए, एक वर्ग का उपयोग करें जो @Provider और एनोटेट @Provider विस्तार करता है:

लिस्टिंग 12. सेवा डिस्कवरी ( स्रोत ) के साथ काम करने के लिए फ़िल्टर

 @Provider @ApplicationScoped class ConsulFilter( @Inject private val consulClient: ConsulClient ) : ClientRequestFilter { override fun filter(requestContext: ClientRequestContext) { val serviceName = requestContext.uri.host val serviceInstance = consulClient.getServiceInstance(serviceName) val newUri: URI = URIBuilder(URI.create(requestContext.uri.toString())) .setHost(serviceInstance.address) .setPort(serviceInstance.port) .build() requestContext.uri = newUri } } 

फ़िल्टर केवल requestContext के URI को क्लाइंट से कॉन्सुल में प्राप्त सेवा स्थान के साथ बदल देता है।

परीक्षण

REST एश्योर्ड लाइब्रेरी का उपयोग करके दो API विधियों के टेस्ट लागू किए जाते हैं:

लिस्टिंग 13. टेस्ट ( स्रोत )

 @QuarkusTest class QuarkusServiceApplicationTest { @Test fun testGet() { given() .`when`().get("/application-info") .then() .statusCode(200) .contentType(ContentType.JSON) .body("name") { `is`("quarkus-service") } .body("framework.name") { `is`("Quarkus") } .body("framework.releaseYear") { `is`(2019) } } @Test fun testGetLogo() { given() .`when`().get("/application-info/logo") .then() .statusCode(200) .contentType("image/png") .body(`is`(notNullValue())) } } 

परीक्षण के दौरान, कॉन्सल के साथ आवेदन को पंजीकृत करने की आवश्यकता नहीं है, इसलिए, परीक्षण के बगल में प्रोजेक्ट के स्रोत कोड में, ConsulClientMock , जो ConsulClient विस्तार ConsulClient :

लिस्टिंग 14. ConsulClient लिए नकली ( स्रोत )

 @Mock @ApplicationScoped class ConsulClientMock : ConsulClient("", 0) { // do nothing override fun register() { } } 

सभा

quarkusBuild build कार्य के दौरान, quarkusBuild कार्य quarkusBuild । डिफ़ॉल्ट रूप से, यह एक रनर JAR और एक lib फ़ोल्डर बनाता है जहाँ निर्भरताएँ स्थित होती हैं। Uber-JAR बनाने के लिए, quarkusBuild कार्य को निम्नानुसार कॉन्फ़िगर किया quarkusBuild चाहिए:

लिस्टिंग 15. uber-JAR पीढ़ी ( स्रोत ) कॉन्फ़िगर करना

 tasks { withType<QuarkusBuild> { isUberJar = true } } 

बनाने के लिए, चलाएँ ./gradlew clean build प्रोजेक्ट के मूल में ./gradlew clean build ।

लांच

Microservice शुरू करने से पहले, आपको Consul ( मुख्य लेख में वर्णित) शुरू करना होगा।

Microservice का उपयोग कर शुरू किया जा सकता है:

• quarkusDev कार्य
  परियोजना की जड़ में चलाएँ:
  ./gradlew :quarkus-service:quarkusDev
  या IDE में कार्य चलाएँ
• uber-जार
  परियोजना की जड़ में चलाएँ:
  java -jar quarkus-service/build/quarkus-service-1.0.0-runner.jar

अब आप REST API का उपयोग कर सकते हैं, उदाहरण के लिए, निम्नलिखित क्वेरी चलाएँ:

GET http://localhost:8084/application-info

परिणाम होगा:

लिस्टिंग 16. एपीआई कॉल का परिणाम

 { "name": "quarkus-service", "framework": { "name": "Quarkus", "releaseYear": 2019 }, "requestedService": null } 

वसंत की अनुकूलता

DI वसंत, वेब , सुरक्षा , डेटा JPA : फ्रेमवर्क कई स्प्रिंग तकनीकों के साथ संगतता प्रदान करता है।

निष्कर्ष

लेख ने कोटलिन और ग्रैडल का उपयोग करके क्वार्कस पर एक सरल आरईएसटी सेवा बनाने के एक उदाहरण की जांच की। मुख्य लेख में, आप देख सकते हैं कि परिणामी एप्लिकेशन में अन्य आधुनिक जेवीएम फ्रेमवर्क पर अनुप्रयोगों के साथ तुलनीय पैरामीटर हैं। इस प्रकार, क्वार्कस के पास गंभीर प्रतियोगी हैं जैसे कि हेलिडॉन माइक्रोप्रोफाइल, माइक्रोन्यूट और स्प्रिंग बूट (यदि हम फुलस्टैक फ्रेमवर्क के बारे में बात कर रहे हैं)। इसलिए, मुझे लगता है कि हम घटनाओं के एक दिलचस्प विकास की प्रतीक्षा कर रहे हैं जो पूरे जावा पारिस्थितिकी तंत्र के लिए उपयोगी होगा।

उपयोगी लिंक

• क्वार्कस - आरंभ करें
• क्वार्कस - आपका पहला आवेदन बनाना
• स्प्रिंग डेवलपर्स के लिए क्वार्कस

PS लेख तैयार करने में मदद के लिए धन्यवाद vladimirsitnikov ।