कसरी क्वार्कसले अत्यावश्यक र प्रतिक्रियात्मक प्रोग्रामिङलाई संयोजन गर्दछ

यस वर्ष हामी कन्टेनर विषयवस्तुहरू गम्भीरताका साथ विकास गर्ने योजना गर्छौं, क्लाउड-नेटिभ जाभा и कुबर्नेट्स। यी विषयहरूको तार्किक निरन्तरता क्वार्कस फ्रेमवर्कको बारेमा कथा हुनेछ, पहिले नै मानिन्छ Habré मा। आजको लेख "सबटोमिक सुपरफास्ट जाभा" को डिजाइनको बारेमा कम र क्वार्कसले इन्टरप्राइजमा ल्याएको प्रतिज्ञाको बारेमा बढी छ।

Java र JVM अझै पनि धेरै लोकप्रिय छन्, तर सर्भरलेस टेक्नोलोजीहरू र क्लाउड-नेटिभ माइक्रोसर्भिसेसहरूसँग काम गर्दा, जाभा र अन्य JVM भाषाहरू कम र कम प्रयोग गरिन्छ किनभने तिनीहरूले धेरै मेमोरी स्पेस लिन्छन् र लोड गर्न धेरै ढिलो हुन्छन्, तिनीहरूलाई बनाउँदै। अल्पकालीन कन्टेनरहरूसँग प्रयोगको लागि कमजोर उपयुक्त। सौभाग्यवश, यो अवस्था अब क्वार्कसलाई धन्यवाद परिवर्तन गर्न थालेको छ।

सुपरफास्ट सबटामिक जाभा नयाँ स्तरमा पुगेको छ!

४२ विमोचन, ८ महिनाको सामुदायिक कार्य र १७७ अद्भुत विकासकर्ताहरू - यी सबैको नतिजा नोभेम्बर २०१९ मा रिलीज भएको थियो क्वार्कस २, एक विज्ञप्ति जसले परियोजनाको विकासमा महत्त्वपूर्ण कोसेढुङ्गा चिन्ह लगाउँछ र धेरै उत्कृष्ट सुविधाहरू र क्षमताहरू प्रदान गर्दछ (तपाईले तिनीहरूको बारेमा थप पढ्न सक्नुहुन्छ। घोषणा).

आज हामी तपाइँलाई देखाउने छौँ कि कसरी क्वार्कसले अनिवार्य र प्रतिक्रियात्मक प्रोग्रामिङ मोडेलहरूलाई एकल प्रतिक्रियात्मक कोरमा संयोजन गर्दछ। हामी संक्षिप्त इतिहासको साथ सुरु गर्नेछौं र त्यसपछि क्वार्कस प्रतिक्रियात्मक कोर द्वैतवाद के हो र कसरी भन्ने बारे विस्तृत रूपमा जानेछौं। Java- विकासकर्ताहरूले यी सुविधाहरूको फाइदा लिन सक्छन्।

सूक्ष्म सेवाहरू, घटना संचालित वास्तुकला и serverless-कार्यहरू - यो सबै हो, तिनीहरूले भनेझैं, आज बढ्दै गएको छ। हालसालै, क्लाउड-केन्द्रित आर्किटेक्चरको सिर्जना धेरै सजिलो र अधिक पहुँचयोग्य भएको छ, तर समस्याहरू रहन्छन् - विशेष गरी जाभा विकासकर्ताहरूको लागि। उदाहरणका लागि, सर्भरलेस प्रकार्यहरू र माइक्रोसर्भिसेसहरूको अवस्थामा, स्टार्टअप समय घटाउन, मेमोरी खपत कम गर्न, र अझै पनि तिनीहरूको विकासलाई अझ सुविधाजनक र रमाइलो बनाउनको लागि तत्काल आवश्यकता छ। जाभाले हालका वर्षहरूमा धेरै सुधारहरू गरेको छ, जस्तै कन्टेनरहरूको लागि सुधारिएको एर्गोनोमिक्स कार्यक्षमता र यस्तै। यद्यपि, जाभालाई कन्टेनरमा राम्ररी काम गर्न पाउनु अझै चुनौतीपूर्ण छ। त्यसोभए हामी जाभाका केही अंतर्निहित जटिलताहरू हेरेर सुरु गर्नेछौं, जुन कन्टेनर-उन्मुख जाभा अनुप्रयोगहरू विकास गर्दा विशेष गरी तीव्र हुन्छ।

पहिले, इतिहास हेरौं।

धाराहरू र कन्टेनरहरू

संस्करण 8u131 बाट सुरु गर्दै, एर्गोनोमिक्स कार्यक्षमतामा सुधारको कारण जाभाले कम वा कम कन्टेनरहरूलाई समर्थन गर्न थाल्यो। विशेष गरी, JVM ले अब कति प्रोसेसर कोर चलिरहेको छ भन्ने थाहा छ र थ्रेड पूलहरू कन्फिगर गर्न सक्छ - सामान्यतया फोर्क/जोइन पूलहरू - तदनुसार। निस्सन्देह, यो राम्रो छ, तर मानौं हामीसँग परम्परागत वेब अनुप्रयोग छ जसले HTTP सर्लेटहरू प्रयोग गर्दछ र Tomcat, Jetty, आदिमा चल्छ। नतिजाको रूपमा, यो अनुप्रयोगले प्रत्येक अनुरोधलाई छुट्टै थ्रेड दिनेछ र I/O अपरेसनहरूको लागि पर्खँदै गर्दा, उदाहरणका लागि, डाटाबेस, फाइलहरू वा अन्य सेवाहरू पहुँच गर्दा यो थ्रेडलाई रोक्न अनुमति दिनेछ। त्यो हो, यस्तो अनुप्रयोगको आकार उपलब्ध कोरहरूको संख्यामा निर्भर गर्दैन, तर एकसाथ अनुरोधहरूको संख्यामा। थप रूपमा, यसको मतलब यो हो कि कुबर्नेट्समा कोरहरूको संख्यामा कोटा वा सीमाहरू यहाँ धेरै सहयोगी हुनेछैन, र यो कुरा अन्ततः थ्रोटलिङमा समाप्त हुनेछ।

मेमोरी थकान

थ्रेडहरू मेमोरी हुन्। र इन्ट्रा-कन्टेनर मेमोरी सीमितता कुनै पनि हिसाबले रामबाण होइन। केवल एप्लिकेसन र थ्रेडहरूको संख्या बढाउन सुरु गर्नुहोस्, र ढिलो वा पछि तपाईंले स्विचिङ फ्रिक्वेन्सीमा महत्त्वपूर्ण वृद्धिको सामना गर्नुहुनेछ र परिणाम स्वरूप, कार्यसम्पादनमा गिरावट आउनेछ। साथै, यदि तपाइँको एप्लिकेसनले परम्परागत माइक्रोसर्भिस फ्रेमवर्क प्रयोग गर्दछ, वा डाटाबेसमा जडान गर्दछ, वा क्यासिंग प्रयोग गर्दछ, वा अन्यथा मेमोरी प्रयोग गर्दछ, तपाइँलाई स्पष्ट रूपमा एउटा उपकरण चाहिन्छ जसले तपाइँलाई JVM भित्र हेर्नको लागि अनुमति दिन्छ र यसलाई कसरी नष्ट नगरी मेमोरी व्यवस्थापन गर्दछ। JVM आफैं (उदाहरणका लागि, XX:+UseCGroupMemoryLimitForHeap)। र यद्यपि, Java 9 देखि, JVM ले cgroups लाई स्वीकार गर्न र तदनुसार अनुकूलन गर्न सिकेको छ, मेमोरी रिजर्भ र प्रबन्धन एक जटिल विषय बनेको छ।

कोटा र सीमाहरू

Java 11 ले CPU कोटाहरूको लागि समर्थन पेश गर्‍यो (जस्तै PreferContainerQuotaForCPUCount)। Kubernetes ले सीमा र कोटाहरूको लागि समर्थन पनि प्रदान गर्दछ। हो, यो सबै अर्थपूर्ण छ, तर यदि एप्लिकेसनले पुन: आवंटित कोटा नाघ्यो भने, हामी फेरि आकारको साथ समाप्त हुन्छौं - जस्तै परम्परागत जाभा अनुप्रयोगहरूको मामलामा - कोरहरूको संख्या र प्रत्येकको लागि छुट्टै थ्रेडको आवंटनको साथ निर्धारण गरिन्छ। अनुरोध गर्नुहोस्, तब यी सबैमा थोरै अर्थ छ।
थप रूपमा, यदि तपाईंले कोटा र सीमाहरू वा Kubernetes अन्तर्निहित प्लेटफर्मको स्केल-आउट प्रकार्यहरू प्रयोग गर्नुहुन्छ भने, समस्याले पनि समाधान गर्दैन। हामी केवल मूल समस्या समाधान गर्न वा अधिक खर्च समाप्त गर्न थप स्रोतहरू खर्च गर्छौं। र यदि यो सार्वजनिक सार्वजनिक क्लाउडमा उच्च-लोड प्रणाली हो भने, हामी लगभग निश्चित रूपमा हामीलाई आवश्यक भन्दा बढी स्रोतहरू प्रयोग गरेर अन्त्य गर्छौं।

र यो सबै संग के गर्ने?

यसलाई सरल रूपमा भन्नको लागि, एसिन्क्रोनस र गैर-ब्लकिङ I/O पुस्तकालयहरू र फ्रेमवर्कहरू प्रयोग गर्नुहोस् जस्तै Netty, Vert.x वा अक्का। तिनीहरूको प्रतिक्रियाशील प्रकृतिको कारण तिनीहरू कन्टेनरहरूमा काम गर्न धेरै उपयुक्त छन्। I/O लाई अवरुद्ध नगरेकोमा धन्यवाद, एउटै थ्रेडले एकै पटक धेरै अनुरोधहरू प्रशोधन गर्न सक्छ। जब एउटा अनुरोध I/O परिणामहरूको लागि पर्खिरहेको छ, थ्रेड प्रशोधन यो जारी गरिएको छ र अर्को अनुरोध द्वारा लिइन्छ। र जब I/O परिणामहरू अन्तमा आइपुग्छन्, पहिलो अनुरोधको प्रक्रिया जारी रहन्छ। एउटै थ्रेड भित्र अनुरोधहरूको इन्टरलिभ गरिएको प्रशोधन गरेर, तपाईंले थ्रेडहरूको कुल संख्या घटाउन र अनुरोधहरू प्रशोधनका लागि स्रोत खपत कम गर्न सक्नुहुन्छ।

गैर-ब्लक I/O संग, कोर को संख्या एक प्रमुख प्यारामिटर बन्छ किनभने यसले I/O थ्रेडहरूको संख्या निर्धारण गर्दछ जुन समानान्तरमा कार्यान्वयन गर्न सकिन्छ। सही रूपमा प्रयोग गर्दा, यसले तपाईंलाई प्रभावकारी रूपमा कोरहरू बीच लोड वितरण गर्न र कम स्रोतहरूसँग उच्च कार्यभारहरू ह्यान्डल गर्न अनुमति दिन्छ।

कसरी, यो सबै?

होइन, अरू केही छ। प्रतिक्रियाशील प्रोग्रामिंगले स्रोतहरूको राम्रो प्रयोग गर्न मद्दत गर्दछ, तर मूल्यमा पनि आउँछ। विशेष गरी, कोडलाई गैर-ब्लक गर्ने सिद्धान्तहरू अनुसार पुन: लेख्नुपर्नेछ र I/O थ्रेडहरू रोक्नबाट जोगिनु पर्छ। र यो विकास र कार्यान्वयनको पूर्णतया फरक मोडेल हो। र यद्यपि यहाँ धेरै उपयोगी पुस्तकालयहरू छन्, यो अझै पनि सोच्ने सामान्य तरिकामा आमूल परिवर्तन हो।

पहिले, तपाईंले एसिन्क्रोनस रूपमा चल्ने कोड कसरी लेख्ने भनेर सिक्नु आवश्यक छ। एकचोटि तपाईंले गैर-ब्लकिङ I/O प्रयोग गर्न थाल्नुभयो भने, तपाईंले अनुरोधको प्रतिक्रिया प्राप्त गर्दा के हुन्छ भनेर स्पष्ट रूपमा निर्दिष्ट गर्न आवश्यक छ। केवल अवरुद्ध र पर्खाइले काम गर्दैन। यसको सट्टा, तपाइँ कलब्याकहरू पास गर्न सक्नुहुन्छ, प्रतिक्रियात्मक प्रोग्रामिङ वा निरन्तरता प्रयोग गर्नुहोस्। तर यो सबै होइन: नन-ब्लकिङ I/O प्रयोग गर्न, तपाईंलाई दुबै गैर-ब्लकिङ सर्भरहरू र क्लाइन्टहरू चाहिन्छ, प्राथमिकता सबै ठाउँमा। HTTP को मामला मा, सबै कुरा सरल छ, तर त्यहाँ डाटाबेस, फाइल प्रणाली, र अधिक पनि छन्।

र यद्यपि कुल अन्त-देखि-अन्त प्रतिक्रियाशीलताले दक्षतालाई अधिकतम बनाउँछ, यस्तो परिवर्तन व्यवहारमा पेट गर्न गाह्रो हुन सक्छ। तसर्थ, प्रतिक्रियात्मक र अनिवार्य कोड संयोजन गर्ने क्षमता एक पूर्व शर्त बन्छ:

1. प्रभावकारी रूपमा सफ्टवेयर प्रणालीको सबैभन्दा लोड क्षेत्रहरूमा स्रोतहरू प्रयोग गर्नुहोस्;
2. यसको बाँकी भागहरूमा सरल शैली कोड प्रयोग गर्नुहोस्।

क्वार्कस प्रस्तुत गर्दै

वास्तवमा, यो क्वार्कसको सार हो - एकल रनटाइम वातावरण भित्र प्रतिक्रियाशील र अनिवार्य मोडेलहरू संयोजन गर्न।

Quarkus Vert.x र Netty मा आधारित छ, विकासकर्तालाई मद्दत गर्नको लागि शीर्षमा प्रतिक्रियाशील फ्रेमवर्क र विस्तारहरूको दायराको साथ। क्वार्कस एचटीटीपी माइक्रोसर्भिसेसहरू मात्र होइन घटना-संचालित आर्किटेक्चरहरू निर्माण गर्न डिजाइन गरिएको हो। यसको प्रतिक्रियात्मक प्रकृतिको कारणले, यसले सन्देश प्रणालीहरू (Apache Kafka, AMQP, आदि) सँग धेरै प्रभावकारी रूपमा काम गर्दछ।

चाल भनेको आवश्यक र प्रतिक्रियात्मक कोड दुवैको लागि समान प्रतिक्रियात्मक इन्जिन कसरी प्रयोग गर्ने हो।

क्वार्कसले यो राम्रोसँग गर्छ। अनिवार्य र प्रतिक्रियात्मक बीचको छनौट स्पष्ट छ - दुबैको लागि प्रतिक्रियात्मक कर्नेल प्रयोग गर्नुहोस्। यसले वास्तवमा के मद्दत गर्दछ छिटो, गैर-ब्लकिङ कोड जसले घटना-लूप थ्रेड, उर्फ ​​​​IO थ्रेड मार्फत जाने लगभग सबै चीजहरू ह्यान्डल गर्दछ। तर यदि तपाईंसँग क्लासिक REST वा क्लाइन्ट-साइड अनुप्रयोगहरू छन् भने, क्वार्कससँग आवश्यक प्रोग्रामिङ मोडेल तयार छ। उदाहरणका लागि, क्वार्कसमा HTTP समर्थन गैर-ब्लकिङ र प्रतिक्रियाशील इन्जिन (Eclipse Vert.x र Netty) को प्रयोगमा आधारित छ। तपाइँको आवेदन द्वारा प्राप्त सबै HTTP अनुरोधहरू पहिले घटना लुप (IO थ्रेड) मार्फत पास गरिन्छ र त्यसपछि अनुरोधहरू व्यवस्थापन गर्ने कोडको भागमा पठाइन्छ। गन्तव्यमा निर्भर गर्दै, अनुरोध व्यवस्थापन कोडलाई छुट्टै थ्रेड भित्र कल गर्न सकिन्छ (तथाकथित कार्यकर्ता थ्रेड, सर्लेट्स र ज्याक्स-आरएसको मामलामा प्रयोग गरिन्छ) वा स्रोत I/O थ्रेड (प्रतिक्रियात्मक मार्ग) प्रयोग गर्नुहोस्।

सन्देश प्रणाली जडानकर्ताहरूले Vert.x इन्जिनको शीर्षमा चलिरहेको गैर-ब्लकिङ क्लाइन्टहरू प्रयोग गर्छन्। तसर्थ, तपाईं प्रभावकारी रूपमा मेसेजिङ मिडलवेयर प्रणालीहरूबाट सन्देशहरू पठाउन, प्राप्त गर्न र प्रक्रिया गर्न सक्नुहुन्छ।

साइटमा Quarkus.io यहाँ केही राम्रा ट्यूटोरियलहरू छन् जसले तपाईंलाई क्वार्कसको साथ सुरू गर्न मद्दत गर्दछ:

• प्रतिक्रियात्मक मार्गहरू प्रयोग गर्दै
• प्रतिक्रियाशील SQL क्लाइन्टहरू
• प्रतिक्रियात्मक सन्देशको साथ Apache Kafka प्रयोग गर्दै
• प्रतिक्रियात्मक सन्देशको साथ AMQP प्रयोग गर्दै
• Vertx API प्रयोग गर्दै

हामीले तपाइँलाई केवल ब्राउजरमा प्रतिक्रियाशील प्रोग्रामिङका विभिन्न पक्षहरू सिकाउनको लागि अनलाइन ह्यान्ड्स-अन ट्यूटोरियलहरू पनि सिर्जना गरेका छौं, कुनै IDE आवश्यक छैन, र कुनै कम्प्युटर आवश्यक छैन। तपाईंले यी पाठहरू फेला पार्न सक्नुहुन्छ यहाँ.

उपयोगी स्रोतहरू

• क्वार्कस प्रयास गर्ने 4 कारणहरू
• क्वार्कस परियोजना वेबसाइट - quarkus.io
• GitHub मा क्वार्कस परियोजना - github.com/quarkusio/quarkus
• क्वार्कस परियोजना ट्विटर - twitter.com/QuarkusIO
• क्वार्कस परियोजना कुराकानी - quarkusio.zulipchat.com
• क्वार्कस परियोजना फोरम - group.google.com/forum/#!forum/quarkus-dev

विषयसँग परिचित हुन क्वार्कसमा १० भिडियो पाठहरू

जसरी तिनीहरू वेबसाइटमा भन्छन् Quarkus.io, क्वार्कस - यो कुबर्नेट्स-उन्मुख जाभा स्ट्याक, GraalVM र OpenJDK HotSpot को लागि अनुकूल र उत्तम जाभा पुस्तकालयहरू र मापदण्डहरूबाट भेला गरिएको।

तपाइँलाई विषय बुझ्न मद्दतको लागि, हामीले क्वार्कसका विभिन्न पक्षहरू र यसको प्रयोगका उदाहरणहरू समेट्ने १० भिडियो ट्युटोरियलहरू चयन गरेका छौं:

1. Quarkus को परिचय दिँदै: Kubernetes को लागि अर्को पुस्ताको जाभा फ्रेमवर्क

थॉमस क्वार्नस्ट्रम र जेसन ग्रीन द्वारा
Quarkus परियोजनाको लक्ष्य Kubernetes र सर्भरलेस वातावरणको लागि जाभा प्लेटफर्म सिर्जना गर्नु हो, र प्रतिक्रियाशील र अनिवार्य प्रोग्रामिङ मोडेलहरूलाई एकल रनटाइम वातावरणमा संयोजन गर्नु हो ताकि विकासकर्ताहरूले वितरित अनुप्रयोग आर्किटेक्चरहरूको विस्तृत दायरासँग काम गर्दा लचिलो रूपमा आफ्नो दृष्टिकोण फरक गर्न सकून्। तलको परिचयात्मक व्याख्यानमा थप जान्नुहोस्।

2. क्वार्कस: सुपरफास्ट सबटोमिक जाभा

द्वारा: Burr Sutter
DevNation Live को यो भिडियो ट्यूटोरियलले Quarkus को उपयोग गर्न कसरी इन्टरप्राइज Java अनुप्रयोगहरू, APIs, microservices, र सर्भरलेस प्रकार्यहरूलाई Kubernetes/OpenShift वातावरणमा अप्टिमाइज गर्ने भनेर देखाउँछ, तिनीहरूलाई धेरै सानो, छिटो, र थप मापनयोग्य बनाउँछ।

3. क्वार्कस र GraalVM: हाइबरनेटलाई सुपर स्पीडमा बढाउँदै र यसलाई सबटॉमिक साइजमा संकुचित गर्दै

लेखक: Sanne Grinovero
प्रस्तुतिबाट तपाईंले क्वार्कस कसरी बन्यो, यसले कसरी काम गर्छ, र यसले तपाईंलाई जटिल पुस्तकालयहरू जस्तै हाइबरनेट ORM, नेटिभ GraalVM छविहरूसँग मिल्दो बनाउन कसरी अनुमति दिन्छ भन्ने कुरा सिक्नुहुनेछ।

4. सर्भररहित अनुप्रयोगहरू विकास गर्न सिक्नुहोस्

लेखक: मार्टिन लुथर
तलको भिडियोले Quarkus प्रयोग गरेर सरल Java अनुप्रयोग कसरी सिर्जना गर्ने र यसलाई Knative मा सर्भरलेस अनुप्रयोगको रूपमा प्रयोग गर्ने देखाउँछ।

5. क्वार्कस: रमाइलो कोडिङ गर्नुहोस्

लेखक: एडसन यानागा
क्वार्कसले विकासकर्ताहरूको मन किन जित्दैछ भन्ने कुरा बुझ्नको लागि तपाईँको पहिलो क्वार्कस परियोजना सिर्जना गर्ने भिडियो गाइड।

6. जाभा र कन्टेनरहरू - तिनीहरूको भविष्य सँगै के हुनेछ

मार्क लिटिल द्वारा पोस्ट गरिएको
यो प्रस्तुतिले जाभाको इतिहास परिचय गराउँछ र क्वार्कस किन जाभाको भविष्य हो भनी बताउँछ।

7. क्वार्कस: सुपरफास्ट सबटोमिक जाभा

लेखक: Dimitris Andreadis
क्वार्कसका फाइदाहरूको एक सिंहावलोकन जसले विकासकर्ताहरूबाट मान्यता प्राप्त गरेको छ: सरलता, अति-उच्च गति, उत्कृष्ट पुस्तकालयहरू र मानकहरू।

8. क्वार्कस र सबएटोमिक रकेट प्रणाली

लेखक: क्लेमेन्ट एस्कोफियर
GraalVM सँग एकीकरणको माध्यमबाट, क्वार्कसले अति-छिटो विकास अनुभव र एक उप-परमाणविक रनटाइम वातावरण प्रदान गर्दछ। लेखक क्वार्कसको प्रतिक्रियात्मक पक्ष र प्रतिक्रियात्मक र स्ट्रिमिङ अनुप्रयोगहरू निर्माण गर्न कसरी प्रयोग गर्ने बारे कुरा गर्छ।

9. एक्लिप्स माइक्रोप्रोफाइलमा क्वार्कस र द्रुत अनुप्रयोग विकास

लेखक: जोन क्लिंगन
Eclipse MicroProfile र Quarkus को संयोजन गरेर, विकासकर्ताहरूले पूर्ण-विशेष कन्टेनराइज्ड माइक्रोप्रोफाइल अनुप्रयोगहरू सिर्जना गर्न सक्छन् जुन दसौं मिलिसेकेन्डमा सुरु हुन्छ। भिडियोले Kubernetes प्लेटफर्ममा डिप्लोयमेन्टको लागि कन्टेनराइज्ड माइक्रोप्रोफाइल एप्लिकेसन कसरी कोड गर्ने भन्ने बारे विस्तृत रूपमा जान्छ।

10. Java, "Turbo" संस्करण

लेखक: मार्कस बिएल
लेखकले सुपर-सानो, सुपर-फास्ट जाभा कन्टेनरहरू सिर्जना गर्न क्वार्कस कसरी प्रयोग गर्ने भनेर देखाउँदछ जसले वास्तविक सफलताहरू सक्षम गर्दछ, विशेष गरी सर्भररहित वातावरणमा।

स्रोत: www.habr.com