All configuration options

Back to Guides

By Version

Configuration property fixed at build time - All other configuration properties are overridable at runtime

Agroal - Database connection pool

Type

Default

quarkus.datasource.jdbc

quarkus.datasource."datasource-name".jdbc

If we create a JDBC datasource for this datasource.

Environment variable: QUARKUS_DATASOURCE_JDBC

boolean

true

quarkus.datasource.jdbc.driver

quarkus.datasource."datasource-name".jdbc.driver

The datasource driver class name

Environment variable: QUARKUS_DATASOURCE_JDBC_DRIVER

string

quarkus.datasource.jdbc.transactions

quarkus.datasource."datasource-name".jdbc.transactions

Whether we want to use regular JDBC transactions, XA, or disable all transactional capabilities.

When enabling XA you will need a driver implementing javax.sql.XADataSource.

Environment variable: QUARKUS_DATASOURCE_JDBC_TRANSACTIONS

enabledIntegrate the JDBC Datasource with the JTA TransactionManager of Quarkus. This is the default., xaSimilarly to enabled, also enables integration with the JTA TransactionManager of Quarkus, but enabling XA transactions as well. Requires a JDBC driver implementing javax.sql.XADataSource, disabledDisables the Agroal integration with the Narayana TransactionManager. This is typically a bad idea, and is only useful in special cases\: make sure to not use this without having a deep understanding of the implications.

enabledIntegrate the JDBC Datasource with the JTA TransactionManager of Quarkus. This is the default.

quarkus.datasource.jdbc.enable-metrics

quarkus.datasource."datasource-name".jdbc.enable-metrics

Enable datasource metrics collection. If unspecified, collecting metrics will be enabled by default if a metrics extension is active.

Environment variable: QUARKUS_DATASOURCE_JDBC_ENABLE_METRICS

boolean

quarkus.datasource.jdbc.telemetry

quarkus.datasource."datasource-name".jdbc.telemetry

Enable OpenTelemetry JDBC instrumentation.

Environment variable: QUARKUS_DATASOURCE_JDBC_TELEMETRY

boolean

false

quarkus.datasource.jdbc.url

quarkus.datasource."datasource-name".jdbc.url

The datasource URL

Environment variable: QUARKUS_DATASOURCE_JDBC_URL

string

quarkus.datasource.jdbc.initial-size

quarkus.datasource."datasource-name".jdbc.initial-size

The initial size of the pool. Usually you will want to set the initial size to match at least the minimal size, but this is not enforced so to allow for architectures which prefer a lazy initialization of the connections on boot, while being able to sustain a minimal pool size after boot.

Environment variable: QUARKUS_DATASOURCE_JDBC_INITIAL_SIZE

int

quarkus.datasource.jdbc.min-size

quarkus.datasource."datasource-name".jdbc.min-size

The datasource pool minimum size

Environment variable: QUARKUS_DATASOURCE_JDBC_MIN_SIZE

int

0

quarkus.datasource.jdbc.max-size

quarkus.datasource."datasource-name".jdbc.max-size

The datasource pool maximum size

Environment variable: QUARKUS_DATASOURCE_JDBC_MAX_SIZE

int

20

quarkus.datasource.jdbc.background-validation-interval

quarkus.datasource."datasource-name".jdbc.background-validation-interval

The interval at which we validate idle connections in the background.

Set to 0 to disable background validation.

Environment variable: QUARKUS_DATASOURCE_JDBC_BACKGROUND_VALIDATION_INTERVAL

Duration

2M

quarkus.datasource.jdbc.foreground-validation-interval

quarkus.datasource."datasource-name".jdbc.foreground-validation-interval

Perform foreground validation on connections that have been idle for longer than the specified interval.

Environment variable: QUARKUS_DATASOURCE_JDBC_FOREGROUND_VALIDATION_INTERVAL

Duration

quarkus.datasource.jdbc.acquisition-timeout

quarkus.datasource."datasource-name".jdbc.acquisition-timeout

The timeout before cancelling the acquisition of a new connection

Environment variable: QUARKUS_DATASOURCE_JDBC_ACQUISITION_TIMEOUT

Duration

5S

quarkus.datasource.jdbc.leak-detection-interval

quarkus.datasource."datasource-name".jdbc.leak-detection-interval

The interval at which we check for connection leaks.

Environment variable: QUARKUS_DATASOURCE_JDBC_LEAK_DETECTION_INTERVAL

Duration

This feature is disabled by default.

quarkus.datasource.jdbc.idle-removal-interval

quarkus.datasource."datasource-name".jdbc.idle-removal-interval

The interval at which we try to remove idle connections.

Environment variable: QUARKUS_DATASOURCE_JDBC_IDLE_REMOVAL_INTERVAL

Duration

5M

quarkus.datasource.jdbc.max-lifetime

quarkus.datasource."datasource-name".jdbc.max-lifetime

The max lifetime of a connection.

Environment variable: QUARKUS_DATASOURCE_JDBC_MAX_LIFETIME

Duration

By default, there is no restriction on the lifespan of a connection.

quarkus.datasource.jdbc.transaction-isolation-level

quarkus.datasource."datasource-name".jdbc.transaction-isolation-level

The transaction isolation level.

Environment variable: QUARKUS_DATASOURCE_JDBC_TRANSACTION_ISOLATION_LEVEL

undefined, none, read-uncommitted, read-committed, repeatable-read, serializable

quarkus.datasource.jdbc.extended-leak-report

quarkus.datasource."datasource-name".jdbc.extended-leak-report

Collect and display extra troubleshooting info on leaked connections.

Environment variable: QUARKUS_DATASOURCE_JDBC_EXTENDED_LEAK_REPORT

boolean

false

quarkus.datasource.jdbc.flush-on-close

quarkus.datasource."datasource-name".jdbc.flush-on-close

Allows connections to be flushed upon return to the pool. It’s not enabled by default.

Environment variable: QUARKUS_DATASOURCE_JDBC_FLUSH_ON_CLOSE

boolean

false

quarkus.datasource.jdbc.detect-statement-leaks

quarkus.datasource."datasource-name".jdbc.detect-statement-leaks

When enabled, Agroal will be able to produce a warning when a connection is returned to the pool without the application having closed all open statements. This is unrelated with tracking of open connections. Disable for peak performance, but only when there’s high confidence that no leaks are happening.

Environment variable: QUARKUS_DATASOURCE_JDBC_DETECT_STATEMENT_LEAKS

boolean

true

quarkus.datasource.jdbc.new-connection-sql

quarkus.datasource."datasource-name".jdbc.new-connection-sql

Query executed when first using a connection.

Environment variable: QUARKUS_DATASOURCE_JDBC_NEW_CONNECTION_SQL

string

quarkus.datasource.jdbc.validation-query-sql

quarkus.datasource."datasource-name".jdbc.validation-query-sql

Query executed to validate a connection.

Environment variable: QUARKUS_DATASOURCE_JDBC_VALIDATION_QUERY_SQL

string

quarkus.datasource.jdbc.validate-on-borrow

quarkus.datasource."datasource-name".jdbc.validate-on-borrow

Forces connection validation prior to acquisition (foreground validation) regardless of the idle status.

Because of the overhead of performing validation on every call, it’s recommended to rely on default idle validation instead, and to leave this to false.

Environment variable: QUARKUS_DATASOURCE_JDBC_VALIDATE_ON_BORROW

boolean

false

quarkus.datasource.jdbc.pooling-enabled

quarkus.datasource."datasource-name".jdbc.pooling-enabled

Disable pooling to prevent reuse of Connections. Use this when an external pool manages the life-cycle of Connections.

Environment variable: QUARKUS_DATASOURCE_JDBC_POOLING_ENABLED

boolean

true

quarkus.datasource.jdbc.transaction-requirement

quarkus.datasource."datasource-name".jdbc.transaction-requirement

Require an active transaction when acquiring a connection. Recommended for production. WARNING: Some extensions acquire connections without holding a transaction for things like schema updates and schema validation. Setting this setting to STRICT may lead to failures in those cases.

Environment variable: QUARKUS_DATASOURCE_JDBC_TRANSACTION_REQUIREMENT

off, warn, strict

quarkus.datasource.jdbc.additional-jdbc-properties."property-key"

quarkus.datasource."datasource-name".jdbc.additional-jdbc-properties."property-key"

Other unspecified properties to be passed to the JDBC driver when creating new connections.

Environment variable: QUARKUS_DATASOURCE_JDBC_ADDITIONAL_JDBC_PROPERTIES__PROPERTY_KEY_

Map<String,String>

quarkus.datasource.jdbc.telemetry.enabled

quarkus.datasource."datasource-name".jdbc.telemetry.enabled

Enable OpenTelemetry JDBC instrumentation.

Environment variable: QUARKUS_DATASOURCE_JDBC_TELEMETRY_ENABLED

boolean

false if quarkus.datasource.jdbc.telemetry=false and true if quarkus.datasource.jdbc.telemetry=true

Amazon Lambda - Common Deployment

Type

Default

quarkus.lambda.mock-event-server.enabled

Setting to true will start event server even if quarkus.devservices.enabled=false

Environment variable: QUARKUS_LAMBDA_MOCK_EVENT_SERVER_ENABLED

boolean

true

quarkus.lambda.mock-event-server.dev-port

Port to access mock event server in dev mode

Environment variable: QUARKUS_LAMBDA_MOCK_EVENT_SERVER_DEV_PORT

int

8080

quarkus.lambda.mock-event-server.test-port

Port to access mock event server in dev mode

Environment variable: QUARKUS_LAMBDA_MOCK_EVENT_SERVER_TEST_PORT

int

8081

quarkus.lambda.expected-exceptions

The exception classes expected to be thrown by the handler. Any exception thrown by the handler that is an instance of a class in this list will not be logged, but will otherwise be handled normally by the lambda runtime. This is useful for avoiding unnecessary stack traces while preserving the ability to log unexpected exceptions.

Environment variable: QUARKUS_LAMBDA_EXPECTED_EXCEPTIONS

list of Class

quarkus.lambda.handler

The handler name. Handler names are specified on handler classes using the @jakarta.inject.Named annotation. If this name is unspecified and there is exactly one unnamed implementation of com.amazonaws.services.lambda.runtime.RequestHandler then this unnamed handler will be used. If there is only a single named handler and the name is unspecified then the named handler will be used.

Environment variable: QUARKUS_LAMBDA_HANDLER

string

Amazon Lambda AWS Gateway REST API

Type

Default

quarkus.lambda-http.enable-security

Enable security mechanisms to process lambda and AWS based security (i.e. Cognito, IAM) from the http event sent from API Gateway

Environment variable: QUARKUS_LAMBDA_HTTP_ENABLE_SECURITY

boolean

false

quarkus.lambda-http.map-cognito-to-roles

If true, runtime will search Cognito JWT claims for "cognito:groups" and add them as Quarkus security roles. True by default

Environment variable: QUARKUS_LAMBDA_HTTP_MAP_COGNITO_TO_ROLES

boolean

true

quarkus.lambda-http.cognito-role-claim

Cognito claim that contains roles you want to map. Defaults to "cognito:groups"

Environment variable: QUARKUS_LAMBDA_HTTP_COGNITO_ROLE_CLAIM

string

cognito:groups

quarkus.lambda-http.cognito-claim-matcher

Regular expression to locate role values within a Cognito claim string. By default it looks for space delimited strings enclosed in brackets "[^\[\] \t]+"

Environment variable: QUARKUS_LAMBDA_HTTP_COGNITO_CLAIM_MATCHER

string

[^\[\] \t]+

Amazon Lambda HTTP

Type

Default

quarkus.lambda-http.enable-security

Enable security mechanisms to process lambda and AWS based security (i.e. Cognito, IAM) from the http event sent from API Gateway

Environment variable: QUARKUS_LAMBDA_HTTP_ENABLE_SECURITY

boolean

false

quarkus.lambda-http.map-cognito-to-roles

If true, runtime will search Cognito JWT claims for "cognito:groups" and add them as Quarkus security roles. True by default

Environment variable: QUARKUS_LAMBDA_HTTP_MAP_COGNITO_TO_ROLES

boolean

true

quarkus.lambda-http.cognito-role-claim

Cognito claim that contains roles you want to map. Defaults to "cognito:groups"

Environment variable: QUARKUS_LAMBDA_HTTP_COGNITO_ROLE_CLAIM

string

cognito:groups

quarkus.lambda-http.cognito-claim-matcher

Regular expression to locate role values within a Cognito claim string. By default it looks for space delimited strings enclosed in brackets "[^\[\] \t]+"

Environment variable: QUARKUS_LAMBDA_HTTP_COGNITO_CLAIM_MATCHER

string

[^\[\] \t]+

ArC

Type

Default

quarkus.arc.remove-unused-beans

If set to all (or true) the container will attempt to remove all unused beans.
If set to none (or false) no beans will ever be removed even if they are unused (according to the criteria set out below)
If set to fwk, then all unused beans will be removed, except the unused beans whose classes are declared in the application code

An unused bean:

is not a built-in bean or interceptor,
is not eligible for injection to any injection point,
is not excluded by any extension,
does not have a name,
does not declare an observer,
does not declare any producer which is eligible for injection to any injection point,
is not directly eligible for injection into any jakarta.enterprise.inject.Instance injection point

Environment variable: QUARKUS_ARC_REMOVE_UNUSED_BEANS

string

all

quarkus.arc.auto-inject-fields

If set to true @Inject is automatically added to all non-static non-final fields that are annotated with one of the annotations defined by AutoInjectAnnotationBuildItem.

Environment variable: QUARKUS_ARC_AUTO_INJECT_FIELDS

boolean

true

quarkus.arc.transform-unproxyable-classes

If set to true, the bytecode of unproxyable beans will be transformed. This ensures that a proxy/subclass can be created properly. If the value is set to false, then an exception is thrown at build time indicating that a subclass/proxy could not be created. Quarkus performs the following transformations when this setting is enabled:

Remove 'final' modifier from classes and methods when a proxy is required.
Create a no-args constructor if needed.
Makes private no-args constructors package-private if necessary.

Environment variable: QUARKUS_ARC_TRANSFORM_UNPROXYABLE_CLASSES

boolean

true

quarkus.arc.transform-private-injected-fields

If set to true, the bytecode of private fields that are injection points will be transformed to package private. This ensures that field injection can be performed completely reflection-free. If the value is set to false, then a reflection fallback is used to perform the injection.

Environment variable: QUARKUS_ARC_TRANSFORM_PRIVATE_INJECTED_FIELDS

boolean

true

quarkus.arc.fail-on-intercepted-private-method

If set to true (the default), the build fails if a private method that is neither an observer nor a producer, is annotated with an interceptor binding. An example of this is the use of Transactional on a private method of a bean. If set to false, Quarkus simply logs a warning that the annotation will be ignored.

Environment variable: QUARKUS_ARC_FAIL_ON_INTERCEPTED_PRIVATE_METHOD

boolean

true

quarkus.arc.selected-alternatives

The list of selected alternatives for an application.

An element value can be:

a fully qualified class name, i.e. org.acme.Foo
a simple class name as defined by Class#getSimpleName(), i.e. Foo
a package name with suffix .*, i.e. org.acme.*, matches a package
a package name with suffix .**, i.e. org.acme.**, matches a package that starts with the value

Each element value is used to match an alternative bean class, an alternative stereotype annotation type or a bean class that declares an alternative producer. If any value matches then the priority of Integer#MAX_VALUE is used for the relevant bean. The priority declared via jakarta.annotation.Priority is overridden.

Environment variable: QUARKUS_ARC_SELECTED_ALTERNATIVES

list of string

quarkus.arc.auto-producer-methods

If set to true then jakarta.enterprise.inject.Produces is automatically added to all non-void methods that are annotated with a scope annotation, a stereotype or a qualifier, and are not annotated with Inject or Produces, and no parameter is annotated with Disposes, Observes or ObservesAsync.

Environment variable: QUARKUS_ARC_AUTO_PRODUCER_METHODS

boolean

true

quarkus.arc.exclude-types

The list of types that should be excluded from discovery.

An element value can be:

a fully qualified class name, i.e. org.acme.Foo
a simple class name as defined by Class#getSimpleName(), i.e. Foo
a package name with suffix .*, i.e. org.acme.*, matches a package
a package name with suffix .**, i.e. org.acme.**, matches a package that starts with the value

If any element value matches a discovered type then the type is excluded from discovery, i.e. no beans and observer methods are created from this type.

Environment variable: QUARKUS_ARC_EXCLUDE_TYPES

list of string

quarkus.arc.unremovable-types

List of types that should be considered unremovable regardless of whether they are directly used or not. This is a configuration option equivalent to using io.quarkus.arc.Unremovable annotation.

An element value can be:

a fully qualified class name, i.e. org.acme.Foo
a simple class name as defined by Class#getSimpleName(), i.e. Foo
a package name with suffix .*, i.e. org.acme.*, matches a package
a package name with suffix .**, i.e. org.acme.**, matches a package that starts with the value

If any element value matches a discovered bean, then such a bean is considered unremovable.

Environment variable: QUARKUS_ARC_UNREMOVABLE_TYPES

list of string

Artifacts that should be excluded from discovery

Type

Default

quarkus.arc.exclude-dependency."dependency-name".group-id

The maven groupId of the artifact.

Environment variable: QUARKUS_ARC_EXCLUDE_DEPENDENCY__DEPENDENCY_NAME__GROUP_ID

string

required

quarkus.arc.exclude-dependency."dependency-name".artifact-id

The maven artifactId of the artifact (optional).

Environment variable: QUARKUS_ARC_EXCLUDE_DEPENDENCY__DEPENDENCY_NAME__ARTIFACT_ID

string

quarkus.arc.exclude-dependency."dependency-name".classifier

The maven classifier of the artifact (optional).

Environment variable: QUARKUS_ARC_EXCLUDE_DEPENDENCY__DEPENDENCY_NAME__CLASSIFIER

string

quarkus.arc.detect-unused-false-positives

If set to true then the container attempts to detect "unused removed beans" false positives during programmatic lookup at runtime. You can disable this feature to conserve some memory when running your application in production.

Environment variable: QUARKUS_ARC_DETECT_UNUSED_FALSE_POSITIVES

boolean

true

quarkus.arc.detect-wrong-annotations

If set to true then the container attempts to detect wrong usages of annotations and eventually fails the build to prevent unexpected behavior of a Quarkus application.

A typical example is @jakarta.ejb.Singleton which is often confused with @jakarta.inject.Singleton. As a result a component annotated with @jakarta.ejb.Singleton would be completely ignored. Another example is an inner class annotated with a scope annotation - this component would be again completely ignored.

Environment variable: QUARKUS_ARC_DETECT_WRONG_ANNOTATIONS

boolean

true

quarkus.arc.strict-compatibility

If set to true, the container will perform additional validations mandated by the CDI specification. Some improvements on top of the CDI specification may be disabled. Applications that work as expected in the strict mode should work without a change in the default, non-strict mode.

The strict mode is mainly introduced to allow passing the CDI Lite TCK. Applications are recommended to use the default, non-strict mode, which makes CDI more convenient to use. The "strictness" of the strict mode (the set of additional validations and the set of disabled improvements on top of the CDI specification) may change over time.

Note that transform-unproxyable-classes and remove-unused-beans also has effect on specification compatibility. You may want to disable these features to get behavior closer to the specification.

Environment variable: QUARKUS_ARC_STRICT_COMPATIBILITY

boolean

false

quarkus.arc.dev-mode.monitoring-enabled

If set to true then the container monitors business method invocations and fired events during the development mode.

This config property should not be changed in the development mode as it requires a full rebuild of the application

Environment variable: QUARKUS_ARC_DEV_MODE_MONITORING_ENABLED

boolean

false

quarkus.arc.dev-mode.generate-dependency-graphs

If set to true then the dependency graphs are generated and available in the Dev UI.

Environment variable: QUARKUS_ARC_DEV_MODE_GENERATE_DEPENDENCY_GRAPHS

boolean

true

quarkus.arc.test.disable-application-lifecycle-observers

If set to true then disable StartupEvent and ShutdownEvent observers declared on application bean classes during the tests.

Environment variable: QUARKUS_ARC_TEST_DISABLE_APPLICATION_LIFECYCLE_OBSERVERS

boolean

false

quarkus.arc.ignored-split-packages

The list of packages that will not be checked for split package issues.

A package string representation can be:

a full name of the package, i.e. org.acme.foo
a package name with suffix .*, i.e. org.acme.*, which matches a package that starts with provided value

Environment variable: QUARKUS_ARC_IGNORED_SPLIT_PACKAGES

list of string

quarkus.arc.context-propagation.enabled

If set to true and the SmallRye Context Propagation extension is present then the CDI contexts will be propagated by means of the MicroProfile Context Propagation API. Specifically, a org.eclipse.microprofile.context.spi.ThreadContextProvider implementation is registered. On the other hand, if set to false then the MicroProfile Context Propagation API will never be used to propagate the CDI contexts. Note that the CDI contexts may be propagated in a different way though. For example with the Vertx duplicated context.

Environment variable: QUARKUS_ARC_CONTEXT_PROPAGATION_ENABLED

boolean

true

Azure Functions

Type

Default

quarkus.azure-functions.app-name

App name for azure function project. This is required setting. Defaults to the base artifact name

Environment variable: QUARKUS_AZURE_FUNCTIONS_APP_NAME

string

quarkus.azure-functions.resource-group

Azure Resource Group for your Azure Functions

Environment variable: QUARKUS_AZURE_FUNCTIONS_RESOURCE_GROUP

string

quarkus

quarkus.azure-functions.region

Specifies the region where your Azure Functions will be hosted; default value is westus. Valid values

Environment variable: QUARKUS_AZURE_FUNCTIONS_REGION

string

westus

quarkus.azure-functions.disable-app-insights

Specifies whether to disable application insights for your function app

Environment variable: QUARKUS_AZURE_FUNCTIONS_DISABLE_APP_INSIGHTS

boolean

false

quarkus.azure-functions.app-insights-key

Specifies the instrumentation key of application insights which will bind to your function app

Environment variable: QUARKUS_AZURE_FUNCTIONS_APP_INSIGHTS_KEY

string

quarkus.azure-functions.runtime.os

Valid values are linux, windows, and docker

Environment variable: QUARKUS_AZURE_FUNCTIONS_RUNTIME_OS

string

linux

quarkus.azure-functions.runtime.java-version

Valid values are 8, 11, and 17

Environment variable: QUARKUS_AZURE_FUNCTIONS_RUNTIME_JAVA_VERSION

string

11

quarkus.azure-functions.runtime.image

URL of docker image if deploying via docker

Environment variable: QUARKUS_AZURE_FUNCTIONS_RUNTIME_IMAGE

string

quarkus.azure-functions.runtime.registry-url

If using docker, url of registry

Environment variable: QUARKUS_AZURE_FUNCTIONS_RUNTIME_REGISTRY_URL

string

quarkus.azure-functions.auth.type

Description of each type can be found here Valid values are

azure_cli Delegates to Azure CLI for login
managed_identity Requires client to be set
oauth2 Requires tenant to be set
device_code Requires tenant to be set
file Filesystem path to a property file that defines authentication. Properties supported are
type Supports same type values as well as service_principal
client
tenant
key Password for service_principal if using password authentication
certificate Path to PEM file if using service_principal
certificate-password Password for PEM file if it is password protected and if using service_principal
environment if using service_principal

Defaults to "azure_cli" for authentication

Environment variable: QUARKUS_AZURE_FUNCTIONS_AUTH_TYPE

string

azure_cli

quarkus.azure-functions.auth.path

Filesystem path to properties file if using file type

Environment variable: QUARKUS_AZURE_FUNCTIONS_AUTH_PATH

string

quarkus.azure-functions.auth.client

Client or App Id required if using managed_identity type

Environment variable: QUARKUS_AZURE_FUNCTIONS_AUTH_CLIENT

string

quarkus.azure-functions.auth.tenant

Tenant Id required if using oauth2 or device_code type

Environment variable: QUARKUS_AZURE_FUNCTIONS_AUTH_TENANT

string

quarkus.azure-functions.app-service-plan-name

Specifies the name of the existing App Service Plan when you do not want to create a new one.

Environment variable: QUARKUS_AZURE_FUNCTIONS_APP_SERVICE_PLAN_NAME

string

java-functions-app-service-plan

quarkus.azure-functions.app-service-plan-resource-group

The app service plan resource group.

Environment variable: QUARKUS_AZURE_FUNCTIONS_APP_SERVICE_PLAN_RESOURCE_GROUP

string

quarkus.azure-functions.subscription-id

Azure subscription id. Required only if there are more than one subscription in your account

Environment variable: QUARKUS_AZURE_FUNCTIONS_SUBSCRIPTION_ID

string

quarkus.azure-functions.pricing-tier

The pricing tier.

Environment variable: QUARKUS_AZURE_FUNCTIONS_PRICING_TIER

string

quarkus.azure-functions.func-port

Port to run azure function in local runtime. Will default to quarkus.http.test-port or 8081

Environment variable: QUARKUS_AZURE_FUNCTIONS_FUNC_PORT

int

quarkus.azure-functions.local-debug-config

Config String for local debug

Environment variable: QUARKUS_AZURE_FUNCTIONS_LOCAL_DEBUG_CONFIG

string

transport=dt_socket,server=y,suspend=n,address=5005

quarkus.azure-functions.app-settings."setting-name"

Specifies the application settings for your Azure Functions, which are defined in name-value pairs

Environment variable: QUARKUS_AZURE_FUNCTIONS_APP_SETTINGS__SETTING_NAME_

Map<String,String>

Cache

Type

Default

quarkus.cache.type

Cache type.

Environment variable: QUARKUS_CACHE_TYPE

string

caffeine

quarkus.cache.enabled

Whether or not the cache extension is enabled.

Environment variable: QUARKUS_CACHE_ENABLED

boolean

true

Default configuration applied to all Caffeine caches (lowest precedence)

Type

Default

quarkus.cache.caffeine.initial-capacity

Minimum total size for the internal data structures. Providing a large enough estimate at construction time avoids the need for expensive resizing operations later, but setting this value unnecessarily high wastes memory.

Environment variable: QUARKUS_CACHE_CAFFEINE_INITIAL_CAPACITY

int

quarkus.cache.caffeine.maximum-size

Maximum number of entries the cache may contain. Note that the cache may evict an entry before this limit is exceeded or temporarily exceed the threshold while evicting. As the cache size grows close to the maximum, the cache evicts entries that are less likely to be used again. For example, the cache may evict an entry because it hasn’t been used recently or very often.

Environment variable: QUARKUS_CACHE_CAFFEINE_MAXIMUM_SIZE

long

quarkus.cache.caffeine.expire-after-write

Specifies that each entry should be automatically removed from the cache once a fixed duration has elapsed after the entry’s creation, or the most recent replacement of its value.

Environment variable: QUARKUS_CACHE_CAFFEINE_EXPIRE_AFTER_WRITE

Duration

quarkus.cache.caffeine.expire-after-access

Specifies that each entry should be automatically removed from the cache once a fixed duration has elapsed after the entry’s creation, the most recent replacement of its value, or its last read.

Environment variable: QUARKUS_CACHE_CAFFEINE_EXPIRE_AFTER_ACCESS

Duration

quarkus.cache.caffeine.metrics-enabled

Whether or not metrics are recorded if the application depends on the Micrometer extension. Setting this value to true will enable the accumulation of cache stats inside Caffeine.

Environment variable: QUARKUS_CACHE_CAFFEINE_METRICS_ENABLED

boolean

quarkus.cache.caffeine."cache-name".initial-capacity

Environment variable: QUARKUS_CACHE_CAFFEINE__CACHE_NAME__INITIAL_CAPACITY

int

quarkus.cache.caffeine."cache-name".maximum-size

Environment variable: QUARKUS_CACHE_CAFFEINE__CACHE_NAME__MAXIMUM_SIZE

long

quarkus.cache.caffeine."cache-name".expire-after-write

Specifies that each entry should be automatically removed from the cache once a fixed duration has elapsed after the entry’s creation, or the most recent replacement of its value.

Environment variable: QUARKUS_CACHE_CAFFEINE__CACHE_NAME__EXPIRE_AFTER_WRITE

Duration

quarkus.cache.caffeine."cache-name".expire-after-access

Specifies that each entry should be automatically removed from the cache once a fixed duration has elapsed after the entry’s creation, the most recent replacement of its value, or its last read.

Environment variable: QUARKUS_CACHE_CAFFEINE__CACHE_NAME__EXPIRE_AFTER_ACCESS

Duration

quarkus.cache.caffeine."cache-name".metrics-enabled

Whether or not metrics are recorded if the application depends on the Micrometer extension. Setting this value to true will enable the accumulation of cache stats inside Caffeine.

Environment variable: QUARKUS_CACHE_CAFFEINE__CACHE_NAME__METRICS_ENABLED

boolean

Container Image

Type

Default

quarkus.container-image.group

The group the container image will be part of

Environment variable: QUARKUS_CONTAINER_IMAGE_GROUP

string

quarkus.container-image.name

The name of the container image. If not set defaults to the application name

Environment variable: QUARKUS_CONTAINER_IMAGE_NAME

string

${quarkus.application.name:unset}

quarkus.container-image.tag

The tag of the container image. If not set defaults to the application version

Environment variable: QUARKUS_CONTAINER_IMAGE_TAG

string

${quarkus.application.version:latest}

quarkus.container-image.additional-tags

Additional tags of the container image.

Environment variable: QUARKUS_CONTAINER_IMAGE_ADDITIONAL_TAGS

list of string

quarkus.container-image.labels."label-name"

Custom labels to add to the generated image.

Environment variable: QUARKUS_CONTAINER_IMAGE_LABELS__LABEL_NAME_

Map<String,String>

quarkus.container-image.registry

The container registry to use

Environment variable: QUARKUS_CONTAINER_IMAGE_REGISTRY

string

quarkus.container-image.image

Represents the entire image string. If set, then group, name, registry, tags, additionalTags are ignored

Environment variable: QUARKUS_CONTAINER_IMAGE_IMAGE

string

quarkus.container-image.username

The username to use to authenticate with the registry where the built image will be pushed

Environment variable: QUARKUS_CONTAINER_IMAGE_USERNAME

string

quarkus.container-image.password

The password to use to authenticate with the registry where the built image will be pushed

Environment variable: QUARKUS_CONTAINER_IMAGE_PASSWORD

string

quarkus.container-image.insecure

Whether or not insecure registries are allowed

Environment variable: QUARKUS_CONTAINER_IMAGE_INSECURE

boolean

false

quarkus.container-image.build

Whether or not a image build will be performed.

Environment variable: QUARKUS_CONTAINER_IMAGE_BUILD

boolean

quarkus.container-image.push

Whether or not an image push will be performed.

Environment variable: QUARKUS_CONTAINER_IMAGE_PUSH

boolean

quarkus.container-image.builder

The name of the container image extension to use (e.g. docker, podman, jib, s2i). The option will be used in case multiple extensions are present.

Environment variable: QUARKUS_CONTAINER_IMAGE_BUILDER

string

Container Image - Buildpack

Type

Default

quarkus.buildpack.jvm-builder-image

The buildpacks builder image to use when building the project in jvm mode.

Environment variable: QUARKUS_BUILDPACK_JVM_BUILDER_IMAGE

string

paketocommunity/builder-ubi-base:latest

quarkus.buildpack.native-builder-image

The buildpacks builder image to use when building the project in native mode.

Environment variable: QUARKUS_BUILDPACK_NATIVE_BUILDER_IMAGE

string

quarkus.buildpack.trust-builder-image

Should the builder image be 'trusted' (use creator lifecycle)

Environment variable: QUARKUS_BUILDPACK_TRUST_BUILDER_IMAGE

boolean

quarkus.buildpack.builder-env."environment-variable-name"

Environment key/values to pass to buildpacks.

Environment variable: QUARKUS_BUILDPACK_BUILDER_ENV__ENVIRONMENT_VARIABLE_NAME_

Map<String,String>

quarkus.buildpack.run-image

The buildpacks run image to use when building the project When not supplied, the run image is determined by the builder image.

Environment variable: QUARKUS_BUILDPACK_RUN_IMAGE

string

quarkus.buildpack.pull-timeout-seconds

Initial pull timeout for builder/run images, in seconds

Environment variable: QUARKUS_BUILDPACK_PULL_TIMEOUT_SECONDS

int

300

quarkus.buildpack.pull-timeout-increase-seconds

Increase pull timeout for builder/run images after failure, in seconds

Environment variable: QUARKUS_BUILDPACK_PULL_TIMEOUT_INCREASE_SECONDS

int

15

quarkus.buildpack.pull-retry-count

How many times to retry an image pull after a failure

Environment variable: QUARKUS_BUILDPACK_PULL_RETRY_COUNT

int

3

quarkus.buildpack.docker-host

DOCKER_HOST value to use. If not set, the env var DOCKER_HOST is used, if that is not set the platform will look for 'npipe:///./pipe/docker_engine' for windows, and unix:///var/run/docker.sock' then `unix:///var/run/podman.sock then unix:///var/run/user//podman/podman.sock for linux

Environment variable: QUARKUS_BUILDPACK_DOCKER_HOST

string

quarkus.buildpack.use-daemon

use Daemon mode? Defaults to 'true'

Environment variable: QUARKUS_BUILDPACK_USE_DAEMON

boolean

true

quarkus.buildpack.docker-network

Use specified docker network during build

Environment variable: QUARKUS_BUILDPACK_DOCKER_NETWORK

string

quarkus.buildpack.log-level

Log level to use.. Defaults to 'info'

Environment variable: QUARKUS_BUILDPACK_LOG_LEVEL

string

info

quarkus.buildpack.base-registry-username

The username to use to authenticate with the registry used to pull the base JVM image

Environment variable: QUARKUS_BUILDPACK_BASE_REGISTRY_USERNAME

string

quarkus.buildpack.base-registry-password

The password to use to authenticate with the registry used to pull the base JVM image

Environment variable: QUARKUS_BUILDPACK_BASE_REGISTRY_PASSWORD

string

Container Image - Docker

Type

Default

quarkus.docker.dockerfile-jvm-path

Path to the JVM Dockerfile. If set to an absolute path then the absolute path will be used, otherwise the path will be considered relative to the project root. If not set src/main/docker/Dockerfile.jvm will be used.

Environment variable: QUARKUS_DOCKER_DOCKERFILE_JVM_PATH

string

src/main/docker/Dockerfile.jvm

quarkus.docker.dockerfile-native-path

Path to the native Dockerfile. If set to an absolute path then the absolute path will be used, otherwise the path will be considered relative to the project root. If not set src/main/docker/Dockerfile.native will be used.

Environment variable: QUARKUS_DOCKER_DOCKERFILE_NATIVE_PATH

string

src/main/docker/Dockerfile.native

quarkus.docker.build-args."arg-name"

Build args passed to docker via --build-arg

Environment variable: QUARKUS_DOCKER_BUILD_ARGS__ARG_NAME_

Map<String,String>

quarkus.docker.cache-from

Images to consider as cache sources. Values are passed to docker build/podman build via the cache-from option

Environment variable: QUARKUS_DOCKER_CACHE_FROM

list of string

quarkus.docker.network

The networking mode for the RUN instructions during build

Environment variable: QUARKUS_DOCKER_NETWORK

string

quarkus.docker.executable-name

Name of binary used to execute the docker/podman commands. This setting can override the global container runtime detection.

Environment variable: QUARKUS_DOCKER_EXECUTABLE_NAME

string

quarkus.docker.additional-args

Additional arbitrary arguments passed to the executable when building the container image.

Environment variable: QUARKUS_DOCKER_ADDITIONAL_ARGS

list of string

Configuration for Docker Buildx options

Type

Default

quarkus.docker.buildx.platform

Which platform(s) to target during the build. See https://docs.docker.com/engine/reference/commandline/buildx_build/#platform

Environment variable: QUARKUS_DOCKER_BUILDX_PLATFORM

list of string

quarkus.docker.buildx.output

Sets the export action for the build result. See https://docs.docker.com/engine/reference/commandline/buildx_build/#output. Note that any filesystem paths need to be absolute paths, not relative from where the command is executed from.

Environment variable: QUARKUS_DOCKER_BUILDX_OUTPUT

string

quarkus.docker.buildx.progress

Set type of progress output (auto, plain, tty). Use plain to show container output (default “auto”). See https://docs.docker.com/engine/reference/commandline/buildx_build/#progress

Environment variable: QUARKUS_DOCKER_BUILDX_PROGRESS

string

Container Image - Jib

Type

Default

quarkus.jib.base-jvm-image

The base image to be used when a container image is being produced for the jar build. When the application is built against Java 21 or higher, registry.access.redhat.com/ubi8/openjdk-21-runtime:1.20 is used as the default. Otherwise registry.access.redhat.com/ubi8/openjdk-17-runtime:1.20 is used as the default.

Environment variable: QUARKUS_JIB_BASE_JVM_IMAGE

string

quarkus.jib.base-native-image

The base image to be used when a container image is being produced for the native binary build. The default is "quay.io/quarkus/quarkus-micro-image". You can also use "registry.access.redhat.com/ubi8/ubi-minimal" which is a bigger base image, but provide more built-in utilities such as the microdnf package manager.

Environment variable: QUARKUS_JIB_BASE_NATIVE_IMAGE

string

quay.io/quarkus/quarkus-micro-image:2.0

quarkus.jib.jvm-arguments

The JVM arguments to pass to the JVM when starting the application

Environment variable: QUARKUS_JIB_JVM_ARGUMENTS

list of string

-Djava.util.logging.manager=org.jboss.logmanager.LogManager

quarkus.jib.jvm-additional-arguments

Additional JVM arguments to pass to the JVM when starting the application

Environment variable: QUARKUS_JIB_JVM_ADDITIONAL_ARGUMENTS

list of string

quarkus.jib.native-arguments

Additional arguments to pass when starting the native application

Environment variable: QUARKUS_JIB_NATIVE_ARGUMENTS

list of string

quarkus.jib.jvm-entrypoint

If this is set, then it will be used as the entry point of the container image. There are a few things to be aware of when creating an entry point

Entrypoint "INHERIT" means to inherit entrypoint from base image, jvmArguments field is used for arguments
A valid entrypoint is jar package specific (see quarkus.package.jar.type)
A valid entrypoint depends on the location of both the launching scripts and the application jar file. To that end it’s helpful to remember that when fast-jar packaging is used (the default), all necessary application jars are added to the /work directory and that the same directory is also used as the working directory. When legacy-jar or uber-jar are used, the application jars are unpacked under the /app directory and that directory is used as the working directory.
Even if the jvmArguments field is set, it is ignored completely unless entrypoint is "INHERIT"

When this is not set, a proper default entrypoint will be constructed. As a final note, a very useful tool for inspecting container image layers that can greatly aid when debugging problems with endpoints is dive

Environment variable: QUARKUS_JIB_JVM_ENTRYPOINT

list of string

quarkus.jib.native-entrypoint

If this is set, then it will be used as the entry point of the container image. There are a few things to be aware of when creating an entry point

Entrypoint "INHERIT" means to inherit entrypoint from base image, nativeArguments field is used for arguments
A valid entrypoint depends on the location of both the launching scripts and the native binary file. To that end it’s helpful to remember that the native application is added to the /work directory and that and the same directory is also used as the working directory
Even if the nativeArguments field is set, it is ignored completely unless entrypoint is "INHERIT"

Environment variable: QUARKUS_JIB_NATIVE_ENTRYPOINT

list of string

quarkus.jib.environment-variables."environment-variable-name"

Environment variables to add to the container image

Environment variable: QUARKUS_JIB_ENVIRONMENT_VARIABLES__ENVIRONMENT_VARIABLE_NAME_

Map<String,String>

quarkus.jib.base-registry-username

The username to use to authenticate with the registry used to pull the base JVM image

Environment variable: QUARKUS_JIB_BASE_REGISTRY_USERNAME

string

quarkus.jib.base-registry-password

The password to use to authenticate with the registry used to pull the base JVM image

Environment variable: QUARKUS_JIB_BASE_REGISTRY_PASSWORD

string

quarkus.jib.ports

The ports to expose

Environment variable: QUARKUS_JIB_PORTS

list of int

${quarkus.http.port:8080}

quarkus.jib.user

The user to use in generated image

Environment variable: QUARKUS_JIB_USER

string

quarkus.jib.working-directory

The working directory to use in the generated image. The default value is chosen to work in accordance with the default base image.

Environment variable: QUARKUS_JIB_WORKING_DIRECTORY

string

/home/jboss

quarkus.jib.always-cache-base-image

Controls the optimization which skips downloading base image layers that exist in a target registry. If the user does not set this property, then read as false. If true, base image layers are always pulled and cached. If false, base image layers will not be pulled/cached if they already exist on the target registry.

Environment variable: QUARKUS_JIB_ALWAYS_CACHE_BASE_IMAGE

boolean

false

quarkus.jib.platforms

List of target platforms. Each platform is defined using the pattern:

<os>|<arch>[/variant]|<os>/<arch>[/variant]

for example:

linux/amd64,linux/arm64/v8

If not specified, OS default is linux and architecture default is amd64. If more than one platform is configured, it is important to note that the base image has to be a Docker manifest or an OCI image index containing a version of each chosen platform. The feature does not work with native images, as cross-compilation is not supported. This configuration is based on an incubating feature of Jib. See Jib FAQ for more information.

Environment variable: QUARKUS_JIB_PLATFORMS

list of string

quarkus.jib.image-digest-file

The path of a file in which the digest of the generated image will be written. If the path is relative, the base path is the output directory of the build tool.

Environment variable: QUARKUS_JIB_IMAGE_DIGEST_FILE

string

jib-image.digest

quarkus.jib.image-id-file

The path of a file in which the id of the generated image will be written. If the path is relative, the base path is the output directory of the build tool.

Environment variable: QUARKUS_JIB_IMAGE_ID_FILE

string

jib-image.id

quarkus.jib.offline-mode

Whether or not to operate offline.

Environment variable: QUARKUS_JIB_OFFLINE_MODE

boolean

false

quarkus.jib.docker-executable-name

Name of binary used to execute the docker commands. This is only used by Jib when the container image is being built locally.

Environment variable: QUARKUS_JIB_DOCKER_EXECUTABLE_NAME

string

quarkus.jib.docker-environment."environment-variable-name"

Sets environment variables used by the Docker executable. This is only used by Jib when the container image is being built locally.

Environment variable: QUARKUS_JIB_DOCKER_ENVIRONMENT__ENVIRONMENT_VARIABLE_NAME_

Map<String,String>

quarkus.jib.use-current-timestamp

Whether to set the creation time to the actual build time. Otherwise, the creation time will be set to the Unix epoch (00:00:00, January 1st, 1970 in UTC). See Jib FAQ for more information

Environment variable: QUARKUS_JIB_USE_CURRENT_TIMESTAMP

boolean

true

quarkus.jib.use-current-timestamp-file-modification

Whether to set the modification time (last modified time) of the files put by Jib in the image to the actual build time. Otherwise, the modification time will be set to the Unix epoch (00:00:00, January 1st, 1970 in UTC). If the modification time is constant (flag is set to false so Unix epoch is used) across two consecutive builds, the docker layer sha256 digest will be different only if the actual files added by Jib to the docker layer were changed. More exactly, having 2 consecutive builds will generate different docker layers only if the actual content of the files within the docker layer was changed. If the current timestamp is used the sha256 digest of the docker layer will always be different even if the content of the files didn’t change.

Environment variable: QUARKUS_JIB_USE_CURRENT_TIMESTAMP_FILE_MODIFICATION

boolean

true

quarkus.jib.base-image-layers-cache

The directory to use for caching base image layers. If not specified, the Jib default directory is used.

Environment variable: QUARKUS_JIB_BASE_IMAGE_LAYERS_CACHE

string

quarkus.jib.application-layers-cache

The directory to use for caching application layers. If not specified, the Jib default directory is used.

Environment variable: QUARKUS_JIB_APPLICATION_LAYERS_CACHE

string

Container Image - OpenShift

Type

Default

quarkus.openshift.build-strategy

The build config strategy to use.

Environment variable: QUARKUS_OPENSHIFT_BUILD_STRATEGY

binary, docker

binary

quarkus.openshift.base-jvm-image

The base image to be used when a container image is being produced for the jar build. The value of this property is used to create an ImageStream for the builder image used in the Openshift build. When it references images already available in the internal Openshift registry, the corresponding streams are used instead. When the application is built against Java 21 or higher, registry.access.redhat.com/ubi8/openjdk-21:1.20 is used as the default. Otherwise registry.access.redhat.com/ubi8/openjdk-17:1.20 is used as the default.

Environment variable: QUARKUS_OPENSHIFT_BASE_JVM_IMAGE

string

quarkus.openshift.base-native-image

The base image to be used when a container image is being produced for the native binary build. The value of this property is used to create an ImageStream for the builder image used in the Openshift build. When it references images already available in the internal Openshift registry, the corresponding streams are used instead.

Environment variable: QUARKUS_OPENSHIFT_BASE_NATIVE_IMAGE

string

quay.io/quarkus/ubi-quarkus-native-binary-s2i:2.0

quarkus.openshift.jvm-dockerfile

The default Dockerfile to use for jvm builds

Environment variable: QUARKUS_OPENSHIFT_JVM_DOCKERFILE

string

src/main/docker/Dockerfile.jvm

quarkus.openshift.native-dockerfile

The default Dockerfile to use for native builds

Environment variable: QUARKUS_OPENSHIFT_NATIVE_DOCKERFILE

string

src/main/docker/Dockerfile.native

quarkus.openshift.jvm-arguments

The JVM arguments to pass to the JVM when starting the application

Environment variable: QUARKUS_OPENSHIFT_JVM_ARGUMENTS

list of string

quarkus.openshift.native-arguments

Additional arguments to pass when starting the native application

Environment variable: QUARKUS_OPENSHIFT_NATIVE_ARGUMENTS

list of string

quarkus.openshift.jar-directory

The directory where the jar is added during the assemble phase. This is dependent on the S2I image and should be supplied if a non default image is used.

Environment variable: QUARKUS_OPENSHIFT_JAR_DIRECTORY

string

quarkus.openshift.jar-file-name

The resulting filename of the jar in the S2I image. This option may be used if the selected S2I image uses a fixed name for the jar.

Environment variable: QUARKUS_OPENSHIFT_JAR_FILE_NAME

string

quarkus.openshift.native-binary-directory

The directory where the native binary is added during the assemble phase. This is dependent on the S2I image and should be supplied if a non-default image is used.

Environment variable: QUARKUS_OPENSHIFT_NATIVE_BINARY_DIRECTORY

string

quarkus.openshift.native-binary-file-name

The resulting filename of the native binary in the S2I image. This option may be used if the selected S2I image uses a fixed name for the native binary.

Environment variable: QUARKUS_OPENSHIFT_NATIVE_BINARY_FILE_NAME

string

quarkus.openshift.build-timeout

The build timeout.

Environment variable: QUARKUS_OPENSHIFT_BUILD_TIMEOUT

Duration

PT5M

quarkus.openshift.build-log-level

The log level of OpenShift build log.

Environment variable: QUARKUS_OPENSHIFT_BUILD_LOG_LEVEL

fatal, error, warn, info, debug, trace

info

quarkus.openshift.image-push-secret

The image push secret to use for pushing to external registries. (see: https://cloud.redhat.com/blog/pushing-application-images-to-an-external-registry)

Environment variable: QUARKUS_OPENSHIFT_IMAGE_PUSH_SECRET

string

quarkus.s2i.build-strategy

The build config strategy to use.

Environment variable: QUARKUS_S2I_BUILD_STRATEGY

binary, docker

binary

quarkus.s2i.base-jvm-image

The base image to be used when a container image is being produced for the jar build. When the application is built against Java 21 or higher, registry.access.redhat.com/ubi8/openjdk-21:1.20 is used as the default. Otherwise registry.access.redhat.com/ubi8/openjdk-17:1.20 is used as the default.

Environment variable: QUARKUS_S2I_BASE_JVM_IMAGE

string

quarkus.s2i.base-native-image

The base image to be used when a container image is being produced for the native binary build

Environment variable: QUARKUS_S2I_BASE_NATIVE_IMAGE

string

quay.io/quarkus/ubi-quarkus-native-binary-s2i:2.0

quarkus.s2i.jvm-arguments

The JVM arguments to pass to the JVM when starting the application

Environment variable: QUARKUS_S2I_JVM_ARGUMENTS

list of string

quarkus.s2i.native-arguments

Additional arguments to pass when starting the native application

Environment variable: QUARKUS_S2I_NATIVE_ARGUMENTS

list of string

quarkus.s2i.jar-directory

The directory where the jar is added during the assemble phase. This is dependent on the S2I image and should be supplied if a non default image is used.

Environment variable: QUARKUS_S2I_JAR_DIRECTORY

string

/deployments/target/

quarkus.s2i.jar-file-name

The resulting filename of the jar in the S2I image. This option may be used if the selected S2I image uses a fixed name for the jar.

Environment variable: QUARKUS_S2I_JAR_FILE_NAME

string

quarkus.s2i.native-binary-directory

The directory where the native binary is added during the assemble phase. This is dependent on the S2I image and should be supplied if a non-default image is used.

Environment variable: QUARKUS_S2I_NATIVE_BINARY_DIRECTORY

string

/home/quarkus/

quarkus.s2i.native-binary-file-name

The resulting filename of the native binary in the S2I image. This option may be used if the selected S2I image uses a fixed name for the native binary.

Environment variable: QUARKUS_S2I_NATIVE_BINARY_FILE_NAME

string

quarkus.s2i.build-timeout

The build timeout.

Environment variable: QUARKUS_S2I_BUILD_TIMEOUT

Duration

PT5M

Container Image - Podman

Type

Default

quarkus.podman.dockerfile-jvm-path

Environment variable: QUARKUS_PODMAN_DOCKERFILE_JVM_PATH

string

src/main/docker/Dockerfile.jvm

quarkus.podman.dockerfile-native-path

Environment variable: QUARKUS_PODMAN_DOCKERFILE_NATIVE_PATH

string

src/main/docker/Dockerfile.native

quarkus.podman.build-args."arg-name"

Build args passed to docker via --build-arg

Environment variable: QUARKUS_PODMAN_BUILD_ARGS__ARG_NAME_

Map<String,String>

quarkus.podman.cache-from

Images to consider as cache sources. Values are passed to docker build/podman build via the cache-from option

Environment variable: QUARKUS_PODMAN_CACHE_FROM

list of string

quarkus.podman.network

The networking mode for the RUN instructions during build

Environment variable: QUARKUS_PODMAN_NETWORK

string

quarkus.podman.executable-name

Name of binary used to execute the docker/podman commands. This setting can override the global container runtime detection.

Environment variable: QUARKUS_PODMAN_EXECUTABLE_NAME

string

quarkus.podman.additional-args

Additional arbitrary arguments passed to the executable when building the container image.

Environment variable: QUARKUS_PODMAN_ADDITIONAL_ARGS

list of string

quarkus.podman.platform

Which platform(s) to target during the build. See https://docs.podman.io/en/latest/markdown/podman-build.1.html#platform-os-arch-variant

Environment variable: QUARKUS_PODMAN_PLATFORM

list of string

quarkus.podman.tls-verify

Require HTTPS and verify certificates when contacting registries

Environment variable: QUARKUS_PODMAN_TLS_VERIFY

boolean

true

Core

Type

Default

Build time analytics

Type

Default

quarkus.analytics.disabled

If Build time analytics are disabled.

Environment variable: QUARKUS_ANALYTICS_DISABLED

boolean

quarkus.analytics.uri.base

The Segment base URI.

Environment variable: QUARKUS_ANALYTICS_URI_BASE

string

quarkus.analytics.timeout

The Timeout to send the build time analytics to segment.

Environment variable: QUARKUS_ANALYTICS_TIMEOUT

int

3000

Application

Type

Default

quarkus.application.name

The name of the application. If not set, defaults to the name of the project (except for tests where it is not set at all).

Environment variable: QUARKUS_APPLICATION_NAME

string

quarkus.application.version

The version of the application. If not set, defaults to the version of the project (except for tests where it is not set at all).

Environment variable: QUARKUS_APPLICATION_VERSION

string

quarkus.application.ui-header

The header to use for UI Screen (Swagger UI, GraphQL UI etc).

Environment variable: QUARKUS_APPLICATION_UI_HEADER

string

{applicationName} (powered by Quarkus)

Banner

Type

Default

quarkus.banner.path

The path of the banner (path relative to root of classpath) which could be provided by user

Environment variable: QUARKUS_BANNER_PATH

string

default_banner.txt

quarkus.banner.enabled

Whether the banner will be displayed

Environment variable: QUARKUS_BANNER_ENABLED

boolean

true

Bootstrap

Type

Default

quarkus.bootstrap.effective-model-builder

If set to true, the workspace initialization will be based on the effective POMs (i.e. properly interpolated, including support for profiles) instead of the raw ones.

Environment variable: QUARKUS_BOOTSTRAP_EFFECTIVE_MODEL_BUILDER

boolean

false

quarkus.bootstrap.workspace-discovery

If set to true, workspace discovery will be enabled for all launch modes. Usually, workspace discovery is enabled by default only for dev and test modes.

Environment variable: QUARKUS_BOOTSTRAP_WORKSPACE_DISCOVERY

boolean

false

quarkus.bootstrap.warn-on-failing-workspace-modules

If set to true, workspace loader will log warnings for modules that could not be loaded for some reason instead of throwing errors.

Environment variable: QUARKUS_BOOTSTRAP_WARN_ON_FAILING_WORKSPACE_MODULES

boolean

false

quarkus.bootstrap.disable-jar-cache

By default, the bootstrap mechanism will create a shared cache of open JARs for Quarkus classloaders to reduce the total number of opened ZIP FileSystems in dev and test modes. Setting system property quarkus.bootstrap.disable-jar-cache to true will make Quarkus classloaders create a new ZIP FileSystem for each JAR classpath element every time it is added to a Quarkus classloader.

Environment variable: QUARKUS_BOOTSTRAP_DISABLE_JAR_CACHE

boolean

false

quarkus.bootstrap.incubating-model-resolver

A temporary option introduced to avoid a logging warning when -Dquarkus.bootstrap.incubating-model-resolver is added to the build command line. This option enables an incubating implementation of the Quarkus Application Model resolver. This option will be removed as soon as the incubating implementation becomes the default one.

Environment variable: QUARKUS_BOOTSTRAP_INCUBATING_MODEL_RESOLVER

boolean

false

quarkus.bootstrap.misaligned-platform-imports

Whether to throw an error, warn or silently ignore misaligned platform BOM imports

Environment variable: QUARKUS_BOOTSTRAP_MISALIGNED_PLATFORM_IMPORTS

error, warn, ignore

error

Builder

Type

Default

quarkus.builder.graph-output

Dump the graph output to a file. This is useful for debugging.

Environment variable: QUARKUS_BUILDER_GRAPH_OUTPUT

string

quarkus.builder.log-conflict-cause

Whether to log the cause of a conflict.

Environment variable: QUARKUS_BUILDER_LOG_CONFLICT_CAUSE

boolean

Class loading

Type

Default

quarkus.class-loading.parent-first-artifacts

Artifacts that are loaded in a parent first manner. This can be used to work around issues where a given class needs to be loaded by the system ClassLoader. Note that if you make a library parent first all its dependencies should generally also be parent first.

Artifacts should be configured as a comma separated list of artifact ids, with the group, artifact-id and optional classifier separated by a colon.

This config property can only be set in application.properties

Environment variable: QUARKUS_CLASS_LOADING_PARENT_FIRST_ARTIFACTS

list of string

quarkus.class-loading.reloadable-artifacts

Artifacts that are loaded in the runtime ClassLoader in dev mode, so they will be dropped and recreated on change.

This is an advanced option, it should only be used if you have a problem with libraries holding stale state between reloads. Note that if you use this any library that depends on the listed libraries will also need to be reloadable.

This setting has no impact on production builds.

Artifacts should be configured as a comma separated list of artifact ids, with the group, artifact-id and optional classifier separated by a colon.

This config property can only be set in application.properties

Environment variable: QUARKUS_CLASS_LOADING_RELOADABLE_ARTIFACTS

string

quarkus.class-loading.removed-artifacts

Artifacts that will never be loaded by the class loader, and will not be packed into the final application. This allows you to explicitly remove artifacts from your application even though they may be present on the class path.

Environment variable: QUARKUS_CLASS_LOADING_REMOVED_ARTIFACTS

list of string

quarkus.class-loading.removed-resources."group-id:artifact-id"

Resources that should be removed/hidden from dependencies.

This allows for classes and other resources to be removed from dependencies, so they are not accessible to the application. This is a map of artifact id (in the form group:artifact) to a list of resources to be removed.

When running in dev and test mode these resources are hidden from the ClassLoader, when running in production mode these files are removed from the jars that contain them.

Note that if you want to remove a class you need to specify the class file name. e.g. to remove com.acme.Foo you would specify com/acme/Foo.class.

Note that for technical reasons this is not supported when running with JBang.

Environment variable: QUARKUS_CLASS_LOADING_REMOVED_RESOURCES__GROUP_ID_ARTIFACT_ID_

Map<String,Set<String>>

Command line

Type

Default

quarkus.args

The arguments passed to the command line.

We don’t make it a list as the args are separated by a space, not a comma.

Environment variable: QUARKUS_ARGS

string

Configuration

Type

Default

quarkus.config.sources.system-only

Set this to true to read configuration from system properties and environment variables only. This only applies to runtime.

Environment variable: QUARKUS_CONFIG_SOURCES_SYSTEM_ONLY

boolean

false

quarkus.profile

A comma separated list of profiles that will be active when Quarkus launches.

Environment variable: QUARKUS_PROFILE

list of string

quarkus.config.profile.parent

Accepts a single configuration profile name. If a configuration property cannot be found in the current active profile, the config performs the same lookup in the profile set by this configuration.

Environment variable: QUARKUS_CONFIG_PROFILE_PARENT

string

quarkus.config.locations

Additional config locations to be loaded with the Config. The configuration support multiple locations separated by a comma and each must represent a valid java.net.URI.

Environment variable: QUARKUS_CONFIG_LOCATIONS

list of URI

quarkus.config.mapping.validate-unknown

Validates that a @ConfigMapping maps every available configuration name contained in the mapping prefix.

Environment variable: QUARKUS_CONFIG_MAPPING_VALIDATE_UNKNOWN

boolean

quarkus.config.log.values

Enable logging of configuration values lookup in DEBUG log level.
The log of configuration values require the category set to DEBUG in the io.smallrye.config category: quarkus.log.category."io.smallrye.config".level=DEBUG.

Environment variable: QUARKUS_CONFIG_LOG_VALUES

boolean

quarkus.uuid

A property that allows accessing a generated UUID. It generates that UUID at startup time. So it changes between two starts including in dev mode.
Access this generated UUID using expressions: ${quarkus.uuid}.

Environment variable: QUARKUS_UUID

string

Configuration tracking and dumping

Type

Default

quarkus.config-tracking.enabled

Whether configuration dumping is enabled

Environment variable: QUARKUS_CONFIG_TRACKING_ENABLED

boolean

false

quarkus.config-tracking.directory

Directory in which the configuration dump should be stored. If not configured the .quarkus directory under the project directory will be used.

Environment variable: QUARKUS_CONFIG_TRACKING_DIRECTORY

path

quarkus.config-tracking.file

File in which the configuration dump should be stored. If not configured, the file-prefix and file-suffix will be used to generate the final file name. If the configured file path is absolute, the directory option will be ignored. Otherwise, the path will be considered relative to the directory.

Environment variable: QUARKUS_CONFIG_TRACKING_FILE

path

quarkus.config-tracking.file-prefix

File name prefix. This option will be ignored in case file is configured.

Environment variable: QUARKUS_CONFIG_TRACKING_FILE_PREFIX

string

quarkus

quarkus.config-tracking.file-suffix

File name suffix. This option will be ignored in case file is configured.

Environment variable: QUARKUS_CONFIG_TRACKING_FILE_SUFFIX

string

-config-dump

quarkus.config-tracking.exclude

A list of config properties that should be excluded from the report. GLOB patterns could be used instead of property names.

Environment variable: QUARKUS_CONFIG_TRACKING_EXCLUDE

list of string

quarkus.config-tracking.hash-options

A list of config properties whose values should be hashed in the report. The values will be hashed using SHA-512 algorithm. GLOB patterns could be used instead of property names.

Environment variable: QUARKUS_CONFIG_TRACKING_HASH_OPTIONS

list of string

quarkus.config-tracking.use-user-home-alias-in-paths

Whether to use a ~ as an alias for user home directory in path values

Environment variable: QUARKUS_CONFIG_TRACKING_USE_USER_HOME_ALIAS_IN_PATHS

boolean

true

quarkus.configuration.build-time-mismatch-at-runtime

What should happen if the application is started with a different build time configuration than it was compiled against. This may be useful to prevent misconfiguration.

If this is set to warn the application will warn at start up.

If this is set to fail the application will fail at start up.

Native tests leveraging`@io.quarkus.test.junit.TestProfile` are always run with quarkus.configuration.build-time-mismatch-at-runtime = fail.

Environment variable: QUARKUS_CONFIGURATION_BUILD_TIME_MISMATCH_AT_RUNTIME

warn, fail

warn

Console

Type

Default

quarkus.console.enabled

If test results and status should be displayed in the console.

If this is false results can still be viewed in the dev console.

Environment variable: QUARKUS_CONSOLE_ENABLED

boolean

true

quarkus.console.disable-input

Disables the ability to enter input on the console.

Environment variable: QUARKUS_CONSOLE_DISABLE_INPUT

boolean

false

quarkus.console.basic

Disable the testing status/prompt message at the bottom of the console and log these messages to STDOUT instead.

Use this option if your terminal does not support ANSI escape sequences.

Environment variable: QUARKUS_CONSOLE_BASIC

boolean

false

quarkus.console.color

If color should be enabled or disabled.

If this is not present then an attempt will be made to guess if the terminal supports color

Environment variable: QUARKUS_CONSOLE_COLOR

boolean

Debugging

Type

Default

quarkus.debug.reflection

If set to true, writes a list of all reflective classes to META-INF

Environment variable: QUARKUS_DEBUG_REFLECTION

boolean

false

quarkus.debug.generated-classes-dir

If set to a directory, all generated classes will be written into that directory

Environment variable: QUARKUS_DEBUG_GENERATED_CLASSES_DIR

string

quarkus.debug.transformed-classes-dir

If set to a directory, all transformed classes (e.g. Panache entities) will be written into that directory

Environment variable: QUARKUS_DEBUG_TRANSFORMED_CLASSES_DIR

string

quarkus.debug.generated-sources-dir

If set to a directory, ZIG files for generated code will be written into that directory.

A ZIG file is a textual representation of the generated code that is referenced in the stacktraces.

Environment variable: QUARKUS_DEBUG_GENERATED_SOURCES_DIR

string

quarkus.debug.dump-build-metrics

If set to true then dump the build metrics to a JSON file in the build directory.

Environment variable: QUARKUS_DEBUG_DUMP_BUILD_METRICS

boolean

false

quarkus.debug.print-startup-times

If set to true, Quarkus prints the wall-clock time each build step took to complete. This is useful as a first step in debugging slow startup times.

Environment variable: QUARKUS_DEBUG_PRINT_STARTUP_TIMES

boolean

false

Deployment

Type

Default

quarkus.deploy.target

Deployment target

Environment variable: QUARKUS_DEPLOY_TARGET

string

Dev Services

Type

Default

quarkus.devservices.enabled

Global flag that can be used to disable all Dev Services. If this is set to false then Dev Services will not be used.

Environment variable: QUARKUS_DEVSERVICES_ENABLED

boolean

true

quarkus.devservices.launch-on-shared-network

Global flag that can be used to force the attachmment of Dev Services to shared network. Default is false.

Environment variable: QUARKUS_DEVSERVICES_LAUNCH_ON_SHARED_NETWORK

boolean

false

quarkus.devservices.timeout

The timeout for starting a container

Environment variable: QUARKUS_DEVSERVICES_TIMEOUT

Duration

quarkus.execution-model-annotations.detection-mode

Detection mode of invalid usage of execution model annotations.

An execution model annotation is @Blocking, @NonBlocking and @RunOnVirtualThread. These annotations may only be used on "entrypoint" methods (methods invoked by various frameworks in Quarkus); using them on methods that can only be invoked by application code is invalid.

Environment variable: QUARKUS_EXECUTION_MODEL_ANNOTATIONS_DETECTION_MODE

failInvalid usage of execution model annotations causes build failure., warnInvalid usage of execution model annotations causes warning during build., disabledNo detection of invalid usage of execution model annotations.

failInvalid usage of execution model annotations causes build failure.

IDE

Type

Default

quarkus.ide.target

The Ide to use to open files from the DevUI. auto means that Quarkus will attempt to determine the Ide being used.

Environment variable: QUARKUS_IDE_TARGET

auto, idea, vscode, eclipse, netbeans

auto

Indexing

Type

Default

Artifacts on the classpath that should also be indexed

Type

Default

quarkus.index-dependency."dependency-name".group-id

The maven groupId of the artifact.

Environment variable: QUARKUS_INDEX_DEPENDENCY__DEPENDENCY_NAME__GROUP_ID

string

required

quarkus.index-dependency."dependency-name".artifact-id

The maven artifactId of the artifact (optional).

Environment variable: QUARKUS_INDEX_DEPENDENCY__DEPENDENCY_NAME__ARTIFACT_ID

string

quarkus.index-dependency."dependency-name".classifier

The maven classifier of the artifact (optional).

Environment variable: QUARKUS_INDEX_DEPENDENCY__DEPENDENCY_NAME__CLASSIFIER

string

Initialization

Type

Default

quarkus.init-and-exit

true to quit exit right after the initialization. The option is not meant be used directly by users.

Environment variable: QUARKUS_INIT_AND_EXIT

boolean

false

JNI

Type

Default

quarkus.jni.library-paths

Paths of library to load.

Environment variable: QUARKUS_JNI_LIBRARY_PATHS

list of string

Launch

Type

Default

quarkus.launch.rebuild

If set to true, Quarkus will perform re-augmentation (assuming the mutable-jar package type is used)

Environment variable: QUARKUS_LAUNCH_REBUILD

boolean

false

Live reload

Type

Default

quarkus.live-reload.enabled

Whether the live-reload feature should be enabled.

Environment variable: QUARKUS_LIVE_RELOAD_ENABLED

boolean

true

quarkus.live-reload.instrumentation

Whether Quarkus should enable its ability to not do a full restart when changes to classes are compatible with JVM instrumentation. If this is set to true, Quarkus will perform class redefinition when possible.

Environment variable: QUARKUS_LIVE_RELOAD_INSTRUMENTATION

boolean

false

quarkus.live-reload.watched-resources

The names of additional resource files to watch for changes, triggering a reload on change. Directories are not supported.

Environment variable: QUARKUS_LIVE_RELOAD_WATCHED_RESOURCES

list of string

quarkus.live-reload.password

Password used to use to connect to the remote dev-mode application

Environment variable: QUARKUS_LIVE_RELOAD_PASSWORD

string

quarkus.live-reload.url

URL used to use to connect to the remote dev-mode application

Environment variable: QUARKUS_LIVE_RELOAD_URL

string

quarkus.live-reload.connect-timeout

The amount of time to wait for a remote dev connect or reconnect

Environment variable: QUARKUS_LIVE_RELOAD_CONNECT_TIMEOUT

Duration

30S

quarkus.live-reload.retry-interval

The amount of time to wait between attempts when connecting to the server side of remote dev

Environment variable: QUARKUS_LIVE_RELOAD_RETRY_INTERVAL

Duration

2S

quarkus.live-reload.retry-max-attempts

The maximum number of attempts when connecting to the server side of remote dev

Environment variable: QUARKUS_LIVE_RELOAD_RETRY_MAX_ATTEMPTS

int

10

Localization

Type

Default

quarkus.locales

The set of supported locales that can be consumed by the extensions.

The locales must be specified in the IETF BCP 47 format e.g. en-US or fr-FR.

For instance, the Hibernate Validator extension makes use of it.

Native-image build uses it to define additional locales that are supposed to be available at runtime.

A special string "all" is translated as ROOT Locale and then used in native-image to include all locales. Image size penalty applies.

Environment variable: QUARKUS_LOCALES

list of Locale

Set containing the build system locale

quarkus.default-locale

Default locale that can be consumed by the extensions.

The locale must be specified in the IETF BCP 47 format e.g. en-US or fr-FR.

For instance, the Hibernate Validator extension makes use of it.

Native-image build uses this property to derive user.language and user.country for the application’s runtime. Starting with GraalVM for JDK 24 user.language and user.country can also be overridden at runtime, provided the selected locale was included at image build time.

Environment variable: QUARKUS_DEFAULT_LOCALE

Locale

Defaults to the JVM’s default locale if not set. Starting with GraalVM for JDK 24, it defaults to en-US for native executables.

Logging

Type

Default

quarkus.log.metrics.enabled

If enabled and a metrics extension is present, logging metrics are published.

Environment variable: QUARKUS_LOG_METRICS_ENABLED

boolean

false

quarkus.log.min-level

The default minimum log level.

Environment variable: QUARKUS_LOG_MIN_LEVEL

Level

DEBUG

quarkus.log.decorate-stacktraces

This will decorate the stacktrace in dev mode to show the line in the code that cause the exception

Environment variable: QUARKUS_LOG_DECORATE_STACKTRACES

boolean

true

quarkus.log.level

The log level of the root category, which is used as the default log level for all categories. <p> JBoss Logging supports Apache-style log levels: <p> * {@link org.jboss.logmanager.Level#FATAL} * {@link org.jboss.logmanager.Level#ERROR} * {@link org.jboss.logmanager.Level#WARN} * {@link org.jboss.logmanager.Level#INFO} * {@link org.jboss.logmanager.Level#DEBUG} * {@link org.jboss.logmanager.Level#TRACE}

In addition, it also supports the standard JDK log levels.

Environment variable: QUARKUS_LOG_LEVEL

Level

INFO

quarkus.log.handlers

The names of additional handlers to link to the root category. These handlers are defined in consoleHandlers, fileHandlers, or syslogHandlers.

Environment variable: QUARKUS_LOG_HANDLERS

list of string

Minimum logging categories

Type

Default

quarkus.log.category."categories".min-level

The minimum log level for this category. By default, all categories are configured with DEBUG minimum level.

To get runtime logging below DEBUG, e.g., TRACE, adjust the minimum level at build time. The right log level needs to be provided at runtime.

As an example, to get TRACE logging, minimum level needs to be at TRACE, and the runtime log level needs to match that.

Environment variable: QUARKUS_LOG_CATEGORY__CATEGORIES__MIN_LEVEL

InheritableLevel

inherit

quarkus.log.category."categories".level

The log level for this category.

Note that to get log levels below INFO, the minimum level build-time configuration option also needs to be adjusted.

Environment variable: QUARKUS_LOG_CATEGORY__CATEGORIES__LEVEL

InheritableLevel

inherit

quarkus.log.category."categories".handlers

The names of the handlers to link to this category.

Environment variable: QUARKUS_LOG_CATEGORY__CATEGORIES__HANDLERS

list of string

quarkus.log.category."categories".use-parent-handlers

Specify whether this logger should send its output to its parent Logger

Environment variable: QUARKUS_LOG_CATEGORY__CATEGORIES__USE_PARENT_HANDLERS

boolean

true

Console logging

Type

Default

quarkus.log.console.enable

If console logging should be enabled

Environment variable: QUARKUS_LOG_CONSOLE_ENABLE

boolean

true

quarkus.log.console.stderr

If console logging should go to System#err instead of System#out.

Environment variable: QUARKUS_LOG_CONSOLE_STDERR

boolean

false

quarkus.log.console.format

The log format. Note that this value is ignored if an extension is present that takes control of console formatting (e.g., an XML or JSON-format extension).

Environment variable: QUARKUS_LOG_CONSOLE_FORMAT

string

%d{yyyy-MM-dd HH:mm:ss,SSS} %-5p [%c{3.}] (%t) %s%e%n

quarkus.log.console.level

The console log level.

Environment variable: QUARKUS_LOG_CONSOLE_LEVEL

Level

ALL

quarkus.log.console.darken

Specify how much the colors should be darkened. Note that this value is ignored if an extension is present that takes control of console formatting (e.g., an XML or JSON-format extension).

Environment variable: QUARKUS_LOG_CONSOLE_DARKEN

int

0

quarkus.log.console.filter

The name of the filter to link to the console handler.

Environment variable: QUARKUS_LOG_CONSOLE_FILTER

string

quarkus.log.console.async

Indicates whether to log asynchronously

Environment variable: QUARKUS_LOG_CONSOLE_ASYNC

boolean

false

quarkus.log.console.async.queue-length

The queue length to use before flushing writing

Environment variable: QUARKUS_LOG_CONSOLE_ASYNC_QUEUE_LENGTH

int

512

quarkus.log.console.async.overflow

Determine whether to block the publisher (rather than drop the message) when the queue is full

Environment variable: QUARKUS_LOG_CONSOLE_ASYNC_OVERFLOW

block, discard

block

File logging

Type

Default

quarkus.log.file.enable

If file logging should be enabled

Environment variable: QUARKUS_LOG_FILE_ENABLE

boolean

false

quarkus.log.file.format

The log format

Environment variable: QUARKUS_LOG_FILE_FORMAT

string

%d{yyyy-MM-dd HH:mm:ss,SSS} %h %N[%i] %-5p [%c{3.}] (%t) %s%e%n

quarkus.log.file.level

The level of logs to be written into the file.

Environment variable: QUARKUS_LOG_FILE_LEVEL

Level

ALL

quarkus.log.file.path

The name of the file in which logs will be written.

Environment variable: QUARKUS_LOG_FILE_PATH

File

quarkus.log

quarkus.log.file.filter

The name of the filter to link to the file handler.

Environment variable: QUARKUS_LOG_FILE_FILTER

string

quarkus.log.file.encoding

The character encoding used

Environment variable: QUARKUS_LOG_FILE_ENCODING

Charset

quarkus.log.file.async

Indicates whether to log asynchronously

Environment variable: QUARKUS_LOG_FILE_ASYNC

boolean

false

quarkus.log.file.async.queue-length

The queue length to use before flushing writing

Environment variable: QUARKUS_LOG_FILE_ASYNC_QUEUE_LENGTH

int

512

quarkus.log.file.async.overflow

Determine whether to block the publisher (rather than drop the message) when the queue is full

Environment variable: QUARKUS_LOG_FILE_ASYNC_OVERFLOW

block, discard

block

quarkus.log.file.rotation.max-file-size

The maximum log file size, after which a rotation is executed. Note that the file is rotated after the log record is written. Thus, this isn’t a hard maximum on the file size; rather, it’s a hard minimum on the size of the file before it is rotated.

Environment variable: QUARKUS_LOG_FILE_ROTATION_MAX_FILE_SIZE

MemorySize

10M

quarkus.log.file.rotation.max-backup-index

The maximum number of backups to keep.

Environment variable: QUARKUS_LOG_FILE_ROTATION_MAX_BACKUP_INDEX

int

5

quarkus.log.file.rotation.file-suffix

The file handler rotation file suffix. When used, the file will be rotated based on its suffix.

The suffix must be in a date-time format that is understood by DateTimeFormatter.

Example fileSuffix: .yyyy-MM-dd

Note: If the suffix ends with .zip or .gz, the rotation file will also be compressed.

Environment variable: QUARKUS_LOG_FILE_ROTATION_FILE_SUFFIX

string

quarkus.log.file.rotation.rotate-on-boot

Indicates whether to rotate log files on server initialization.

You need to either set a max-file-size or configure a file-suffix for it to work.

Environment variable: QUARKUS_LOG_FILE_ROTATION_ROTATE_ON_BOOT

boolean

true

Syslog logging

Type

Default

quarkus.log.syslog.enable

If syslog logging should be enabled

Environment variable: QUARKUS_LOG_SYSLOG_ENABLE

boolean

false

quarkus.log.syslog.endpoint

The IP address and port of the Syslog server

Environment variable: QUARKUS_LOG_SYSLOG_ENDPOINT

host:port

localhost:514

quarkus.log.syslog.app-name

The app name used when formatting the message in RFC5424 format

Environment variable: QUARKUS_LOG_SYSLOG_APP_NAME

string

quarkus.log.syslog.hostname

The name of the host the messages are being sent from

Environment variable: QUARKUS_LOG_SYSLOG_HOSTNAME

string

quarkus.log.syslog.facility

Sets the facility used when calculating the priority of the message as defined by RFC-5424 and RFC-3164

Environment variable: QUARKUS_LOG_SYSLOG_FACILITY

kernel, user-level, mail-system, system-daemons, security, syslogd, line-printer, network-news, uucp, clock-daemon, security2, ftp-daemon, ntp, log-audit, log-alert, clock-daemon2, local-use-0, local-use-1, local-use-2, local-use-3, local-use-4, local-use-5, local-use-6, local-use-7

user-level

quarkus.log.syslog.syslog-type

Set the SyslogType syslog type this handler should use to format the message sent

Environment variable: QUARKUS_LOG_SYSLOG_SYSLOG_TYPE

rfc5424, rfc3164

rfc5424

quarkus.log.syslog.protocol

Sets the protocol used to connect to the Syslog server

Environment variable: QUARKUS_LOG_SYSLOG_PROTOCOL

tcp, udp, ssl-tcp

tcp

quarkus.log.syslog.use-counting-framing

If enabled, the message being sent is prefixed with the size of the message

Environment variable: QUARKUS_LOG_SYSLOG_USE_COUNTING_FRAMING

boolean

false

quarkus.log.syslog.truncate

Set to true to truncate the message if it exceeds maximum length

Environment variable: QUARKUS_LOG_SYSLOG_TRUNCATE

boolean

true

quarkus.log.syslog.block-on-reconnect

Enables or disables blocking when attempting to reconnect a Protocol#TCP TCP or Protocol#SSL_TCP SSL TCP protocol

Environment variable: QUARKUS_LOG_SYSLOG_BLOCK_ON_RECONNECT

boolean

false

quarkus.log.syslog.format

The log message format

Environment variable: QUARKUS_LOG_SYSLOG_FORMAT

string

%d{yyyy-MM-dd HH:mm:ss,SSS} %-5p [%c{3.}] (%t) %s%e%n

quarkus.log.syslog.level

The log level specifying what message levels will be logged by the Syslog logger

Environment variable: QUARKUS_LOG_SYSLOG_LEVEL

Level

ALL

quarkus.log.syslog.filter

The name of the filter to link to the file handler.

Environment variable: QUARKUS_LOG_SYSLOG_FILTER

string

quarkus.log.syslog.max-length

The maximum length, in bytes, of the message allowed to be sent. The length includes the header and the message.

If not set, the default value is 2048 when sys-log-type is rfc5424 (which is the default) and 1024 when sys-log-type is rfc3164

Environment variable: QUARKUS_LOG_SYSLOG_MAX_LENGTH

MemorySize

quarkus.log.syslog.async

Indicates whether to log asynchronously

Environment variable: QUARKUS_LOG_SYSLOG_ASYNC

boolean

false

quarkus.log.syslog.async.queue-length

The queue length to use before flushing writing

Environment variable: QUARKUS_LOG_SYSLOG_ASYNC_QUEUE_LENGTH

int

512

quarkus.log.syslog.async.overflow

Determine whether to block the publisher (rather than drop the message) when the queue is full

Environment variable: QUARKUS_LOG_SYSLOG_ASYNC_OVERFLOW

block, discard

block

Socket logging

Type

Default

quarkus.log.socket.enable

If socket logging should be enabled

Environment variable: QUARKUS_LOG_SOCKET_ENABLE

boolean

false

quarkus.log.socket.endpoint

The IP address and port of the server receiving the logs

Environment variable: QUARKUS_LOG_SOCKET_ENDPOINT

host:port

localhost:4560

quarkus.log.socket.protocol

Sets the protocol used to connect to the syslog server

Environment variable: QUARKUS_LOG_SOCKET_PROTOCOL

tcp, udp, ssl-tcp

tcp

quarkus.log.socket.block-on-reconnect

Enables or disables blocking when attempting to reconnect a Protocol#TCP TCP or Protocol#SSL_TCP SSL TCP protocol

Environment variable: QUARKUS_LOG_SOCKET_BLOCK_ON_RECONNECT

boolean

false

quarkus.log.socket.format

The log message format

Environment variable: QUARKUS_LOG_SOCKET_FORMAT

string

%d{yyyy-MM-dd HH:mm:ss,SSS} %-5p [%c{3.}] (%t) %s%e%n

quarkus.log.socket.level

The log level specifying, which message levels will be logged by socket logger

Environment variable: QUARKUS_LOG_SOCKET_LEVEL

Level

ALL

quarkus.log.socket.filter

The name of the filter to link to the file handler.

Environment variable: QUARKUS_LOG_SOCKET_FILTER

string

quarkus.log.socket.async

Indicates whether to log asynchronously

Environment variable: QUARKUS_LOG_SOCKET_ASYNC

boolean

false

quarkus.log.socket.async.queue-length

The queue length to use before flushing writing

Environment variable: QUARKUS_LOG_SOCKET_ASYNC_QUEUE_LENGTH

int

512

quarkus.log.socket.async.overflow

Determine whether to block the publisher (rather than drop the message) when the queue is full

Environment variable: QUARKUS_LOG_SOCKET_ASYNC_OVERFLOW

block, discard

block

Console handlers

Type

Default

quarkus.log.handler.console."console-handlers".enable

If console logging should be enabled

Environment variable: QUARKUS_LOG_HANDLER_CONSOLE__CONSOLE_HANDLERS__ENABLE

boolean

true

quarkus.log.handler.console."console-handlers".stderr

If console logging should go to System#err instead of System#out.

Environment variable: QUARKUS_LOG_HANDLER_CONSOLE__CONSOLE_HANDLERS__STDERR

boolean

false

quarkus.log.handler.console."console-handlers".format

The log format. Note that this value is ignored if an extension is present that takes control of console formatting (e.g., an XML or JSON-format extension).

Environment variable: QUARKUS_LOG_HANDLER_CONSOLE__CONSOLE_HANDLERS__FORMAT

string

%d{yyyy-MM-dd HH:mm:ss,SSS} %-5p [%c{3.}] (%t) %s%e%n

quarkus.log.handler.console."console-handlers".level

The console log level.

Environment variable: QUARKUS_LOG_HANDLER_CONSOLE__CONSOLE_HANDLERS__LEVEL

Level

ALL

quarkus.log.handler.console."console-handlers".darken

Specify how much the colors should be darkened. Note that this value is ignored if an extension is present that takes control of console formatting (e.g., an XML or JSON-format extension).

Environment variable: QUARKUS_LOG_HANDLER_CONSOLE__CONSOLE_HANDLERS__DARKEN

int

0

quarkus.log.handler.console."console-handlers".filter

The name of the filter to link to the console handler.

Environment variable: QUARKUS_LOG_HANDLER_CONSOLE__CONSOLE_HANDLERS__FILTER

string

quarkus.log.handler.console."console-handlers".async

Indicates whether to log asynchronously

Environment variable: QUARKUS_LOG_HANDLER_CONSOLE__CONSOLE_HANDLERS__ASYNC

boolean

false

quarkus.log.handler.console."console-handlers".async.queue-length

The queue length to use before flushing writing

Environment variable: QUARKUS_LOG_HANDLER_CONSOLE__CONSOLE_HANDLERS__ASYNC_QUEUE_LENGTH

int

512

quarkus.log.handler.console."console-handlers".async.overflow

Determine whether to block the publisher (rather than drop the message) when the queue is full

Environment variable: QUARKUS_LOG_HANDLER_CONSOLE__CONSOLE_HANDLERS__ASYNC_OVERFLOW

block, discard

block

File handlers

Type

Default

quarkus.log.handler.file."file-handlers".enable

If file logging should be enabled

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__ENABLE

boolean

false

quarkus.log.handler.file."file-handlers".format

The log format

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__FORMAT

string

%d{yyyy-MM-dd HH:mm:ss,SSS} %h %N[%i] %-5p [%c{3.}] (%t) %s%e%n

quarkus.log.handler.file."file-handlers".level

The level of logs to be written into the file.

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__LEVEL

Level

ALL

quarkus.log.handler.file."file-handlers".path

The name of the file in which logs will be written.

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__PATH

File

quarkus.log

quarkus.log.handler.file."file-handlers".filter

The name of the filter to link to the file handler.

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__FILTER

string

quarkus.log.handler.file."file-handlers".encoding

The character encoding used

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__ENCODING

Charset

quarkus.log.handler.file."file-handlers".async

Indicates whether to log asynchronously

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__ASYNC

boolean

false

quarkus.log.handler.file."file-handlers".async.queue-length

The queue length to use before flushing writing

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__ASYNC_QUEUE_LENGTH

int

512

quarkus.log.handler.file."file-handlers".async.overflow

Determine whether to block the publisher (rather than drop the message) when the queue is full

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__ASYNC_OVERFLOW

block, discard

block

quarkus.log.handler.file."file-handlers".rotation.max-file-size

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__ROTATION_MAX_FILE_SIZE

MemorySize

10M

quarkus.log.handler.file."file-handlers".rotation.max-backup-index

The maximum number of backups to keep.

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__ROTATION_MAX_BACKUP_INDEX

int

5

quarkus.log.handler.file."file-handlers".rotation.file-suffix

The file handler rotation file suffix. When used, the file will be rotated based on its suffix.

The suffix must be in a date-time format that is understood by DateTimeFormatter.

Example fileSuffix: .yyyy-MM-dd

Note: If the suffix ends with .zip or .gz, the rotation file will also be compressed.

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__ROTATION_FILE_SUFFIX

string

quarkus.log.handler.file."file-handlers".rotation.rotate-on-boot

Indicates whether to rotate log files on server initialization.

You need to either set a max-file-size or configure a file-suffix for it to work.

Environment variable: QUARKUS_LOG_HANDLER_FILE__FILE_HANDLERS__ROTATION_ROTATE_ON_BOOT

boolean

true

Syslog handlers

Type

Default

quarkus.log.handler.syslog."syslog-handlers".enable

If syslog logging should be enabled

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__ENABLE

boolean

false

quarkus.log.handler.syslog."syslog-handlers".endpoint

The IP address and port of the Syslog server

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__ENDPOINT

host:port

localhost:514

quarkus.log.handler.syslog."syslog-handlers".app-name

The app name used when formatting the message in RFC5424 format

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__APP_NAME

string

quarkus.log.handler.syslog."syslog-handlers".hostname

The name of the host the messages are being sent from

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__HOSTNAME

string

quarkus.log.handler.syslog."syslog-handlers".facility

Sets the facility used when calculating the priority of the message as defined by RFC-5424 and RFC-3164

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__FACILITY

user-level

quarkus.log.handler.syslog."syslog-handlers".syslog-type

Set the SyslogType syslog type this handler should use to format the message sent

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__SYSLOG_TYPE

rfc5424, rfc3164

rfc5424

quarkus.log.handler.syslog."syslog-handlers".protocol

Sets the protocol used to connect to the Syslog server

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__PROTOCOL

tcp, udp, ssl-tcp

tcp

quarkus.log.handler.syslog."syslog-handlers".use-counting-framing

If enabled, the message being sent is prefixed with the size of the message

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__USE_COUNTING_FRAMING

boolean

false

quarkus.log.handler.syslog."syslog-handlers".truncate

Set to true to truncate the message if it exceeds maximum length

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__TRUNCATE

boolean

true

quarkus.log.handler.syslog."syslog-handlers".block-on-reconnect

Enables or disables blocking when attempting to reconnect a Protocol#TCP TCP or Protocol#SSL_TCP SSL TCP protocol

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__BLOCK_ON_RECONNECT

boolean

false

quarkus.log.handler.syslog."syslog-handlers".format

The log message format

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__FORMAT

string

%d{yyyy-MM-dd HH:mm:ss,SSS} %-5p [%c{3.}] (%t) %s%e%n

quarkus.log.handler.syslog."syslog-handlers".level

The log level specifying what message levels will be logged by the Syslog logger

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__LEVEL

Level

ALL

quarkus.log.handler.syslog."syslog-handlers".filter

The name of the filter to link to the file handler.

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__FILTER

string

quarkus.log.handler.syslog."syslog-handlers".max-length

The maximum length, in bytes, of the message allowed to be sent. The length includes the header and the message.

If not set, the default value is 2048 when sys-log-type is rfc5424 (which is the default) and 1024 when sys-log-type is rfc3164

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__MAX_LENGTH

MemorySize

quarkus.log.handler.syslog."syslog-handlers".async

Indicates whether to log asynchronously

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__ASYNC

boolean

false

quarkus.log.handler.syslog."syslog-handlers".async.queue-length

The queue length to use before flushing writing

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__ASYNC_QUEUE_LENGTH

int

512

quarkus.log.handler.syslog."syslog-handlers".async.overflow

Determine whether to block the publisher (rather than drop the message) when the queue is full

Environment variable: QUARKUS_LOG_HANDLER_SYSLOG__SYSLOG_HANDLERS__ASYNC_OVERFLOW

block, discard

block

Socket handlers

Type

Default

quarkus.log.handler.socket."socket-handlers".enable

If socket logging should be enabled

Environment variable: QUARKUS_LOG_HANDLER_SOCKET__SOCKET_HANDLERS__ENABLE

boolean

false

quarkus.log.handler.socket."socket-handlers".endpoint

The IP address and port of the server receiving the logs

Environment variable: QUARKUS_LOG_HANDLER_SOCKET__SOCKET_HANDLERS__ENDPOINT

host:port

localhost:4560

quarkus.log.handler.socket."socket-handlers".protocol

Sets the protocol used to connect to the syslog server

Environment variable: QUARKUS_LOG_HANDLER_SOCKET__SOCKET_HANDLERS__PROTOCOL

tcp, udp, ssl-tcp

tcp

quarkus.log.handler.socket."socket-handlers".block-on-reconnect

Enables or disables blocking when attempting to reconnect a Protocol#TCP TCP or Protocol#SSL_TCP SSL TCP protocol

Environment variable: QUARKUS_LOG_HANDLER_SOCKET__SOCKET_HANDLERS__BLOCK_ON_RECONNECT

boolean

false

quarkus.log.handler.socket."socket-handlers".format

The log message format

Environment variable: QUARKUS_LOG_HANDLER_SOCKET__SOCKET_HANDLERS__FORMAT

string

%d{yyyy-MM-dd HH:mm:ss,SSS} %-5p [%c{3.}] (%t) %s%e%n

quarkus.log.handler.socket."socket-handlers".level

The log level specifying, which message levels will be logged by socket logger

Environment variable: QUARKUS_LOG_HANDLER_SOCKET__SOCKET_HANDLERS__LEVEL

Level

ALL

quarkus.log.handler.socket."socket-handlers".filter

The name of the filter to link to the file handler.

Environment variable: QUARKUS_LOG_HANDLER_SOCKET__SOCKET_HANDLERS__FILTER

string

quarkus.log.handler.socket."socket-handlers".async

Indicates whether to log asynchronously

Environment variable: QUARKUS_LOG_HANDLER_SOCKET__SOCKET_HANDLERS__ASYNC

boolean

false

quarkus.log.handler.socket."socket-handlers".async.queue-length

The queue length to use before flushing writing

Environment variable: QUARKUS_LOG_HANDLER_SOCKET__SOCKET_HANDLERS__ASYNC_QUEUE_LENGTH

int

512

quarkus.log.handler.socket."socket-handlers".async.overflow

Determine whether to block the publisher (rather than drop the message) when the queue is full

Environment variable: QUARKUS_LOG_HANDLER_SOCKET__SOCKET_HANDLERS__ASYNC_OVERFLOW

block, discard

block

Log cleanup filters - internal use

Type

Default

quarkus.log.filter."filters".if-starts-with

The message prefix to match

Environment variable: QUARKUS_LOG_FILTER__FILTERS__IF_STARTS_WITH

list of string

inherit

quarkus.log.filter."filters".target-level

The new log level for the filtered message. Defaults to DEBUG.

Environment variable: QUARKUS_LOG_FILTER__FILTERS__TARGET_LEVEL

Level

DEBUG

Naming

Type

Default

quarkus.naming.enable-jndi

By default, Quarkus will install a non-functional JNDI initial context, to help mitigate against Log4Shell style attacks. If your application does need to use JNDI you can change this flag.

Environment variable: QUARKUS_NAMING_ENABLE_JNDI

boolean

false

Native executables

Type

Default

quarkus.native.enabled

Set to enable native-image building using GraalVM.

Environment variable: QUARKUS_NATIVE_ENABLED

boolean

false

quarkus.native.sources-only

Set to prevent the native-image process from actually building the native image.

Environment variable: QUARKUS_NATIVE_SOURCES_ONLY

boolean

false

quarkus.native.additional-build-args

Comma-separated, additional arguments to pass to the build process. If an argument includes the , symbol, it needs to be escaped, e.g. \\,

Environment variable: QUARKUS_NATIVE_ADDITIONAL_BUILD_ARGS

list of string

quarkus.native.enable-http-url-handler

If the HTTP url handler should be enabled, allowing you to do URL.openConnection() for HTTP URLs

Environment variable: QUARKUS_NATIVE_ENABLE_HTTP_URL_HANDLER

boolean

true

quarkus.native.enable-https-url-handler

If the HTTPS url handler should be enabled, allowing you to do URL.openConnection() for HTTPS URLs

Environment variable: QUARKUS_NATIVE_ENABLE_HTTPS_URL_HANDLER

boolean

false

quarkus.native.headless

The default value for java.awt.headless JVM option. Switching this option affects linking of awt libraries.

Environment variable: QUARKUS_NATIVE_HEADLESS

boolean

true

quarkus.native.file-encoding

Defines the file encoding as in -Dfile.encoding=…. Native image runtime uses the host’s (i.e. build time) value of file.encoding system property. We intentionally default this to UTF-8 to avoid platform specific defaults to be picked up which can then result in inconsistent behavior in the generated native executable.

Environment variable: QUARKUS_NATIVE_FILE_ENCODING

string

UTF-8

quarkus.native.add-all-charsets

If all character sets should be added to the native executable.

Note that some extensions (e.g. the Oracle JDBC driver) also take this setting into account to enable support for all charsets at the extension level.

This increases image size.

Environment variable: QUARKUS_NATIVE_ADD_ALL_CHARSETS

boolean

false

quarkus.native.graalvm-home

The location of the Graal distribution

Environment variable: QUARKUS_NATIVE_GRAALVM_HOME

string

${GRAALVM_HOME:}

quarkus.native.java-home

The location of the JDK

Environment variable: QUARKUS_NATIVE_JAVA_HOME

File

${java.home}

quarkus.native.native-image-xmx

The maximum Java heap to be used during the native image generation

Environment variable: QUARKUS_NATIVE_NATIVE_IMAGE_XMX

string

quarkus.native.debug-build-process

If the native image build should wait for a debugger to be attached before running. This is an advanced option and is generally only intended for those familiar with GraalVM internals

Environment variable: QUARKUS_NATIVE_DEBUG_BUILD_PROCESS

boolean

false

quarkus.native.publish-debug-build-process-port

If the debug port should be published when building with docker and debug-build-process is true

Environment variable: QUARKUS_NATIVE_PUBLISH_DEBUG_BUILD_PROCESS_PORT

boolean

true

quarkus.native.enable-isolates

If isolates should be enabled

Environment variable: QUARKUS_NATIVE_ENABLE_ISOLATES

boolean

true

quarkus.native.enable-fallback-images

If a JVM based 'fallback image' should be created if native image fails. This is not recommended, as this is functionally the same as just running the application in a JVM

Environment variable: QUARKUS_NATIVE_ENABLE_FALLBACK_IMAGES

boolean

false

quarkus.native.auto-service-loader-registration

If all META-INF/services entries should be automatically registered

Environment variable: QUARKUS_NATIVE_AUTO_SERVICE_LOADER_REGISTRATION

boolean

false

quarkus.native.dump-proxies

If the bytecode of all proxies should be dumped for inspection

Environment variable: QUARKUS_NATIVE_DUMP_PROXIES

boolean

false

quarkus.native.container-build

If this build should be done using a container runtime. Unless container-runtime is also set, docker will be used by default. If docker is not available or is an alias to podman, podman will be used instead as the default.

Environment variable: QUARKUS_NATIVE_CONTAINER_BUILD

boolean

quarkus.native.pie

Explicit configuration option to generate a native Position Independent Executable (PIE) for Linux. If the system supports PIE generation, the default behaviour is to disable it for performance reasons. However, some systems can only run position-independent executables, so this option enables the generation of such native executables.

Environment variable: QUARKUS_NATIVE_PIE

boolean

quarkus.native.march

Generate instructions for a specific machine type. Defaults to x86-64-v3 on AMD64 and armv8-a on AArch64. Use compatibility for best compatibility, or native for best performance if a native executable is deployed on the same machine or on a machine with the same CPU features. A list of all available machine types is available by executing native-image -march=list

Environment variable: QUARKUS_NATIVE_MARCH

string

quarkus.native.remote-container-build

If this build is done using a remote docker daemon.

Environment variable: QUARKUS_NATIVE_REMOTE_CONTAINER_BUILD

boolean

false

quarkus.native.builder-image

The docker image to use to do the image build. It can be one of graalvm, mandrel, or the full image path, e.g. quay.io/quarkus/ubi-quarkus-mandrel-builder-image:jdk-21.

Environment variable: QUARKUS_NATIVE_BUILDER_IMAGE

string

mandrel

quarkus.native.builder-image.pull

The strategy for pulling the builder image during the build.

Defaults to 'always', which will always pull the most up-to-date image; useful to keep up with fixes when a (floating) tag is updated.

Use 'missing' to only pull if there is no image locally; useful on development environments where building with out-of-date images is acceptable and bandwidth may be limited.

Use 'never' to fail the build if there is no image locally.

Environment variable: QUARKUS_NATIVE_BUILDER_IMAGE_PULL

alwaysAlways pull the most recent image., missingOnly pull the image if it’s missing locally., neverNever pull any image; fail if the image is missing locally.

alwaysAlways pull the most recent image.

quarkus.native.container-runtime

The container runtime (e.g. docker) that is used to do an image based build. If this is set then a container build is always done.

Environment variable: QUARKUS_NATIVE_CONTAINER_RUNTIME

docker, docker-rootless, wsl, wsl-rootless, podman, podman-rootless, unavailable

quarkus.native.container-runtime-options

Options to pass to the container runtime

Environment variable: QUARKUS_NATIVE_CONTAINER_RUNTIME_OPTIONS

list of string

quarkus.native.monitoring

Enable monitoring various monitoring options. The value should be comma separated.

jfr for JDK flight recorder support
jvmstat for JVMStat support
heapdump for heampdump support
jmxclient for JMX client support (experimental)
jmxserver for JMX server support (experimental)
nmt for native memory tracking support
all for all monitoring features

Environment variable: QUARKUS_NATIVE_MONITORING

list of heapdump, jvmstat, jfr, jmxserver, jmxclient, nmt, all

quarkus.native.enable-reports

If the reports on call paths and included packages/classes/methods should be generated

Environment variable: QUARKUS_NATIVE_ENABLE_REPORTS

boolean

false

quarkus.native.report-exception-stack-traces

If exceptions should be reported with a full stack trace

Environment variable: QUARKUS_NATIVE_REPORT_EXCEPTION_STACK_TRACES

boolean

true

quarkus.native.report-errors-at-runtime

If errors should be reported at runtime. This is a more relaxed setting, however it is not recommended as it means your application may fail at runtime if an unsupported feature is used by accident. Note that the use of this flag may result in build time failures due to `ClassNotFoundException`s. Reason most likely being that the Quarkus extension already optimized it away or do not actually need it. In such cases you should explicitly add the corresponding dependency providing the missing classes as a dependency to your project.

Environment variable: QUARKUS_NATIVE_REPORT_ERRORS_AT_RUNTIME

boolean

false

quarkus.native.reuse-existing

Don’t build a native image if it already exists. This is useful if you have already built an image and you want to use Quarkus to deploy it somewhere. Note that this is not able to detect if the existing image is outdated, if you have modified source or config and want a new image you must not use this flag.

Environment variable: QUARKUS_NATIVE_REUSE_EXISTING

boolean

false

quarkus.native.resources.includes

A comma separated list of globs to match resource paths that should be added to the native image.

Use slash (/) as a path separator on all platforms. Globs must not start with slash.

By default, no resources are included.

Example: Given that you have src/main/resources/ignored.png and src/main/resources/foo/selected.png in your source tree and one of your dependency JARs contains bar/some.txt file, with the following configuration

quarkus.native.resources.includes = foo/**,bar/**/*.txt

the files src/main/resources/foo/selected.png and bar/some.txt will be included in the native image, while src/main/resources/ignored.png will not be included.

Supported glob features

Feature Description

*

Matches a (possibly empty) sequence of characters that does not contain slash (/)

**

Matches a (possibly empty) sequence of characters that may contain slash (/)

?

Matches one character, but not slash

[abc]

Matches one character given in the bracket, but not slash

[a-z]

Matches one character from the range given in the bracket, but not slash

[!abc]

Matches one character not named in the bracket; does not match slash

[a-z]

Matches one character outside the range given in the bracket; does not match slash

{one,two,three}

Matches any of the alternating tokens separated by comma; the tokens may contain wildcards, nested alternations and ranges

\

The escape character

Note that there are three levels of escaping when passing this option via application.properties:

application.properties parser
MicroProfile Config list converter that splits the comma separated list
Glob parser

All three levels use backslash (\) as the escaping character. So you need to use an appropriate number of backslashes depending on which level you want to escape.

Note that Quarkus extensions typically include the resources they require by themselves. This option is useful in situations when the built-in functionality is not sufficient.

Environment variable: QUARKUS_NATIVE_RESOURCES_INCLUDES

list of string

quarkus.native.resources.excludes

A comma separated list of globs to match resource paths that should not be added to the native image.

Use slash (/) as a path separator on all platforms. Globs must not start with slash.

Please refer to includes for details about the glob syntax.

By default, no resources are excluded.

Example: Given that you have src/main/resources/red.png and src/main/resources/foo/green.png in your source tree and one of your dependency JARs contains bar/blue.png file, with the following configuration

quarkus.native.resources.includes = **/*.png
quarkus.native.resources.excludes = foo/**,**/green.png

the resource red.png will be available in the native image while the resources foo/green.png and bar/blue.png will not be available in the native image.

Environment variable: QUARKUS_NATIVE_RESOURCES_EXCLUDES

list of string

quarkus.native.debug.enabled

If debug is enabled and debug symbols are generated. The symbols will be generated in a separate .debug file.

Environment variable: QUARKUS_NATIVE_DEBUG_ENABLED

boolean

false

quarkus.native.enable-dashboard-dump

Generate the report files for GraalVM Dashboard.

Environment variable: QUARKUS_NATIVE_ENABLE_DASHBOARD_DUMP

boolean

false

quarkus.native.include-reasons-in-config-files

Include a reasons entries in the generated json configuration files.

Environment variable: QUARKUS_NATIVE_INCLUDE_REASONS_IN_CONFIG_FILES

boolean

false

quarkus.native.compression.level

The compression level in [1, 10]. 10 means best.

Higher compression level requires more time to compress the executable.

Environment variable: QUARKUS_NATIVE_COMPRESSION_LEVEL

int

quarkus.native.compression.additional-args

Allows passing extra arguments to the UPX command line (like --brute). The arguments are comma-separated. The exhaustive list of parameters can be found in https://github.com/upx/upx/blob/devel/doc/upx.pod.

Environment variable: QUARKUS_NATIVE_COMPRESSION_ADDITIONAL_ARGS

list of string

quarkus.native.agent-configuration-apply

Configuration files generated by the Quarkus build, using native image agent, are informative by default. In other words, the generated configuration files are presented in the build log but are not applied. When this option is set to true, generated configuration files are applied to the native executable building process.

Enabling this option should be done with care, because it can make native image configuration and/or behaviour dependant on other non-obvious factors. For example, if the native image agent generated configuration was generated from running JVM unit tests, disabling test(s) can result in a different native image configuration being generated, which in turn can misconfigure the native executable or affect its behaviour in unintended ways.

Environment variable: QUARKUS_NATIVE_AGENT_CONFIGURATION_APPLY

boolean

false

Packaging the application

Type

Default

quarkus.package.jar.enabled

If set to false, no JAR will be produced.

Environment variable: QUARKUS_PACKAGE_JAR_ENABLED

boolean

true

quarkus.package.jar.type

The JAR output type to use.

Environment variable: QUARKUS_PACKAGE_JAR_TYPE

fast-jarThe "fast JAR" packaging type., uber-jarThe "Uber-JAR" packaging type., mutable-jarThe "mutable JAR" packaging type (for remote development mode)., legacy-jarThe "legacy JAR" packaging type. This corresponds to the packaging type used in Quarkus before version 1.12.

fast-jarThe "fast JAR" packaging type.

quarkus.package.jar.compress

Whether the created jar will be compressed. This setting is not used when building a native image

Environment variable: QUARKUS_PACKAGE_JAR_COMPRESS

boolean

true

quarkus.package.jar.manifest.add-implementation-entries

Specify whether the Implementation information should be included in the runner jar’s MANIFEST.MF.

Environment variable: QUARKUS_PACKAGE_JAR_MANIFEST_ADD_IMPLEMENTATION_ENTRIES

boolean

true

quarkus.package.jar.manifest.attributes."attribute-name"

Custom manifest attributes to be added to the main section of the MANIFEST.MF file. An example of the user defined property: quarkus.package.jar.manifest.attributes."Entry-key1"=Value1 quarkus.package.jar.manifest.attributes."Entry-key2"=Value2

Environment variable: QUARKUS_PACKAGE_JAR_MANIFEST_ATTRIBUTES__ATTRIBUTE_NAME_

Map<String,String>

quarkus.package.jar.manifest.sections."section-name"

Custom manifest sections to be added to the MANIFEST.MF file. An example of the user defined property: quarkus.package.jar.manifest.sections."Section-Name"."Entry-Key1"=Value1 quarkus.package.jar.manifest.sections."Section-Name"."Entry-Key2"=Value2

Environment variable: QUARKUS_PACKAGE_JAR_MANIFEST_SECTIONS__SECTION_NAME_

Map<String,Map<String,String>>

quarkus.package.jar.user-configured-ignored-entries

Files that should not be copied to the output artifact.

Environment variable: QUARKUS_PACKAGE_JAR_USER_CONFIGURED_IGNORED_ENTRIES

list of string

quarkus.package.jar.included-optional-dependencies

List of all the dependencies that have been defined as optional to include into the final package of the application. Each optional dependency needs to be expressed in the following format:

groupId:artifactId[:[classifier][:[type]]]

With the classifier and type being optional (note that the brackets ([]) denote optionality and are not a part of the syntax specification). The group ID and artifact ID must be present and non-empty.

If the type is missing, the artifact is assumed to be of type jar.

This parameter is optional; if absent, no optional dependencies will be included into the final package of the application.

For backward compatibility reasons, this parameter is ignored by default and can be enabled by setting the parameter quarkus.package.jar.filter-optional-dependencies to true.

This parameter is meant to be used in modules where multi-builds have been configured to avoid getting a final package with unused dependencies.

Environment variable: QUARKUS_PACKAGE_JAR_INCLUDED_OPTIONAL_DEPENDENCIES

list of GACT

quarkus.package.jar.filter-optional-dependencies

Flag indicating whether the optional dependencies should be filtered out or not.

This parameter is meant to be used in modules where multi-builds have been configured to avoid getting a final package with unused dependencies.

Environment variable: QUARKUS_PACKAGE_JAR_FILTER_OPTIONAL_DEPENDENCIES

boolean

false

quarkus.package.jar.add-runner-suffix

Indicates whether the generated JAR file should have the runner suffix appended. Only applicable to the JarType#UBER_JAR uber-JAR output type. If disabled, the JAR built by the original build system (Maven, Gradle, etc.) will be replaced with the Quarkus-built uber-JAR.

Environment variable: QUARKUS_PACKAGE_JAR_ADD_RUNNER_SUFFIX

boolean

true

quarkus.package.jar.appcds.enabled

Whether to automate the creation of AppCDS. Furthermore, this option only works for Java 11+ and is considered experimental for the time being. Finally, care must be taken to use the same exact JVM version when building and running the application.

Environment variable: QUARKUS_PACKAGE_JAR_APPCDS_ENABLED

boolean

false

quarkus.package.jar.appcds.builder-image

When AppCDS generation is enabled, if this property is set, then the JVM used to generate the AppCDS file will be the JVM present in the container image. The builder image is expected to have the 'java' binary on its PATH. This flag is useful when the JVM to be used at runtime is not the same exact JVM version as the one used to build the jar. Note that this property is consulted only when quarkus.package.jar.appcds.enabled=true and it requires having docker available during the build.

Environment variable: QUARKUS_PACKAGE_JAR_APPCDS_BUILDER_IMAGE

string

quarkus.package.jar.appcds.use-container

Whether creation of the AppCDS archive should run in a container if available.

Normally, if either a suitable container image to use to create the AppCDS archive can be determined automatically or if one is explicitly set using the quarkus.<package-type>.appcds.builder-image setting, the AppCDS archive is generated by running the JDK contained in the image as a container.

If this option is set to false, a container will not be used to generate the AppCDS archive. Instead, the JDK used to build the application is also used to create the archive. Note that the exact same JDK version must be used to run the application in this case.

Ignored if quarkus.package.jar.appcds.enabled is set to false.

Environment variable: QUARKUS_PACKAGE_JAR_APPCDS_USE_CONTAINER

boolean

true

quarkus.package.jar.user-providers-directory

This is an advanced option that only takes effect for development mode.

If this is specified a directory of this name will be created in the jar distribution. Users can place jar files in this directory, and when re-augmentation is performed these will be processed and added to the class-path.

Note that before reaugmentation has been performed these jars will be ignored, and if they are updated the app should be reaugmented again.

Environment variable: QUARKUS_PACKAGE_JAR_USER_PROVIDERS_DIRECTORY

string

quarkus.package.jar.include-dependency-list

If this option is true then a list of all the coordinates of the artifacts that made up this image will be included in the quarkus-app directory. This list can be used by vulnerability scanners to determine if your application has any vulnerable dependencies. Only supported for the JarType#FAST_JAR fast JAR and JarType#MUTABLE_JAR mutable JAR output types.

Environment variable: QUARKUS_PACKAGE_JAR_INCLUDE_DEPENDENCY_LIST

boolean

true

quarkus.package.jar.decompiler.enabled

Enable decompilation of generated and transformed bytecode into a filesystem.

Environment variable: QUARKUS_PACKAGE_JAR_DECOMPILER_ENABLED

boolean

false

quarkus.package.jar.decompiler.output-directory

The directory into which to save the decompilation output.

A relative path is understood as relative to the build directory.

Environment variable: QUARKUS_PACKAGE_JAR_DECOMPILER_OUTPUT_DIRECTORY

string

decompiler

quarkus.package.jar.decompiler.jar-directory

The directory into which to save the decompilation tool if it doesn’t exist locally.

Environment variable: QUARKUS_PACKAGE_JAR_DECOMPILER_JAR_DIRECTORY

string

${user.home}/.quarkus

quarkus.package.main-class

The entry point of the application. This can either be a fully qualified name of a standard Java class with a main method, or io.quarkus.runtime.QuarkusApplication.

If your application has main classes annotated with io.quarkus.runtime.annotations.QuarkusMain then this can also reference the name given in the annotation, to avoid the need to specify fully qualified names in the config.

Environment variable: QUARKUS_PACKAGE_MAIN_CLASS

string

quarkus.package.output-directory

The directory into which the output package(s) should be written. Relative paths are resolved from the build systems target directory.

Environment variable: QUARKUS_PACKAGE_OUTPUT_DIRECTORY

path

quarkus.package.output-name

The name of the final artifact, excluding the suffix and file extension.

Environment variable: QUARKUS_PACKAGE_OUTPUT_NAME

string

quarkus.package.write-transformed-bytecode-to-build-output

Setting this switch to true will cause Quarkus to write the transformed application bytecode to the build tool’s output directory. This is useful for post-build tools that need to scan the application bytecode (for example, offline code-coverage tools).

For example, if using Maven, enabling this feature will result in the classes in target/classes being replaced with classes that have been transformed by Quarkus.

Setting this to true, however, should be done with a lot of caution and only if subsequent builds are done in a clean environment (i.e. the build tool’s output directory has been completely cleaned).

Environment variable: QUARKUS_PACKAGE_WRITE_TRANSFORMED_BYTECODE_TO_BUILD_OUTPUT

boolean

false

quarkus.package.runner-suffix

The suffix that is applied to the runner artifact’s base file name.

Environment variable: QUARKUS_PACKAGE_RUNNER_SUFFIX

string

-runner

Platform

Type

Default

quarkus.platform.group-id

groupId of the platform to use

Environment variable: QUARKUS_PLATFORM_GROUP_ID

string

io.quarkus.platform

quarkus.platform.artifact-id

artifactId of the platform to use

Environment variable: QUARKUS_PLATFORM_ARTIFACT_ID

string

quarkus-bom

quarkus.platform.version

version of the platform to use

Environment variable: QUARKUS_PLATFORM_VERSION

string

999-SNAPSHOT

Shutdown

Type

Default

quarkus.shutdown.delay-enabled

Whether Quarkus should wait between shutdown being requested and actually initiated. This delay gives the infrastructure time to detect that the application instance is shutting down and stop routing traffic to it.

Environment variable: QUARKUS_SHUTDOWN_DELAY_ENABLED

boolean

false

quarkus.shutdown.timeout

The timeout to wait for running requests to finish. If this is not set then the application will exit immediately. Setting this timeout will incur a small performance penalty, as it requires active requests to be tracked.

Environment variable: QUARKUS_SHUTDOWN_TIMEOUT

Duration

quarkus.shutdown.delay

Delay between shutdown being requested and actually initiated. Also called the pre-shutdown phase. In pre-shutdown, the server continues working as usual, except a readiness probe starts reporting "down" (if the smallrye-health extension is present). This gives the infrastructure time to detect that the application instance is shutting down and stop routing traffic to it. Notice that this property will only take effect if quarkus.shutdown.delay-enabled is explicitly set to true.

Environment variable: QUARKUS_SHUTDOWN_DELAY

Duration

SnapStart

Type

Default

quarkus.snapstart.enable

Enable/Disable SnapStart integration

Default value is dependent on extensions deployed (i.e. when using AWS Lambda extensions, this will be set to true by default)

Environment variable: QUARKUS_SNAPSTART_ENABLE

boolean

quarkus.snapstart.preload-classes

Will do a classpath search for all META-INF/quarkus-preload-classes.txt files These files contain fully qualified classnames that should be loaded in the SnapStart/CRaC beforeCheckpoint() phase.

Environment variable: QUARKUS_SNAPSTART_PRELOAD_CLASSES

boolean

true

quarkus.snapstart.initialize-classes

if preloading classes, specify whether to do static initialization when preloading these classes.

Environment variable: QUARKUS_SNAPSTART_INITIALIZE_CLASSES

boolean

true

quarkus.snapstart.full-warmup

Start the full application during the snapshotting process. In other words, when enabled, it performs Application.start() within SnapStart/CRaC beforeCheckpoint() phase.

Environment variable: QUARKUS_SNAPSTART_FULL_WARMUP

boolean

true

quarkus.snapstart.generate-application-class-list

When SnapStart is enabled, it generates the application class list, so it can be preloaded. Only used if preload-classes is set to true.

Environment variable: QUARKUS_SNAPSTART_GENERATE_APPLICATION_CLASS_LIST

boolean

true

SSL

Type

Default

quarkus.ssl.native

Enable native SSL support.

Environment variable: QUARKUS_SSL_NATIVE

boolean

Testing

Type

Default

quarkus.test.continuous-testing

If continuous testing is enabled. The default value is 'paused', which will allow you to start testing from the console or the Dev UI, but will not run tests on startup. If this is set to 'enabled' then testing will start as soon as the application has started. If this is 'disabled' then continuous testing is not enabled, and can’t be enabled without restarting the application.

Environment variable: QUARKUS_TEST_CONTINUOUS_TESTING

paused, enabled, disabled

paused

quarkus.test.display-test-output

If output from the running tests should be displayed in the console.

Environment variable: QUARKUS_TEST_DISPLAY_TEST_OUTPUT

boolean

false

quarkus.test.include-tags

Tags that should be included for continuous testing. This supports JUnit Tag Expressions.

Environment variable: QUARKUS_TEST_INCLUDE_TAGS

list of string

quarkus.test.exclude-tags

Tags that should be excluded by default with continuous testing. This is ignored if include-tags has been set. Defaults to 'slow'. This supports JUnit Tag Expressions.

Environment variable: QUARKUS_TEST_EXCLUDE_TAGS

list of string

slow

quarkus.test.include-pattern

Tests that should be included for continuous testing. This is a regular expression and is matched against the test class name (not the file name).

Environment variable: QUARKUS_TEST_INCLUDE_PATTERN

string

quarkus.test.exclude-pattern

Tests that should be excluded with continuous testing. This is a regular expression and is matched against the test class name (not the file name). This is ignored if include-pattern has been set.

Environment variable: QUARKUS_TEST_EXCLUDE_PATTERN

string

.*\.IT[^.]+|.*IT|.*ITCase

quarkus.test.include-engines

Test engine ids that should be included for continuous testing.

Environment variable: QUARKUS_TEST_INCLUDE_ENGINES

list of string

quarkus.test.exclude-engines

Test engine ids that should be excluded by default with continuous testing. This is ignored if include-engines has been set.

Environment variable: QUARKUS_TEST_EXCLUDE_ENGINES

list of string

quarkus.test.flat-class-path

Changes tests to use the 'flat' ClassPath used in Quarkus 1.x versions. This means all Quarkus and test classes are loaded in the same ClassLoader, however it means you cannot use continuous testing. Note that if you find this necessary for your application then you may also have problems running in development mode, which cannot use a flat class path.

Environment variable: QUARKUS_TEST_FLAT_CLASS_PATH

boolean

false

quarkus.test.native-image-profile

The profile to use when testing the native image

Environment variable: QUARKUS_TEST_NATIVE_IMAGE_PROFILE

string

prod

quarkus.test.integration-test-profile

The profile to use when testing using @QuarkusIntegrationTest

Environment variable: QUARKUS_TEST_INTEGRATION_TEST_PROFILE

string

prod

quarkus.test.profile

A comma separated list of profiles (dev, test, prod or custom profiles) to use when testing using @QuarkusTest

Environment variable: QUARKUS_TEST_PROFILE

list of string

test

quarkus.test.profile.tags

The tags this profile is associated with. When the quarkus.test.profile.tags System property is set (its value is a comma separated list of strings) then Quarkus will only execute tests that are annotated with a @TestProfile that has at least one of the supplied (via the aforementioned system property) tags.

Environment variable: QUARKUS_TEST_PROFILE_TAGS

list of string

quarkus.test.container.network

Controls the container network to be used when @QuarkusIntegration needs to launch the application in a container. This setting only applies if Quarkus does not need to use a shared network - which is the case if DevServices are used when running the test.

Environment variable: QUARKUS_TEST_CONTAINER_NETWORK

string

quarkus.test.container.additional-exposed-ports."host-port"

Set additional ports to be exposed when @QuarkusIntegration needs to launch the application in a container.

Environment variable: QUARKUS_TEST_CONTAINER_ADDITIONAL_EXPOSED_PORTS__HOST_PORT_

Map<String,String>

quarkus.test.container.labels."label-name"

A set of labels to add to the launched container

Environment variable: QUARKUS_TEST_CONTAINER_LABELS__LABEL_NAME_

Map<String,String>

quarkus.test.container.volume-mounts."host-path"

A set of volume mounts to add to the launched container

Environment variable: QUARKUS_TEST_CONTAINER_VOLUME_MOUNTS__HOST_PATH_

Map<String,String>

quarkus.test.arg-line

Additional launch parameters to be used when Quarkus launches the produced artifact for @QuarkusIntegrationTest When the artifact is a jar, this string is passed right after the java command. When the artifact is a container, this string is passed right after the docker run command. When the artifact is a native binary, this string is passed right after the native binary name.

Environment variable: QUARKUS_TEST_ARG_LINE

list of string

quarkus.test.env."environment-variable-name"

Additional environment variables to be set in the process that @QuarkusIntegrationTest launches.

Environment variable: QUARKUS_TEST_ENV__ENVIRONMENT_VARIABLE_NAME_

Map<String,String>

quarkus.test.wait-time

Used in @QuarkusIntegrationTest to determine how long the test will wait for the application to launch

Environment variable: QUARKUS_TEST_WAIT_TIME

Duration

PT1M

quarkus.test.hang-detection-timeout

Configures the hang detection in @QuarkusTest. If no activity happens (i.e. no test callbacks are called) over this period then QuarkusTest will dump all threads stack traces, to help diagnose a potential hang. Note that the initial timeout (before Quarkus has started) will only apply if provided by a system property, as it is not possible to read all config sources until Quarkus has booted.

Environment variable: QUARKUS_TEST_HANG_DETECTION_TIMEOUT

Duration

10M

quarkus.test.type

The type of test to run, this can be either: quarkus-test: Only runs @QuarkusTest annotated test classes unit: Only runs classes that are not annotated with @QuarkusTest all: Runs both, running the unit tests first

Environment variable: QUARKUS_TEST_TYPE

unit, quarkus-test, all

all

quarkus.test.only-test-application-module

If this is true then only the tests from the main application module will be run (i.e. the module that is currently running mvn quarkus:dev). If this is false then tests from all dependency modules will be run as well.

Environment variable: QUARKUS_TEST_ONLY_TEST_APPLICATION_MODULE

boolean

false

quarkus.test.include-module-pattern

Modules that should be included for continuous testing. This is a regular expression and is matched against the module groupId:artifactId.

Environment variable: QUARKUS_TEST_INCLUDE_MODULE_PATTERN

string

quarkus.test.exclude-module-pattern

Modules that should be excluded for continuous testing. This is a regular expression and is matched against the module groupId:artifactId. This is ignored if include-module-pattern has been set.

Environment variable: QUARKUS_TEST_EXCLUDE_MODULE_PATTERN

string

quarkus.test.enable-callbacks-for-integration-tests

If the test callbacks should be invoked for the integration tests (tests annotated with @QuarkusIntegrationTest).

Environment variable: QUARKUS_TEST_ENABLE_CALLBACKS_FOR_INTEGRATION_TESTS

boolean

false

Core thread pool

Type

Default

quarkus.thread-pool.core-threads

The core thread pool size. This number of threads will always be kept alive.

Environment variable: QUARKUS_THREAD_POOL_CORE_THREADS

int

1

quarkus.thread-pool.prefill

Prefill core thread pool. The core thread pool will be initialised with the core number of threads at startup

Environment variable: QUARKUS_THREAD_POOL_PREFILL

boolean

true

quarkus.thread-pool.max-threads

The maximum number of threads. If this is not specified then it will be automatically sized to the greatest of 8 * the number of available processors and 200. For example if there are 4 processors the max threads will be 200. If there are 48 processors it will be 384.

Environment variable: QUARKUS_THREAD_POOL_MAX_THREADS

int

quarkus.thread-pool.queue-size

The queue size. For most applications this should be unbounded

Environment variable: QUARKUS_THREAD_POOL_QUEUE_SIZE

int

quarkus.thread-pool.growth-resistance

The executor growth resistance. A resistance factor applied after the core pool is full; values applied here will cause that fraction of submissions to create new threads when no idle thread is available. A value of 0.0f implies that threads beyond the core size should be created as aggressively as threads within it; a value of 1.0f implies that threads beyond the core size should never be created.

Environment variable: QUARKUS_THREAD_POOL_GROWTH_RESISTANCE

float

0f

quarkus.thread-pool.shutdown-timeout

The shutdown timeout. If all pending work has not been completed by this time then additional threads will be spawned to attempt to finish any pending tasks, and the shutdown process will continue

Environment variable: QUARKUS_THREAD_POOL_SHUTDOWN_TIMEOUT

Duration

1M

quarkus.thread-pool.shutdown-interrupt

The amount of time to wait for thread pool shutdown before tasks should be interrupted. If this value is greater than or equal to the value for shutdown-timeout, then tasks will not be interrupted before the shutdown timeout occurs.

Environment variable: QUARKUS_THREAD_POOL_SHUTDOWN_INTERRUPT

Duration

10S

quarkus.thread-pool.shutdown-check-interval

The frequency at which the status of the thread pool should be checked during shutdown. Information about waiting tasks and threads will be checked and possibly logged at this interval. Setting this key to an empty value disables the shutdown check interval.

Environment variable: QUARKUS_THREAD_POOL_SHUTDOWN_CHECK_INTERVAL

Duration

5S

quarkus.thread-pool.keep-alive-time

The amount of time a thread will stay alive with no work.

Environment variable: QUARKUS_THREAD_POOL_KEEP_ALIVE_TIME

Duration

30S

CycloneDX

Type

Default

quarkus.cyclonedx.skip

Whether to skip SBOM generation

Environment variable: QUARKUS_CYCLONEDX_SKIP

boolean

false

quarkus.cyclonedx.format

SBOM file format. Supported formats are {code json} and {code xml}. The default format is JSON. If both are desired then all could be used as the value of this option.

Environment variable: QUARKUS_CYCLONEDX_FORMAT

string

json

quarkus.cyclonedx.schema-version

CycloneDX specification version. The default value be the latest supported by the integrated CycloneDX library.

Environment variable: QUARKUS_CYCLONEDX_SCHEMA_VERSION

string

quarkus.cyclonedx.include-license-text

Whether to include the license text into generated SBOMs.

Environment variable: QUARKUS_CYCLONEDX_INCLUDE_LICENSE_TEXT

boolean

false

Datasources

Type

Default

quarkus.datasource.health.enabled

Whether or not a health check is published in case the smallrye-health extension is present.

This is a global setting and is not specific to a datasource.

Environment variable: QUARKUS_DATASOURCE_HEALTH_ENABLED

boolean

true

quarkus.datasource.metrics.enabled

Whether or not datasource metrics are published in case a metrics extension is present.

This is a global setting and is not specific to a datasource.

This is different from the "jdbc.enable-metrics" property that needs to be set on the JDBC datasource level to enable collection of metrics for that datasource.

Environment variable: QUARKUS_DATASOURCE_METRICS_ENABLED

boolean

false

quarkus.datasource.db-kind

quarkus.datasource."datasource-name".db-kind

The kind of database we will connect to (e.g. h2, postgresql…).

Environment variable: QUARKUS_DATASOURCE_DB_KIND

string

quarkus.datasource.db-version

quarkus.datasource."datasource-name".db-version

The version of the database we will connect to (e.g. '10.0').

The version number set here should follow the same numbering scheme as the string returned by java.sql.DatabaseMetaData#getDatabaseProductVersion() for your database’s JDBC driver. This numbering scheme may be different from the most popular one for your database; for example Microsoft SQL Server 2016 would be version 13.

As a rule, the version set here should be as high as possible, but must be lower than or equal to the version of any database your application will connect to.

A high version will allow better performance and using more features (e.g. Hibernate ORM may generate more efficient SQL, avoid workarounds and take advantage of more database features), but if it is higher than the version of the database you want to connect to, it may lead to runtime exceptions (e.g. Hibernate ORM may generate invalid SQL that your database will reject).

Some extensions (like the Hibernate ORM extension) will try to check this version against the actual database version on startup, leading to a startup failure when the actual version is lower or simply a warning in case the database cannot be reached.

The default for this property is specific to each extension; the Hibernate ORM extension will default to the oldest version it supports.

Environment variable: QUARKUS_DATASOURCE_DB_VERSION

string

quarkus.datasource.health-exclude

quarkus.datasource."datasource-name".health-exclude

Whether this particular data source should be excluded from the health check if the general health check for data sources is enabled.

By default, the health check includes all configured data sources (if it is enabled).

Environment variable: QUARKUS_DATASOURCE_HEALTH_EXCLUDE

boolean

false

quarkus.datasource.active

quarkus.datasource."datasource-name".active

Whether this datasource should be active at runtime.

See this section of the documentation.

Environment variable: QUARKUS_DATASOURCE_ACTIVE

boolean

`true if the URL is set, false otherwise`

quarkus.datasource.username

quarkus.datasource."datasource-name".username

The datasource username

Environment variable: QUARKUS_DATASOURCE_USERNAME

string

quarkus.datasource.password

quarkus.datasource."datasource-name".password

The datasource password

Environment variable: QUARKUS_DATASOURCE_PASSWORD

string

quarkus.datasource.credentials-provider

quarkus.datasource."datasource-name".credentials-provider

The credentials provider name

Environment variable: QUARKUS_DATASOURCE_CREDENTIALS_PROVIDER

string

quarkus.datasource.credentials-provider-name

quarkus.datasource."datasource-name".credentials-provider-name

The credentials provider bean name.

This is a bean name (as in @Named) of a bean that implements CredentialsProvider. It is used to select the credentials provider bean when multiple exist. This is unnecessary when there is only one credentials provider available.

For Vault, the credentials provider bean name is vault-credentials-provider.

Environment variable: QUARKUS_DATASOURCE_CREDENTIALS_PROVIDER_NAME

string

Dev Services

Type

Default

quarkus.datasource.devservices.enabled

quarkus.datasource."datasource-name".devservices.enabled

Whether this Dev Service should start with the application in dev mode or tests.

Dev Services are enabled by default unless connection configuration (e.g. the JDBC URL or reactive client URL) is set explicitly.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_ENABLED

boolean

quarkus.datasource.devservices.image-name

quarkus.datasource."datasource-name".devservices.image-name

The container image name for container-based Dev Service providers.

This has no effect if the provider is not a container-based database, such as H2 or Derby.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_IMAGE_NAME

string

quarkus.datasource.devservices.container-env."environment-variable-name"

quarkus.datasource."datasource-name".devservices.container-env."environment-variable-name"

Environment variables that are passed to the container.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_CONTAINER_ENV__ENVIRONMENT_VARIABLE_NAME_

Map<String,String>

quarkus.datasource.devservices.container-properties."property-key"

quarkus.datasource."datasource-name".devservices.container-properties."property-key"

Generic properties that are passed for additional container configuration.

Properties defined here are database-specific and are interpreted specifically in each database dev service implementation.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_CONTAINER_PROPERTIES__PROPERTY_KEY_

Map<String,String>

quarkus.datasource.devservices.properties."property-key"

quarkus.datasource."datasource-name".devservices.properties."property-key"

Generic properties that are added to the database connection URL.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_PROPERTIES__PROPERTY_KEY_

Map<String,String>

quarkus.datasource.devservices.port

quarkus.datasource."datasource-name".devservices.port

Optional fixed port the dev service will listen to.

If not defined, the port will be chosen randomly.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_PORT

int

quarkus.datasource.devservices.command

quarkus.datasource."datasource-name".devservices.command

The container start command to use for container-based Dev Service providers.

This has no effect if the provider is not a container-based database, such as H2 or Derby.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_COMMAND

string

quarkus.datasource.devservices.db-name

quarkus.datasource."datasource-name".devservices.db-name

The database name to use if this Dev Service supports overriding it.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_DB_NAME

string

quarkus.datasource.devservices.username

quarkus.datasource."datasource-name".devservices.username

The username to use if this Dev Service supports overriding it.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_USERNAME

string

quarkus.datasource.devservices.password

quarkus.datasource."datasource-name".devservices.password

The password to use if this Dev Service supports overriding it.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_PASSWORD

string

quarkus.datasource.devservices.init-script-path

quarkus.datasource."datasource-name".devservices.init-script-path

The path to a SQL script to be loaded from the classpath and applied to the Dev Service database.

This has no effect if the provider is not a container-based database, such as H2 or Derby.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_INIT_SCRIPT_PATH

string

quarkus.datasource.devservices.volumes."host-path"

quarkus.datasource."datasource-name".devservices.volumes."host-path"

The volumes to be mapped to the container.

The map key corresponds to the host location; the map value is the container location. If the host location starts with "classpath:", the mapping loads the resource from the classpath with read-only permission.

When using a file system location, the volume will be generated with read-write permission, potentially leading to data loss or modification in your file system.

This has no effect if the provider is not a container-based database, such as H2 or Derby.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_VOLUMES__HOST_PATH_

Map<String,String>

quarkus.datasource.devservices.reuse

quarkus.datasource."datasource-name".devservices.reuse

Whether to keep Dev Service containers running after a dev mode session or test suite execution to reuse them in the next dev mode session or test suite execution.

Within a dev mode session or test suite execution, Quarkus will always reuse Dev Services as long as their configuration (username, password, environment, port bindings, …) did not change. This feature is specifically about keeping containers running when Quarkus is not running to reuse them across runs.

This feature needs to be enabled explicitly in testcontainers.properties, may require changes to how you configure data initialization in dev mode and tests, and may leave containers running indefinitely, forcing you to stop and remove them manually. See this section of the documentation for more information.

This configuration property is set to true by default, so it is mostly useful to disable reuse, if you enabled it in testcontainers.properties but only want to use it for some of your Quarkus applications or datasources.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_REUSE

boolean

true

quarkus.datasource.devservices.show-logs

quarkus.datasource."datasource-name".devservices.show-logs

Whether the logs should be consumed by the JBoss logger.

This has no effect if the provider is not a container-based database, such as H2 or Derby.

Environment variable: QUARKUS_DATASOURCE_DEVSERVICES_SHOW_LOGS

boolean

false

DevServices - Keycloak

Type

Default

quarkus.keycloak.devservices.enabled

Flag to enable (default) or disable Dev Services. When enabled, Dev Services for Keycloak automatically configures and starts Keycloak in Dev or Test mode, and when Docker is running.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_ENABLED

boolean

true

quarkus.keycloak.devservices.image-name

The container image name for Dev Services providers. Defaults to a Quarkus-based Keycloak image. For a WildFly-based distribution, use an image like quay.io/keycloak/keycloak:19.0.3-legacy. Keycloak Quarkus and WildFly images are initialized differently. Dev Services for Keycloak will assume it is a Keycloak Quarkus image unless the image version ends with -legacy. Override with quarkus.keycloak.devservices.keycloak-x-image.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_IMAGE_NAME

string

quay.io/keycloak/keycloak:25.0.6

quarkus.keycloak.devservices.keycloak-x-image

Indicates if a Keycloak-X image is used. By default, the image is identified by keycloak-x in the image name. For custom images, override with quarkus.keycloak.devservices.keycloak-x-image. You do not need to set this property if the default check works.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_KEYCLOAK_X_IMAGE

boolean

quarkus.keycloak.devservices.shared

Determines if the Keycloak container is shared. When shared, Quarkus uses label-based service discovery to find and reuse a running Keycloak container, so a second one is not started. Otherwise, if a matching container is not is found, a new container is started. The service discovery uses the quarkus-dev-service-label label, whose value is set by the service-name property. Container sharing is available only in dev mode.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_SHARED

boolean

true

quarkus.keycloak.devservices.service-name

The value of the quarkus-dev-service-keycloak label for identifying the Keycloak container. Used in shared mode to locate an existing container with this label. If not found, a new container is initialized with this label. Applicable only in dev mode.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_SERVICE_NAME

string

quarkus

quarkus.keycloak.devservices.realm-path

A comma-separated list of class or file system paths to Keycloak realm files. This list is used to initialize Keycloak. The first value in this list is used to initialize default tenant connection properties.

To learn more about Keycloak realm files, consult the Importing and Exporting Keycloak Realms documentation.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_REALM_PATH

list of string

quarkus.keycloak.devservices.resource-aliases."alias-name"

Aliases to additional class or file system resources that are used to initialize Keycloak. Each map entry represents a mapping between an alias and a class or file system resource path.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_RESOURCE_ALIASES__ALIAS_NAME_

Map<String,String>

quarkus.keycloak.devservices.resource-mappings."resource-name"

Additional class or file system resources that are used to initialize Keycloak. Each map entry represents a mapping between a class or file system resource path alias and the Keycloak container location.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_RESOURCE_MAPPINGS__RESOURCE_NAME_

Map<String,String>

quarkus.keycloak.devservices.java-opts

The JAVA_OPTS passed to the keycloak JVM

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_JAVA_OPTS

string

quarkus.keycloak.devservices.show-logs

Show Keycloak log messages with a "Keycloak:" prefix.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_SHOW_LOGS

boolean

false

quarkus.keycloak.devservices.start-command

Keycloak start command. Use this property to experiment with Keycloak start options, see https://www.keycloak.org/server/all-config. Note, it is ignored when loading legacy Keycloak WildFly images.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_START_COMMAND

string

quarkus.keycloak.devservices.realm-name

The name of the Keycloak realm. This property is used to create the realm if the realm file pointed to by the realm-path property does not exist. The default value is quarkus in this case. It is recommended to always set this property so that Dev Services for Keycloak can identify the realm name without parsing the realm file.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_REALM_NAME

string

quarkus.keycloak.devservices.create-realm

Specifies whether to create the Keycloak realm when no realm file is found at the realm-path. Set to false if the realm is to be created using either the Keycloak Administration Console or the Keycloak Admin API provided by io.quarkus.test.common.QuarkusTestResourceLifecycleManager.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_CREATE_REALM

boolean

true

quarkus.keycloak.devservices.create-client

Specifies whether to create the default client id quarkus-app with a secret secret and register them if the create-realm property is set to true. For OIDC extension configuration properties quarkus.oidc.client.id and quarkus.oidc.credentials.secret will be configured. For OIDC Client extension configuration properties quarkus.oidc-client.client.id and quarkus.oidc-client.credentials.secret will be configured. Set to false if clients have to be created using either the Keycloak Administration Console or the Keycloak Admin API provided by io.quarkus.test.common.QuarkusTestResourceLifecycleManager or registered dynamically.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_CREATE_CLIENT

boolean

true

quarkus.keycloak.devservices.start-with-disabled-tenant

Specifies whether to start the container even if the default OIDC tenant is disabled. Setting this property to true may be necessary in a multi-tenant OIDC setup, especially when OIDC tenants are created dynamically.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_START_WITH_DISABLED_TENANT

boolean

false

quarkus.keycloak.devservices.users."users"

A map of Keycloak usernames to passwords. If empty, default users alice and bob are created with their names as passwords. This map is used for user creation when no realm file is found at the realm-path.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_USERS__USERS_

Map<String,String>

quarkus.keycloak.devservices.roles."role-name"

A map of roles for Keycloak users. If empty, default roles are assigned: alice receives admin and user roles, while other users receive user role. This map is used for role creation when no realm file is found at the realm-path.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_ROLES__ROLE_NAME_

Map<String,List<String>>

quarkus.keycloak.devservices.port

The specific port for the dev service to listen on.

If not specified, a random port is selected.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_PORT

int

quarkus.keycloak.devservices.container-env."environment-variable-name"

Environment variables to be passed to the container.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_CONTAINER_ENV__ENVIRONMENT_VARIABLE_NAME_

Map<String,String>

quarkus.keycloak.devservices.container-memory-limit

Memory limit for Keycloak container

If not specified, 750MiB is the default memory limit.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_CONTAINER_MEMORY_LIMIT

MemorySize

750M

quarkus.keycloak.devservices.web-client-timeout

The WebClient timeout. Use this property to configure how long an HTTP client used by OIDC dev service admin client will wait for a response from OpenId Connect Provider when acquiring admin token and creating realm.

Environment variable: QUARKUS_KEYCLOAK_DEVSERVICES_WEB_CLIENT_TIMEOUT

Duration

4S

Eclipse Vert.x - HTTP

Type

Default

quarkus.dev-ui.history-size

The number of history log entries to remember.

Environment variable: QUARKUS_DEV_UI_HISTORY_SIZE

int

50

quarkus.dev-ui.show-json-rpc-log

Show the JsonRPC Log. Useful for extension developers

Environment variable: QUARKUS_DEV_UI_SHOW_JSON_RPC_LOG

boolean

false

quarkus.dev-ui.hosts

More hosts allowed for Dev UI Comma separated list of valid URLs, e.g.: www.quarkus.io, myhost.com (This can also be a regex) By default localhost and 127.0.0.1 will always be allowed

Environment variable: QUARKUS_DEV_UI_HOSTS

list of string

quarkus.dev-ui.cors.enabled

Enable CORS filter.

Environment variable: QUARKUS_DEV_UI_CORS_ENABLED

boolean

true

quarkus.http.root-path

The HTTP root path. All web content will be served relative to this root path.

Environment variable: QUARKUS_HTTP_ROOT_PATH

string

/

quarkus.http.auth.basic

If basic auth should be enabled. If both basic and form auth is enabled then basic auth will be enabled in silent mode. The basic auth is enabled by default if no authentication mechanisms are configured or Quarkus can safely determine that basic authentication is required.

Environment variable: QUARKUS_HTTP_AUTH_BASIC

boolean

quarkus.http.auth.form.enabled

If form authentication is enabled.

Environment variable: QUARKUS_HTTP_AUTH_FORM_ENABLED

boolean

false

quarkus.http.auth.form.post-location

The post location.

Environment variable: QUARKUS_HTTP_AUTH_FORM_POST_LOCATION

string

/j_security_check

quarkus.http.auth.proactive

If this is true and credentials are present then a user will always be authenticated before the request progresses. If this is false then an attempt will only be made to authenticate the user if a permission check is performed or the current user is required for some other reason.

Environment variable: QUARKUS_HTTP_AUTH_PROACTIVE

boolean

true

quarkus.http.auth.inclusive

Require that all registered HTTP authentication mechanisms must complete the authentication.

Typically, this property has to be true when the credentials are carried over mTLS, when both mTLS and another authentication, for example, OIDC bearer token authentication, must succeed. In such cases, SecurityIdentity created by the first mechanism, mTLS, can be injected, identities created by other mechanisms will be available on SecurityIdentity. The mTLS mechanism is always the first mechanism, because its priority is elevated when inclusive authentication is enabled. The identities can be retrieved using utility method as in the example below:

`io.quarkus.vertx.http.runtime.security.HttpSecurityUtils.getSecurityIdentities(securityIdentity)`

This property is false by default which means that the authentication process is complete as soon as the first SecurityIdentity is created.

This property will be ignored if the path specific authentication is enabled.

Environment variable: QUARKUS_HTTP_AUTH_INCLUSIVE

boolean

false

quarkus.http.ssl.client-auth

Configures the engine to require/request client authentication. NONE, REQUEST, REQUIRED.

When set to REQUIRED, it’s recommended to also set quarkus.http.insecure-requests=disabled to disable the plain HTTP port. If quarkus.http.insecure-requests is not set, but this parameter is set to REQUIRED, then, quarkus.http.insecure-requests is automatically set to disabled.

Environment variable: QUARKUS_HTTP_SSL_CLIENT_AUTH

none, request, required

none

quarkus.http.virtual

If this is true then only a virtual channel will be set up for vertx web. We have this switch for testing purposes.

Environment variable: QUARKUS_HTTP_VIRTUAL

boolean

false

quarkus.http.non-application-root-path

A common root path for non-application endpoints. Various extension-provided endpoints such as metrics, health, and openapi are deployed under this path by default. <p> * Relative path (Default, q) → Non-application endpoints will be served from ${quarkus.http.root-path}/${quarkus.http.non-application-root-path}. * Absolute path (/q) → Non-application endpoints will be served from the specified path. * ${quarkus.http.root-path} → Setting this path to the same value as HTTP root path disables this root path. All extension-provided endpoints will be served from ${quarkus.http.root-path}. <p> If the management interface is enabled, the root path for the endpoints exposed on the management interface is configured using the quarkus.management.root-path property instead of this property.

Environment variable: QUARKUS_HTTP_NON_APPLICATION_ROOT_PATH

string

q

quarkus.http.test-timeout

The REST Assured client timeout for testing.

Environment variable: QUARKUS_HTTP_TEST_TIMEOUT

Duration

30S

quarkus.http.enable-compression

If enabled then the response body is compressed if the Content-Type header is set and the value is a compressed media type as configured via compress-media-types.

Note that the RESTEasy Reactive and Reactive Routes extensions also make it possible to enable/disable compression declaratively using the annotations io.quarkus.vertx.http.Compressed and io.quarkus.vertx.http.Uncompressed.

Environment variable: QUARKUS_HTTP_ENABLE_COMPRESSION

boolean

false

quarkus.http.enable-decompression

When enabled, vert.x will decompress the request’s body if it’s compressed.

Note that the compression format (e.g., gzip) must be specified in the Content-Encoding header in the request.

Environment variable: QUARKUS_HTTP_ENABLE_DECOMPRESSION

boolean

false

quarkus.http.compressors

If user adds br, then brotli will be added to the list of supported compression algorithms. It implies loading libbrotli native library via JNI and in case of native image, packing the native library into the native image as a resource thus inflating its size. Note that a native shared object library must be available for your platform in Brotli4J project.

Client expresses its capability by sending Accept-Encoding header, e.g. Accept-Encoding: deflate, gzip, br Server chooses the compression algorithm based on the client’s capabilities and marks it in a response header, e.g.: content-encoding: gzip

Environment variable: QUARKUS_HTTP_COMPRESSORS

list of string

gzip,deflate

quarkus.http.compress-media-types

List of media types for which the compression should be enabled automatically, unless declared explicitly via Compressed or Uncompressed.

Environment variable: QUARKUS_HTTP_COMPRESS_MEDIA_TYPES

list of string

text/html,text/plain,text/xml,text/css,text/javascript,application/javascript,application/json,application/graphql+json,application/xhtml+xml

quarkus.http.compression-level

The compression level used when compression support is enabled.

Environment variable: QUARKUS_HTTP_COMPRESSION_LEVEL

int

quarkus.http.cors

Enable the CORS filter.

Environment variable: QUARKUS_HTTP_CORS

boolean

false

quarkus.http.port

The HTTP port

Environment variable: QUARKUS_HTTP_PORT

int

8080

quarkus.http.test-port

The HTTP port used to run tests

Environment variable: QUARKUS_HTTP_TEST_PORT

int

8081

quarkus.http.host

The HTTP host

In dev/test mode this defaults to localhost, in prod mode this defaults to 0.0.0.0

Defaulting to 0.0.0.0 makes it easier to deploy Quarkus to container, however it is not suitable for dev/test mode as other people on the network can connect to your development machine.

As an exception, when running in Windows Subsystem for Linux (WSL), the HTTP host defaults to 0.0.0.0 even in dev/test mode since using localhost makes the application inaccessible.

Environment variable: QUARKUS_HTTP_HOST

string

required

quarkus.http.test-host

Used when QuarkusIntegrationTest is meant to execute against an application that is already running and listening on the host specified by this property.

Environment variable: QUARKUS_HTTP_TEST_HOST

string

quarkus.http.host-enabled

Enable listening to host:port

Environment variable: QUARKUS_HTTP_HOST_ENABLED

boolean

true

quarkus.http.ssl-port

The HTTPS port

Environment variable: QUARKUS_HTTP_SSL_PORT

int

8443

quarkus.http.test-ssl-port

The HTTPS port used to run tests

Environment variable: QUARKUS_HTTP_TEST_SSL_PORT

int

8444

quarkus.http.test-ssl-enabled

Used when QuarkusIntegrationTest is meant to execute against an application that is already running to configure the test to use SSL.

Environment variable: QUARKUS_HTTP_TEST_SSL_ENABLED

boolean

quarkus.http.insecure-requests

If insecure (i.e. http rather than https) requests are allowed. If this is enabled then http works as normal. redirect will still open the http port, but all requests will be redirected to the HTTPS port. disabled will prevent the HTTP port from opening at all.

Default is enabled except when client auth is set to required (configured using quarkus.http.ssl.client-auth=required). In this case, the default is disabled.

Environment variable: QUARKUS_HTTP_INSECURE_REQUESTS

enabled, redirect, disabled

quarkus.http.http2

If this is true (the default) then HTTP/2 will be enabled.

Note that for browsers to be able to use it HTTPS must be enabled, and you must be running on JDK11 or above, as JDK8 does not support ALPN.

Environment variable: QUARKUS_HTTP_HTTP2

boolean

true

quarkus.http.http2-push-enabled

Enables or Disable the HTTP/2 Push feature. This setting can be used to disable server push. The server will not send a PUSH_PROMISE frame if it receives this parameter set to @{code false}.

Environment variable: QUARKUS_HTTP_HTTP2_PUSH_ENABLED

boolean

true

quarkus.http.ssl.certificate.credentials-provider

The CredentialsProvider. If this property is configured, then a matching 'CredentialsProvider' will be used to get the keystore, keystore key, and truststore passwords unless these passwords have already been configured.

Please note that using MicroProfile ConfigSource which is directly supported by Quarkus Configuration should be preferred unless using CredentialsProvider provides for some additional security and dynamism.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_CREDENTIALS_PROVIDER

string

quarkus.http.ssl.certificate.credentials-provider-name

The credentials provider bean name.

For Vault, the credentials provider bean name is vault-credentials-provider.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_CREDENTIALS_PROVIDER_NAME

string

quarkus.http.ssl.certificate.files

The list of path to server certificates using the PEM format. Specifying multiple files requires SNI to be enabled.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_FILES

list of path

quarkus.http.ssl.certificate.key-files

The list of path to server certificates private key files using the PEM format. Specifying multiple files requires SNI to be enabled.

The order of the key files must match the order of the certificates.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_KEY_FILES

list of path

quarkus.http.ssl.certificate.key-store-file

An optional keystore that holds the certificate information instead of specifying separate files.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_KEY_STORE_FILE

path

quarkus.http.ssl.certificate.key-store-file-type

An optional parameter to specify the type of the keystore file. If not given, the type is automatically detected based on the file name.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_KEY_STORE_FILE_TYPE

string

quarkus.http.ssl.certificate.key-store-provider

An optional parameter to specify a provider of the keystore file. If not given, the provider is automatically detected based on the keystore file type.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_KEY_STORE_PROVIDER

string

quarkus.http.ssl.certificate.key-store-password

A parameter to specify the password of the keystore file. If not given, and if it can not be retrieved from CredentialsProvider.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_KEY_STORE_PASSWORD

string

password

quarkus.http.ssl.certificate.key-store-password-key

A parameter to specify a CredentialsProvider property key, which can be used to get the password of the key store file from CredentialsProvider.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_KEY_STORE_PASSWORD_KEY

string

quarkus.http.ssl.certificate.key-store-alias

An optional parameter to select a specific key in the keystore. When SNI is disabled, and the keystore contains multiple keys and no alias is specified; the behavior is undefined.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_KEY_STORE_ALIAS

string

quarkus.http.ssl.certificate.key-store-alias-password

An optional parameter to define the password for the key, in case it is different from key-store-password If not given, it might be retrieved from CredentialsProvider.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_KEY_STORE_ALIAS_PASSWORD

string

quarkus.http.ssl.certificate.key-store-alias-password-key

A parameter to specify a CredentialsProvider property key, which can be used to get the password for the alias from CredentialsProvider.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_KEY_STORE_ALIAS_PASSWORD_KEY

string

quarkus.http.ssl.certificate.trust-store-file

An optional trust store that holds the certificate information of the trusted certificates.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_TRUST_STORE_FILE

path

quarkus.http.ssl.certificate.trust-store-files

An optional list of trusted certificates using the PEM format. If you pass multiple files, you must use the PEM format.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_TRUST_STORE_FILES

list of path

quarkus.http.ssl.certificate.trust-store-file-type

An optional parameter to specify the type of the trust store file. If not given, the type is automatically detected based on the file name.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_TRUST_STORE_FILE_TYPE

string

quarkus.http.ssl.certificate.trust-store-provider

An optional parameter to specify a provider of the trust store file. If not given, the provider is automatically detected based on the trust store file type.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_TRUST_STORE_PROVIDER

string

quarkus.http.ssl.certificate.trust-store-password

A parameter to specify the password of the trust store file. If not given, it might be retrieved from CredentialsProvider.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_TRUST_STORE_PASSWORD

string

quarkus.http.ssl.certificate.trust-store-password-key

A parameter to specify a CredentialsProvider property key, which can be used to get the password of the trust store file from CredentialsProvider.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_TRUST_STORE_PASSWORD_KEY

string

quarkus.http.ssl.certificate.trust-store-cert-alias

An optional parameter to trust a single certificate from the trust store rather than trusting all certificates in the store.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_TRUST_STORE_CERT_ALIAS

string

quarkus.http.ssl.certificate.reload-period

When set, the configured certificate will be reloaded after the given period. Note that the certificate will be reloaded only if the file has been modified.

Also, the update can also occur when the TLS certificate is configured using paths (and not in-memory).

The reload period must be equal or greater than 30 seconds. If not set, the certificate will not be reloaded.

It’s recommended to use the TLS registry to handle the certificate reloading.

Environment variable: QUARKUS_HTTP_SSL_CERTIFICATE_RELOAD_PERIOD

Duration

quarkus.http.ssl.cipher-suites

The cipher suites to use. If none is given, a reasonable default is selected.

Environment variable: QUARKUS_HTTP_SSL_CIPHER_SUITES

list of string

quarkus.http.ssl.protocols

Sets the ordered list of enabled SSL/TLS protocols.

If not set, it defaults to "TLSv1.3, TLSv1.2". The following list of protocols are supported: TLSv1, TLSv1.1, TLSv1.2, TLSv1.3. To only enable TLSv1.3, set the value to to "TLSv1.3".

Note that setting an empty list, and enabling SSL/TLS is invalid. You must at least have one protocol.

Environment variable: QUARKUS_HTTP_SSL_PROTOCOLS

list of string

TLSv1.3,TLSv1.2

quarkus.http.ssl.sni

Enables Server Name Indication (SNI), an TLS extension allowing the server to use multiple certificates. The client indicate the server name during the TLS handshake, allowing the server to select the right certificate.

Environment variable: QUARKUS_HTTP_SSL_SNI

boolean

false

quarkus.http.tls-configuration-name

The name of the TLS configuration to use.

If not set and the default TLS configuration is configured (quarkus.tls.*) then that will be used. If a name is configured, it uses the configuration from quarkus.tls.<name>.* If a name is configured, but no TLS configuration is found with that name then an error will be thrown.

If no TLS configuration is set, and quarkus.tls.* is not configured, then, quarkus.http.ssl will be used.

Environment variable: QUARKUS_HTTP_TLS_CONFIGURATION_NAME

string

quarkus.http.handle-100-continue-automatically

When set to true, the HTTP server automatically sends 100 CONTINUE response when the request expects it (with the Expect: 100-Continue header).

Environment variable: QUARKUS_HTTP_HANDLE_100_CONTINUE_AUTOMATICALLY

boolean

false

quarkus.http.io-threads

The number if IO threads used to perform IO. This will be automatically set to a reasonable value based on the number of CPU cores if it is not provided. If this is set to a higher value than the number of Vert.x event loops then it will be capped at the number of event loops.

In general this should be controlled by setting quarkus.vertx.event-loops-pool-size, this setting should only be used if you want to limit the number of HTTP io threads to a smaller number than the total number of IO threads.

Environment variable: QUARKUS_HTTP_IO_THREADS

int

quarkus.http.idle-timeout

Http connection idle timeout

Environment variable: QUARKUS_HTTP_IDLE_TIMEOUT

Duration

30M

quarkus.http.read-timeout

Http connection read timeout for blocking IO. This is the maximum amount of time a thread will wait for data, before an IOException will be thrown and the connection closed.

Environment variable: QUARKUS_HTTP_READ_TIMEOUT

Duration

60S

quarkus.http.body.handle-file-uploads

Whether the files sent using multipart/form-data will be stored locally.

If true, they will be stored in quarkus.http.body-handler.uploads-directory and will be made available via io.vertx.ext.web.RoutingContext.fileUploads(). Otherwise, the files sent using multipart/form-data will not be stored locally, and io.vertx.ext.web.RoutingContext.fileUploads() will always return an empty collection. Note that even with this option being set to false, the multipart/form-data requests will be accepted.

Environment variable: QUARKUS_HTTP_BODY_HANDLE_FILE_UPLOADS

boolean

true

quarkus.http.body.uploads-directory

The directory where the files sent using multipart/form-data should be stored.

Either an absolute path or a path relative to the current directory of the application process.

Environment variable: QUARKUS_HTTP_BODY_UPLOADS_DIRECTORY

string

${java.io.tmpdir}/uploads

quarkus.http.body.merge-form-attributes

Whether the form attributes should be added to the request parameters.

If true, the form attributes will be added to the request parameters; otherwise the form parameters will not be added to the request parameters

Environment variable: QUARKUS_HTTP_BODY_MERGE_FORM_ATTRIBUTES

boolean

true

quarkus.http.body.delete-uploaded-files-on-end

Whether the uploaded files should be removed after serving the request.

If true the uploaded files stored in quarkus.http.body-handler.uploads-directory will be removed after handling the request. Otherwise, the files will be left there forever.

Environment variable: QUARKUS_HTTP_BODY_DELETE_UPLOADED_FILES_ON_END

boolean

true

quarkus.http.body.preallocate-body-buffer

Whether the body buffer should pre-allocated based on the Content-Length header value.

If true the body buffer is pre-allocated according to the size read from the Content-Length header. Otherwise, the body buffer is pre-allocated to 1KB, and is resized dynamically

Environment variable: QUARKUS_HTTP_BODY_PREALLOCATE_BODY_BUFFER

boolean

false

quarkus.http.body.multipart.file-content-types

A comma-separated list of ContentType to indicate whether a given multipart field should be handled as a file part. You can use this setting to force HTTP-based extensions to parse a message part as a file based on its content type. For now, this setting only works when using RESTEasy Reactive.

Environment variable: QUARKUS_HTTP_BODY_MULTIPART_FILE_CONTENT_TYPES

list of string

quarkus.http.auth.session.encryption-key

The encryption key that is used to store persistent logins (e.g. for form auth). Logins are stored in a persistent cookie that is encrypted with AES-256 using a key derived from a SHA-256 hash of the key that is provided here.

If no key is provided then an in-memory one will be generated, this will change on every restart though so it is not suitable for production environments. This must be more than 16 characters long for security reasons

Environment variable: QUARKUS_HTTP_AUTH_SESSION_ENCRYPTION_KEY

string

quarkus.http.so-reuse-port

Enable socket reuse port (linux/macOs native transport only)

Environment variable: QUARKUS_HTTP_SO_REUSE_PORT

boolean

false

quarkus.http.tcp-quick-ack

Enable tcp quick ack (linux native transport only)

Environment variable: QUARKUS_HTTP_TCP_QUICK_ACK

boolean

false

quarkus.http.tcp-cork

Enable tcp cork (linux native transport only)

Environment variable: QUARKUS_HTTP_TCP_CORK

boolean

false

quarkus.http.tcp-fast-open

Enable tcp fast open (linux native transport only)

Environment variable: QUARKUS_HTTP_TCP_FAST_OPEN

boolean

false

quarkus.http.accept-backlog

The accept backlog, this is how many connections can be waiting to be accepted before connections start being rejected

Environment variable: QUARKUS_HTTP_ACCEPT_BACKLOG

int

-1

quarkus.http.initial-window-size

Set the SETTINGS_INITIAL_WINDOW_SIZE HTTP/2 setting. Indicates the sender’s initial window size (in octets) for stream-level flow control. The initial value is 2^16-1 (65,535) octets.

Environment variable: QUARKUS_HTTP_INITIAL_WINDOW_SIZE

int

quarkus.http.domain-socket

Path to a unix domain socket

Environment variable: QUARKUS_HTTP_DOMAIN_SOCKET

string

/var/run/io.quarkus.app.socket

quarkus.http.domain-socket-enabled

Enable listening to host:port

Environment variable: QUARKUS_HTTP_DOMAIN_SOCKET_ENABLED

boolean

false

quarkus.http.record-request-start-time

If this is true then the request start time will be recorded to enable logging of total request time.

This has a small performance penalty, so is disabled by default.

Environment variable: QUARKUS_HTTP_RECORD_REQUEST_START_TIME

boolean

false

quarkus.http.unhandled-error-content-type-default

Provides a hint (optional) for the default content type of responses generated for the errors not handled by the application.

If the client requested a supported content-type in request headers (e.g. "Accept: application/json", "Accept: text/html"), Quarkus will use that content type.

Otherwise, it will default to the content type configured here.

Environment variable: QUARKUS_HTTP_UNHANDLED_ERROR_CONTENT_TYPE_DEFAULT

json, html, text

quarkus.http.same-site-cookie."same-site-cookie".case-sensitive

If the cookie pattern is case-sensitive

Environment variable: QUARKUS_HTTP_SAME_SITE_COOKIE__SAME_SITE_COOKIE__CASE_SENSITIVE

boolean

false

quarkus.http.same-site-cookie."same-site-cookie".value

The value to set in the samesite attribute

Environment variable: QUARKUS_HTTP_SAME_SITE_COOKIE__SAME_SITE_COOKIE__VALUE

none, strict, lax

required

quarkus.http.same-site-cookie."same-site-cookie".enable-client-checker

Some User Agents break when sent SameSite=None, this will detect them and avoid sending the value

Environment variable: QUARKUS_HTTP_SAME_SITE_COOKIE__SAME_SITE_COOKIE__ENABLE_CLIENT_CHECKER

boolean

true

quarkus.http.same-site-cookie."same-site-cookie".add-secure-for-none

If this is true then the 'secure' attribute will automatically be sent on cookies with a SameSite attribute of None.

Environment variable: QUARKUS_HTTP_SAME_SITE_COOKIE__SAME_SITE_COOKIE__ADD_SECURE_FOR_NONE

boolean

true

Authentication configuration

Type

Default

quarkus.http.auth.permission."permissions".enabled

Determines whether the entire permission set is enabled, or not. By default, if the permission set is defined, it is enabled.

Environment variable: QUARKUS_HTTP_AUTH_PERMISSION__PERMISSIONS__ENABLED

boolean

quarkus.http.auth.permission."permissions".policy

The HTTP policy that this permission set is linked to. There are three built-in policies: permit, deny and authenticated. Role based policies can be defined, and extensions can add their own policies.

Environment variable: QUARKUS_HTTP_AUTH_PERMISSION__PERMISSIONS__POLICY

string

required

quarkus.http.auth.permission."permissions".methods

The methods that this permission set applies to. If this is not set then they apply to all methods. Note that if a request matches any path from any permission set, but does not match the constraint due to the method not being listed then the request will be denied. Method specific permissions take precedence over matches that do not have any methods set. This means that for example if Quarkus is configured to allow GET and POST requests to /admin to and no other permissions are configured PUT requests to /admin will be denied.

Environment variable: QUARKUS_HTTP_AUTH_PERMISSION__PERMISSIONS__METHODS

list of string

quarkus.http.auth.permission."permissions".paths

The paths that this permission check applies to. If the path ends in /* then this is treated as a path prefix, otherwise it is treated as an exact match. Matches are done on a length basis, so the most specific path match takes precedence. If multiple permission sets match the same path then explicit methods matches take precedence over matches without methods set, otherwise the most restrictive permissions are applied.

Environment variable: QUARKUS_HTTP_AUTH_PERMISSION__PERMISSIONS__PATHS

list of string

quarkus.http.auth.permission."permissions".auth-mechanism

Path specific authentication mechanism which must be used to authenticate a user. It needs to match HttpCredentialTransport authentication scheme such as 'basic', 'bearer', 'form', etc.

Environment variable: QUARKUS_HTTP_AUTH_PERMISSION__PERMISSIONS__AUTH_MECHANISM

string

quarkus.http.auth.permission."permissions".shared

Indicates that this policy always applies to the matched paths in addition to the policy with a winning path. Avoid creating more than one shared policy to minimize the performance impact.

Environment variable: QUARKUS_HTTP_AUTH_PERMISSION__PERMISSIONS__SHARED

boolean

false

quarkus.http.auth.permission."permissions".applies-to

Whether permission check should be applied on all matching paths, or paths specific for the Jakarta REST resources.

Environment variable: QUARKUS_HTTP_AUTH_PERMISSION__PERMISSIONS__APPLIES_TO

allApply on all matching paths., jaxrsDeclares that a permission check must only be applied on the Jakarta REST request paths. Use this option to delay the permission check if an authentication mechanism is chosen with an annotation on the matching Jakarta REST endpoint. This option must be set if the following REST endpoint annotations are used\: - io.quarkus.oidc.Tenant annotation which selects an OIDC authentication mechanism with a tenant identifier - io.quarkus.vertx.http.runtime.security.annotation.BasicAuthentication which selects the Basic authentication mechanism - io.quarkus.vertx.http.runtime.security.annotation.FormAuthentication which selects the Form-based authentication mechanism - io.quarkus.vertx.http.runtime.security.annotation.MTLSAuthentication which selects the mTLS authentication mechanism - io.quarkus.security.webauthn.WebAuthn which selects the WebAuth authentication mechanism - io.quarkus.oidc.BearerTokenAuthentication which selects the OpenID Connect Bearer token authentication mechanism - io.quarkus.oidc.AuthorizationCodeFlow which selects the OpenID Connect Code authentication mechanism

allApply on all matching paths.

quarkus.http.auth.policy."role-policy".roles-allowed

The roles that are allowed to access resources protected by this policy. By default, access is allowed to any authenticated user.

Environment variable: QUARKUS_HTTP_AUTH_POLICY__ROLE_POLICY__ROLES_ALLOWED

list of string

**

quarkus.http.auth.policy."role-policy".roles."role-name"

Add roles granted to the SecurityIdentity based on the roles that the SecurityIdentity already have. For example, the Quarkus OIDC extension can map roles from the verified JWT access token, and you may want to remap them to a deployment specific roles.

Environment variable: QUARKUS_HTTP_AUTH_POLICY__ROLE_POLICY__ROLES__ROLE_NAME_

Map<String,List<String>>

quarkus.http.auth.policy."role-policy".permissions."role-name"

Permissions granted to the SecurityIdentity if this policy is applied successfully (the policy allows request to proceed) and the authenticated request has required role. For example, you can map permission perm1 with actions action1 and action2 to role admin by setting quarkus.http.auth.policy.role-policy1.permissions.admin=perm1:action1,perm1:action2 configuration property. Granted permissions are used for authorization with the @PermissionsAllowed annotation.

Environment variable: QUARKUS_HTTP_AUTH_POLICY__ROLE_POLICY__PERMISSIONS__ROLE_NAME_

Map<String,List<String>>

quarkus.http.auth.policy."role-policy".permission-class

Permissions granted by this policy will be created with a java.security.Permission implementation specified by this configuration property. The permission class must declare exactly one constructor that accepts permission name (String) or permission name and actions (String, String[]). Permission class must be registered for reflection if you run your application in a native mode.

Environment variable: QUARKUS_HTTP_AUTH_POLICY__ROLE_POLICY__PERMISSION_CLASS

string

io.quarkus.security.StringPermission

quarkus.http.auth.roles-mapping."role-name"

Map the SecurityIdentity roles to deployment specific roles and add the matching roles to SecurityIdentity.

For example, if SecurityIdentity has a user role and the endpoint is secured with a 'UserRole' role, use this property to map the user role to the UserRole role, and have SecurityIdentity to have both user and UserRole roles.

Environment variable: QUARKUS_HTTP_AUTH_ROLES_MAPPING__ROLE_NAME_

Map<String,List<String>>

quarkus.http.auth.certificate-role-attribute

Client certificate attribute whose values are going to be mapped to the 'SecurityIdentity' roles according to the roles mapping specified in the certificate properties file. The attribute must be either one of the Relative Distinguished Names (RDNs) or Subject Alternative Names (SANs). By default, the Common Name (CN) attribute value is used for roles mapping. Supported values are:

RDN type - Distinguished Name field. For example 'CN' represents Common Name field. Multivalued RNDs and multiple instances of the same attributes are currently not supported.
'SAN_RFC822' - Subject Alternative Name field RFC 822 Name.
'SAN_URI' - Subject Alternative Name field Uniform Resource Identifier (URI).
'SAN_ANY' - Subject Alternative Name field Other Name. Please note that only simple case of UTF8 identifier mapping is supported. For example, you can map 'other-identifier' to the SecurityIdentity roles. If you use 'openssl' tool, supported Other name definition would look like this: subjectAltName=otherName:1.2.3.4;UTF8:other-identifier

Environment variable: QUARKUS_HTTP_AUTH_CERTIFICATE_ROLE_ATTRIBUTE

string

CN

quarkus.http.auth.certificate-role-properties

Properties file containing the client certificate attribute value to role mappings. Use it only if the mTLS authentication mechanism is enabled with either quarkus.http.ssl.client-auth=required or quarkus.http.ssl.client-auth=request.

Properties file is expected to have the CN_VALUE=role1,role,…,roleN format and should be encoded using UTF-8.

Environment variable: QUARKUS_HTTP_AUTH_CERTIFICATE_ROLE_PROPERTIES

path

quarkus.http.auth.realm

The authentication realm

Environment variable: QUARKUS_HTTP_AUTH_REALM

string

quarkus.http.auth.form.login-page

The login page. Redirect to login page can be disabled by setting quarkus.http.auth.form.login-page=.

Environment variable: QUARKUS_HTTP_AUTH_FORM_LOGIN_PAGE

string

/login.html

quarkus.http.auth.form.username-parameter

The username field name.

Environment variable: QUARKUS_HTTP_AUTH_FORM_USERNAME_PARAMETER

string

j_username

quarkus.http.auth.form.password-parameter

The password field name.

Environment variable: QUARKUS_HTTP_AUTH_FORM_PASSWORD_PARAMETER

string

j_password

quarkus.http.auth.form.error-page

The error page. Redirect to error page can be disabled by setting quarkus.http.auth.form.error-page=.

Environment variable: QUARKUS_HTTP_AUTH_FORM_ERROR_PAGE

string

/error.html

quarkus.http.auth.form.landing-page

The landing page to redirect to if there is no saved page to redirect back to. Redirect to landing page can be disabled by setting quarkus.http.auth.form.landing-page=.

Environment variable: QUARKUS_HTTP_AUTH_FORM_LANDING_PAGE

string

/index.html

quarkus.http.auth.form.location-cookie

Option to control the name of the cookie used to redirect the user back to the location they want to access.

Environment variable: QUARKUS_HTTP_AUTH_FORM_LOCATION_COOKIE

string

quarkus-redirect-location

quarkus.http.auth.form.timeout

The inactivity (idle) timeout When inactivity timeout is reached, cookie is not renewed and a new login is enforced.

Environment variable: QUARKUS_HTTP_AUTH_FORM_TIMEOUT

Duration

PT30M

quarkus.http.auth.form.new-cookie-interval

How old a cookie can get before it will be replaced with a new cookie with an updated timeout, also referred to as "renewal-timeout". Note that smaller values will result in slightly more server load (as new encrypted cookies will be generated more often); however, larger values affect the inactivity timeout because the timeout is set when a cookie is generated. For example if this is set to 10 minutes, and the inactivity timeout is 30m, if a user’s last request is when the cookie is 9m old then the actual timeout will happen 21m after the last request because the timeout is only refreshed when a new cookie is generated. That is, no timeout is tracked on the server side; the timestamp is encoded and encrypted in the cookie itself, and it is decrypted and parsed with each request.

Environment variable: QUARKUS_HTTP_AUTH_FORM_NEW_COOKIE_INTERVAL

Duration

PT1M

quarkus.http.auth.form.cookie-name

The cookie that is used to store the persistent session

Environment variable: QUARKUS_HTTP_AUTH_FORM_COOKIE_NAME

string

quarkus-credential

quarkus.http.auth.form.cookie-path

The cookie path for the session and location cookies.

Environment variable: QUARKUS_HTTP_AUTH_FORM_COOKIE_PATH

string

/

quarkus.http.auth.form.http-only-cookie

Set the HttpOnly attribute to prevent access to the cookie via JavaScript.

Environment variable: QUARKUS_HTTP_AUTH_FORM_HTTP_ONLY_COOKIE

boolean

false

quarkus.http.auth.form.cookie-same-site

SameSite attribute for the session and location cookies.

Environment variable: QUARKUS_HTTP_AUTH_FORM_COOKIE_SAME_SITE

strict, lax, none

strict

quarkus.http.auth.form.cookie-max-age

Max-Age attribute for the session cookie. This is the amount of time the browser will keep the cookie. The default value is empty, which means the cookie will be kept until the browser is closed.

Environment variable: QUARKUS_HTTP_AUTH_FORM_COOKIE_MAX_AGE

Duration

The CORS config

Type

Default

quarkus.http.cors.origins

Origins allowed for CORS Comma separated list of valid URLs, e.g.: http://www.quarkus.io,http://localhost:3000 In case an entry of the list is surrounded by forward slashes, it is interpreted as a regular expression.

Environment variable: QUARKUS_HTTP_CORS_ORIGINS

list of string

quarkus.http.cors.methods

HTTP methods allowed for CORS Comma separated list of valid methods. ex: GET,PUT,POST The filter allows any method if this is not set. default: returns any requested method as valid

Environment variable: QUARKUS_HTTP_CORS_METHODS

list of string

quarkus.http.cors.headers

HTTP headers allowed for CORS Comma separated list of valid headers. ex: X-Custom,Content-Disposition The filter allows any header if this is not set. default: returns any requested header as valid

Environment variable: QUARKUS_HTTP_CORS_HEADERS

list of string

quarkus.http.cors.exposed-headers

HTTP headers exposed in CORS Comma separated list of valid headers. ex: X-Custom,Content-Disposition default: empty

Environment variable: QUARKUS_HTTP_CORS_EXPOSED_HEADERS

list of string

quarkus.http.cors.access-control-max-age

The Access-Control-Max-Age response header value indicating how long the results of a pre-flight request can be cached.

Environment variable: QUARKUS_HTTP_CORS_ACCESS_CONTROL_MAX_AGE

Duration

quarkus.http.cors.access-control-allow-credentials

The Access-Control-Allow-Credentials header is used to tell the browsers to expose the response to front-end JavaScript code when the request’s credentials mode Request.credentials is “include”. The value of this header will default to true if quarkus.http.cors.origins property is set and there is a match with the precise Origin header.

Environment variable: QUARKUS_HTTP_CORS_ACCESS_CONTROL_ALLOW_CREDENTIALS

boolean

Static Resources

Type

Default

quarkus.http.static-resources.index-page

Set the index page when serving static resources.

Environment variable: QUARKUS_HTTP_STATIC_RESOURCES_INDEX_PAGE

string

index.html

quarkus.http.static-resources.include-hidden

Set whether hidden files should be served.

Environment variable: QUARKUS_HTTP_STATIC_RESOURCES_INCLUDE_HIDDEN

boolean

true

quarkus.http.static-resources.enable-range-support

Set whether range requests (resumable downloads; media streaming) should be enabled.

Environment variable: QUARKUS_HTTP_STATIC_RESOURCES_ENABLE_RANGE_SUPPORT

boolean

true

quarkus.http.static-resources.caching-enabled

Set whether cache handling is enabled.

Environment variable: QUARKUS_HTTP_STATIC_RESOURCES_CACHING_ENABLED

boolean

true

quarkus.http.static-resources.cache-entry-timeout

Set the cache entry timeout. The default is 30 seconds.

Environment variable: QUARKUS_HTTP_STATIC_RESOURCES_CACHE_ENTRY_TIMEOUT

Duration

30S

quarkus.http.static-resources.max-age

Set value for max age in caching headers. The default is 24 hours.

Environment variable: QUARKUS_HTTP_STATIC_RESOURCES_MAX_AGE

Duration

24H

quarkus.http.static-resources.max-cache-size

Set the max cache size.

Environment variable: QUARKUS_HTTP_STATIC_RESOURCES_MAX_CACHE_SIZE

int

10000

quarkus.http.static-resources.content-encoding

Content encoding for text related files

Environment variable: QUARKUS_HTTP_STATIC_RESOURCES_CONTENT_ENCODING

Charset

UTF-8

Server limits

Type

Default

quarkus.http.limits.max-header-size

The maximum length of all headers.

Environment variable: QUARKUS_HTTP_LIMITS_MAX_HEADER_SIZE

MemorySize

20K

quarkus.http.limits.max-body-size

The maximum size of a request body.

Environment variable: QUARKUS_HTTP_LIMITS_MAX_BODY_SIZE

MemorySize

10240K

quarkus.http.limits.max-chunk-size

The max HTTP chunk size

Environment variable: QUARKUS_HTTP_LIMITS_MAX_CHUNK_SIZE

MemorySize

8192

quarkus.http.limits.max-initial-line-length

The maximum length of the initial line (e.g. "GET / HTTP/1.0").

Environment variable: QUARKUS_HTTP_LIMITS_MAX_INITIAL_LINE_LENGTH

int

4096

quarkus.http.limits.max-form-attribute-size

The maximum length of a form attribute.

Environment variable: QUARKUS_HTTP_LIMITS_MAX_FORM_ATTRIBUTE_SIZE

MemorySize

2048

quarkus.http.limits.max-form-fields

Set the maximum number of fields of a form. Set to -1 to allow unlimited number of attributes.

Environment variable: QUARKUS_HTTP_LIMITS_MAX_FORM_FIELDS

int

256

quarkus.http.limits.max-form-buffered-bytes

Set the maximum number of bytes a server can buffer when decoding a form. Set to -1 to allow unlimited length

Environment variable: QUARKUS_HTTP_LIMITS_MAX_FORM_BUFFERED_BYTES

MemorySize

1K

quarkus.http.limits.max-parameters

The maximum number of HTTP request parameters permitted for incoming requests.

If a client sends more than this number of parameters in a request, the connection is closed.

Environment variable: QUARKUS_HTTP_LIMITS_MAX_PARAMETERS

int

1000

quarkus.http.limits.max-connections

The maximum number of connections that are allowed at any one time. If this is set it is recommended to set a short idle timeout.

Environment variable: QUARKUS_HTTP_LIMITS_MAX_CONNECTIONS

int

quarkus.http.limits.header-table-size

Set the SETTINGS_HEADER_TABLE_SIZE HTTP/2 setting.

Allows the sender to inform the remote endpoint of the maximum size of the header compression table used to decode header blocks, in octets. The encoder can select any size equal to or less than this value by using signaling specific to the header compression format inside a header block. The initial value is 4,096 octets.

Environment variable: QUARKUS_HTTP_LIMITS_HEADER_TABLE_SIZE

long

quarkus.http.limits.max-concurrent-streams

Set SETTINGS_MAX_CONCURRENT_STREAMS HTTP/2 setting.

Indicates the maximum number of concurrent streams that the sender will allow. This limit is directional: it applies to the number of streams that the sender permits the receiver to create. Initially, there is no limit to this value. It is recommended that this value be no smaller than 100, to not unnecessarily limit parallelism.

Environment variable: QUARKUS_HTTP_LIMITS_MAX_CONCURRENT_STREAMS

long

quarkus.http.limits.max-frame-size

Set the SETTINGS_MAX_FRAME_SIZE HTTP/2 setting. Indicates the size of the largest frame payload that the sender is willing to receive, in octets. The initial value is 2^14 (16,384) octets.

Environment variable: QUARKUS_HTTP_LIMITS_MAX_FRAME_SIZE

int

quarkus.http.limits.max-header-list-size

Set the SETTINGS_MAX_HEADER_LIST_SIZE HTTP/2 setting. This advisory setting informs a peer of the maximum size of header list that the sender is prepared to accept, in octets. The value is based on the uncompressed size of header fields, including the length of the name and value in octets plus an overhead of 32 octets for each header field. The default value is 8192

Environment variable: QUARKUS_HTTP_LIMITS_MAX_HEADER_LIST_SIZE

long

quarkus.http.limits.rst-flood-max-rst-frame-per-window

Set the max number of RST frame allowed per time window, this is used to prevent HTTP/2 RST frame flood DDOS attacks. The default value is 200, setting zero or a negative value, disables flood protection.

Environment variable: QUARKUS_HTTP_LIMITS_RST_FLOOD_MAX_RST_FRAME_PER_WINDOW

int

quarkus.http.limits.rst-flood-window-duration

Set the duration of the time window when checking the max number of RST frames, this is used to prevent HTTP/2 RST frame flood DDOS attacks.. The default value is 30 s, setting zero or a negative value, disables flood protection.

Environment variable: QUARKUS_HTTP_LIMITS_RST_FLOOD_WINDOW_DURATION

Duration

Access logs

Type

Default

quarkus.http.access-log.enabled

If access logging is enabled. By default this will log via the standard logging facility

Environment variable: QUARKUS_HTTP_ACCESS_LOG_ENABLED

boolean

false

quarkus.http.access-log.exclude-pattern

A regular expression that can be used to exclude some paths from logging.

Environment variable: QUARKUS_HTTP_ACCESS_LOG_EXCLUDE_PATTERN

string

quarkus.http.access-log.pattern

The access log pattern.

If this is the string common, combined or long then this will use one of the specified named formats:

common: %h %l %u %t "%r" %s %b
combined: %h %l %u %t "%r" %s %b "%{i,Referer}" "%{i,User-Agent}"
long: %r\n%{ALL_REQUEST_HEADERS}

Otherwise, consult the Quarkus documentation for the full list of variables that can be used.

Environment variable: QUARKUS_HTTP_ACCESS_LOG_PATTERN

string

common

quarkus.http.access-log.log-to-file

If logging should be done to a separate file.

Environment variable: QUARKUS_HTTP_ACCESS_LOG_LOG_TO_FILE

boolean

false

quarkus.http.access-log.base-file-name

The access log file base name, defaults to 'quarkus' which will give a log file name of 'quarkus.log'.

Environment variable: QUARKUS_HTTP_ACCESS_LOG_BASE_FILE_NAME

string

quarkus

quarkus.http.access-log.log-directory

The log directory to use when logging access to a file If this is not set then the current working directory is used.

Environment variable: QUARKUS_HTTP_ACCESS_LOG_LOG_DIRECTORY

string

quarkus.http.access-log.log-suffix

The log file suffix

Environment variable: QUARKUS_HTTP_ACCESS_LOG_LOG_SUFFIX

string

.log

quarkus.http.access-log.category

The log category to use if logging is being done via the standard log mechanism (i.e. if base-file-name is empty).

Environment variable: QUARKUS_HTTP_ACCESS_LOG_CATEGORY

string

io.quarkus.http.access-log

quarkus.http.access-log.rotate

If the log should be rotated daily

Environment variable: QUARKUS_HTTP_ACCESS_LOG_ROTATE

boolean

true

quarkus.http.access-log.consolidate-rerouted-requests

If rerouted requests should be consolidated into one log entry

Environment variable: QUARKUS_HTTP_ACCESS_LOG_CONSOLIDATE_REROUTED_REQUESTS

boolean

false

Traffic shaping

Type

Default

quarkus.http.traffic-shaping.enabled

Enables the traffic shaping.

Environment variable: QUARKUS_HTTP_TRAFFIC_SHAPING_ENABLED

boolean

false

quarkus.http.traffic-shaping.inbound-global-bandwidth

Set bandwidth limit in bytes per second for inbound connections. If not set, no limits are applied.

Environment variable: QUARKUS_HTTP_TRAFFIC_SHAPING_INBOUND_GLOBAL_BANDWIDTH

MemorySize

quarkus.http.traffic-shaping.outbound-global-bandwidth

Set bandwidth limit in bytes per second for outbound connections. If not set, no limits are applied.

Environment variable: QUARKUS_HTTP_TRAFFIC_SHAPING_OUTBOUND_GLOBAL_BANDWIDTH

MemorySize

quarkus.http.traffic-shaping.max-delay

Set the maximum delay to wait in case of traffic excess. Default is 15s. Must be less than the HTTP timeout.

Environment variable: QUARKUS_HTTP_TRAFFIC_SHAPING_MAX_DELAY

Duration

quarkus.http.traffic-shaping.check-interval

Set the delay between two computations of performances for channels. If set to 0, no stats are computed. Despite 0 is accepted (no accounting), it is recommended to set a positive value for the check interval, even if it is high since the precision of the traffic shaping depends on the period where the traffic is computed. In this case, a suggested value is something close to 5 or 10 minutes.

If not default, it defaults to 1s.

Environment variable: QUARKUS_HTTP_TRAFFIC_SHAPING_CHECK_INTERVAL

Duration

quarkus.http.traffic-shaping.peak-outbound-global-bandwidth

Set the maximum global write size in bytes per second allowed in the buffer globally for all channels before write are suspended. The default value is 400 MB.

Environment variable: QUARKUS_HTTP_TRAFFIC_SHAPING_PEAK_OUTBOUND_GLOBAL_BANDWIDTH

MemorySize

Additional HTTP Headers always sent in the response

Type

Default

quarkus.http.header."header".path

The path this header should be applied

Environment variable: QUARKUS_HTTP_HEADER__HEADER__PATH

string

/*

quarkus.http.header."header".value

The value for this header configuration

Environment variable: QUARKUS_HTTP_HEADER__HEADER__VALUE

string

required

quarkus.http.header."header".methods

The HTTP methods for this header configuration

Environment variable: QUARKUS_HTTP_HEADER__HEADER__METHODS

list of string

Additional HTTP configuration per path

Type

Default

quarkus.http.filter."filter".matches

A regular expression for the paths matching this configuration

Environment variable: QUARKUS_HTTP_FILTER__FILTER__MATCHES

string

required

quarkus.http.filter."filter".header."header-name"

Additional HTTP Headers always sent in the response

Environment variable: QUARKUS_HTTP_FILTER__FILTER__HEADER__HEADER_NAME_

Map<String,String>

quarkus.http.filter."filter".methods

The HTTP methods for this path configuration

Environment variable: QUARKUS_HTTP_FILTER__FILTER__METHODS

list of string

quarkus.http.filter."filter".order

Order in which this path config is applied. Higher priority takes precedence

Environment variable: QUARKUS_HTTP_FILTER__FILTER__ORDER

int

Proxy

Type

Default

quarkus.http.proxy.use-proxy-protocol

Set whether the server should use the HA PROXY protocol when serving requests from behind a proxy. (see the PROXY Protocol). When set to true, the remote address returned will be the one from the actual connecting client. If it is set to false (default), the remote address returned will be the one from the proxy.

Environment variable: QUARKUS_HTTP_PROXY_USE_PROXY_PROTOCOL

boolean

false

quarkus.http.proxy.proxy-address-forwarding

If this is true then the address, scheme etc. will be set from headers forwarded by the proxy server, such as X-Forwarded-For. This should only be set if you are behind a proxy that sets these headers.

Environment variable: QUARKUS_HTTP_PROXY_PROXY_ADDRESS_FORWARDING

boolean

false

quarkus.http.proxy.allow-forwarded

If this is true and proxy address forwarding is enabled then the standard Forwarded header will be used. In case the not standard X-Forwarded-For header is enabled and detected on HTTP requests, the standard header has the precedence. Activating this together with quarkus.http.proxy.allow-x-forwarded has security implications as clients can forge requests with a forwarded header that is not overwritten by the proxy. Therefore, proxies should strip unexpected Forwarded or X-Forwarded-* headers from the client.

Environment variable: QUARKUS_HTTP_PROXY_ALLOW_FORWARDED

boolean

false

quarkus.http.proxy.allow-x-forwarded

If either this or allow-forwarded are true and proxy address forwarding is enabled then the not standard Forwarded header will be used. In case the standard Forwarded header is enabled and detected on HTTP requests, the standard header has the precedence. Activating this together with quarkus.http.proxy.allow-forwarded has security implications as clients can forge requests with a forwarded header that is not overwritten by the proxy. Therefore, proxies should strip unexpected Forwarded or X-Forwarded-* headers from the client.

Environment variable: QUARKUS_HTTP_PROXY_ALLOW_X_FORWARDED

boolean

quarkus.http.proxy.enable-forwarded-host

Enable override the received request’s host through a forwarded host header.

Environment variable: QUARKUS_HTTP_PROXY_ENABLE_FORWARDED_HOST

boolean

false

quarkus.http.proxy.forwarded-host-header

Configure the forwarded host header to be used if override enabled.

Environment variable: QUARKUS_HTTP_PROXY_FORWARDED_HOST_HEADER

string

X-Forwarded-Host

quarkus.http.proxy.enable-forwarded-prefix

Enable prefix the received request’s path with a forwarded prefix header.

Environment variable: QUARKUS_HTTP_PROXY_ENABLE_FORWARDED_PREFIX

boolean

false

quarkus.http.proxy.forwarded-prefix-header

Configure the forwarded prefix header to be used if prefixing enabled.

Environment variable: QUARKUS_HTTP_PROXY_FORWARDED_PREFIX_HEADER

string

X-Forwarded-Prefix

quarkus.http.proxy.enable-trusted-proxy-header

Adds the header X-Forwarded-Trusted-Proxy if the request is forwarded by a trusted proxy. The value is true if the request is forwarded by a trusted proxy, otherwise null.

The forwarded parser detects forgery attempts and if the incoming request contains this header, it will be removed from the request.

The X-Forwarded-Trusted-Proxy header is a custom header, not part of the standard Forwarded header.

Environment variable: QUARKUS_HTTP_PROXY_ENABLE_TRUSTED_PROXY_HEADER

boolean

false

quarkus.http.proxy.trusted-proxies

Configure the list of trusted proxy addresses. Received Forwarded, X-Forwarded or X-Forwarded-* headers from any other proxy address will be ignored. The trusted proxy address should be specified as the IP address (IPv4 or IPv6), hostname or Classless Inter-Domain Routing (CIDR) notation. Please note that Quarkus needs to perform DNS lookup for all hostnames during the request. For that reason, using hostnames is not recommended.

Examples of a socket address in the form of host or host:port:

127.0.0.1:8084
[0:0:0:0:0:0:0:1]
[0:0:0:0:0:0:0:1]:8084
[::]
localhost
localhost:8084

Examples of a CIDR notation:

::/128
::/0
127.0.0.0/8

Please bear in mind that IPv4 CIDR won’t match request sent from the IPv6 address and the other way around.

Environment variable: QUARKUS_HTTP_PROXY_TRUSTED_PROXIES

list of TrustedProxyCheckPart

All proxy addresses are trusted

WebSocket Server configuration

Type

Default

quarkus.http.websocket-server.max-frame-size

The maximum amount of data that can be sent in a single frame. Messages larger than this must be broken up into continuation frames. Default 65536 (from HttpServerOptions of Vert.X HttpServerOptions)

Environment variable: QUARKUS_HTTP_WEBSOCKET_SERVER_MAX_FRAME_SIZE

int

quarkus.http.websocket-server.max-message-size

The maximum WebSocket message size. Default 262144 (from HttpServerOptions of Vert.X HttpServerOptions)

Environment variable: QUARKUS_HTTP_WEBSOCKET_SERVER_MAX_MESSAGE_SIZE

int

quarkus.management.enabled

Enables / Disables the usage of a separate interface/port to expose the management endpoints. If sets to true, the management endpoints will be exposed to a different HTTP server. This avoids exposing the management endpoints on a publicly available server.

Environment variable: QUARKUS_MANAGEMENT_ENABLED

boolean

false

quarkus.management.auth.basic

If basic auth should be enabled.

Environment variable: QUARKUS_MANAGEMENT_AUTH_BASIC

boolean