Guides

Version:

所有配置选项列出每个扩展的所有配置属性

Creating your first application Build a REST API with live reload, dependency injection, and tests, in under 15 minutes.
Your second Quarkus application Discover some of the features that make developing with Quarkus a joyful experience.
Using our tooling 探索Quarkus开发者工具链，让Quarkus开发如此快速和愉快。
Quarkus tools in your favorite IDE 了解更多关于Quarkus在IDE中的整合。

Packaging overview An overview of the different ways to package a Quarkus application (JARs, uber-JARs, AOT caching, jlink images, native executables, and container images) with guidance on choosing the right option for your workload.
Ahead-of-time (AOT) caching This guide explains how to use Leyden AOT caching with Quarkus for dramatically faster startup times on JDK 24+.
Tree-shaking JAR dependencies This guide explains how to reduce JAR size by removing unreachable classes from runtime dependencies.
JLink packaging The jlink extension produces a custom Java runtime image containing only the modules needed to run the application.
Re-augment a Quarkus application 使用易变的jars来重建具有不同构建时间配置的应用程序。

构建一个本地可执行文件用GraalVM或Mandrel构建原生可执行文件。
Native reference guide This guide is a companion to the Building a Native Executable, Using SSL With Native Images, and Writing Native Applications, guides.
编写原生应用程序的提示本指南收集了一些提示，帮助你解决将应用程序编译为原生可执行文件时遇到的问题。
Using SSL with native executables In this guide, we will discuss how you can get your native images to support SSL, as native images don't support it out of the box.
Compressing native executables using UPX Ultimate Packer for eXecutables (UPX) is a compression tool reducing the size of executables.

Container images Learn how to build and push container images with Jib, OpenShift, Docker, or Podman as part of the Quarkus build.
Quarkus base runtime image To ease the containerization of native executables, Quarkus provides a base image providing the requirements to run these executables.

Generating and using CycloneDX SBOMs This guide explains how to generate and use SBOMs for Quarkus applications in the CycloneDX format.
Packaging and releasing with JReleaser This guide covers packaging and releasing CLI applications using the JReleaser tool.

Introduction to Contexts and Dependency Injection (CDI) Quarkus DI solution is based on the [Jakarta Contexts and Dependency Injection 4.1](https://jakarta.ee/specifications/cdi/4.1/jakarta-cdi-spec-4.1.html) specification.
Contexts and Dependency Injection 更深入地了解Quarkus对CDI的实现。
Application initialization and termination You often need to execute custom actions when the application starts and clean up everything when the application stops.

Dev Services overview An introduction to Dev Services and a list of all extensions that support Dev Services and their configuration options.
Compose Dev Services Configure custom Dev Services using Docker or Podman Compose.
Using Podman with Quarkus Podman is an open-source, daemonless, and rootless container engine for developing, managing, and running OCI Containers on Linux, Windows and Mac.

Configuring your application Hardcoded values in your code is a no go (even if we all did it at some point ;-)).
YAML configuration Optionally, use application.yaml instead of application.properties to configure your application.
Mapping configuration to objects 将多个配置属性分组到一个对象中。
Configuration reference guide 了解更多关于如何配置你的Quarkus应用程序。
Extending configuration support 扩展和定制配置。
所有配置选项列出每个扩展的所有配置属性

Using Eclipse Vert.x API from a Quarkus application 本指南解释了如何在Quarkus中使用Vert.x来构建响应式应用程序。
Vert.x reference guide 本参考指南提供了关于Quarkus使用的Vert.x实例的使用和配置的高级细节。

Testing your application This guide covers testing in JVM mode, native mode, and injection of resources into tests
Continuous testing 通过持续测试获得早期测试反馈。
Testing components This reference guide covers the `QuarkusComponentTestExtension`, a JUnit extension to ease the testing of components and mocking of their dependencies.
测量你的测试的覆盖率本指南解释了如何测量你的Quarkus应用程序的测试覆盖率。

Quarkus for the Web Learn more about creating all kinds of Web applications with Quarkus.
HTTP reference 了解更多关于配置Quarkus基于Vert.x的HTTP层的信息--如果你使用servlets的话，还有Undertow。
HTTP/3 reference Enable HTTP/3 (QUIC) support in Quarkus for reduced latency and improved performance.
Native transport reference Configure Netty native transports (epoll, kqueue, io_uring) for improved I/O performance.
使用响应式路由本指南演示了如何使用响应式路由。

Writing REST services with Quarkus REST (formerly RESTEasy Reactive) Discover how to develop highly scalable reactive REST services with Jakarta REST and Quarkus REST.
Using the REST Client This guide explains how to use the REST Client.
Writing JSON REST services JSON is now the lingua franca between microservices.
使用OpenAPI和Swagger UI 本指南解释了如何使用OpenAPI扩展来生成OpenAPI描述符，并获得一个Swagger UI前端来测试你的REST端点。
RESTEasy Classic
Using the legacy REST Client This guide explains how to use the RESTEasy Classic REST Client in order to interact with REST APIs (JSON and other) with very little effort.
Using the legacy REST Client with Multipart This guide explains how to use the RESTEasy Classic REST Client to send multipart REST requests, typically to upload documents.
Generating Jakarta REST resources with Panache Hibernate ORM REST Data with Panache simplifies the creation of CRUD applications based on Jakarta REST and Hibernate ORM.
Use virtual threads in REST applications How to use virtual threads in a REST application
Migrating to Quarkus REST (formerly RESTEasy Reactive) Migrating from RESTEasy Classic to Quarkus REST (formerly RESTEasy Reactive) is straightforward in most cases, however there are a few cases that require some attention.

SmallRye GraphQL 本指南解释了如何利用SmallRye GraphQL来实现GraphQL服务。
SmallRye GraphQL Client 本指南解释了如何利用SmallRye GraphQL客户端来消费GraphQL服务。

Getting started with WebSockets Next Get started with WebSockets Next to create interactive web applications.
WebSockets Next reference guide The quarkus-websockets-next extension provides a modern declarative API to define WebSocket server and client endpoints.
Using WebSockets with Undertow This guide explains how your Quarkus application can utilize web sockets to create interactive web applications.

Web dependency locator Learn more about how to use the web dependency locator

Configure data sources in Quarkus Use a unified configuration model to define data sources for Java Database Connectivity (JDBC) and Reactive drivers.
Reactive SQL clients 本指南涵盖了如何在Quarkus中使用响应式SQL客户端。
Dev Services for databases When testing or running in dev mode Quarkus can provide you with a zero-config database out of the box, a feature we refer to as Dev Services.

Using Hibernate ORM and Jakarta Persistence Hibernate ORM is the de facto Jakarta Persistence implementation and offers you the full breadth of an Object Relational Mapper.
Simplified Hibernate with Quarkus Data Hibernate Hibernate is the de facto Jakarta Persistence implementation and offers you the full breadth of an Object Relational Mapper.
Getting Started with Quarkus Data Hibernate A step-by-step guide to database access in Quarkus
使用Panache简化Hibernate ORM Panache focuses on making your Hibernate ORM entities trivial and fun to write.
用Panache和Kotlin简化Hibernate ORM This explains the specifics of using Hibernate ORM with Panache in a Kotlin project.
使用Hibernate响应式 Hibernate Reactive is a reactive API for Hibernate ORM, supporting non-blocking database drivers and a reactive style of interaction with the database.
使用Panache简化Hibernate Reactive 基于Hibernate 响应式的简化响应式ORM层。
Use Hibernate Search with Hibernate ORM and Elasticsearch/OpenSearch Hibernate Search with Hibernate ORM allows you to index your entities in an Elasticsearch/OpenSearch cluster and easily offer full text search in all your Hibernate ORM-based applications.
Use Hibernate Search in Standalone mode with Elasticsearch/OpenSearch Hibernate Search Standalone allows you to index your entities in an Elasticsearch/OpenSearch cluster and easily offer full text search in all your applications, even without Hibernate ORM.
使用Blaze-Persistence 本指南解释了如何使用Blaze-Persistence来简化你的数据和DTO层。

Using transactions in Quarkus The quarkus-narayana-jta extension provides a Transaction Manager that coordinates and exposes transactions to your applications as described in the Jakarta Transactions specification, formerly known as Java Transaction API (JTA).
Using Software Transactional Memory in Quarkus This guide covers the usage of Software Transactional Memory (STM).
Narayana LRA participant support This guide covers the usage of LRA to coordinate activities across services.
Dev Services for LRA Start the Narayana LRA coordinator automatically in dev and test modes.

用Hibernate验证器进行验证本指南包括如何在REST服务中使用Hibernate验证器/Bean验证。

使用MongoDB客户端本指南包括如何在Quarkus中使用MongoDB。
使用Panache简化MongoDB 本指南涵盖了MongoDB使用活动记录和存储库的用法。
用Panache和Kotlin简化MongoDB 本指南涵盖了在Kotlin项目中使用活动记录和存储库的MongoDB的用法。
Dev Services for MongoDB Quarkus supports a feature called Dev Services that allows you to create various datasources without any config.
使用Redis客户端本指南包括如何在Quarkus中使用Redis数据存储。
Redis extension reference guide Redis is an in-memory data store used as a database, cache, streaming engine, and message broker.
Redis的Dev Services 在开发和测试模式下自动启动Redis。
Connecting to an Elasticsearch cluster This guide covers how to interact with an Elasticsearch cluster using the low level REST client or the Elasticsearch Java client.
Dev Services for Elasticsearch Start Elasticsearch automatically in dev and test modes
Using the Cassandra Client 本指南包括如何在Quarkus中使用Apache Cassandra NoSQL数据库。

Application data caching 本指南解释了如何使用简单的注解来缓存CDI Bean中昂贵的方法调用。
Redis Cache Use Redis as the Quarkus cache backend
Infinispan Cache Use Infinispan as the Quarkus cache backend
Using the Infinispan Client This guide covers how to use Infinispan with Quarkus.
Infinispan Client extension reference guide Infinispan is an in memory distributed data store and cache server that offers flexible deployment options and robust capabilities for storing, managing, and processing data.
Dev Services for Infinispan Start Infinispan automatically in dev and test modes.

使用Flyway 本指南包括如何使用Flyway扩展来管理你的模式迁移。
Using Liquibase 本指南涵盖了如何使用Liquibase扩展来管理你的模式迁移。
Using Liquibase MongoDB Liquibase is an open source tool for database schema change management, it allows managing MongoDB databases via its MongoDB Extension.

Quarkus Messaging extensions Event-driven messaging systems have become the backbone of most modern applications, enabling the building of message-driven microservices or complex data streaming pipelines.
Quarkus virtual thread support with Reactive Messaging This guide explains how to benefit from Java virtual threads when writing message processing applications in Quarkus.

Quarkus Signals Learn more about how application components can interact in a loosely coupled fashion
使用事件总线本指南解释了不同的Bean如何使用事件总线进行交互。

使用JMS 本指南演示了你的Quarkus应用程序如何使用AMQP 1.0的Apache Qpid JMS，或使用Apache ActiveMQ Artemis JMS进行JMS信息传递。

Getting started with Quarkus Messaging and Apache Kafka Build two applications that communicate via Apache Kafka using Quarkus Messaging.
Apache Kafka reference guide This reference guide provides an in-depth look on Apache Kafka and Quarkus Messaging extensions.
Kafka开发服务（Dev Services）在开发和测试模式下自动启动Apache Kafka。
使用Apache Kafka Streams 本指南展示了你的Quarkus应用如何利用Apache Kafka Streams API来实现基于Apache Kafka的流处理应用。
使用Apache Kafka与模式仓库和Avro 使用Apache Kafka，Avro序列化记录，并连接到一个模式注册中心。
Using Apache Kafka with Schema Registry and JSON Schema Use Apache Kafka, Json Schema serialized records, and connect to a schema registry.
Kafka Dev UI Dev UI extension for Apache Kafka for development purposes.
Apicurio注册表的开发服务在开发和测试模式下自动启动Apicurio仓库。

Getting started with Quarkus Messaging and AMQP 1.0 This guide demonstrates how your Quarkus application can utilize Quarkus Messaging to interact with AMQP.
Reactive Messaging AMQP 1.0 Connector reference documentation This guide is the companion to the Getting Started with AMQP 1.0.
AMQP的开发服务在开发和测试模式下自动启动AMQP。

Getting started with Quarkus Messaging and Apache Pulsar This guide demonstrates how your Quarkus application can utilize Quarkus Messaging to interact with Apache Pulsar.
Apache Pulsar reference guide This reference guide provides an in-depth look on Apache Pulsar and the Quarkus Messaging extensions.
Dev Services for Pulsar With Quarkus Messaging Pulsar extension (quarkus-messaging-pulsar) Dev Services for Pulsar automatically starts a Pulsar broker in dev mode and when running tests.

Getting started with Quarkus Messaging and RabbitMQ This guide demonstrates how your Quarkus application can utilize Quarkus Messaging to interact with RabbitMQ.
Reactive Messaging RabbitMQ Connector reference documentation This guide is the companion to the Getting Started with RabbitMQ.
Dev Services for RabbitMQ Dev Services for RabbitMQ automatically starts a RabbitMQ broker in dev mode and when running tests.

Quarkus Security overview Quarkus Security is a framework that provides the architecture, multiple authentication and authorization mechanisms, and other tools to build secure and production-quality Java applications.
Quarkus Security architecture The Quarkus Security architecture provides several built-in authentication mechanisms and is highly customizable.
Getting started with security by using Basic authentication and Jakarta Persistence Get started with Quarkus Security by securing your Quarkus application endpoints with the built-in Quarkus Basic authentication and the Jakarta Persistence identity provider, enabling role-based access control.
Security tips and tricks
Authorization of web endpoints Quarkus incorporates a pluggable web security layer.
主动认证 Learn how to manage proactive authentication in Quarkus, including customizing settings and handling exceptions.
Cross-Origin Resource Sharing (CORS) Enable and configure CORS in Quarkus to specify allowed origins, methods, and headers, guiding browsers in handling cross-origin requests safely.
Cross-Site Request Forgery prevention Cross-Site Request Forgery (CSRF) is an attack that forces an end user to execute unwanted actions on a web application in which they are currently authenticated.
Using security with .properties file 本指南展示了你的Quarkus应用程序如何使用.properties文件来存储你的用户身份。
Security testing This document describes how to test Quarkus Security.
Secrets in configuration Use encrypted configuration values to protect sensitive passwords, secrets, tokens and keys.
Using a credentials provider This guide explains how to use the Vault credentials provider or implement your own custom one.
Using SSL with native executables In this guide, we will discuss how you can get your native images to support SSL, as native images don't support it out of the box.
Security vulnerability detection and reporting in Quarkus Most of the Quarkus tags are registered in the US National Vulnerability Database (NVD) in Common Platform Enumeration (CPE) name format.

Authentication mechanisms in Quarkus The Quarkus Security framework supports multiple authentication mechanisms, which you can use to secure your applications.
Basic authentication HTTP Basic authentication is one of the least resource-demanding techniques that enforce access controls to web resources.
Enable Basic authentication Enable Basic authentication to require a username and password before users can access your Quarkus application.
使用 JWT RBAC This guide explains how your application can use SmallRye JWT to provide secured access to the Jakarta REST endpoints.
Build, sign, and encrypt JSON Web Tokens JSON Web Token (JWT) is defined by the RFC 7519 specification as a compact, URL-safe means of representing claims.
使用OAuth2 RBAC This guide explains how your Quarkus application can utilize OAuth2 tokens to provide secured access to the Jakarta REST endpoints.
Using security with WebAuthn 本指南演示了你的Quarkus应用程序如何使用WebAuthn认证来代替密码。
SPIFFE Client SPIFFE (Secure Production Identity Framework for Everyone) provides cryptographic workload identities in zero-trust environments.

OpenID Connect authorization code flow mechanism for protecting web applications To protect your web applications, you can use the industry-standard OpenID Connect (OIDC) Authorization Code Flow mechanism provided by the Quarkus OIDC extension.
Protect a web application by using OpenID Connect (OIDC) authorization code flow Discover how to secure application HTTP endpoints by using the Quarkus OpenID Connect (OIDC) authorization code flow mechanism with the Quarkus OIDC extension, providing robust authentication and authorization.
OpenID Connect (OIDC) Bearer token authentication Secure HTTP access to Jakarta REST (formerly known as JAX-RS) endpoints in your application with Bearer token authentication by using the Quarkus OpenID Connect (OIDC) extension.
Protect a service application by using OpenID Connect (OIDC) Bearer token authentication Use the Quarkus OpenID Connect (OIDC) extension to secure a Jakarta REST application with Bearer token authentication.
Protect a Quarkus web application by using an Auth0 OpenID Connect provider Quarkus Security provides comprehensive OpenId Connect (OIDC) and OAuth2 support with its quarkus-oidc extension, supporting both Authorization code flow and Bearer token authentication mechanisms.
OpenID Connect (OIDC) configuration properties As a Quarkus developer, you configure the Quarkus OpenID Connect (OIDC) extension by setting the following properties in the src/main/resources/application.properties file.
Quarkus OpenID Connect (OIDC) expanded configuration reference Quarkus OIDC quarkus-oidc extension provides a comprehensive, highly adaptable and configurable OIDC and OAuth2 adapter implementation.
Configuring well-known OpenID Connect providers This document explains how to configure well-known social OIDC and OAuth2 providers.
OpenID Connect client and token propagation quickstart Learn how to use OpenID Connect (OIDC) and OAuth2 clients with filters to get, refresh, and propagate access tokens in your applications.
OpenID Connect (OIDC) and OAuth2 client and filters You can use Quarkus extensions for OpenID Connect and OAuth 2.0 access token management, focusing on acquiring, refreshing, and propagating tokens.
OpenID Connect (OIDC) and OAuth2 dynamic client registration Typically, you have to register an OIDC client (application) manually in your OIDC provider’s dashboard.
Using OpenID Connect (OIDC) multitenancy This guide demonstrates how your OpenID Connect (OIDC) application can support multitenancy to serve multiple tenants from a single application.
Dev Services and Dev UI for OpenID Connect (OIDC) You can use Dev Services for Keycloak and the Dev UI for the OpenID Connect (OIDC) Keycloak provider and adapt these services for other OpenID Connect providers.
Migrate from Vert.x OIDC to Quarkus OIDC Learn how to migrate your Vert.x OIDC application to Quarkus and choose to either retain Vert.x OIDC or replace it with Quarkus OIDC.

身份提供者（Identity Providers） In the Quarkus Security framework, identity providers play a crucial role in authentication and authorization by verifying user identities.
Quarkus Security with Jakarta Persistence You can configure your application to use Jakarta Persistence to store users' identities.
Using security with JDBC 本指南展示了你的Quarkus应用程序如何使用数据库来存储你的用户身份。
Using security with an LDAP realm This guide demonstrates how your Quarkus application can use an LDAP directory to store your user identities.
Using OpenID Connect (OIDC) and Keycloak to centralize authorization Learn how to enable bearer token authorization in your Quarkus application by using Keycloak Authorization Services for secure access to protected resources.
Using Keycloak Admin Client The Quarkus Keycloak Admin Client and its reactive twin support Keycloak Admin Client which can be used to configure a running Keycloak server.

Virtual thread support reference This guide explains how to benefit from Java 21+ virtual threads in Quarkus application.
Use virtual threads in REST applications How to use virtual threads in a REST application
Quarkus virtual thread support for gRPC services This guide explains how to benefit from Java virtual threads when implementing a gRPC service.
Quarkus virtual thread support with Reactive Messaging This guide explains how to benefit from Java virtual threads when writing message processing applications in Quarkus.

Getting started with Reactive 了解有关使用Quarkus开发响应式应用程序的更多信息。
Mutiny - Async for mere mortals Mutiny is an intuitive, reactive programming library.
Quarkus reactive architecture 了解关于Quarkus响应式架构的更多信息。
使用响应式路由本指南演示了如何使用响应式路由。
Reactive SQL clients 本指南涵盖了如何在Quarkus中使用响应式SQL客户端。
使用Hibernate响应式 Hibernate Reactive is a reactive API for Hibernate ORM, supporting non-blocking database drivers and a reactive style of interaction with the database.
使用Panache简化Hibernate Reactive 基于Hibernate 响应式的简化响应式ORM层。
使用事件总线本指南解释了不同的Bean如何使用事件总线进行交互。

Context propagation in Quarkus 了解更多关于如何利用SmallRye Context Propagation传递上下文信息的信息。
Duplicated context, context locals, asynchronous processing and propagation When using a traditional, blocking, and synchronous framework, processing of each request is performed in a dedicated thread.

Kubernetes extension 本指南涵盖了如何在Kubernetes上部署一个原生应用程序。
Deploying Quarkus applications to OpenShift This guide describes the deployment of Quarkus applications to OpenShift.
Deploying Quarkus applications to OpenShift in a single step This guide describes how to build and deploy a Quarkus application to OpenShift in a single step.
Using S2I to deploy Quarkus applications to OpenShift This guide describes how to build and deploy a Quarkus application on OpenShift by using Source-to-Image (S2I).
Deploying Quarkus Java applications to OpenShift by using a Docker build strategy This guide describes how to build and deploy a Quarkus application on OpenShift by using the Docker build strategy.
Deploying Quarkus applications compiled to native executables This guide describes how to deploy a Quarkus application to OpenShift compiled to native executables.
部署到微软Azure云 Deploy a Quarkus application to the Microsoft Azure cloud platform.
Deploying to Google Cloud Platform (GCP) 本指南解释了如何将Quarkus应用程序部署到谷歌云。
部署到Heroku 在Heroku上部署你的Quarkus应用程序。
Automate Quarkus deployment with Ansible Build and deploy your Quarkus App using Ansible

AWS Lambda This guide explains how you can deploy Quarkus-based AWS Lambdas.
AWS Lambda with Quarkus REST, Undertow, or Reactive Routes This guide explains how you can deploy Vert.x Web, Servlet, or RESTEasy microservices as an AWS Lambda.
AWS Lambda SnapStart configuration This document explains how to optimize your AWS Lambda application for SnapStart
Google Cloud Functions (serverless) 本指南解释了如何部署基于Quarkus的Google Cloud Functions。
Google Cloud Functions (Serverless) with Quarkus REST, Undertow, or Reactive Routes 本指南介绍了如何将Vert.x Web、Servlet或RESTEasy微服务部署为Google Cloud Function。
Azure Functions Integrate Quarkus with the Microsoft Azure functions that you have written.
Azure Functions with Quarkus REST, Undertow, or Reactive Routes Deploy Vert.x Web, Servlet, or RESTEasy microservices as a Microsoft Azure Function.
Funqy 本指南解释了Funqy框架的基础知识，这是一个简单的可移植的跨供应商的云功能API。
Funqy HTTP binding (standalone) 本指南解释了Funqy的HTTP绑定。
Funqy AWS Lambda binding This guide explains Funqy's AWS Lambda binding.
Funqy HTTP Binding with AWS Lambda� This guide explains Funqy's AWS Lambda HTTP binding.
Funqy Google Cloud Functions 本指南解释了Funqy的Google Cloud Platform Functions绑定。
Funqy HTTP binding with Google Cloud Functions 本指南解释了Funqy的Google Cloud Platform Functions HTTP绑定。
Funqy HTTP binding with Azure Functions Use Funqy HTTP binding with Microsoft Azure Functions to deploy your serverless Quarkus applications.
Funqy Knative events binding 本指南解释了Funqy的Knative Events绑定。

Kubernetes Client 本指南演示了如何使用Fabric8 Kubernetes客户端与你的Kubernetes集群互动。
Kubernetes Config 使用ConfigMaps作为Quarkus应用程序的配置源。
Dev Services for Kubernetes Start a Kubernetes API server automatically in dev and test modes.
Initialization tasks This reference guide explains how to configure initialization tasks

Getting started with SmallRye Stork The essence of distributed systems resides in the interaction between services.
Using Stork with Kubernetes This guide explains how to use Stork with Kubernetes for service discovery and load balancing.
Stork reference guide This guide is the companion to the Stork Getting Started Guide.
Automatic service registration with SmallRye Stork for Quarkus This guide explains how to enable automatic registration and deregistration of a Quarkus application using SmallRye Stork and Consul, with minimal or no configuration.
Implementing a custom Stork service registrar This guide explains how to implement a custom service registrar for SmallRye Stork and use it to programmatically register service instances at startup.

Management interface reference Management interface configuration
TLS registry reference TLS registry configuration and usage
Using Proxy Registry This guide explains how to use the Proxy Registry in your Quarkus application.

SmallRye Health 本指南展示了您的Quarkus应用程序如何利用SmallRye Health扩展。
Application info endpoint Expose build, git, Java, and OS information via the /q/info endpoint.

Logging configuration Read about the use of logging API in Quarkus, configuring logging output, and using logging adapters to unify the output from other logging APIs.
Centralized log management (Graylog, Logstash, Fluentd) This guide explains how to centralize your logs with Graylog, Logstash or Fluentd.
Using OpenTelemetry Logging This guide explains how your Quarkus application can utilize OpenTelemetry Logging to provide centralised logging for interactive web applications.

Micrometer Metrics Use Micrometer to collect metrics produced by Quarkus, its extensions, and your application.
Collect metrics using Micrometer Create an application that uses the Micrometer metrics library to collect runtime, extension and application metrics and expose them as a Prometheus (OpenMetrics) endpoint.
Observability in Quarkus An overview of the observability capabilities of Quarkus.
使用OpenTelemetry This guide explains how your Quarkus application can utilize OpenTelemetry to provide observability for interactive web applications.
Using OpenTelemetry Tracing This guide explains how your Quarkus application can utilize OpenTelemetry Tracing to provide distributed tracing for interactive web applications.
Using OpenTelemetry Metrics This guide explains how your Quarkus application can utilize OpenTelemetry to provide metrics for interactive web applications.
Micrometer and OpenTelemetry extension Guide to send Micrometer data to OpenTelemetry.
Migrate from OpenTracing to OpenTelemetry tracing Migrate an application from OpenTracing to OpenTelemetry tracing in Quarkus 3.x.
Using JDK Flight Recorder This guide explains how JDK Flight Recorder (JFR) can be extended to provide additional insight into your Quarkus application.
Observability Dev Services Entry point for Observability DevServices
Observability Dev Services with Grafana OTel LGTM Instructions on how to use Grafana Otel LGTM
Micrometer Observation API Use the Micrometer Observation API to produce correlated traces and metrics from a single instrumentation point.

SmallRye Fault Tolerance 本指南展示了你的Quarkus应用程序如何通过SmallRye容错扩展来利用SmallRye容错规范。
Load shedding reference guide Load shedding is the practice of detecting service overload and rejecting requests.

Writing JSON REST services JSON is now the lingua franca between microservices.

gRPC 一切gRPC的总入口。
Getting started with gRPC 本指南解释了如何在你的Quarkus应用程序中开始使用gRPC。
Implementing a gRPC service 本指南解释了如何在你的Quarkus应用程序中实现gRPC服务。
Consuming a gRPC service 本指南解释了如何在你的Quarkus应用程序中消费gRPC服务。
Using gRPC CLI This page explains how to use gRPC CLI.
gRPC reference guide Learn how to configure gRPC server and clients.
gRPC code generation reference guide Learn how to configure gRPC code generation.
Deploying your gRPC service in Kubernetes This guide explains how to deploy your gRPC services in Quarkus to Kubernetes.
Quarkus virtual thread support for gRPC services This guide explains how to benefit from Java virtual threads when implementing a gRPC service.

Command mode applications 本参考指南解释了如何用Quarkus开发命令行应用程序。
Command mode with Picocli 用Picocli扩展简化了命令行应用程序的创建。
Command mode with Aesh Develop command line applications with the Aesh extension.
Scripting with Quarkus 用jbang轻松实现基于Quarkus的脚本。

Sending emails using SMTP 了解更多关于如何使用我们的响应式电子邮件客户端从Quarkus应用程序发送电子邮件。
Mailer reference guide 本参考指南更详细地解释了Quarkus Mailer的配置和使用。

Scheduling periodic tasks Modern applications often need to run specific tasks periodically.
Scheduler reference guide 了解更多关于Scheduler扩展的信息。
Scheduling periodic tasks with Quartz 你的计划任务需要集群支持？本指南解释了如何使用Quartz扩展来实现这一点。

Qute templating engine 了解更多关于如何利用Qute模板引擎在你的应用程序中使用模板。
Qute reference guide 了解你需要知道的关于Qute模板引擎的一切。

Building Quarkus apps with Quarkus Command Line Interface (CLI) 使用Quarkus CLI来创建、构建、运行和管理Quarkus项目的扩展。
Quarkus and Maven Develop and build your Quarkus application with Maven
Quarkus Maven plugin The Quarkus Maven Plugin builds the Quarkus applications, and provides helpers to launch dev mode or build native executables.
Quarkus and Gradle Develop and build your Quarkus application with Gradle
Build analytics This guide presents what build analytics is and how to configure it.
Update projects to the latest Quarkus version Learn how to upgrade your projects to the latest version of Quarkus

Quarkus extension for Spring DI API 虽然我们鼓励你使用CDI注解进行注入，但Quarkus以spring-di扩展的形式为Spring依赖注入提供了一个兼容层。
Quarkus extension for Spring Web API While you are encouraged to use Jakarta REST annotations for defining REST endpoints, Quarkus provides a compatibility layer for Spring Web in the form of the spring-web extension.
Extension for Spring Data API 虽然我们鼓励你使用Hibernate ORM与Panache作为你的数据层，但Quarkus以spring-data-jpa扩展的形式为Spring Data JPA提供了一个兼容层。
Quarkus extension for Spring Transaction API While you are encouraged to use Jakarta @Transactional directly, Quarkus provides a compatibility layer for Spring @Transactional in the form of the spring-tx extension.
使用Spring Boot属性API访问应用程序属性 Use Spring Boot's @ConfigurationProperties in place of MicroProfile Config annotations
Quarkus extension for Spring Security API While you are encouraged to use the Quarkus Security layer to secure your applications, Quarkus provides a compatibility layer for Spring Security in the form of the spring-security extension.
Quarkus extension for Spring Cache API 虽然我们鼓励你使用Cache扩展来进行应用级缓存，但Quarkus以spring-cache扩展的形式为Spring Cache提供了一个兼容层。
Quarkus extension for Spring Scheduling API 虽然我们鼓励你使用Scheduler或Quartz扩展来安排任务，但Quarkus以spring-scheduled扩展的形式为Spring Scheduled提供了一个兼容层。
Extension for Spring Data REST Spring Data REST简化了基于我们Spring Data兼容层的CRUD应用程序的创建。
从 Spring Cloud 配置服务器中读取配置属性 Quarkus以spring-cloud-config-client扩展的形式为Spring Cloud Config提供了一个兼容层。
Testing Spring-style applications in Quarkus Quarkus supports the @SpringBootTest annotation out of the box, letting Spring developers write tests in a familiar style while running on the Quarkus runtime.

Apache Camel on Quarkus 本指南包括与Apache Camel的系统集成

使用Kotlin 本指南解释了如何使用Kotlin。

Quarkus reactive architecture 了解关于Quarkus响应式架构的更多信息。
平台了解更多关于Quarkus 世界中我们称之为平台的东西。
Class loading reference 了解关于Quarkus类加载基础设施的更多信息。
Quarkus modularity Quarkus modularity builds on JPMS to produce a complete and enhanced module graph for the application at build time.
Modularity SPI reference Reference for the build items that Quarkus extensions use to participate in Quarkus modularity.
开发模式与生产应用程序有何不同开发模式与生产应用程序有何不同
Quarkus extension registry 了解更多关于扩展仓库的概念，以及如何使用自己的扩展仓库。
Measuring performance 本指南解释了如何最好地测量Quarkus应用程序的占用空间。

Writing your own extension Quarkus extensions optimize your applications by pushing as much work as possible to the build operation.
Building my first extension 一步一步地学习如何构建一个简单的扩展。
Quarkus extension metadata Quarkus extensions are distributed as Maven JAR artifacts that application and other libraries may depend on.
Extension capabilities 在Quarkus中如何实现和使用功能。
CDI integration guide 了解如何将你的扩展与Quarkus的CDI容器集成。
Conditional extension dependencies Trigger the inclusion of additional extensions based on certain conditions.
Build items 探索你可以在你的扩展中消费/提供的所有BuildItems。
开发用户界面 Learn more about Dev UI
Extension codestart Provide users with initial code for extensions when generating Quarkus applications on code.quarkus.io and all the Quarkus tooling.
Writing a Dev Service Learn how to develop a Dev Service for your extension in order to replace an external service in development mode.
Dev MCP Learn more about Dev MCP
Agent MCP Learn more about the Quarkus Agent MCP server for AI coding agents
Dev Assistant Learn more about the Dev Assistant
A maturity matrix for Quarkus extensions Quarkus extensions can do a lot, or a little.
Frequently asked questions about writing extensions

Contribute to Quarkus documentation Contribute to the documentation by using the recommended diataxis content types, steps, workflow, and style guidance to ensure the content successfully renders on the Quarkus website portal.
Quarkus documentation content types Quarkus documentation is structured into four distinct content types: concepts, how-tos, tutorials, and references.
Quarkus style and content guidelines Guidelines are provided to help you to contribute clear and consistent content that is also sourced in the required diataxis structure and composition of Quarkus documentation.
Creating a tutorial Create a new tutorial that guides users through creating, running, and testing a Quarkus application that uses annotations from an imaginary extension.

Defining and executing business rules with Drools Drools is the most used rule engine implementation in the Java ecosystem.

Quarkus是开放的。这个项目的所有依赖关系在Apache Software License 2.0许可或者可以在有互换性的许可下使用。

这个网站使用 Jekyll 来构建，代码托管于Github Pages，完全开源。当需要改善和丰富内容的时候，我们会从网站项目创建分支，然后修正并发布到网站。

导航栏

社交媒体

协助

Languages

Quarkus由社区项目组成：

Copyright © Quarkus. All rights reserved. For details on our trademarks, please visit our Trademark Policy and Trademark List. Trademarks of third parties are owned by their respective holders and their mention here does not suggest any endorsement or association.