Quarkus as a powerful runtime - Blog post #2

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

Apply suggestions from code review

Co-authored-by: Jiri Herrmann <[email protected]>

Author: MichalMaler

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

@@ -0,0 +1,161 @@
+---
+layout: post
+title: 'Quarkus: A 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 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%]
+
+Cloud platforms reward services that start fast and stay lean.
+Quarkus is engineered for that reality: build-time processing reduces runtime overhead; the result is rapid startup, a small memory footprint, and frictionless deployment to containers, Kubernetes, and serverless.
+
+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, smooth Kubernetes/serverless deployments, and a great developer experience with live reload, which allows you to have very fast feedback by immediately seeing any changes you make to your code without the need to recompile and restart the server.
+
+On top of that, Quarkus integrates established Java frameworks, such as CDI, JAX-RS, and Hibernate. However, 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 adheres to 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 staple traits of 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
+
+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.
+For a broader industry perspective, see the link:https://cacm.acm.org/practice/application-frameworks/[ACM article on application frameworks].
+
+Native image generation with GraalVM enables cold starts in milliseconds and a minimal memory footprint.
+As such, it allows cost-effective deployment in containers and serverless environments.
+
+Quarkus also includes structured health checks, metrics, and tracing, and thereby aligns 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 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
+
+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 has been exemplified 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 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.
+
+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.