مقدمة إلى Quarkus: لماذا ينتقل مطورو Java إلى Supersonic Java

منذ ما يقرب من ثلاثة عقود، كانت Java هي القوة المهيمنة في تطوير برمجيات المؤسسات. إن نظامها البيئي الغني، وأساسها القوي الموجه للكائنات، واستقلال النظام الأساسي عبر Java Virtual Machine (JVM)، والأطر التي تم اختبارها في المعركة مثل Spring Boot، جعلها ملك البنية التحتية الخلفية بلا منازع.

ومع ذلك، فإن التحول نحو البنى السحابية الأصلية، تنسيق Kubernetes، الحاويات (Docker)، والحوسبة بدون خادم (AWS Lambda، Knative) كشف عن ثغرة أمنية خطيرة في أطر عمل تطبيقات Java التقليدية: عبء كبير للذاكرة وأوقات بدء تشغيل بطيئة.

عندما تحتاج الخدمة الصغيرة إلى التوسع أفقيًا من صفر إلى 100 نسخة متماثلة استجابةً لزيادة كبيرة في حركة المرور، أو عند تنفيذ وظيفة بدون خادم عند الطلب، فإن الانتظار من 3 إلى 10 ثوانٍ حتى يتم تشغيل عملية Java أمر غير مقبول. تتطلب البنية التحتية السحابية الحديثة بدء تشغيل فوري واستهلاكًا خفيفًا للذاكرة، وهي سمات محفوظة تقليديًا للغات مثل Go أو Rust أو Node.js.

أدخل Quarkus: إطار عمل Java أصلي من Kubernetes مصمم خصيصًا لـ GraalVM وOpenJDK HotSpot. يُطلق على برنامج Quarkus في كثير من الأحيان اسم “Java Subatomic Subsonic”*، وهو يعيد بشكل أساسي هندسة كيفية تجميع تطبيقات Java وتشغيلها.

في هذا الدليل التفصيلي، سنستكشف سبب احتضان مطوري Java لـ Quarkus، وكيف يحقق Quarkus أوقات بدء تشغيل أقل من ثانية وآثار ذاكرة صغيرة، والميكانيكيات المعمارية Build-Time Optimization، وكيفية إنشاء خدمة صغيرة تفاعلية جاهزة للإنتاج في Java باستخدام Quarkus.

1. معضلة السحابة الأصلية في جافا التقليدية

لفهم سبب وجود Quarkus، يجب علينا فحص كيفية عمل أطر عمل Java التقليدية مثل Spring Boot أو Jakarta EE تحت الغطاء.

أ. تكلفة تهيئة وقت التشغيل الثقيلة

تعتمد أطر عمل Java التقليدية بشكل كبير على الانعكاس الديناميكي في وقت التشغيل، وفحص مسار الفئة، وإنشاء الوكيل:

1. ** Classpath Scanning **: أثناء بدء التشغيل، يقوم JVM بفحص كل ملف JAR في مسار الفصل لاكتشاف التعليقات التوضيحية مثل @Component، أو @Service، أو @Controller، أو @Entity.
2. معالجة التعليقات التوضيحية والانعكاس: يستخدم إطار العمل الانعكاس (Class.forName()، getDeclaredFields()) لإنشاء رسم بياني في الذاكرة للفاصوليا وخصائص التكوين والتبعيات.
3. إنشاء الوكيل الديناميكي: يقوم CGLIB أو ByteBuddy بإنشاء وكلاء رمز بايت ديناميكي في ذاكرة وقت التشغيل لدعم البرمجة الموجهة نحو الجوانب (AOP)، وإدارة معاملات قاعدة البيانات (@Transactional)، وحدود الأمان.
4. ** تضخم مساحة التعريف و RSS **: يجب الاحتفاظ بجميع البيانات التعريفية وواصفات الفئة المنعكسة والوكلاء الذين تم إنشاؤهم في الذاكرة داخل مساحة تعريف JVM وحجم المجموعة المضمنة (RSS).

تتطلب حلقة الانعكاس في وقت التشغيل هذه دورات كبيرة لوحدة المعالجة المركزية (CPU) وتؤدي إلى تضخم استهلاك ذاكرة الكومة. يمكن لخدمة CRUD REST الأساسية في Java التقليدية أن تستهلك بسهولة 140 ميجابايت إلى 300 ميجابايت من ذاكرة الوصول العشوائي في وضع الخمول وتستغرق 3 إلى 8 ثوانٍ للبدء.

ب. العقوبة المالية في الحوسبة السحابية

في البيئات التي لا تحتوي على خادم والتي تحتوي على حاويات، يتقاضى مقدمو الخدمات السحابية الرسوم بناءً على مقياسين: الذاكرة المخصصة (جيجابايت) و مدة التنفيذ (مللي ثانية).

• بدء التشغيل على البارد: إذا استغرق تشغيل وظيفة بدون خادم 5 ثوانٍ، فسيواجه المستخدمون النهائيون زمن استجابة ملحوظًا، وستدفع مقابل 5 ثوانٍ من حساب بدء التشغيل الخامل.
• الكثافة وقابلية التوسع: في مجموعة Kubernetes التي تحتوي على عقدة عاملة تمتلك 16 جيجابايت من ذاكرة الوصول العشوائي، يمكنك فقط تشغيل حوالي 40 مثيلًا تقليديًا للخدمة الصغيرة لـ Spring Boot قبل نفاد الذاكرة. إذا استهلك كل مثيل 15 ميغابايت فقط من ذاكرة الوصول العشوائي (RAM)، فيمكن أن تستضيف نفس العقدة أكثر من 800 مثيل.

2. بنية Quarkus: تحويل العمل من وقت التشغيل إلى وقت البناء

يحل Quarkus معضلة السحابة الأصلية من خلال نقلة نوعية جذرية في البنية: نقل العمليات الديناميكية من وقت التشغيل إلى وقت البناء.

معالجة وقت البناء (التحسين المسبق)

بدلاً من تنفيذ فحص مسار الفئة، وتحليل التعليقات التوضيحية، وتوصيل الرسم البياني في كل مرة يتم فيها تشغيل التطبيق، يقوم Quarkus بتنفيذ كل هذه العمليات الثقيلة مرة واحدة أثناء مرحلة الإنشاء (mvn package أو ./gradlew build).

1. هندسة الامتداد وخطوات البناء: يستخدم Quarkus إطار عمل ملحق قابل للتوصيل. عند تجميع التطبيق الخاص بك، تقوم ملحقات Quarkus بتحليل التعليقات التوضيحية وإنشاء رمز بايت ثابت محسّن وحل الرسوم البيانية لحقن التبعية مقدمًا.
2. ** البيانات الوصفية المخبوزة مسبقًا **: يتم حساب جميع البيانات الوصفية لحقن التبعية مسبقًا. عند بدء تشغيل التطبيق، يقوم Quarkus مباشرة بإنشاء مثيل للفئات المترجمة مسبقًا دون استدعاء الانعكاس أو مسح مسارات الفئات.
3. إزالة التعليمات البرمجية الميتة (اهتزاز الشجرة): أثناء عملية الإنشاء، يحدد Quarkus الفئات والأساليب والمكتبات التي لا يستخدمها تطبيقك ويزيلها تمامًا.

بحلول الوقت الذي يتم فيه إنتاج تطبيقك JAR أو البرنامج الثنائي الأصلي، تكون قد تم التخلص من كافة تكاليف وقت التشغيل. يقوم JVM ببساطة بتحميل الرموز الثانوية الثابتة السلكية مسبقًا ويبدأ على الفور.

3. الصورة الأصلية GraalVM مقابل OpenJDK HotSpot

يوفر Quarkus نموذج تنفيذ مزدوج: فهو يعمل بسرعة استثنائية على OpenJDK HotSpot القياسي، ولكنه يصل إلى أقصى إمكانات الأداء عند تجميعه في GraalVM Native Image.

+-----------------------------------------------------------------------+
|                         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    |
   +----------------------------------+   +----------------------------------+

التجميع المسبق (AOT) والركيزة VM

تأخذ GraalVM Native Image كود Java الثانوي وتجمعه مباشرة في ملف ثنائي مستقل قابل للتنفيذ خاص بنظام التشغيل (ELF ثنائي على Linux، Mach-O على macOS، EXE على Windows).

• افتراض العالم المغلق: يفترض GraalVM أن جميع التعليمات البرمجية والفئات والموارد التي يمكن الوصول إليها معروفة في وقت الإنشاء.
• Substrate VM: يتضمن الملف القابل للتنفيذ الأصلي محرك تشغيل مصغر يسمى Substrate VM، والذي يتعامل مع إدارة الذاكرة وجدولة سلسلة الرسائل وجمع البيانات المهملة دون تشغيل مثيل JVM كامل.
• Zero Reflection Overhead: نظرًا لأن Quarkus يقوم بإعداد تكوينات الانعكاس وتعريفات الوكيل أثناء وقت الإنشاء، فإن تجميع الصور الأصلية لـ GraalVM ينجح بسلاسة دون الحاجة إلى ملفات التكوين اليدوية المطلوبة تاريخيًا من خلال إصدارات GraalVM الأصلية.

4. معايير الأداء: الأدلة التجريبية

لتوضيح التناقض الصارخ في الأداء، دعونا نفحص مقارنات معايير الصناعة القياسية عبر ثلاثة تكوينات لوقت تشغيل Java تشغل خدمة REST + Database CRUD القياسية:

1. المكدس التقليدي للسحابة الأصلية (JVM التقليدي / Spring Boot)
2. Quarkus على OpenJDK HotSpot
3. Quarkus على الصورة الأصلية GraalVM

جدول ملخص الأداء

لاحظ أن Quarkus الذي تم تجميعه إلى صورة أصلية يتم تشغيله في 14 مللي ثانية — أسرع من غمضة عين واحدة — ويستهلك مجرد 13 ميجابايت من ذاكرة الوصول العشوائي. وهذا يجعل Java قادرة على المنافسة بشكل كامل مع Go وRust لعمليات النشر بدون خادم والسحابة الأصلية.

5. محرك ثنائي النواة تفاعلي وحتمي

تاريخيًا، كان على مطوري Java الاختيار بين نموذجين برمجيين حصريين:

1. أمر ضروري (سلسلة رسائل لكل طلب): رمز حظر بسيط وقابل للقراءة باستخدام برامج تشغيل JDBC القياسية ونقاط نهاية REST المتزامنة.
2. رد الفعل (حلقة الأحداث): تعليمات برمجية غير متزامنة وغير قابلة للحظر (على سبيل المثال، RxJava وProject Reactor) قادرة على إنتاجية عالية، ولكنها مشهورة بسلاسل رد الاتصال المعقدة وتصحيح الأخطاء الصعبة.

يوحد Quarkus كلا العالمين تحت محرك واحد متماسك مدعوم بـ Eclipse Vert.x و Netty.

                      +---------------------------------+
                      |     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 |
                 +-------------------+   +-------------------+

في Quarkus، يعتبر الإدخال/الإخراج غير المحظور هو الأساس. إذا قمت بكتابة تعليمات برمجية حظر تقليدية، فسيقوم Quarkus تلقائيًا بإرسال التنفيذ إلى تجمع مؤشرات ترابط عامل مُدار. إذا كنت تستخدم أنواعًا تفاعلية مثل SmallRye Mutiny (Uni<T> وMulti<T>)، فسيظل التنفيذ على سلسلة حلقات الأحداث عالية الأداء وغير المحظورة.

6. فرحة المطور: خدمات التطوير والبرمجة المباشرة

بالإضافة إلى الأداء في وقت التشغيل، يقدم Quarkus تجربة مطور ثورية مصممة للتخلص من حلقة ردود الفعل المملة للبناء والاختبار وإعادة التشغيل.

أ. الترميز المباشر بدون إعادة التشغيل (quarkus:dev)

عند تشغيل mvn quarkus:dev، يقوم Quarkus بتشغيل وضع الترميز المباشر. يمكنك تحرير ملفات Java أو تغيير الخصائص أو تعديل قوالب HTML أو تحديث مخططات قاعدة البيانات.

في المرة التالية التي تقوم فيها بتشغيل طلب HTTP في متصفحك أو جهازك الطرفي، يكتشف Quarkus تغييرات الملف، ويعيد تطبيق خطوات البناء، ويعيد تحميل التطبيق بسرعة في أقل من 500 مللي ثانية. لن تحتاج أبدًا إلى إيقاف خادم التطبيق وإعادة تشغيله يدويًا أثناء التطوير.

ب. خدمات تطوير Quarkus (حاويات اختبار بدون تكوين)

عادةً ما يتطلب توصيل خدمة صغيرة بقاعدة بيانات PostgreSQL أو وسيط Kafka أو ذاكرة التخزين المؤقت لـ Redis كتابة ملف docker-compose.yml وتكوين منافذ قاعدة البيانات المحلية.

مع خدمات Quarkus Dev:

• إذا اكتشف Quarkus تبعية قاعدة بيانات (على سبيل المثال، quarkus-reactive-pg-client) ولكن لم يتم تكوين عنوان URL لقاعدة البيانات في application.properties، فإن Quarkus يقوم تلقائيًا بتدوير حاوية Docker بتشغيل PostgreSQL عبر Testcontainers في الخلفية.
• يقوم بإدخال بيانات اعتماد الاتصال في التطبيق قيد التشغيل تلقائيًا.
• عند إيقاف وضع التطوير، تقوم الحاوية بتنظيف نفسها بشكل نظيف.

7. الإرشادات العملية: بناء خدمة Quarkus التفاعلية الجاهزة للإنتاج

لنقم ببناء خدمة Quarkus صغيرة نظيفة وعالية الأداء في Java والتي تكشف عن واجهة REST API المتصلة بقاعدة بيانات PostgreSQL باستخدام Hibernate Reactive with Panache.

الخطوة 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>

الخطوة الثانية: تحديد الكيان التفاعلي (UserEntity.java)

قام Quarkus بتبسيط الوصول إلى البيانات باستخدام Panache، وهو تطبيق لنمط Active-Record أعلى Hibernate.

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: تنفيذ مورد REST التفاعلي (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

لاحظ أننا لم نقم بتكوين عناوين URL لقاعدة البيانات أو أسماء المستخدمين أو كلمات المرور! عند تشغيل ./mvnw quarkus:dev، يكتشف Quarkus تلقائيًا PostgreSQL، ويطلق حاوية Docker، ويقوم بإعداد جداول مخطط قاعدة البيانات، ويفتح Swagger UI على http://localhost:8080/swagger-ui.

الخطوة 5: إنشاء وتنفيذ الملفات التنفيذية الأصلية

للتشغيل في وضع تطوير الترميز المباشر الفوري:

./mvnw quarkus:dev

لإنشاء ثنائي Linux أصلي باستخدام GraalVM داخل حاوية Docker (لا يلزم تثبيت GraalVM محليًا):

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

لتشغيل الملف الثنائي الناتج مباشرةً على نظام التشغيل لديك:

./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. مقارنة الميزات الإستراتيجية: Quarkus مقابل Spring Boot

9. الخلاصة: هل حان الوقت للتحول إلى Quarkus؟

Quarkus ليس مجرد إطار ويب آخر؛ إنه يمثل ** تطور Java في عصر السحابة الأصلية **. من خلال الجمع بين تحسين وقت البناء والتجميع الأصلي لـ GraalVM، يبطل Quarkus الصورة النمطية القديمة التي تقول إن Java بطيئة جدًا أو مثقلة بالذاكرة بالنسبة للخدمات الصغيرة الحديثة والوظائف التي لا تحتوي على خادم.

متى يجب عليك اختيار Quarkus؟

• التطبيقات التي لا تعتمد على خادم والتي تعتمد على الأحداث: إذا كنت تقوم بنشر خدمات صغيرة إلى AWS Lambda، أو GCP Cloud Run، أو Knative، فإن ثنائيات Quarkus الأصلية تقضي تمامًا على مشكلات البدء البارد.
• مجموعات Kubernetes عالية الكثافة: إذا كان استهلاك ذاكرة الوصول العشوائي للمجموعة يهيمن على فاتورة البنية التحتية لديك، فإن ترحيل الخدمات إلى Quarkus يمكن أن يقلل تكاليف الذاكرة بنسبة تصل إلى 75%.
• الخدمات الصغيرة التفاعلية: إذا كنت تنشئ أنظمة عالية الإنتاجية تتطلب تدفقًا غير محظور (Kafka وgRPC وWebSockets)، فإن Quarkus يقدم أداءً عالي المستوى خارج الصندوق.

لم تعد Java مرتكزة على عمليات بدء التشغيل البطيئة أو أوقات التشغيل المتضخمة. باستخدام Quarkus، يمكن لمطوري Java إنشاء تطبيقات سحابية أصلية مع سرعة تفوق سرعة الصوت وبصمة دون ذرية.