Using JDK Flight Recorder

Why
- WHAT IS QUARKUS?
- DEVELOPER JOY
- PERFORMANCE
- KUBERNETES NATIVE
- STANDARDS
- VERSATILITY
- CONTAINER FIRST
- USING SPRING?
  - SPRING OVERVIEW
  - MIGRATE TO QUARKUS
- AI
Learn
Extensions
Community
- SUPPORT
- BLOG
- DISCUSSION
- WORKING GROUPS
- PODCAST
- EVENTS
- NEWSLETTER
- ROADMAP
- BENEFACTORS
START CODING

Back to Guides

Version:

Main
Latest
3.40
3.33
3.27
3.20
3.15

Edit this Page

Guide categories

Getting started

Creating your first application
Your second Quarkus application
Using our tooling
Quarkus tools in your favorite IDE

Packaging

JARs

Packaging overview
Ahead-of-time (AOT) caching
Tree-shaking JAR dependencies
JLink packaging
Re-augment a Quarkus application

Native

Building a native executable
Native reference guide
Tips for writing native applications
Using SSL with native executables
Compressing native executables using UPX

Containers

Container images
Quarkus base runtime image

Release and distribution

Generating and using CycloneDX SBOMs
Packaging and releasing with JReleaser

Core

Contexts and Dependency Injection (CDI)

Introduction to Contexts and Dependency Injection (CDI)
Contexts and Dependency Injection
Application initialization and termination

Dev Services

Dev Services overview
Compose Dev Services
Using Podman with Quarkus

Configuration

Configuring your application
YAML configuration
Mapping configuration to objects
Configuration reference guide
Extending configuration support
All configuration options

Vert.x

Using Eclipse Vert.x API from a Quarkus application
Vert.x reference guide

Testing

Testing your application
Continuous testing
Testing components
Measuring the coverage of your tests

Web

HTTP

Quarkus for the Web
HTTP reference
Using Reactive Routes

REST

Writing REST services with Quarkus REST (formerly RESTEasy Reactive)
Using the REST Client
Writing JSON REST services
Using OpenAPI and Swagger UI
RESTEasy Classic
Using the legacy REST Client
Using the legacy REST Client with Multipart
Generating Jakarta REST resources with Panache
Use virtual threads in REST applications
Migrating to Quarkus REST (formerly RESTEasy Reactive)

GraphQL

SmallRye GraphQL
SmallRye GraphQL Client

WebSockets

Getting started with WebSockets Next
WebSockets Next reference guide
Using WebSockets with Undertow

Frontend

Web dependency locator

Data

Datasources

Configure data sources in Quarkus
Reactive SQL clients
Dev Services for databases

ORM and Hibernate

Using Hibernate ORM and Jakarta Persistence
Simplified Hibernate with Quarkus Data Hibernate
Simplified Hibernate ORM with Panache
Simplified Hibernate ORM with Panache and Kotlin
Using Hibernate Reactive
Simplified Hibernate Reactive with Panache
Use Hibernate Search with Hibernate ORM and Elasticsearch/OpenSearch
Use Hibernate Search in Standalone mode with Elasticsearch/OpenSearch
Using Blaze-Persistence

Transactions

Using transactions in Quarkus
Using Software Transactional Memory in Quarkus
Narayana LRA participant support
Dev Services for LRA

Validation

Validation with Hibernate Validator

NoSQL

Using the MongoDB Client
Simplified MongoDB with Panache
Simplified MongoDB with Panache and Kotlin
Dev Services for MongoDB
Using the Redis Client
Redis extension reference guide
Dev Services for Redis
Connecting to an Elasticsearch cluster
Dev Services for Elasticsearch
Using the Cassandra Client

Caching

Application data caching
Redis Cache
Infinispan Cache
Using the Infinispan Client
Infinispan Client extension reference guide
Dev Services for Infinispan

Database migration

Using Flyway
Using Liquibase
Using Liquibase MongoDB

Messaging

Messaging core

Quarkus Messaging extensions
Quarkus virtual thread support with Reactive Messaging

Events

Quarkus Signals
Using the event bus

JMS

Using JMS

Kafka

Getting started with Quarkus Messaging and Apache Kafka
Apache Kafka reference guide
Dev Services for Kafka
Using Apache Kafka Streams
Using Apache Kafka with Schema Registry and Avro
Using Apache Kafka with Schema Registry and JSON Schema
Kafka Dev UI
Dev Services for Apicurio Registry

AMQP

Getting started with Quarkus Messaging and AMQP 1.0
Reactive Messaging AMQP 1.0 Connector reference documentation
Dev Services for AMQP

Pulsar

Getting started with Quarkus Messaging and Apache Pulsar
Apache Pulsar reference guide
Dev Services for Pulsar

RabbitMQ

Getting started with Quarkus Messaging and RabbitMQ
Reactive Messaging RabbitMQ Connector reference documentation
Dev Services for RabbitMQ

Security

Security core

Quarkus Security overview
Quarkus Security architecture
Getting started with security by using Basic authentication and Jakarta Persistence
Security tips and tricks
Authorization of web endpoints
Proactive authentication
Cross-Origin Resource Sharing (CORS)
Cross-Site Request Forgery prevention
Using security with .properties file
Security testing
Secrets in configuration
Using a credentials provider
Using SSL with native executables
Security vulnerability detection and reporting in Quarkus

Authentication

Authentication mechanisms in Quarkus
Basic authentication
Enable Basic authentication
Using JWT RBAC
Build, sign, and encrypt JSON Web Tokens
Using OAuth2 RBAC
Using security with WebAuthn

OpenID Connect (OIDC)

OpenID Connect authorization code flow mechanism for protecting web applications
Protect a web application by using OpenID Connect (OIDC) authorization code flow
OpenID Connect (OIDC) Bearer token authentication
Protect a service application by using OpenID Connect (OIDC) Bearer token authentication
Protect a Quarkus web application by using an Auth0 OpenID Connect provider
OpenID Connect (OIDC) configuration properties
Quarkus OpenID Connect (OIDC) expanded configuration reference
Configuring well-known OpenID Connect providers
OpenID Connect client and token propagation quickstart
OpenID Connect (OIDC) and OAuth2 client and filters
OpenID Connect (OIDC) and OAuth2 dynamic client registration
Using OpenID Connect (OIDC) multitenancy
Dev Services and Dev UI for OpenID Connect (OIDC)
Migrate from Vert.x OIDC to Quarkus OIDC

Identity providers

Identity providers
Quarkus Security with Jakarta Persistence
Using security with JDBC
Using security with an LDAP realm
Using OpenID Connect (OIDC) and Keycloak to centralize authorization
Using Keycloak Admin Client

Execution model

Virtual threads

Virtual thread support reference
Use virtual threads in REST applications
Quarkus virtual thread support for gRPC services
Quarkus virtual thread support with Reactive Messaging

Reactive

Getting started with Reactive
Mutiny - Async for mere mortals
Quarkus reactive architecture
Using Reactive Routes
Reactive SQL clients
Using Hibernate Reactive
Simplified Hibernate Reactive with Panache
Using the event bus

Context propagation

Context propagation in Quarkus
Duplicated context, context locals, asynchronous processing and propagation

Cloud

Deployment

Kubernetes extension
Deploying Quarkus applications to OpenShift
Deploying Quarkus applications to OpenShift in a single step
Using S2I to deploy Quarkus applications to OpenShift
Deploying Quarkus Java applications to OpenShift by using a Docker build strategy
Deploying Quarkus applications compiled to native executables
Deploying to Microsoft Azure Cloud
Deploying to Google Cloud Platform (GCP)
Deploying to Heroku
Automate Quarkus deployment with Ansible

Serverless functions

AWS Lambda
AWS Lambda with Quarkus REST, Undertow, or Reactive Routes
AWS Lambda SnapStart configuration
Google Cloud Functions (serverless)
Google Cloud Functions (Serverless) with Quarkus REST, Undertow, or Reactive Routes
Azure Functions
Azure Functions with Quarkus REST, Undertow, or Reactive Routes
Funqy
Funqy HTTP binding (standalone)
Funqy AWS Lambda binding
Funqy HTTP Binding with AWS Lambda
Funqy Google Cloud Functions
Funqy HTTP binding with Google Cloud Functions
Funqy HTTP binding with Azure Functions
Funqy Knative events binding

Kubernetes

Kubernetes Client
Kubernetes Config
Dev Services for Kubernetes
Initialization tasks

Service discovery

Getting started with SmallRye Stork
Using Stork with Kubernetes
Stork reference guide
Automatic service registration with SmallRye Stork for Quarkus
Implementing a custom Stork service registrar

Operations

Management

Management interface reference
TLS registry reference
Using Proxy Registry

Health

SmallRye Health
Application info endpoint

Logging

Logging configuration
Centralized log management (Graylog, Logstash, Fluentd)
Using OpenTelemetry Logging

Metrics and telemetry

Micrometer Metrics
Collect metrics using Micrometer
Observability in Quarkus
Using OpenTelemetry
Using OpenTelemetry Tracing
Using OpenTelemetry Metrics
Micrometer and OpenTelemetry extension
Migrate from OpenTracing to OpenTelemetry tracing
Using JDK Flight Recorder
Observability Dev Services
Observability Dev Services with Grafana OTel LGTM

Resilience

SmallRye Fault Tolerance
Load shedding reference guide

Serialization

JSON

Writing JSON REST services

gRPC

gRPC
Getting started with gRPC
Implementing a gRPC service
Consuming a gRPC service
Using gRPC CLI
gRPC reference guide
gRPC code generation reference guide
Deploying your gRPC service in Kubernetes
Quarkus virtual thread support for gRPC services
Using xDS gRPC

Command line

Command mode applications
Command mode with Picocli
Command mode with Aesh
Scripting with Quarkus

Miscellaneous

Mail

Sending emails using SMTP
Mailer reference guide

Scheduling

Scheduling periodic tasks
Scheduler reference guide
Scheduling periodic tasks with Quartz

Templating

Qute templating engine
Qute reference guide