Quarkus: Runtime and Framework for Cloud-Native Java - Blog post #2

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

@@ -0,0 +1,189 @@
+---
+layout: post
+title: 'Quarkus: A Runtime and Framework for Cloud-Native Java'
+date: 2025-11-04
+tags: quarkus runtime framework performance cloud-native
+synopsis: This post explores how Quarkus speeds up development, cuts costs, and streamlines 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: A 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%]
+
+Public clouds such as AWS, Microsoft Azure, and Google Cloud, and platforms like Red Hat OpenShift, favor services that start fast and stay lean.
+Quarkus is engineered for exactly that.
+Build time processing reduces runtime overhead and results in rapid startup, a small memory footprint, and frictionless deployment across Kubernetes, OpenShift, serverless, and managed container services in any cloud.
+If your Java services need to start in milliseconds, run dense on shared nodes, and still feel great to build, Quarkus was made for that job.
+
+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.
+In this post, “runtime” means the full execution stack in production: JVM or native, plus Quarkus and the integrated frameworks.
+
+Quarkus itself can also work as a framework, as it constitutes a higher-level layer that provides structure and APIs.
+
+== 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 is a cloud-native Java runtime that integrates multiple frameworks and optimizes them for fast startup, low memory use, and smooth deployment across any cloud.
+It runs well on Kubernetes and Red Hat OpenShift, and it also integrates with native cloud services, from compute platforms such as AWS EC2 and Google Cloud Run to serverless offerings and managed container platforms.
+
+Then, during development, Quarkus live reload provides instant feedback by applying code changes without a rebuild or restart.
+This shortens the inner loop and helps teams iterate faster than traditional redeploy cycles.
+
+But beyond speed and live reload, Quarkus integrates established Java specifications such as CDI-Lite, JAX-RS, and JPA, with implementations provided by Arc (CDI-Lite), RESTEasy (JAX-RS), and Hibernate ORM (JPA).
+It also enforces its own conventions, drives behavior with annotations, and defines how applications are structured.
+
+In this sense, Quarkus is a framework that also serves as a runtime and platform for cloud-native Java applications.
+It adheres to industry standards and offers compatibility with technologies such as Spring, Apache Kafka, and Apache Camel to support familiar, flexible development models.
+
+== Quarkus as a versatile framework
+
+Beyond staple traits of modern frameworks, Quarkus introduces two platform-defining features: buildtime optimization and deep extensibility.
+
+* *Buildtime 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.
++
+.Quarkus performs at build time what traditional frameworks do at runtime: reading configuration files, scanning annotations, and building a model of the application.
+image::2-build-time-principle.png[alt="Buildtime principle in Quarkus: being fast by doing less at runtime", width=100%]
++
+.Thanks to buildtime initialization, the resulting application starts faster and consumes less memory.
+image::3-BuildTimeP-Benefits-JVM.png[alt="Benefits of Quarkus buildtime processing on the JVM", width=100%]
++
+.All the benefits of buildtime initialization also apply when compiling to a native binary.
+image::4-BuildTimeP-Benefits-native.png[alt="Benefits of Quarkus native image compared to JVM", width=100%]
+
+* *Extensibility*: Quarkus exposes extension points for everything from startup hooks to request filters.
+Over 800 link:https://extensions.quarkus.io[extensions] allow seamless integration with modern technologies such as Kafka, OpenTelemetry, and OpenID Connect.
++
+These extensions integrate with Quarkus and participate in its buildtime and runtime lifecycle, making them first-class citizens of the Quarkus platform.
+
+=== Simplified developer experience
+
+Frameworks succeed when they reduce complexity without sacrificing flexibility.
+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.
+
+.Frictionless developer experience: Vastly improved development feedback loop, unified approach to producing different package types, and using proven APIs that Java developers already know.
+image::6-Frictionless.png[alt="Frictionless developer experience: live reload, dev services, continuous testing", width=100%]
+
+These features give developers structure, sensible defaults, and clear conventions during development, and they deliver fast startup, low memory use, and operational consistency in production.
+
+=== Performance that matters
+
+In practice, the two goals that matter most for production-grade frameworks at scale are fast startup and resilience against cascading failures.
+Rapid startup improves elasticity and recovery, while resilience prevents local faults from spreading and enables services to handle failures gracefully.
+For a broader industry perspective, see the link:https://cacm.acm.org/practice/application-frameworks/[ACM article on application frameworks].
+
+Quarkus shifts work from runtime to build time, thus enabling faster cold starts.
+Additionally, it offers the option to generate native executables with GraalVM's native-image, enabling cold starts in milliseconds and a minimal memory footprint.
+This results in higher pod density, quicker horizontal scaling, and lower idle costs.
+As such, it enables cost-effective deployment in containers and serverless environments.
+
+Native images often provide faster startup and lower RSS. However, they can deliver lower peak throughput and exhibit scaling limits on multi-core machines.
+Current native images typically use a single-threaded garbage collector, which is inefficient for large heaps and does not benefit from multiple cores.
+We generally recommend native execution for services that run on smaller instances, up to 2 vCPUs with roughly 2-4 gigabytes of RAM, where startup time and memory footprint dominate cost and user experience.
+
+JVM execution, by contrast, takes longer to start and warm up.
+However, it can achieve higher peak performance through just-in-time compilation. It also scales well beyond two cores and it offers more capable garbage collectors and tuning options.
+
+Choose the mode that matches your workload profile, cold-start targets, and cost envelope, and let Quarkus maintain a consistent development model across both paths.
+
+* If you optimize for native execution, audit reflection and resource usage, enable dead-code elimination-friendly patterns, and consider profile-guided optimizations where appropriate.
+* If you optimize for JVM execution, budget for warm up, enable the right GC for your heap and latency goals, and measure steady-state throughput under realistic load.
+
+Quarkus also includes structured health checks, metrics, and tracing, which align the runtime with production standards from day one.
+
+Taken together, these in production choices provide measurable wins:
+
+image::7-success-stories.png[alt="Real-world success stories using Quarkus", width=100%]
+
+* link:https://quarkus.io/blog/vodafone-greece-replaces-spring-boot/[Vodafone Greece replaces Spring Boot with Quarkus]
+* link:https://www.logicmonitor.com/blog/quarkus-vs-spring[Quarkus vs. Spring Boot]
+
+=== Security
+
+Quarkus uses a standards-first composable security model.
+You enable what you need and configure it for your environment:
+
+* **Transport:** Enable HTTPS in the application by configuring TLS.
+* **Authentication:** Choose Basic, form-based, mTLS, OpenID Connect (OIDC), or WebAuthN.
+* **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 extensions for authentication, tracing, messaging, and more.
+* Dev Services for automatic provisioning of databases, brokers, and containers in dev mode.
+
+Whether you are 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
+
+We will explore this topic in depth in part 3 of this series.
+For now, here is how Quarkus fits into the picture.
+
+Frameworks can serve as a foundation for creating higher-level abstractions.
+
+Quarkus fits naturally into this model — not by becoming a platform in 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, including internal stacks built on a unified Quarkus extension architecture.
+
+By encouraging consistency, offering buildtime integration, and exposing clean extension points, Quarkus supports the creation of opinionated, scalable internal frameworks without forking or reinventing the core.
+
+By packaging Quarkus extensions, curated defaults, and service templates into an internal Quarkus stack, teams focus on business logic.
+At the same time, your framework layer standardizes infrastructure, security, and operational integrations across services.
+This has been proven by Logicdrop, who refactored their 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 development 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.
+
+Quarkus is built in the open under the Apache License 2.0, governed with the Commonhaus model, and developed end-to-end on GitHub.
+Beyond the core project, the ecosystem includes the link:https://hub.quarkiverse.io/[Quarkiverse Hub], a community-run collection of link:https://quarkus.io/extensions/[Quarkus extensions] and related projects.
+The Quarkiverse Hub provides repository hosting with build, CI, and release publishing, so features land as versioned, testable modules you can adopt, fork, or extend.
+
+image::8-expectations.png[alt="Setting expectations for performance and developer experience with Quarkus", width=100%]
+
+So, that’s all for now, thank you for reading, and let’s meet again in the third article of this series, which will cover building your own stack with Quarkus.
+
+For a closer look at how Quarkus makes Java cloud-native, see the https://quarkus.io/blog/mmaler-blogpost-1-intro/[introductory blog post].