क्वार्कस का परिचय: क्यों जावा डेवलपर्स सुपरसोनिक जावा की ओर बढ़ रहे हैं

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

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

जब ट्रैफ़िक में बढ़ोतरी के जवाब में एक माइक्रोसर्विस को शून्य से 100 प्रतिकृतियों तक क्षैतिज रूप से स्केल करने की आवश्यकता होती है, या जब सर्वर रहित फ़ंक्शन मांग पर निष्पादित होता है, तो जावा प्रक्रिया को बूट करने के लिए 3 से 10 सेकंड तक प्रतीक्षा करना अस्वीकार्य है। आधुनिक क्लाउड इंफ्रास्ट्रक्चर तत्काल स्टार्टअप और हल्की मेमोरी खपत की मांग करता है - पारंपरिक रूप से गो, रस्ट या नोड.जेएस जैसी भाषाओं के लिए आरक्षित विशेषताएँ।

क्वार्कस दर्ज करें: एक कुबेरनेट्स-मूल जावा फ्रेमवर्क जो विशेष रूप से GraalVM और OpenJDK हॉटस्पॉट के लिए डिज़ाइन किया गया है। अक्सर “सुपरसोनिक सबटॉमिक जावा” करार दिया गया, क्वार्कस मूल रूप से जावा अनुप्रयोगों को संकलित करने, बूट करने और चलाने के तरीके को फिर से इंजीनियर करता है।

इस गहन गाइड में, हम यह पता लगाएंगे कि जावा डेवलपर्स क्वार्कस को क्यों अपना रहे हैं, क्वार्कस उप-सेकंड स्टार्टअप समय और माइक्रो-मेमोरी फ़ुटप्रिंट्स कैसे प्राप्त करता है, बिल्ड-टाइम ऑप्टिमाइज़ेशन के वास्तुशिल्प यांत्रिकी, और क्वार्कस के साथ जावा में उत्पादन के लिए तैयार प्रतिक्रियाशील माइक्रोसर्विस कैसे बनाएं।

1. पारंपरिक जावा की क्लाउड-नेटिव दुविधा

यह समझने के लिए कि क्वार्कस क्यों मौजूद है, हमें यह जांचना चाहिए कि स्प्रिंग बूट या जकार्ता ईई जैसे पारंपरिक जावा फ्रेमवर्क हुड के तहत कैसे काम करते हैं।

ए. भारी रनटाइम आरंभीकरण लागत

पारंपरिक जावा फ्रेमवर्क रनटाइम डायनेमिक रिफ्लेक्शन, क्लासपाथ स्कैनिंग और प्रॉक्सी जेनरेशन पर बहुत अधिक निर्भर करते हैं:

1. क्लासपाथ स्कैनिंग: स्टार्टअप के दौरान, JVM @Component, @Service, @Controller, या @Entity जैसे एनोटेशन खोजने के लिए क्लासपाथ में प्रत्येक JAR फ़ाइल को स्कैन करता है।
2. एनोटेशन प्रोसेसिंग और रिफ्लेक्शन: फ्रेमवर्क बीन्स, कॉन्फ़िगरेशन गुणों और निर्भरताओं का इन-मेमोरी ग्राफ बनाने के लिए रिफ्लेक्शन (Class.forName(), getDeclaredFields()) का उपयोग करता है।
3. डायनेमिक प्रॉक्सी निर्माण: सीजीएलआईबी या बाइटबड्डी आस्पेक्ट-ओरिएंटेड प्रोग्रामिंग (एओपी), डेटाबेस लेनदेन प्रबंधन (@Transactional), और सुरक्षा सीमाओं का समर्थन करने के लिए रनटाइम मेमोरी में डायनामिक बाइटकोड प्रॉक्सी उत्पन्न करता है।
4. मेटास्पेस और आरएसएस इन्फ्लेशन: सभी मेटाडेटा, प्रतिबिंबित क्लास डिस्क्रिप्टर और जेनरेट किए गए प्रॉक्सी को जेवीएम के मेटास्पेस और रेजिडेंट सेट साइज (आरएसएस) के अंदर मेमोरी में बनाए रखा जाना चाहिए।

इस रनटाइम रिफ्लेक्शन लूप के लिए काफी सीपीयू चक्र की आवश्यकता होती है और ढेर मेमोरी खपत बढ़ जाती है। पारंपरिक जावा में एक बुनियादी CRUD REST सेवा आसानी से 140MB से 300MB RAM का उपभोग कर सकती है और इसे शुरू होने में 3 से 8 सेकंड का समय लग सकता है।

बी. क्लाउड कंप्यूटिंग में वित्तीय जुर्माना

सर्वर रहित और कंटेनरीकृत वातावरण में, क्लाउड प्रदाता दो मैट्रिक्स के आधार पर शुल्क लेते हैं: आवंटित मेमोरी (जीबी) और निष्पादन अवधि (मिलीसेकंड)।

• कोल्ड स्टार्ट: यदि सर्वर रहित फ़ंक्शन को बूट होने में 5 सेकंड लगते हैं, तो अंतिम उपयोगकर्ताओं को ध्यान देने योग्य विलंबता का अनुभव होता है, और आप निष्क्रिय स्टार्टअप गणना के 5 सेकंड के लिए भुगतान करते हैं।
• घनत्व और पॉड स्केलेबिलिटी: 16 जीबी रैम वाले वर्कर नोड वाले कुबेरनेट्स क्लस्टर में, आप मेमोरी खत्म होने से पहले केवल ~40 पारंपरिक स्प्रिंग बूट माइक्रोसर्विस इंस्टेंस चला सकते हैं। यदि प्रत्येक इंस्टेंस केवल 15एमबी रैम की खपत करता है, तो वही नोड 800 से अधिक इंस्टेंसेस को होस्ट कर सकता है।

2. क्वार्कस आर्किटेक्चर: कार्य को रनटाइम से बिल्ड टाइम में स्थानांतरित करना

क्वार्कस एक क्रांतिकारी वास्तुशिल्प प्रतिमान बदलाव के माध्यम से क्लाउड-नेटिव दुविधा को हल करता है: ** गतिशील संचालन को रनटाइम से बिल्ड टाइम तक ले जाना**।

बिल्ड-टाइम प्रोसेसिंग (समय से पहले अनुकूलन)

हर बार एप्लिकेशन बूट होने पर क्लासपाथ स्कैनिंग, एनोटेशन पार्सिंग और बीन ग्राफ वायरिंग निष्पादित करने के बजाय, क्वार्कस इन सभी भारी ऑपरेशनों को बिल्ड चरण (mvn package या ./gradlew build) के दौरान एक बार करता है।

1. एक्सटेंशन आर्किटेक्चर और निर्माण चरण: क्वार्कस एक प्लग करने योग्य एक्सटेंशन फ्रेमवर्क का उपयोग करता है। आपके एप्लिकेशन को संकलित करते समय, क्वार्कस एक्सटेंशन एनोटेशन को पार्स करता है, अनुकूलित स्टेटिक बाइटकोड उत्पन्न करता है, और निर्भरता इंजेक्शन ग्राफ़ को पहले से हल करता है।
2. प्री-बेक्ड मेटाडेटा: सभी निर्भरता इंजेक्शन मेटाडेटा की पूर्व-गणना की जाती है। जब एप्लिकेशन शुरू होता है, तो क्वार्कस प्रतिबिंब या क्लासपाथ को स्कैन किए बिना सीधे पूर्व-संकलित कक्षाओं को तुरंत चालू करता है।
3. डेड कोड एलिमिनेशन (ट्री शेकिंग): निर्माण प्रक्रिया के दौरान, क्वार्कस उन कक्षाओं, विधियों और पुस्तकालयों की पहचान करता है जो आपके एप्लिकेशन द्वारा उपयोग नहीं किए जाते हैं और उन्हें पूरी तरह से हटा देता है।

जब तक आपका एप्लिकेशन JAR या नेटिव बाइनरी तैयार होता है, तब तक सभी रनटाइम ओवरहेड समाप्त हो चुके होते हैं। जेवीएम बस प्री-वायर्ड स्टैटिक बाइटकोड लोड करता है और तुरंत शुरू हो जाता है।

3. ग्रेलवीएम नेटिव इमेज बनाम ओपनजेडीके हॉटस्पॉट

क्वार्कस एक दोहरा निष्पादन मॉडल प्रदान करता है: यह मानक OpenJDK हॉटस्पॉट पर असाधारण रूप से तेज़ चलता है, लेकिन GraalVM नेटिव इमेज में संकलित होने पर यह अपनी अधिकतम प्रदर्शन क्षमता तक पहुँच जाता है।

+-----------------------------------------------------------------------+
|                         Java Source Code (.java)                      |
+-----------------------------------------------------------------------+
                                    |
                                    v (Standard javac)
+-----------------------------------------------------------------------+
|                            Bytecode (.class)                          |
+-----------------------------------------------------------------------+
                       /                         \
                      /                           \
                     v                             v
   +----------------------------------+   +----------------------------------+
   |      OpenJDK HotSpot JVM         |   |     GraalVM Native Image (AOT)   |
   |  - JIT Compilation (C1/C2)       |   |  - Substrate VM                  |
   |  - Dynamic Class Loading         |   |  - No Classpath Scanning          |
   |  - Fast throughput, longer boot  |   |  - Millisecond boot, tiny RAM    |
   +----------------------------------+   +----------------------------------+

समय से पहले (एओटी) संकलन और सबस्ट्रेट वीएम

GraalVM नेटिव इमेज जावा बाइटकोड लेती है और इसे सीधे ओएस-विशिष्ट स्टैंडअलोन निष्पादन योग्य बाइनरी (लिनक्स पर ईएलएफ बाइनरी, मैकओएस पर मैक-ओ, विंडोज पर EXE) में संकलित करती है।

• क्लोज्ड-वर्ल्ड असेम्प्शन: GraalVM मानता है कि निर्माण के समय सभी पहुंच योग्य कोड, कक्षाएं और संसाधन ज्ञात होते हैं।
• सब्सट्रेट वीएम: मूल निष्पादन योग्य एक लघु रनटाइम इंजन को एम्बेड करता है जिसे सब्सट्रेट वीएम कहा जाता है, जो पूर्ण जेवीएम इंस्टेंस लॉन्च किए बिना मेमोरी प्रबंधन, थ्रेड शेड्यूलिंग और कचरा संग्रह को संभालता है।
• शून्य परावर्तन ओवरहेड: क्योंकि क्वार्कस निर्माण समय के दौरान प्रतिबिंब कॉन्फ़िगरेशन और प्रॉक्सी परिभाषाएँ तैयार करता है, GraalVM मूल छवि संकलन मूल GraalVM बिल्ड द्वारा ऐतिहासिक रूप से आवश्यक मैन्युअल कॉन्फ़िगरेशन फ़ाइलों के बिना आसानी से सफल होता है।

4. प्रदर्शन बेंचमार्क: अनुभवजन्य साक्ष्य

प्रदर्शन में स्पष्ट अंतर को स्पष्ट करने के लिए, आइए मानक REST + डेटाबेस CRUD सेवा चलाने वाले तीन जावा रनटाइम कॉन्फ़िगरेशन में मानक उद्योग बेंचमार्क तुलनाओं की जांच करें:

1. पारंपरिक क्लाउड-नेटिव स्टैक (पारंपरिक जेवीएम/स्प्रिंग बूट)
2. ओपनजेडीके हॉटस्पॉट पर क्वार्कस
3. ग्रेलवीएम नेटिव इमेज पर क्वार्कस

प्रदर्शन सारांश तालिका

ध्यान दें कि क्वार्कस ने एक मूल छवि को 14 मिलीसेकंड में संकलित किया है - पलक झपकने से भी तेज गति से - और केवल 13 एमबी रैम की खपत करता है। यह जावा को सर्वर रहित और क्लाउड-नेटिव परिनियोजन के लिए गो और रस्ट के साथ पूरी तरह से प्रतिस्पर्धी बनाता है।

5. प्रतिक्रियाशील और अनिवार्य डुअल-कोर इंजन

ऐतिहासिक रूप से, जावा डेवलपर्स को दो परस्पर अनन्य प्रोग्रामिंग मॉडल के बीच चयन करना होता था:

1. अनिवार्य (थ्रेड-प्रति-अनुरोध): मानक जेडीबीसी ड्राइवरों और सिंक्रोनस आरईएसटी एंडपॉइंट्स का उपयोग करके सरल, पठनीय ब्लॉकिंग कोड।
2. रिएक्टिव (इवेंट लूप): एसिंक्रोनस, नॉन-ब्लॉकिंग कोड (जैसे, RxJava, प्रोजेक्ट रिएक्टर) उच्च थ्रूपुट में सक्षम, लेकिन जटिल कॉलबैक चेन और कठिन डिबगिंग के लिए कुख्यात।

क्वार्कस एक्लिप्स वर्ट.x और नेट्टी द्वारा संचालित एक एकल, एकजुट इंजन के तहत दोनों दुनियाओं को एकीकृत करता है।

                      +---------------------------------+
                      |     Client HTTP Request         |
                      +---------------------------------+
                                       |
                                       v
                      +---------------------------------+
                      |       Eclipse Vert.x I/O        |
                      |          (Event Loop)           |
                      +---------------------------------+
                                   /       \
                                  /         \
                                 v           v
                 +-------------------+   +-------------------+
                 | Reactive Endpoint |   |Blocking Endpoint  |
                 | (Event Loop)      |   | (Worker Thread)   |
                 | - Mutiny (Uni/Multi)| | - Standard JDBC   |
                 | - Non-blocking    |   | - Imperative Code |
                 +-------------------+   +-------------------+

क्वार्कस में, नॉन-ब्लॉकिंग I/O नींव है। यदि आप पारंपरिक ब्लॉकिंग कोड लिखते हैं, तो क्वार्कस स्वचालित रूप से एक प्रबंधित वर्कर थ्रेड पूल को निष्पादन भेजता है। यदि आप SmallRye Mutiny (Uni<T> और Multi<T>) जैसे प्रतिक्रियाशील प्रकारों का उपयोग करते हैं, तो निष्पादन उच्च-प्रदर्शन वाले गैर-अवरुद्ध ईवेंट लूप थ्रेड पर रहता है।

6. डेवलपर जॉय: लाइव कोडिंग और देव सेवाएँ

रनटाइम प्रदर्शन से परे, क्वार्कस एक क्रांतिकारी डेवलपर अनुभव प्रदान करता है जिसे थकाऊ बिल्ड-टेस्ट-रीस्टार्ट फीडबैक लूप को खत्म करने के लिए डिज़ाइन किया गया है।

ए. जीरो-रीस्टार्ट लाइव कोडिंग (quarkus:dev)

mvn quarkus:dev चलाते समय, क्वार्कस लाइव-कोडिंग मोड लॉन्च करता है। आप जावा फ़ाइलों को संपादित कर सकते हैं, गुण बदल सकते हैं, HTML टेम्पलेट संशोधित कर सकते हैं, या डेटाबेस स्कीमा अपडेट कर सकते हैं।

अगली बार जब आप अपने ब्राउज़र या टर्मिनल में HTTP अनुरोध ट्रिगर करते हैं, तो क्वार्कस फ़ाइल परिवर्तनों का पता लगाता है, बिल्ड चरणों को फिर से लागू करता है, और 500 मिलीसेकंड से कम में एप्लिकेशन को हॉट-रीलोड करता है। आपको विकास के दौरान अपने एप्लिकेशन सर्वर को मैन्युअल रूप से रोकने और पुनः आरंभ करने की आवश्यकता नहीं है।

बी. क्वार्कस देव सेवाएँ (शून्य-कॉन्फ़िगरेशन टेस्टकंटेनर)

किसी माइक्रोसर्विस को PostgreSQL डेटाबेस, काफ्का ब्रोकर या रेडिस कैश से कनेक्ट करने के लिए आमतौर पर docker-compose.yml फ़ाइल लिखने और स्थानीय डेटाबेस पोर्ट को कॉन्फ़िगर करने की आवश्यकता होती है।

क्वार्कस देव सेवाओं के साथ:

• यदि क्वार्कस एक डेटाबेस निर्भरता का पता लगाता है (उदाहरण के लिए, quarkus-reactive-pg-client) लेकिन application.properties में कोई डेटाबेस URL कॉन्फ़िगर नहीं किया गया है, तो क्वार्कस ** स्वचालित रूप से एक डॉकर कंटेनर को स्पिन करता है** पृष्ठभूमि में टेस्टकंटेनर के माध्यम से PostgreSQL चलाता है।
• यह स्वचालित रूप से आपके चल रहे एप्लिकेशन में कनेक्शन क्रेडेंशियल इंजेक्ट करता है।
• जब आप डेव मोड बंद करते हैं, तो कंटेनर अपने आप साफ हो जाता है।

7. व्यावहारिक पूर्वाभ्यास: उत्पादन के लिए तैयार रिएक्टिव क्वार्कस सेवा का निर्माण

आइए जावा में एक स्वच्छ, उच्च-प्रदर्शन क्वार्कस माइक्रोसर्विस का निर्माण करें जो पैनाचे के साथ हाइबरनेट रिएक्टिव का उपयोग करके पोस्टग्रेएसक्यूएल डेटाबेस से जुड़े एक आरईएसटी एपीआई को उजागर करता है।

चरण 1: परियोजना निर्भरताएँ (pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ghaznix.quarkus</groupId>
    <artifactId>user-service</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <properties>
        <compiler-plugin.version>3.13.0</compiler-plugin.version>
        <maven.compiler.release>21</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <quarkus.platform.artifact-id>quarkus-bom</quarkus.platform.artifact-id>
        <quarkus.platform.group-id>io.quarkus.platform</quarkus.platform.group-id>
        <quarkus.platform.version>3.15.1</quarkus.platform.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>${quarkus.platform.group-id}</groupId>
                <artifactId>${quarkus.platform.artifact-id}</artifactId>
                <version>${quarkus.platform.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- RESTEasy Reactive for high-performance HTTP endpoints -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-resteasy-reactive-jackson</artifactId>
        </dependency>

        <!-- Hibernate Reactive with Panache for active-record data access -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-hibernate-reactive-panache</artifactId>
        </dependency>

        <!-- Reactive PostgreSQL Driver -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-reactive-pg-client</artifactId>
        </dependency>

        <!-- Quarkus SmallRye OpenAPI / Swagger UI -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-smallrye-openapi</artifactId>
        </dependency>

        <!-- Testing -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-junit5</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.rest-assured</groupId>
            <artifactId>rest-assured</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>${quarkus.platform.group-id}</groupId>
                <artifactId>quarkus-maven-plugin</artifactId>
                <version>${quarkus.platform.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

चरण 2: प्रतिक्रियाशील इकाई को परिभाषित करें (UserEntity.java)

क्वार्कस ने हाइबरनेट के शीर्ष पर एक सक्रिय-रिकॉर्ड पैटर्न कार्यान्वयन पैनाचे के साथ डेटा एक्सेस को सरल बनाया।

package com.ghaznix.quarkus.entity;

import io.quarkus.hibernate.reactive.panache.PanacheEntity;
import io.smallrye.mutiny.Uni;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import java.time.Instant;

@Entity
@Table(name = "users")
public class UserEntity extends PanacheEntity {

    @NotBlank(message = "Username cannot be blank")
    @Column(unique = true, nullable = false)
    public String username;

    @Email(message = "Email must be valid")
    @Column(unique = true, nullable = false)
    public String email;

    @Column(nullable = false)
    public String role;

    @Column(name = "created_at", nullable = false, updatable = false)
    public Instant createdAt = Instant.now();

    /**
     * Helper method to find a user reactively by email.
     */
    public static Uni<UserEntity> findByEmail(String email) {
        return find("email", email).firstResult();
    }
}

चरण 3: रिएक्टिव रेस्ट संसाधन लागू करें (UserResource.java)

RESTEasy Reactive और SmallRye Mutiny का उपयोग करते हुए, हमारे HTTP एंडपॉइंट गैर-अवरुद्ध थ्रेड्स पर पूरी तरह से अतुल्यकालिक रूप से काम करते हैं:

package com.ghaznix.quarkus.resource;

import com.ghaznix.quarkus.entity.UserEntity;
import io.quarkus.hibernate.reactive.panache.Panache;
import io.smallrye.mutiny.Uni;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.validation.Valid;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import java.net.URI;
import java.util.List;

@Path("/api/v1/users")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@ApplicationScoped
public class UserResource {

    @GET
    public Uni<List<UserEntity>> getAllUsers() {
        return UserEntity.listAll();
    }

    @GET
    @Path("/{id}")
    public Uni<Response> getUserById(@PathParam("id") Long id) {
        return UserEntity.<UserEntity>findById(id)
                .onItem().ifNotNull().transform(user -> Response.ok(user).build())
                .onItem().ifNull().continueWith(() -> Response.status(Response.Status.NOT_FOUND).build());
    }

    @POST
    public Uni<Response> createUser(@Valid UserEntity user) {
        return Panache.withTransaction(user::persist)
                .replaceWith(() -> Response.created(URI.create("/api/v1/users/" + user.id))
                        .entity(user)
                        .build());
    }

    @DELETE
    @Path("/{id}")
    public Uni<Response> deleteUser(@PathParam("id") Long id) {
        return Panache.withTransaction(() -> UserEntity.deleteById(id))
                .map(deleted -> deleted 
                        ? Response.noContent().build() 
                        : Response.status(Response.Status.NOT_FOUND).build());
    }
}

चरण 4: एप्लिकेशन कॉन्फ़िगरेशन (application.properties)

# Quarkus Application Configuration
quarkus.application.name=user-service
quarkus.http.port=8080

# Database Schema Management (Automatically managed by Dev Services in dev mode)
quarkus.hibernate-orm.database.generation=drop-and-create
quarkus.hibernate-orm.log.sql=true

# SmallRye OpenAPI & Swagger UI Configuration
quarkus.smallrye-openapi.path=/swagger-ui
quarkus.swagger-ui.always-include=true

ध्यान दें कि हमने डेटाबेस यूआरएल, उपयोगकर्ता नाम या पासवर्ड कॉन्फ़िगर नहीं किया है! जब आप ./mvnw quarkus:dev चलाते हैं, तो क्वार्कस स्वचालित रूप से PostgreSQL का पता लगाता है, एक डॉकर कंटेनर लॉन्च करता है, डेटाबेस स्कीमा टेबल सेट करता है, और http://localhost:8080/swagger-ui पर स्वैगर UI खोलता है।

चरण 5: मूल निष्पादनयोग्य का निर्माण और निष्पादन

तत्काल लाइव-कोडिंग डेव मोड में चलाने के लिए:

./mvnw quarkus:dev

डॉकर कंटेनर के अंदर GraalVM का उपयोग करके एक मूल लिनक्स बाइनरी बनाने के लिए (कोई स्थानीय GraalVM इंस्टॉलेशन आवश्यक नहीं है):

./mvnw package -Dnative -Dquarkus.native.container-build=true

परिणामी बाइनरी को सीधे अपने OS पर लॉन्च करने के लिए:

./target/user-service-1.0.0-SNAPSHOT-runner

__  ____  __  _____   ___  __ ____  ______ 
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/ 
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \   
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/   
2026-08-26 01:37:15,102 INFO  [io.quarkus] (main) user-service 1.0.0-SNAPSHOT native (powered by Quarkus 3.15.1) started in 0.016s. Listening on: http://0.0.0.0:8080
2026-08-26 01:37:15,103 INFO  [io.quarkus] (main) Profile prod activated. 
2026-08-26 01:37:15,103 INFO  [io.quarkus] (main) Installed features: [cdi, hibernate-reactive, panache, reactive-pg-client, resteasy-reactive, resteasy-reactive-jackson, smallrye-openapi]

0.016 सेकंड स्टार्टअप!

8. रणनीतिक विशेषता तुलना: क्वार्कस बनाम स्प्रिंग बूट

9. निष्कर्ष: क्या क्वार्कस पर स्विच करने का समय आ गया है?

क्वार्कस महज एक अन्य वेब ढांचा नहीं है; यह क्लाउड-नेटिव युग के लिए जावा के विकास का प्रतिनिधित्व करता है। GraalVM मूल संकलन के साथ बिल्ड-टाइम ऑप्टिमाइज़ेशन को जोड़कर, क्वार्कस ने विरासती स्टीरियोटाइप को अमान्य कर दिया है कि जावा आधुनिक माइक्रोसर्विसेज और सर्वर रहित फ़ंक्शंस के लिए बहुत धीमा या बहुत मेमोरी-भारी है।

आपको क्वार्कस कब चुनना चाहिए?

• सर्वर रहित और इवेंट-संचालित एप्लिकेशन: यदि आप एडब्ल्यूएस लैम्ब्डा, जीसीपी क्लाउड रन, या नेटिव में माइक्रोसर्विसेज तैनात कर रहे हैं, तो क्वार्कस देशी बायनेरिज़ कोल्ड स्टार्ट समस्याओं को पूरी तरह से खत्म कर देते हैं।
• उच्च-घनत्व कुबेरनेट्स क्लस्टर: यदि आपके बुनियादी ढांचे के बिल में क्लस्टर रैम की खपत हावी है, तो क्वार्कस में सेवाओं को स्थानांतरित करने से मेमोरी लागत में 75% तक की कटौती हो सकती है।
• रिएक्टिव माइक्रोसर्विसेज: यदि आप नॉन-ब्लॉकिंग स्ट्रीमिंग (काफ्का, जीआरपीसी, वेबसॉकेट) की आवश्यकता वाले उच्च-थ्रूपुट सिस्टम का निर्माण करते हैं, तो क्वार्कस बॉक्स से बाहर शीर्ष स्तरीय प्रदर्शन प्रदान करता है।

जावा अब धीमे स्टार्टअप या फूले हुए रनटाइम से प्रभावित नहीं है। क्वार्कस के साथ, जावा डेवलपर्स सुपरसोनिक स्पीड और सबटॉमिक फ़ुटप्रिंट के साथ क्लाउड-नेटिव एप्लिकेशन बना सकते हैं।