Quarkus as a powerful runtime - Blog post #2

Signed-off-by: Michal Maléř <[email protected]>

Author: MichalMaler

_posts/2025-10-23-mmaler-blogpost-2-quarkus-runtime-and-framework-for-cloud-native-java.adoc

@@ -0,0 +1,151 @@
+---
+layout: post
+title: 'Quarkus: Runtime and Framework for Cloud-Native Java'
+date: 2025-10-22
+tags: quarkus runtime framework performance cloud-native
+synopsis: This post explores how Quarkus speeds up development, cuts costs, and makes development enjoyable for cloud-native Java.
+author: mmaler
+thumbnailimage: /assets/images/posts/mmaler-blog-posts/quarkus-as-a-powerful-runtime.jpeg
+---
+:imagesdir: /assets/images/posts/mmaler-blog-posts/2-Quarkus-as-a-powerful-runtime/
+ifdef::env-github,env-browser,env-vscode[:imagesdir: ../assets/images/posts/mmaler-blog-posts/2-Quarkus-as-a-powerful-runtime/]
+
+= Quarkus: Runtime and Framework for Cloud-Native Java
+
+image::/assets/images/posts/mmaler-blog-posts/quarkus-as-a-powerful-runtime.jpeg[alt="Quarkus: Runtime and Framework for Cloud-Native Java", width=100%]
+
+In this post, “runtime” means the full execution stack in production: JVM or native, plus Quarkus and the integrated frameworks.
+Quarkus is a Java runtime that seamlessly integrates popular frameworks and libraries, shaping both the structure of modern applications and the developer experience behind them.
+
+From a complementary perspective, “framework” denotes the higher-level layer that provides structure and APIs; in this sense, Quarkus can also be viewed as a framework.
+
+== Why Quarkus stands out
+
+In modern software development, runtimes and frameworks form the foundation of productivity and consistency.
+Frameworks promote uniformity, simplify infrastructure, and enable automation at scale.
+
+image::1-history.png[alt="A brief timeline leading to modern Java and Quarkus", width=100%]
+
+Quarkus, a truly cloud-native Java runtime, integrates multiple frameworks under one roof and optimizes them for developer efficiency, memory usage, and lightning-fast startup.
+As a result, it provides a solid foundation for building modern, cloud-native applications.
+
+Quarkus integrates established Java frameworks, such as CDI, JAX-RS, and Hibernate, but it also enforces its own conventions, uses annotations to drive behavior, and defines how applications are structured.
+
+In this sense, Quarkus is a framework that serves as a runtime and platform for cloud-native Java applications. It also embraces industry standards, offering compatibility with technologies such as Spring, Kafka, and Camel to support familiar and flexible development models.
+
+== Quarkus as a versatile framework
+
+Beyond standard traits common to modern frameworks, Quarkus introduces two platform-defining features: build-time optimization and deep extensibility.
+
+* *Build-time optimization*: Quarkus shifts work from runtime to build time wherever possible.
+This approach reduces startup overhead and memory usage, resulting in a lean, fast, and efficient application tailored for production.
++
+image::2-build-time-principle.png[alt="Build-time principle in Quarkus: being fast by doing less at runtime", width=100%]
++
+image::3-BuildTimeP-Benefits-JVM.png[alt="Benefits of Quarkus build-time processing on the JVM", width=100%]
++
+image::4-BuildTimeP-Benefits-native.png[alt="Benefits of Quarkus native image compared to JVM", width=100%]
++
+image::5-JVM-Snapshotting-Native.png[alt="JVM snapshotting vs native images in Quarkus", width=100%]
+
+* *Extensibility*: Quarkus exposes extension points for everything from startup hooks to request filters.
+Over 800 extensions allow seamless integration with modern technologies such as Kafka, OpenTelemetry, and OpenID Connect.
+
+These extensions integrate with Quarkus and participate in its build-time and runtime lifecycle, making them first-class citizens of the Quarkus platform.
+
+=== Simplified developer experience
+
+Frameworks succeed when they reduce complexity without sacrificing power.
+Quarkus does exactly that:
+
+* Preconfigures popular libraries with sensible defaults.
+* Offers unified configuration and developer tooling.
+* Provides instant feedback with live reload and continuous testing.
+
+This makes Quarkus both powerful and approachable.
+
+You can start with a simple REST endpoint and scale it into a production-grade service without changing your development model.
+
+image::6-Frictionless.png[alt="Frictionless developer experience: live reload, dev services, continuous testing", width=100%]
+
+These features reflect Quarkus’s dual role: it behaves like a framework during development, offering structure, defaults, and conventions, and it acts as a runtime during execution, delivering performance, efficiency, and operational consistency.
+
+=== Performance that matters
+
+As discussed in the link:https://cacm.acm.org/practice/application-frameworks/[ACM article on application frameworks], two recurring goals are fast startup and resilience against cascading failures.
+
+Native image generation with GraalVM enables cold starts in milliseconds and a minimal memory footprint, allowing cost-effective deployment in containers and serverless environments.
+
+Quarkus also includes structured health checks, metrics, and tracing, thereby aligning with production standards from day one.
+
+image::7-success-stories.png[alt="Real-world success stories using Quarkus", width=100%]
+
+
+=== Security
+
+Quarkus uses a standards-first, composable, security model.
+You enable what you need and configure it for your environment:
+
+* **Transport:** Enable TLS for HTTPS, or terminate TLS at your ingress.
+* **Authentication:** Choose Basic, form-based, mTLS, or OpenID Connect (OIDC).
+* **Authorization:** Enforce RBAC on web endpoints with `@RolesAllowed`, `@DenyAll`, and `@PermitAll`.
+
+This lets you apply the right security controls for each deployment.
+
+=== Observability and control surfaces
+
+Common control surfaces, such as metrics, logging, tracing, and configuration, are essential for Site Reliability Engineers (SREs) and platform teams.
+
+Quarkus exposes:
+
+* Unified logging with link:https://quarkus.io/guides/logging[`quarkus-logging`].
+* Structured metrics and tracing with link:https://quarkus.io/guides/telemetry-micrometer-to-opentelemetry[Micrometer and OpenTelemetry].
+* Unified configuration of all the application's aspects by using `application.properties` or environment variables.
+
+This standardization enables automation and scalable monitoring.
+
+=== Modular and production-ready
+
+Following a lean-core, modular-at-the-edge approach, Quarkus delivers:
+
+* A minimal core for fast startup.
+* Pluggable modules for authentication, tracing, messaging, and more.
+* Dev Services for automatic provisioning of databases, brokers, and containers in dev mode.
+
+Whether you're building a prototype or deploying to OpenShift, Quarkus adapts.
+This modularity spans both the framework-level APIs developers work with and the runtime behaviors that execute beneath them.
+
+Because Quarkus modularity is declarative and unified across extensions, it supports a platform-like developer experience without the rigidity of traditional frameworks.
+
+=== Building your stack with Quarkus
+
+Frameworks can serve as a foundation for creating higher-level abstractions.
+
+Quarkus fits naturally into this model—not by becoming a platform itself, but by enabling teams to build their customized stacks and frameworks on top of it.
+
+Unlike many traditional frameworks, Quarkus provides a unified extension architecture that supports deep customization.
+Organizations can tailor Quarkus to fit specific domains, technologies, or compliance needs.
+This enables the creation of organization-specific developer experiences, as seen in solutions like Amadeus’s SQube.
+
+By encouraging consistency, offering build-time integration, and exposing clean extension points, Quarkus supports the creation of opinionated, scalable internal frameworks without forking or reinventing the core.
+
+With Quarkus, teams can focus on business logic while the runtime handles infrastructure concerns, and the platform provides consistency across services.
+This is similar to Logicdrop, which refactored its entire Spring Boot stack with Quarkus, reducing container size by ~75%, achieving sub-second startup times, and significantly improving developer productivity.
+
+For more information, see the link:https://quarkus.io/blog/logicdrop-customer-story/[Logicdrop customer story] and their link:https://quarkus.io/blog/logicdrop-automating-quarkus-with-gitlab/?utm_source=chatgpt.com[GitLab automation write-up].
+
+== Conclusion
+
+Quarkus unifies the strengths of a framework and a runtime.
+
+As a framework, it provides structure, conventions, and a cohesive developer experience; as a runtime, it delivers fast startup, low memory use, and operational consistency in the cloud.
+
+This dual role helps teams standardize practices, reduce costs, and ship resilient cloud-native services — while preserving developer joy.
+
+image::8-expectations.png[alt="Setting expectations for performance and developer experience with Quarkus", width=100%]
+
+For a closer look at how Quarkus makes Java cloud-native, see the https://quarkus.io/blog/mmaler-blogpost-1-intro/[introductory blog post].
+
+== What’s next?
+
+Explore more Quarkus use cases in the link:https://quarkus.io/blog/[official blog archive], or check out the link:https://quarkus.io/guides/[Quarkus guides] to start building your own cloud-native stack today.