Quarkus

Cheat-Sheet

What is Quarkus? Or in Kotlin: Command mode

Quarkus is a Kubernetes Native Java stack tailored for GraalVM & plugins { You can de ne the main CLI method to start Quarkus. There are two
OpenJDK HotSpot, crafted from the best of breed Java libraries and java ways, implementing [Link]
standards. Also focused on developer experience, making things } interface or use the Java main method to launch Quarkus.
just work with little to no con guration and allowing to do live apply(plugin = "[Link]")
coding. @[Link]
repositories { public class HelloWorldMain implements QuarkusApplication {
Cheat-sheet tested with Quarkus [Link]. mavenCentral() @Override
} public int run(String... args) throws Exception {
Getting Started [Link]("Hello World");
dependencies { return 10;
Quarkus comes with a Maven archetype to scaffold a very simple implementation(enforcedPlatform("[Link]:quarkus-bo }
starting project. m:0.26.1")) }
implementation("[Link]:quarkus-resteasy")
}
mvn [Link]:quarkus-maven-plugin:[Link]:create \
-DprojectGroupId=[Link] \ run method called when Quarkus starts, and stops when it nishes.
-DprojectArtifactId=getting-started \
-DclassName="[Link]" \ Packaging As Java main :
-Dpath="/hello"

mvn clean package @QuarkusMain

public class JavaMain {
This creates a simple JAX-RS resource called GreetingResource . public static void main(String... args) {
[Link]([Link], args);
You need to distribute the -[Link] le together with lib }
@Path("/hello")
directory. }
public class GreetingResource {
If [Link]-jar property is set to true, then a uber-jar is
@GET created with all dependencies bundled inside the JAR.
@Produces(MediaType.TEXT_PLAIN)
public String hello() { If [Link] property is set to fast-jar then Quarkus Use @QuarkusMain in only one place.
return "hello"; brings a JAR with faster startup times.
}
[Link] Use [Link]() from the main thread if you want to run
}
some logic on startup, and then run like a normal application (i.e.
[Link]-jar=true not exit).
[Link]=fast-jar
Gradle You can inject
command line arguments by using
@CommandLineArguments annotation:

There is no way to scaffold a project in Gradle but you only need to To compile to native, you need to set GRAALVM_HOME environment
do: variable and run the native pro le. @CommandLineArguments
String[] args;

plugins { mvn clean package -Pnative

id 'java'
id '[Link]' version '0.26.1' ./gradlew build -[Link]=native Picocli
}
You can use Picocli to implement CLI applications:
repositories {
Possible [Link] are: jar , fast-jar , uber-jar and
mavenCentral() ./mvnw quarkus:add-extension
native .
} -Dextensions="picocli"

AppCDS
dependencies {
implementation enforcedPlatform('[Link]:quarkus-bo Automatically generate AppCDS as part of the build process set the
m:0.26.1') next property: [Link]-appcds=true .
implementation '[Link]:quarkus-resteasy'
} To make use of it, just run java -jar -XX:SharedArchiveFile=app-
[Link] [Link] .
 @[Link] @[Link] Dev Mode
public class HelloCommand implements Runnable { public class EntryCommand implements Runnable {
@[Link](names = "-c", description = "JDBC c
./mvnw compile quarkus:dev
@[Link](names = {"-n", "--name"}, descripti onnection string")

on = "Who will we greet?", defaultValue = "World") String connectionString;
./gradlew quarkusDev
String name;
@Inject
private final GreetingService greetingService; DataSource dataSource;
} Endpoints are registered automatically to provide some basic
public HelloCommand(GreetingService greetingService) { debug info in dev mode:
[Link] = greetingService; @ApplicationScoped
HTTP GET /quarkus/arc/beans
} class DatasourceConfiguration {

Query Parameters: scope , beanClass , kind .
@Override @Produces
public void run() { @ApplicationScoped HTTP GET /quarkus/arc/observers
[Link](name); DataSource dataSource([Link] parseResu
}
}
lt) {
[Link]([Link]("c").g
Adding Con guration Parameters
etValue().toString());
}
To add con guration to your application, Quarkus relies on
}
MicroPro le Con g spec.
All classes annotated with [Link] are
registered as CDI beans.
@ConfigProperty(name = "[Link]")
String message;
If only one class annotated with [Link] it will
be used as entry point. If you want to provide your own
Extensions
@ConfigProperty(name = "[Link]",
@QuarkusMain :
Quarkus comes with extensions to integrate with some libraries defaultValue = "Hello")
such as JSON-B, Camel or MicroPro le spec. To list all available String messageWithDefault;
@QuarkusMain extensions just run:
@[Link](name = "demo", mixinStandardHelpOption
@ConfigProperty(name = "[Link]")
s = true)
./mvnw quarkus:list-extensions Optional<String> optionalMessage;
public class ExampleApp implements Runnable, QuarkusApplica
tion {

@Inject You can use -DsearchPattern=panache to lter out all Properties can be set (in decreasing priority) as:
[Link] factory; extensions except the ones matching the expression.
System properties ( -[Link] ).
@Override And to register the extensions into build tool:
Environment variables ( GREETINGS_MESSAGE ).
public void run() {
}
./mvnw quarkus:add-extension -Dextensions="" Environment le named .env placed in the current working

directory ( GREETING_MESSAGE= ).
@Override
./mvnw quarkus:remove-extension -Dextensions=""
public int run(String... args) throws Exception { External con g directory under the current working directory:
return new CommandLine(this, factory).execute(arg config/[Link] .
s);
} extensions property supports CSV format to register more Resources src/main/resources/[Link] .
} than one extension at once.
[Link] = Hello World
Application Lifecycle
Use [Link] to false to use
the picocli-codegen annotation processor instead of build steps. You can be noti ed when the application starts/stops by observing
Array , List and Set are supported. The delimiter is comma
StartupEvent and ShutdownEvent events.
You can also con gure CDI beans with PicoCLI arguments: ( , ) char and \ is the escape char.

@ApplicationScoped Con guration Pro les

public class ApplicationLifecycle {
void onStart(@Observes StartupEvent event) {} Quarkus allow you to have multiple con guration in the same le
void onStop(@Observes ShutdownEvent event) {} ( [Link] ).
}
The syntax for this is %{profile}.[Link]=value .

Quarkus supports graceful shutdown. By default there is no timeout [Link]=9090

but can be set by using the [Link] con g %[Link]=8181
HTTP port will be 9090, unless the 'dev' pro le is active. @[Link] annotation can be used to
@ConfigProperties(prefix = "greeting", namingStrategy=Namin
ignore the injection of con guration elements.
gStrategy.KEBAB_CASE)
Default pro les are:
public class GreetingConfiguration {
private String message; @ConfigIgnore
dev : Activated when in development mode ( quarkus:dev ).
// getter/setter public Integer ignored;
test : Activated when running tests. }

prod : The default pro le when not running in development or YAML Con g
test mode
This class maps [Link] property de ned in
[Link] . YAML con guration is also supported. The con guration le is
You can create custom pro le names by enabling the pro le either called [Link] and you need to register a dependency to
setting [Link] system property or QUARKUS_PROFILE enable its support:
You can inject this class by using CDI @Inject GreetingConfiguration
environment variable. greeting; .
[Link]

[Link]=9090 Also you can use an interface approach: <dependency>

%[Link]=9999 <groupId>[Link]</groupId>
@ConfigProperties(prefix = "greeting", namingStrategy=Namin <artifactId>quarkus-config-yaml</artifactId>
gStrategy.KEBAB_CASE) </dependency>
And enable it [Link]=staging . public interface GreetingConfiguration {

To get the active pro le programmatically
use @ConfigProperty(name = "message")
String message(); quarkus:
[Link]() .
String getSuffix(); datasource:
url: jdbc:postgresql://localhost:5432/some-database
You can also set it in the build tool:
driver: [Link]

<groupId>[Link]</groupId> If property does not follow getter/setter naming convention you

<artifactId>maven-surefire-plugin</artifactId> need to use [Link]
<version>${[Link]}</version> to set it. Or with pro les:
<configuration>
<systemPropertyVariables>
Nested objects are also supporte: "%dev":
<[Link]>foo</[Link]> quarkus:
<buildDirectory>${[Link]} @ConfigProperties(prefix = "greeting", namingStrategy=Namin datasource:
</buildDirectory> gStrategy.KEBAB_CASE) url: jdbc:postgresql://localhost:5432/some-database
</systemPropertyVariables> public class GreetingConfiguration { driver: [Link]
</configuration> public String message;
public HiddenConfig hidden;

In case of subkeys ~ is used to refer to the unpre xed part.
public static class HiddenConfig {
Same for maven-failsafe-plugin . public List<String> recipients;
} quarkus:
} http:
test { cors:
useJUnitPlatform() ~: true
systemProperty "[Link]", "foo" methods: GET,PUT,POST
}
And an [Link] mapping previous class:

[Link] = hello
Is equivalent to:
[Link]=Jane,John
Special properties are set in prod mode:
[Link] and [Link] to get [Link]=true
them available at runtime. [Link]=GET,PUT,POST
Bean Validation is also supported so properties are validated at
startup time, for example @Size(min = 20) public String message; .
@ConfigProperty(name = "[Link]")
String applicationName; Custom Loader
prefix attribute is not mandatory. If not provided, attribute
is determined by class name (ie GreeetingConfiguration is
translated to greeting or GreetingExtraConfiguration to You can implement your own ConfigSource to load con guration
@Con gProperties from different places than the default ones provided by Quarkus.
greeting-extra ). The su x of the class is always removed.
For example, database, custom XML, REST Endpoints, …
As an alternative to injecting multiple related con guration values, Naming strategy can be changed with property namingStrategy .
you can also use the @[Link] You need to create a new class and implement ConfigSource
KEBAB_CASE ([Link]-bar) or VERBATIM ([Link]).
annotation to group properties. interface:
 Then you need to register the Converter as Java service. Create a Quali ers
package [Link];
le with the following content:
public class InMemoryConfig implements ConfigSource {
You can use quali ers to return different implementations of the
/META-INF/services/[Link]
same interface or to customize the con guration of the bean.
private Map<String, String> prop = new HashMap<>();
[Link]
public InMemoryConfig() { @Qualifier
// Init properties @Retention(RUNTIME)
} @Target({TYPE, METHOD, FIELD, PARAMETER})

Undertow Properties public @interface Quote {
@Override @Nonbinding String value();
public int getOrdinal() { Possible parameters with pre x [Link] : }
// The highest ordinal takes precedence
context-path @Produces
return 900;
} The context path to serve all Servlet context from. (default: / ) @Quote("")
Message message(InjectionPoint msg) {
@Override default-charset Message m = new Message();
[Link](
public Map<String, String> getProperties() { The default charset to use for reading and writing requests.
[Link]()
return prop; (default: UTF-8 )
} .getAnnotation([Link])
.value()

@Override
Injection );
public String getValue(String propertyName) {
return [Link](propertyName);
Quarkus is based on CDI 2.0 to implement injection of code. It is return m;
}
not fully supported and only a subset of the speci cation is }

implemented.
@Override @Inject
public String getName() { @ApplicationScoped @Quote("Aloha Beach")
return "MemoryConfigSource"; public class GreetingService { Message message;
}
} public String message(String message) {
return [Link]();
Quarkus breaks the CDI spec by allowing you to inject
}
quali ed beans without using @Inject annotation.
}
Then you need to register the ConfigSource as Java service. Create
a le with the following content: @Quote("Aloha Beach")
Message message;
/META-INF/services/[Link]
Scope annotation is mandatory to make the bean discoverable.
[Link]
@Inject
Quarkus breaks the CDI spec by skipping the @Produces
GreetingService greetingService;
annotation completely if the producer method is annotated
Custom Converters with a scope annotation, a stereotype or a quali er.

You can implement your own conversion types from String. Quarkus is designed with Substrate VM in mind. For this @Quote("")
Implement [Link] reason, we encourage you to use package-private scope Message message(InjectionPoint msg) {
interface: instead of private. }

@Priority(DEFAULT_QUARKUS_CONVERTER_PRIORITY + 100) Produces @Quote("Aloha Beach")
public class CustomInstantConverter Message message;
implements Converter<Instant> { You can also create a factory of an object by using
@[Link] annotation.
@Override
Alternatives
public Instant convert(String value) { @Produces
if ("now".equals([Link]())) { @ApplicationScoped It is also possible to select alternatives for an application using
return [Link](); Message message() { [Link] .
} Message m = new Message();
return [Link](value); [Link]("Hello");
[Link]-alternatives=[Link],[Link].*,B
} return m;
ar
} }

@Inject
Message msg; Beans by Quarkus Pro le
@Priority annotation is used to override the default
InstantConverter .
Using @[Link] and By default the class is in write mode (so no concurrent calls
@ApplicationScoped
@[Link] annotations, you can allowed) except when lock type is READ where the method can be public class CustomObjectMapperConfig {
conditionally enable a bean. called concurrently if no write operation in process.
@Singleton
@Produces
@Dependent JSON Marshalling/Unmarshalling public ObjectMapper objectMapper() {
public class TracerConfiguration { ObjectMapper objectMapper = new ObjectMapper();
@Produces To work with JSON-B you need to add a dependency: // perform configuration
@IfBuildProfile("prod") return objectMapper;
public Tracer realTracer(Reporter reporter, Configurati ./mvnw quarkus:add-extension }
on configuration) { -Dextensions="[Link]:quarkus-resteasy-jsonb" }
return new RealTracer(reporter, configuration);
}
@Produces
@DefaultBean Any POJO is marshaled/unmarshalled automatically.
Default media type in Quarkus RestEasy is JSON.
public Tracer noopTracer() {
return new NoopTracer(); public class Sauce {
} private String name; XML Marshalling/Unmarshalling
} private long scovilleHeatUnits;

To work with JAX-B you need to add a dependency:
// getter/setters
}
Using @[Link] annotation, you can ./mvnw quarkus:add-extension
conditionally enable a bean. @[Link] sets the -Dextensions="quarkus-resteasy-jaxb"
default bean.
JSON equivalent:
@Dependent
Then annotated POJOs are converted to XML.
public class TracerConfiguration { {
@Produces "name":"Blair's Ultra Death",
@IfBuildProperty(name = "[Link]", stringVa "scovilleHeatUnits": 1100000 @XmlRootElement
lue = "true") } public class Message {
public Tracer realTracer(Reporter reporter, Configurati }
on configuration) {}
@GET
In a POST endpoint example: @Produces(MediaType.APPLICATION_XML)
@Produces
@DefaultBean public Message hello() {
public Tracer noopTracer() {} @POST return message;
} @Consumes(MediaType.APPLICATION_JSON) }
public Response create(Sauce sauce) {
// Create Sauce
return [Link]([Link]([Link]()))
Properties set at runtime have absolutely no effect on the .build(); JAXP
bean resolution using @IfBuildProperty . }
To work with JAX-P you need to add a dependency:
Container-managed Concurrency
./mvnw quarkus:add-extension
To work with Jackson you need to add:
Quarkus provides @[Link] and a built-in interceptor for -Dextensions="jaxp"
concurrency control.
./mvnw quarkus:add-extension
-Dextensions="quarkus-resteasy-jackson"
@Lock
final DocumentBuilder dBuilder = [Link]
@ApplicationScoped
Instance().newDocumentBuilder();
class SharedService {
If you don’t want to use the default ObjectMapper you can customize final Document doc = [Link](in);

it by: return [Link]().getTextContent();
void addAmount(BigDecimal amout) {
}

@Lock(value = [Link], time = 1, unit = TimeUni Validator
[Link])
BigDecimal getAmount() {
Quarkus uses Hibernate Validator to validate input/output of REST
}
services and business services using Bean validation spec.
}

./mvnw quarkus:add-extension
-Dextensions="[Link]:quarkus-hibernate-validator"
Annotate POJO objects with validator annotations such as: You can con gure how Quarkus logs:
@NotExpired
@NotNull , @Digits , @NotBlank , @Min , @Max , …
@JsonbDateFormat(value = "yyyy-MM-dd")
private LocalDate expired; [Link]=true
public class Sauce { [Link]=DEBUG
[Link]=false
@NotBlank(message = "Name may not be blank") [Link]."[Link]".level=DEBUG
private String name;
Manual Validation
@Min(0)
You can call the validation process manually instead of relaying to
private long scovilleHeatUnits;
@Valid by injecting Validator class. Pre x is [Link] .

// getter/setters category."<category-name>".level
} @Inject
Validator validator; Minimum level category (default: INFO )

level
To validate an object use @Valid annotation: Default minimum level (default: INFO )
And use it:
public Response create(@Valid Sauce sauce) {} [Link]
Set<ConstraintViolation<Sauce>> violations =
[Link](sauce); Console logging enabled (default: true )

If a validation error is triggered, a violation report is [Link]

generated and serialized as JSON. If you want to Format pattern to use for logging. Default value:
manipulate the output, you need to catch in the code the Localization
%d{yyyy-MM-dd HH:mm:ss,SSS} %-5p [%c{3.}] (%t) %s%e%n
ConstraintViolationException exception.
You can con gure the based locale for validation messages.
[Link]
Create Your Custom Constraints
[Link]-locale=ca-ES Minimum log level (default: INFO )
First you need to create the custom annotation: # Supported locales resolved by Accept-Language
[Link]=en-US,es-ES,fr-FR, ca_ES [Link]

@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, Allow color rendering (default: true )
PARAMETER, TYPE_USE })
ValidationMessages_ca_ES.properties [Link]
@Retention(RUNTIME)
@Documented
[Link]=No conforme al patro File logging enabled (default: false )
@Constraint(validatedBy = { [Link]})
public @interface NotExpired { [Link]

Format pattern to use for logging. Default value:
String message() default "Sauce must not be expired"; @Pattern(regexp = "A.*", message = "{[Link]}") %d{yyyy-MM-dd HH:mm:ss,SSS} %h %N[%i] %-5p [%c{3.}] (%t) %s%e%n
Class<?>[] groups() default { }; private String name;
Class<? extends Payload>[] payload() default { };
[Link]

} Minimum log level (default: ALL )
Bean Validation can be con gured . The pre x is:
[Link]-validator . [Link]

You need to implement the validator logic in a class that fail-fast

The path to log le (default: [Link] )
implements ConstraintValidator . When fail fast is enabled the validation will stop on the rst
[Link]-file-size
constraint violation detected. (default: false )
public class NotExpiredValidator The maximum le size of the log le
implements ConstraintValidator<NotExpired, LocalDate> [Link]-overriding-parameter-constraints
{ [Link]-backup-index
De ne whether overriding methods that override constraints
The maximum number of backups to keep (default: 1 )
should throw an exception. (default: false ).
@Override
public boolean isValid(LocalDate value, [Link]-suffix
[Link]-parameter-constraints-on-parallel-methods
ConstraintValidatorContext ctx) {
if ( value == null ) return true; De ne whether parallel methods that de ne constraints should Rotating log le su x.
LocalDate today = [Link](); throw an exception. (default: false ).
[Link]-on-boot
return [Link](today, value) > 0;
} [Link]-multiple-cascaded-validation-on-return- Indicates rotate logs at bootup (default: true )
} values
De ne whether more than one constraint on a return value may [Link]
be marked for cascading validation are allowed. (default: false ). Log asynchronously (default: false )
And use it normally:
Logging file async queue-length
 The queue length to use before ushing writing (default: 512 ) You can con gure the output to be in GELF format instead of plain JSON output is "pretty-printed" (default: false)
text.
[Link] [Link]-format
Action when queue is full (default: BLOCK ) ./mvnw quarkus:add-extension Specify the date format to use (default: the default format)
-Dextensions="quarkus-logging-gelf"
[Link] [Link]-delimiter
syslog logging is enabled (default: false ) Record delimiter to add (default: no delimiter)
[Link]
[Link] Enable GELF logging handler (default: false ) [Link]-id
The format pattern to use for logging to syslog. Default value: The time zone ID
%d{yyyy-MM-dd HH:mm:ss,SSS} %h %N[%i] %-5p [%c{3.}] (%t) %s%e%n [Link]
Hostname/IP of Logstash/Graylof. Prepend tcp: for using TCP [Link]-output-type
[Link] protocol. (default: udp:localhost ) The exception output type: detailed , formatted , detailed-and-
The minimum log level to write to syslog (default: ALL ) formatted (default: detailed )
[Link]
[Link] The port. (default: 12201 ) [Link]-details
The IP address and port of the syslog server (default: Detailed caller information should be logged (default: false)
localhost:514 ) [Link]
GELF version. (default: 1.1 ) Rest Client
[Link]-name
The app name used when formatting the message in RFC5424 [Link]-stack-trace Quarkus implements MicroPro le Rest Client spec:
format (default: current process name) Post Stack-Trace to StackTrace eld. (default: true )
./mvnw quarkus:add-extension
[Link] [Link]-trace-throwable-reference -Dextensions="quarkus-rest-client"
The name of the host the messages are being sent from (default: Gets the cause level to stack trace. 0 is fulls tack trace. (default:
current hostname) 0)
To get content from [Link]
[Link] [Link]-stack-trace you need to create a service interface:
Priority of the message as de ned by RFC-5424 and RFC-3164 Stack-Trace ltering. (default: false )
(default: USER_LEVEL ) @Path("/api")
[Link]-pattern @RegisterRestClient
[Link]-type public interface WorldClockService {
Java Date pattern. (default: yyyy-MM-dd HH:mm:ss,SSS )
The syslog type of format message (default: RFC5424 )
[Link]
@GET @Path("/json/cet/now")
[Link] @Produces(MediaType.APPLICATION_JSON)
Log level [Link] . (default: ALL ) WorldClock getNow();
Protocol used (default: TCP )

[Link]
@GET
[Link]-counting-framing
Name of the facility. (default: jboss-logmanage ) @Path("/json/{where}/now")
Message pre xed with the size of the message (default false ) @Produces(MediaType.APPLICATION_JSON)
[Link]-field.<field>.<subfield> WorldClock getSauce(@BeanParam
[Link] WorldClockOptions worldClockOptions);
Post additional elds. [Link]-
Message should be truncated (default: true ) [Link]=String
}
[Link]-on-reconnect JSON output
Block when attempting to reconnect (default: true )
You can con gure the output to be in JSON format instead of plain
text. public class WorldClockOptions {
[Link]
@HeaderParam("Authorization")
Log asynchronously (default: false ) String auth;
./mvnw quarkus:add-extension

[Link]-length -Dextensions="quarkus-logging-json"
@PathParam("where")
The queue length to use before ushing writing (default: 512 ) String where;
}
[Link] And the con guration values are pre x with [Link] :
Action when queue is full (default: BLOCK )
json
And con gure the hostname at [Link] :
Gelf ouput JSON logging is enabled (default: true).

[Link]-print
 [Link]/mp-rest/url=
Reactive import
[Link] [Link]
Rest Client also integrates with reactive library named Mutiny. To
ipartForm;
start using it you need to add the quarkus-rest-client-mutiny .

After that, a methodon a client interface can return a @Path("/echo")
Injecting the client:
[Link] instance. @RegisterRestClient
public interface MultipartService {
@RestClient
WorldClockService worldClockService; @GET @Path("/json/cet/now")
@POST
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.MULTIPART_FORM_DATA)
Uni<WorldClock> getNow();
@Produces(MediaType.TEXT_PLAIN)
If invokation happens within JAX-RS, you can propagate headers String sendMultipartData(@MultipartForm
from incoming to outgoing by using next property. MultipartBody data);
Multipart
}
[Link]=
It is really easy to send multipart form-data with Rest Client.
Authorization,MyCustomHeader

<dependency> SSL
<groupId>[Link]</groupId>
You can still use the JAX-RS client without any problem <artifactId>resteasy-multipart-provider</artifactId> You can con gure Rest Client key stores.
[Link]().target(…
) </dependency>

[Link]/mp-rest/trustStore=
Adding headers
classpath:/[Link]
You can customize the headers passed by implementing The model object: [Link]/mp-rest/trustStorePas
MicroPro le ClientHeadersFactory annotation: sword=
import [Link]; supersecret

@RegisterForReflection
public class BaggageHeadersFactory import [Link];
implements ClientHeadersFactory { import [Link]; Possible con guration properties:
@Override
public MultivaluedMap<String, String> update( import %s/mp-rest/trustStore
MultivaluedMap<String, String> incomingHeaders, [Link] Trust store location de ned with classpath: or file: pre x.
MultivaluedMap<String, String> outgoingHeaders) {} Type;
} %s/mp-rest/trustStorePassword
public class MultipartBody {

Trust store password.
@FormParam("file")
And registering it in the client using RegisterClientHeaders
@PartType(MediaType.APPLICATION_OCTET_STREAM) %s/mp-rest/trustStoreType
annotation. private InputStream file; Trust store type (default: JKS )

@RegisterClientHeaders([Link]) @FormParam("fileName") %s/mp-rest/hostnameVerifier
@RegisterRestClient @PartType(MediaType.TEXT_PLAIN) Custom hostname veri er class name. To disable SSL veri cation
public interface WorldClockService {} private String name; you can use [Link] .

// getter/setters
%s/mp-rest/keyStore
}
Or statically set: Key store location de ned with classpath: or file: pre x.

@GET %s/mp-rest/keyStorePassword
@ClientHeaderParam(name="X-Log-Level", value="ERROR") And the Rest client interface:
Key store password.
Response getNow();

%s/mp-rest/keyStoreType
Key store type (default: JKS )
Asynchronous
Timeout
A method on client interface can return a CompletionStage class to
be executed asynchronously. You can de ne the timeout of the Rest Client:

@GET @Path("/json/cet/now")
@Produces(MediaType.APPLICATION_JSON)
CompletionStage<WorldClock> getNow();
 [Link]/mp-rest/connectTimeou @QuarkusTest
You need to create a class implementing
t= @TestHTTPEndpoint([Link])
QuarkusTestResourceLifecycleManager interface and register it in the
1000 public class GreetingResourceTest {
test via @QuarkusTestResource annotation.
[Link]/mp-rest/readTimeout= @Test
2000 public void testHelloEndpoint() {
given() public class MyCustomTestResource
.when().get() implements QuarkusTestResourceLifecycleManager {
.then()
Instantiate client programmatically @Override
.statusCode(200)
.body(is("hello")); public Map<String, String> start() {
MovieReviewService reviewSvc = [Link] } // return system properties that
() } // should be set for the running test
.baseUri(apiUri) return [Link]();
.build([Link]); }

Root path is calculated automatically, not necessary to explicitly @Override
set. public void stop() {
Testing }
If you want any changes made to be rolled back at the end ofthe
Quarkus archetype adds test dependencies with JUnit 5 and Rest- test you can use the [Link] annotation.
// optional
Assured library to test REST endpoints. @Override
QuarkusTestPro le
public void inject(Object testInstance) {
@QuarkusTest You can de ne for each Test class a different con guration options. }
public class GreetingResourceTest {
// optional
@Test This implies that the Quarkus service is restarted. @Override
public void testHelloEndpoint() { public int order() {
given() return 0;
.when().get("/hello") public class MyProfile implements [Link] }
.then() rkusTestProfile { }
.statusCode(200)
.body(is("hello")); @Override
} public Map<String, String> getConfigOverrides() {
} return [Link]("[Link]", "This is a Test" Returning new system properties implies running parallel
); tests in different JVMs.
}
And the usage:
Test port can be set in [Link]-port property. Timeout @Override
can be set in [Link]-timeout property. public String getConfigProfile() { @QuarkusTestResource([Link])
return "my-test-profile"; public class MyTest {
You can also inject the URL where Quarkus is started: } }
}
@TestHTTPResource("[Link]")
URL url; @QuarkusTest
@TestProfile([Link]) Testing Callbacks
public class MyTestClass {
You can enrich all your @QuarkusTest classes by implementing the
}
@TestHTTPEndpoint([Link]) following callback interfaces:
@TestHTTPResource
URL url; [Link]
Quarkus Test Resource
[Link]
You can execute some logic before the rst test run ( start ) and back
execute some logic at the end of the test suite ( stop ).
[Link]

[Link]

public class SimpleAnnotationCheckerBeforeClassCallback imp

lements QuarkusTestBeforeClassCallback {
@Override
public void beforeClass(Class<?> testClass) {
}
}
And needs to be registered as Java SPI: To Mock REST Client, you need to de ne the interface with Persistence
@ApplicationScope :
META-
INF/services/[Link] Quarkus works with JPA(Hibernate) as persistence solution. But
@ApplicationScoped also provides an Active Record pattern implementation under
[Link] @RegisterRestClient Panache project.
ck public interface GreetingService {
} To use database access you need to add Quarkus JDBC drivers
instead of the original ones. At this time Apache Derby , H2 , MariaDB ,
Mocking @InjectMock MySQL , MSSQL and PostgreSQL drivers are supported.
@RestClient
If you need to provide an alternative implementation of a service GreetingService greetingService; ./mvnw quarkus:add-extension
(for testing purposes) you can do it by using CDI @Alternative -Dextensions="[Link]:quarkus-hibernate-orm-panache,
annotation using it in the test service placed at src/test/java : [Link]([Link]()).thenReturn("hello fro [Link]:quarkus-jdbc-mariadb"
m mockito");
@Alternative
@Priority(1)
@Entity
@ApplicationScoped Interceptors
public class MockExternalService extends ExternalService {} public class Developer extends PanacheEntity {
Tests are actually full CDI beans, so you can apply CDI interceptors:
// id field is implicit

@QuarkusTest
public String name;
This does not work when using native image testing. @Stereotype
}
@Transactional
@Retention([Link])
A stereotype annotation [Link] is provided declaring
@Target([Link])
@Alternative , @Priority(1) and @Dependent .
public @interface TransactionalQuarkusTest { And con guration in src/main/resources/[Link] :
}
Mockito
[Link]=jdbc:mariadb://localhost:3306/m
Instead of creating stubs, you can also create mocks of your @TransactionalQuarkusTest ydb
services with mockito. Add the following dependency public class TestStereotypeTestCase {} [Link]-kind=mariadb
[Link]:quarkus-junit5-mockito : [Link]=developer
[Link]=developer
@InjectMock Test Coverage Due the nature of Quarkus to calculate correctly the [Link]=update
GreetingService greetingService; coverage information with JaCoCo, you might need o ine
instrumentation. I recommend reading this document to
@BeforeEach understand how JaCoCo and Quarkus works and how you can List of datasource parameters.
public void setup() { con gure JaCoCo to get correct data.
[Link]([Link]()).thenReturn("Hi"); [Link] as pre x is skipped in the next table.
} Native Testing
db-kind
To test native executables annotate the test with @NativeImageTest .
@Path("/hello") Built-in datasource kinds so the JDBC driver is resolved
public class ExampleResource { automatically. Possible values: derby , h2 , mariadb , mssql , mysql ,
postgresql , db2 .
@Inject
GreetingService greetingService; username
}
Username to access.

password
Mock is automatically injected and only valid for the de ned test Password to access.
class.
driver
Also spy is supported:
JDBC Driver class. It is not necessary to set if db-kind used.
@InjectSpy
credentials-provider
GreetingService greetingService;
Sets a custom credential provider name.
[Link](greetingService, [Link](1)).greet();
credentials-provider-name
It is the @Named value of the credentials provider bean. Not
REST Client necessary if only one implementation.
[Link] dialect Number of rows fetched at a time.
The datasource URL. Class name of the Hibernate ORM dialect.
[Link]-batch-size
[Link]-size [Link]-engine Number of updates sent at a time.
The datasource pool minimum size. (default: 0 ) The storage engine when the dialect supports multiple storage
engines. [Link]
[Link]-size Show SQL logs (default: false )
The datasource pool maximum size. (default: 20 ) sql-load-script
Name of the le containing the SQL statements to execute when [Link]-warnings
[Link]-size starts. no-file force Hibernate to skip SQL import. (default: statistics
[Link] )
The initial size of the pool. Enable statiscs collection. (default: false )

batch-fetch-size
[Link]-validation-interval physical-naming-strategy
The interval at which we validate idle connections in the The size of the batches. (default: -1 disabled) Class name of the Hibernate PhysicalNamingStrategy
background. (default: 2M ) implementation.
maxFetchDepth

[Link]-timeout The maximum depth of outer join fetch tree for single-ended globally-quoted-identifiers
The timeout before cancelling the acquisition of a new associations. Should quote all identi ers. (default: false )
connection. (default: 5 )
multitenant
metrics-enabled
[Link]-detection-interval De nes the method for multi-tenancy. Possible values: DATABASE , Metrics published with smallrye-metrics extension (default:
NONE , SCHEMA . (default: NONE )
The interval at which we check for connection leaks. false )

multitenant-schema-datasource
[Link]-removal-interval second-level-caching-enabled
The interval at which we try to remove idle connections. (default: De nes the name of the data source to use in case of SCHEMA Enable/Disable 2nd level cache. (default: true )
5M )
approach.
Database operations:
[Link]-plan-cache-max-size
[Link]-lifetime
The max lifetime of a connection. The maximum size of the query plan cache. // Insert
Developer developer = new Developer();
[Link]-null-ordering [Link] = "Alex";
[Link]-isolation-level
The transaction isolation level. Possible values: UNDEFINED , NONE , Default precedence of null values in ORDER BY . Possible values: [Link]();
none , first , last . (default: none )
READ_UNCOMMITTED , READ_COMMITTED , REPEATABLE_READ , SERIALIZABLE .
// Find All
[Link] [Link]().list();
[Link]-statement-leaks
Database schema is generation. Possible values: none , create ,

Warn when a connection is returned to the pool without the // Hibernate Filters
drop-and-create , drop , update . (default: none )
application having closed all open statements. (default: true ) [Link]().filter("[Link]", [Link](
"name", "Alex"));
[Link]-on-error
[Link]-connection-sql
Query executed when rst using a connection. Stop on the rst error when applying the schema. (default: false ) // Find By Query
[Link]("name", "Alex").firstResult();
[Link]-schemas
[Link]-query-sql
Query executed to validate a connection. Hibernate ORM should create the schemas automatically (for // Delete
databases supporting them). Developer developer = new Developer();
[Link] = 1;
[Link]-enabled
[Link]-catalog [Link]();
Disable pooling to prevent reuse of Connections. (default: true )
Default catalog.
[Link](id);
[Link]-metrics // Delete By Query
[Link]-schema
Enable datasource metrics collection when using quarkus- long numberOfDeleted = [Link]("name", "Alex");
smallrye-metrics extension.
Default Schema.

[Link]
[Link]-jdbc-properties.<extraProperty>
Remember to annotate methods with @Transactional annotation to
Unspeci ed properties to be passed to the JDBC driver when Charset.
make changes persisted in the database.
creating new connections.
[Link] If queries start with the keyword from then they are treated as HQL
Hibernate con guration properties. Pre x [Link]-orm is Time Zone JDBC driver. query, if not then next short form is supported:
skipped.
[Link]-fetch-size order by which expands to from EntityName order by …
 <columnName> which expands to from EntityName where count : String , [ Object… , Map<String, Object> , Parameters ] If entities are de ned in external JAR, you need to enable in these
<columnName>=? Number of entities meeting given query with parameters set. projects the Jandex plugin in project.

<query> which is expanded to from EntityName where <query>

Enables a Hibernate lter during fetching of results for this query. <plugin>
<groupId>[Link]</groupId>
Static Methods
deleteAll <artifactId>jandex-maven-plugin</artifactId>
findById : Object Number of deleted entities. <version>1.0.3</version>
<executions>
Returns object or null if not found. Overloaded version with
delete : String , [ Object… , Map<String, Object> , Parameters ] <execution>
LockModeType is provided.
<id>make-index</id>
Number of deleted entities meeting given query with parameters
<goals>
findByIdOptional : Optional<Object> set.
<goal>jandex</goal>
Returns object or [Link] . </goals>
deleteById : boolean , [ Object ]
</execution>
find : String , [ Object… , Map<String, Object> , Parameters ] Delete by id. Returns if deleted or not. </executions>
Lists of entities meeting given query with parameters set. <dependencies>
Returning a PanacheQuery . persist : [ Iterable , Steram , Object… ] <dependency>
Persist object. <groupId>[Link]</groupId>
find : String , Sort , [ Object… , Map<String, Object> , Parameters ] <artifactId>jandex</artifactId>
In case of using streams, remember to close them or use a <version>[Link]</version>
Lists of entities meeting given query with parameters set sorted
try/catch block: try (Stream<Person> persons = [Link]()) . </dependency>
by Sort attribute/s. Returning a PanacheQuery .
</dependencies>
find
methods de nes a withLock(LockModeType) to de ne </plugin>
findAll
the lock type and withHint(QueryHints.HINT_CACHEABLE,
Finds all entities. Returning a PanacheQuery . "true") to de ne hints.
Panache includes an annotation processor that enhance your
findAll : Sort Named Queries entities. If you disable annotation processors you might need to
Finds all entities sorted by Sort attribute/s. Returning a create a marker le on Panache archives at META-INF/panache-
PanacheQuery . @Entity [Link] manually.
@NamedQuery(name = "[Link]", query = "from Person
list : String , [ Object… , Map<String, Object> , Parameters ] where name = :name") Testing
Lists of entities meeting given query with parameters set. public class Person extends PanacheEntity {
To mock using active record pattern:
Returning a List .
public static Person findByName(String name){
list : String , Sort , [ Object… , Map<String, Object> , Parameters ] return find("#[Link]", name).firstResult <dependency>
(); <groupId>[Link]</groupId>
Lists of entities meeting given query with parameters set sorted
} <artifactId>quarkus-panache-mock</artifactId>
by Sort attribute/s. Returning a List .
} <scope>test</scope>
</dependency>
listAll
Finds all entities. Returning a List .
Pagination
listAll : Sort @Test
PanacheQuery<Person> livingPersons = Person public void testPanacheMocking() {
Finds all entities sorted by Sort attribute/s. Returning a List .
.find("status", [Link]); [Link]([Link]);
[Link]([Link](25));
stream : String , [ Object… , Map<String, Object> , Parameters ]
[Link]([Link]()).thenReturn(23l);
[Link] of entities meeting given query with // get the first page [Link](23, [Link]());
parameters set. List<Person> firstPage = [Link](); [Link]([Link], [Link](1)).coun
// get the second page t();
stream : String , Sort , [ Object… , Map<String, Object> , Parameters ] List<Person> secondPage = [Link]().list(); }
[Link]
of entities meeting given query with
parameters set sorted by Sort attribute/s.
Range DAO pattern
streamAll
[Link] of all entities. Also supports DAO pattern with PanacheRepository<TYPE> .
PanacheQuery<Person> livingPersons = Person
.find("status", [Link]);
streamAll : Sort List<Person> secondRange = [Link](25, 49).list
[Link] of all entities sorted by Sort attribute/s. ();

count
Number of entities You cannot mix pagination and range
 You can implement your custom credentials provider (ie Azure
@ApplicationScoped @QuarkusTestResource([Link])
public class DeveloperRepository public class FlywayTestResources {
KeyVault) to provide a username/password for the database
connection. Name information is not necessary if there is only one
implements PanacheRepository<Person> { }
custom credential provider.
public Person findByName(String name){
return find("name", name).firstResult();
} @ApplicationScoped
Transactions
} @Unremovable
@Named("my-credentials-provider")
The easiest way to de ne your transaction boundaries is to use the
public class CustomCredentialsProvider implements Credentia
@Transactional annotation.
lsProvider {
EntityManager You can inject EntityManager in your classes: @Inject
Transactions are mandatory in case of none idempotent
operations. Config config;
@Inject
EntityManager em; @Override
@Transactional
public Properties getCredentials(String credentials
[Link](car); public void createDeveloper() {}
ProviderName) {

[Link](CredentialsProvider.USER_PROPERTY_NA
Multiple datasources You can control the transaction scope: ME, "hibernate_orm_test");
[Link]([Link]
You can register more than one datasource. @Transactional(REQUIRED) (default): starts a transaction if none _PROPERTY_NAME, "hibernate_orm_test");
was started, stays with the existing one otherwise.
}
# default @Transactional(REQUIRES_NEW) : starts a transaction if none was
}
[Link]-kind=h2 started; if an existing one was started, suspends it and starts a
[Link]=jdbc:h2:tcp://localhost/mem:def new one for the boundary of that method.
ault
.... @Transactional(MANDATORY) : fails if no transaction was started ; [Link]-provider=
# users datasource works within the existing transaction otherwise. custom
[Link]-kind=h2
[Link]-provider-name=
[Link]..[Link]=jdbc:h2:tcp://localhost/ @Transactional(SUPPORTS) : if a transaction was started, joins it ;
my-credentials-provider
mem:users otherwise works with no transaction.

@Transactional(NOT_SUPPORTED) :
if a transaction was started,
suspends it and works with no transaction for the boundary of Hibernate Multitenancy
Notice that after datasource you set the datasource name, in
the method; otherwise works with no transaction.
previous case users . Multitenancy is supported using Schema or Database approach.
@Transactional(NEVER) : if a transaction was started, raises an First you need to de ne how tenant is identi ed:
You can inject then AgroalDataSource with
exception; otherwise works with no transaction.
[Link] .
@RequestScoped
You can con gure the default transaction timeout using
@Unremovable
@DataSource("users") [Link]-transaction-timeout
public class CustomTenantResolver implements TenantResolver
AgroalDataSource dataSource1; con guration property. By default it is set to 60 seconds.
{

You can set a timeout property, in seconds, that applies to
@Inject
transactions created within the annotated method by using
Flushing RoutingContext context;
@TransactionConfiguration annotation.

You can force ush operation by calling .flush() or @Override
.persistAndFlush() to make it in a single call. @Transactional public String getDefaultTenantId() {
@TransactionConfiguration(timeout=40) return "base";
This ush is less e cient and you still need to commit public void createDeveloper() {} }
transaction.
@Override
Testing If you want more control over transactions you can inject public String resolveTenantId() {
UserTransaction and use a programmatic way. }
There is a Quarkus Test Resource that starts and stops H2 server
before and after test suite. }
@Inject UserTransaction transaction

Register dependency [Link]:quarkus-test-h2:test .
[Link]();
And annotate the test: [Link](); Schema approach
[Link]();
 [Link]=none public interface DeveloperResource extends PanacheRepositor @Entity
yResource<DeveloperRepository, Developer, Long> { @Table(name = "dev")
[Link]=SCHEMA } public class Developer {
}

@Inject
Database approach Quarkus will generate automatically the implementation for you
CompletionStage<[Link]> stageSession;
following the next rules:

[Link]=none @Inject

Default path is a hyphenated lowercase resource name
without a su x of resource or controller . Uni<[Link]> mutinySession;
[Link]=DATABASE

get(@PathParam("id")) , list , add(Developer) , public Uni<Long> reactivePersist() {
# default tenant
update(@PathParam("id"), Developer) , delete(@PathParam("id")) return mutinySession
[Link]-kind=postgresql .flatMap(s -> [Link](new Developer(1, "Alex"))
[Link]=quarkus_test You can customize these defaults by using @ResourceProperties and .flatMap(v -> [Link]())
... @MethodProperties annotations. ....
# Tenant 'mycompany'
[Link]-kind=postgresql }
@ResourceProperties(hal = true, path = "my-developer")
[Link]=mycompany
public interface DeveloperResource extends PanacheEntityRes
[Link]=classpath:database/mycom public CompletionStage<Developer> reactiveFind() {
ource<Developer, Long> {
pany return stageSession
@MethodProperties(path = "all")
... .thenCompose(session -> {
List<Developer> list();
@MethodProperties(exposed = false) [Link]([Link], 1);
void delete(Long id); });
If you need more dynamic approach implement: @ApplicationScoped } }
[Link]

Hibernate Envers If hal is true , you need to send the Accept: application/hal+json In nispan
HTTP header to get the response.
Quarkus supports Hibernate Envers. Quarkus integrates with In nispan:
Hibernate Reactive
./mvnw quarkus:add-extension
./mvnw quarkus:add-extension
-Dextensions="hibernate-envers"
./mvnw quarkus:add-extension -Dextensions="infinispan-client"
-Dextensions="quarkus-hibernate-reactive, quarkus-resteas
y-mutiny, "
REST Data Panache Serialization uses a library called Protostream.

REST Data with Panache extension can generate the basic CRUD Annotation based
Also you need to add the reactive driver (ie quarkus-reactive-pg-
endpoints for your entities and repositories. client ).
@ProtoFactory
./mvnw quarkus:add-extension You can use: [Link] or public Author(String name, String surname) {
-Dextensions="hibernate-orm-rest-data-panache" [Link] . [Link] = name;
[Link] = surname;
}

You also need to add the JDBC driver extension and a JSON
@ProtoField(number = 1)
Marshaller (ie resteasy-jackson ).
public String getName() {
return name;
Then you can de ne interfaces for de ning endpoints:
}
In case of Active Record pattern:
@ProtoField(number = 2)
public String getSurname() {
public interface DeveloperResource extends PanacheEntityRes
return surname;
ource<Developer, Long> {
}
}

Initializer to set con guration settings.

In case of Repository:
 @AutoProtoSchemaBuilder(includeClasses = public class AuthorMarshaller
Con guration in [Link] :
{ [Link], [Link] }, implements MessageMarshaller<Author> {
schemaPackageName = "book_sample")
interface BookContextInitializer @Override <local-cache name="quarkus-transaction">
extends SerializationContextInitializer { public String getTypeName() { <transaction
} return "book_sample.Author"; transaction-manager-lookup=
} "[Link]
TAManagerLookup"/>
@Override </local-cache>
User written based
public Class<? extends Author> getJavaClass() {
There are three ways to create your schema: return [Link];
} Set con guration le location in [Link] :
Proto le
@Override
[Link]-config=[Link]
Creates a .proto le in the META-INF directory. public void writeTo(ProtoStreamWriter writer,
Author author) throws IOException {
package book_sample; [Link]("name", [Link]());
[Link]("surname", [Link]()); And you can inject the main entry point for the cache:
message Author { }
required string name = 1; @Inject
required string surname = 2; @Override [Link] cacheManager;
} public Author readFrom(ProtoStreamReader reader)
throws IOException {
String name = [Link]("name");
String surname = [Link]("surname"); Redis
In case of having a Collection eld you need to use the repeated key return new Author(name, surname);
(ie repeated Author authors = 4 ). } Quarkus integrates with Redis.
}
In code
./mvnw quarkus:add-extension
Setting proto schema directly in a produced bean. -Dextensions="redis-client"
And producing the marshaller:
@Produces
FileDescriptorSource bookProtoDefinition() { @Produces Con gure Redis location:
return FileDescriptorSource MessageMarshaller authorMarshaller() {
.fromString("[Link]", return new AuthorMarshaller(); [Link]=localhost:6379
"package book_sample;\n" + }
"message Author {\n" +
" required string name = 1;\n" +
" required string surname = 2;\n" +
You can use synchronous or reactive clients:
In nispan Embedded
"}");
} @Inject
./mvnw quarkus:add-extension RedisClient redisClient;
-Dextensions="infinispan-embeddedy"
@Inject
Marshaller
ReactiveRedisClient reactiveRedisClient;

Using [Link] interface.

 void increment(String key, Integer incrementBy) { Flyway sql-migration-prefix

[Link](key, [Link]()); Pre x for versioned SQL migrations (default: V )

} Quarkus integrates with Flyway to help you on database schema
migrations. repeatable-sql-migration-prefix:: Pre x for repeatable SQL
Uni<List<String>> keys() { migrations (default: R )
return reactiveRedisClient ./mvnw quarkus:add-extension
.keys("*") baseline-on-migrate
-Dextensions="quarkus-flyway"
.map(response -> { Only migrations above baseline-version will then be applied
List<String> result = new ArrayList<>();
for (Response r : response) { baseline-version
[Link]([Link]());
Then place migration les to the migrations folder
( classpath:db/migration ). Version to tag an existing schema with when executing baseline
}
(default: 1)
return result;
You can inject [Link] to programmatically
});
execute the migration. baseline-description
}
Description to tag an existing schema with when executing
@Inject baseline (default: Flyway Baseline )
Flyway flyway;
Multiple Redis Clients validate-on-migrate
[Link](); Validate the applied migrations against the available ones
[Link] = localhost:6379
(default: true )
[Link] = localhost:6379

Or can be automatically executed by setting migrate-at-start placeholder-prefix

property to true . Pre x of every placeholder (default: ${ )
@Inject
RedisClient defaultRedisClient; [Link]-at-start=true placeholder-suffix
Su x of every placeholder (default: } )
@Inject
@RedisClientName("second") Multiple Datasources
List of Flyway parameters.
RedisClient redisClient2;
[Link] as pre x is skipped in the next table. To use multiple datasource in Flyway you just need to add the
datasource name just after the flyway property:
clean-at-start
List of Redis parameters.
Execute Flyway clean command (default: false ) [Link]=jdbc:h2:tcp://localhost/m
[Link] as pre x is skipped in the next table. em:users
migrate-at-start [Link]=jdbc:h2:tcp://localho
[Link] st/mem:inventory
Flyway migration automatically (default: false )
Health check is published in case the smallrye-health extension # ...
is present. (default: true ) locations

[Link]=USERS_TEST_SCHEMA
CSV locations to scan recursively for migrations. Supported [Link]=INVENTORY_TEST_SCHEMA
password
pre xes classpath and filesystem (default:
The Redis password. # ...
classpath:db/migration ).

hosts connect-retries
The Redis hosts. (default: localhost:6379 ) The maximum number of retries when attempting to connect Liquibase
(default: 0)
database Quarkus integrates with Liquibase to help you on database schema
The Redis database. schemas migrations.
CSV case-sensitive list of schemas managed (default: none)
timeout ./mvnw quarkus:add-extension
The maximum delay to wait before a blocking command to redis table -Dextensions="quarkus-liquibase"
server times out. (default: 10s ) The name of Flyway’s schema history table (default:
flyway_schema_history )
ssl Then place changelog les to the ( src/main/resources/db ) folder.
Enables or disables the SSL on connect. out-of-order
You can inject [Link] to
Allows migrations to be run "out of order". programmatically execute the migration.
clinet-type
The Redis client type. Possible values: standalone , cluster , ignore-missing-migrations
sentinel (default: standalone ) Ignore missing migrations when reading the history table.
 liquibase-schema-name
@Inject public class MyQuarkusAnalysisConfigurer
LiquibaseFactory liquibaseFactory; The liquibase tables schema name. implements ElasticsearchAnalysisConfigurer {

try (Liquibase liquibase = [Link] liquibase-tablespace-name @Override
()) { The liquibase tables tablespace name. public void configure(
... ElasticsearchAnalysisDefinitionContainerContext ct
} Multiple Datasources x)
{
To use multiple datasource in Liquibase you just need to add the [Link]("english").custom()

Or can be automatically executed by setting migrate-at-start

datasource name just after the liquibase property: .withTokenizer("standard")
.withTokenFilters("asciifolding",
property to true .
"lowercase", "porter_stem");
[Link]=jdbc:h2:tcp://localhost/m

[Link]-at-start=true em:users
[Link]("sort").custom()
[Link]=jdbc:h2:tcp://localho
.withTokenFilters("asciifolding", "lowercase");
st/mem:inventory
}
# ...
List of Liquibase parameters.
}

[Link]=USERS_TEST_SCHEMA
[Link] as pre x is skipped in the next table.
[Link]=INVENTORY_TEST_SCHEMA

change-log
# ... Use Hibernate Search in REST service:
The change log le. XML , YAML , JSON , SQL formats supported.
public class LibraryResource {
(default: db/[Link] )
Hibernate Search
@Inject
change-log-parameters."<parameter-name>"
EntityManager em;
Liquibase changelog parameters. Quarkus integrates with Elasticsearch to provide a full-featured full-

text search using Hibernate Search API.
@Transactional
migrate-at-start public List<Author> searchAuthors(
The migrate at start ag. (default: false ) ./mvnw quarkus:add-extension @QueryParam("pattern") String pattern) {
-Dextensions="quarkus-hibernate-search-elasticsearch" return [Link](em)
validate-on-migrate .search([Link])
.predicate(f ->
The validate on update ag. (default: false )
You need to annotate your model with Hibernate Search API to pattern == null || [Link]() ?

clean-at-start index it: [Link]() :

[Link]()
The clean at start ag. (default: false ) .onFields("firstName",
@Entity
"lastName", "[Link]")
@Indexed
contexts .matching(pattern)
public class Author extends PanacheEntity {
The list of contexts.
)
.sort(f -> [Link]("lastName_sort")
@FullTextField(analyzer = "english")
labels public String bio;
.then().byField("firstName_sort"))
.fetchHits();
The list of labels.
}
@FullTextField(analyzer = "name")
database-change-log-table-name @KeywordField(name = "firstName_sort",
The database change log lock table name. (default: sortable = [Link],
DATABASECHANGELOG )
normalizer = "sort") When not using Hibernate ORM, index data using
public String firstName; [Link](em).createIndexer()
database-change-log-lock-table-name .startAndWait() at startup time.
@OneToMany
The database change log lock table name. (default: @IndexedEmbedded Con gure the extension in [Link] :
DATABASECHANGELOGLOCK )
public List<Book> books;

default-catalog-name [Link]=7
}
[Link].
The default catalog name. analysis-configurer=MyQuarkusAnalysisConfigurer
[Link].
default-schema-name [Link]-strategy=searchable
The default schema name. It is not mandatory to use Panache. [Link].
[Link]=drop-and-create
liquibase-catalog-name You need to de ne the analyzers and normalizers de ned in [Link].
The liquibase tables catalog name. [Link]-status=yellow
annotations. You only need to implement
ElasticsearchAnalysisConfigurer interface and con gure it.
List of Hibernate-Elasticsearch properties pre xed with Waiting time before failing the bootstrap.
@Inject
[Link] :
DynamoDbAsyncClient dynamoDB;
[Link]-after-write

backends
Set if index should be refreshed after writes. [Link]().completionStage(() -> [Link](scanRe
Map of con guration of additional backends. quest()))....
Possible annotations:
version

Version of Elasticsearch @Indexed

To use it as a local DynamoDB instance:
Register entity as full text index
analysis-configurer
[Link]=
Class or name of the neab used to con gure. @FullTextField
eu-central-1
Full text search. Need to set an analyzer to split tokens. [Link]-override=
hosts [Link]
List of Elasticsearch servers hosts. @KeywordField [Link]=STATIC
The string is kept as one single token but can be normalized. [Link]-provider
username .access-key-id=test-key
[Link]-provider
Username for auth. IndexedEmbedded
.secret-access-key=test-secret
Include the Book elds into the Author index.
password
Password for auth. @ContainerExtraction
Sets how to extract a value from container, e.g from a Map . If you want to work with an AWS account, you’d need to set it with:
connection-timeout
Duration of connection timeout. @DocumentId [Link]=<YOUR_REGION>
[Link]=DEFAULT
Map an unusual entity identi er to a document identi er.
max-connections

Max number of connections to servers. @GenericField

DEFAULT credentials provider chain:
Full text index for any supported type.
max-connections-per-route
System properties [Link] , [Link]
Max number of connections to server. @IdentifierBridgeRef
Reference to the identi er bridge to use for a @DocumentId . Env. Varables AWS_ACCESS_KEY_ID , AWS_SECRET_ACCESS_KEY
indexes
Per-index speci c con guration. @IndexingDependency Credentials pro le ~/.aws/credentials
How a dependency of the indexing process to a property should
Credentials through the Amazon EC2 container service if the
[Link] affect automatic reindexing.
AWS_CONTAINER_CREDENTIALS_RELATIVE_URI set
Enables automatic discovery.
@ObjectPath Credentials through Amazon EC2 metadata service.
[Link]-interval @ScaledNumberField
Con guration parameters pre xed with [Link] :
Refresh interval of node list. For [Link] or [Link] that you need
higher precision.
[Link]-scheme Parameter Default Description
Scheme to be used for the new nodes. Amazon DynamoDB
[Link]-strategy Quarkus integrates with [Link] Endpoint discovery
Status for which you wait before considering the operation enable-endpoint- for a service API that
false
completed ( queued , committed or searchable ). discovery supports endpoint
./mvnw quarkus:add-extension
discovery.
-Dextensions="quarkus-amazon-dynamodb"
[Link]-dirty-check
When enabled, re-indexing of is skipped if the changes are on Con gure the
properties that are not used when indexing. endpoint with which
@Inject endpoint-override
DynamoDbClient dynamoDB;
the SDK should
[Link] communicate.
Index lifecycle ( none , validate , update , create , drop-and-create ,
drop-abd-create-drop )
To use asycnhronous client with Mutiny: Time to complete an
api-call-timeout
[Link]-status
execution.
./mvnw quarkus:add-extension
Minimal cluster status ( green , yellow , red )
-Dextensions="quarkus-amazon-dynamodb, resteasy-mutiny"
interceptors List of class
index-defaults lifecycle required-status-wait-timeout interceptors
 Parameter Default Description Parameter Default Description
Con guration parameters pre xed with [Link] :
Command to execute [Link] false Enables HTTP proxy.
process-
Parameter Default Description to retrieve
[Link]
credentials.
[Link] Proxy username.
Region that hosts
region
DynamoDB.
process-
Max bytes to retrieve
[Link]- 1024 [Link] Proxy password.
from process.
output-limit
Credentials that
should be used For NTLM, domain
DEFAULT , STATIC , [Link]-domain
The amount of time name.
SYSTEM_PROPERTY , process-
[Link] DEFAULT between credentials
ENV_VARIABLE , [Link]- PT15S
expire and
PROFILE , CONTAINER , refresh-threshold
For NTLM,
credentials refreshed. [Link]-
INSTANCE_PROFILE , workstation workstation name.
PROCESS , ANONYMOUS

process-
[Link]- Should fetch [Link]-
Authenticate pre-
Credentials speci c parameters pre xed with false
credential-update- credentials async. basic-authentication-
emptively.
[Link] :
enabled enabled

Parameter Default Description

In case of synchronous client, the next parameters can be [Link]-proxy- List of non proxy
DEFAULT con gured pre xed by [Link]-client : hosts hosts.

Parameter Default Description

default- TLS manager: none ,
tls-managers-
[Link]- Should fetch system-property system-property ,
false connection- Connection [Link]
credential-update- credentials async. 10S file-store
acquisition-timeout acquisation timeout.
enabled

Max time to tls-managers-

default- Should reuse the last connection-max-idle- [Link]- Path to key store.
60S connection to be
[Link]-last- true successful time [Link]
opened.
provider-enabled credentials.

connection-timeout Connection timeout. tls-managers-

STATIC [Link]- Key store type.
[Link]
connection-time-to- Max time connection
static- 0
live to be open.
[Link]-key- AWS access key id. tls-managers-
id [Link]- Key store password.
socket-timeout 30S Time to wait for data. [Link]

static-
AWS secret access
[Link]-
key. max-connections 50 Max connections. In case of asynchronous client, the next parameters can be
access-key con gured pre xed by [Link]-client :

Client send an HTTP Parameter Default Description

PROFILE expect-continue-
true expect-continue
enabled
handsake. connection- Connection
10S
acquisition-timeout acquisation timeout.
profile- The name of the
default
[Link]-name pro le to use. Connections in pool
use-idle-connection-
true should be closed Max time to
reaper connection-max-idle-
asynchronously. 60S connection to be
PROCESS time
opened.

Endpoint of the proxy

[Link]
server. connection-timeout Connection timeout.
Parameter Default Description Parameter Default Description @Inject
S3AsyncClient s3AsyncClient;
connection-time-to- Max time connection Enable custom event
0 [Link] false
live to be open. loop conf.
And you need to add the asynchronous Netty client:
Max number of [Link]-of- Number of threads to
max-concurrency 50 concurrent threads use in event loop. <dependency>
connections. <groupId>[Link]</groupId>
<artifactId>netty-nio-client</artifactId>
[Link]- aws-java-sdk- Pre x of thread </dependency>
Connections in pool name-prefix NettyEventLoop names.
use-idle-connection-
true should be closed
reaper
asynchronously.
Con guration properties are the same as Amazon DynamoDB but
Amazon S3 changing the pre x from dynamodb to s3 .
read-timeout 30S Read timeout.
./mvnw quarkus:add-extension Neo4j
-Dextensions="quarkus-amazon-s3"
write-timeout 30S Write timeout. Quarkus integrates with Neo4j:

./mvnw quarkus:add-extension
Endpoint of the proxy @Inject
-Dextensions="quarkus-neo4j"
[Link]
server. S3Client s3Client;

[Link] false Enables HTTP proxy. You need to set a HTTP client either URL Connection : @Inject
[Link] driver;

[Link]-proxy- List of non proxy <dependency>

hosts hosts. <groupId>[Link]</groupId>
<artifactId>url-connection-client</artifactId> Con guration properties:
</dependency>
TLS manager: none , quarkus.neo4j as pre x is skipped in the next table.
tls-managers-
system-property system-property ,
[Link] Pre x is quarkus.neo4j .
file-store or Apache HTTP:
uri
<dependency> URI of Neo4j. (default: localhost:7687 )
tls-managers-
<groupId>[Link]</groupId>
[Link]- Path to key store.
<artifactId>apache-client</artifactId> [Link]
[Link]
</dependency>
Username. (default: neo4j )

tls-managers- [Link]
[Link]- Key store type.
[Link]=apache Password. (default: neo4j )
[Link]

[Link]
tls-managers- And con gure it: Disable authentication. (default: false )
[Link]- Key store password.
[Link] [Link]-override=[Link] [Link]-enabled
[Link]=[Link].s3.S3ModifyRes Enable metrics. (default: false )
ponse
SSL Provider ( jdk , [Link]=us-east-1 [Link]-leaked-sessions
ssl-provider openssl , openssl-
[Link]=static
refcnt ). Enable leaked sessions logging. (default:`false`)
[Link]-key-id=te
st-key
[Link]-connection-pool-size
[Link]-access-ke
Sets the HTTP Max amount of connections. (default: 100 )
protocol HTTP_1_1 y=test-secret
protocol.
[Link]-connection-lifetime

Max number of You can inject asynchronous client too: Pooled connections older will be closed and removed from the
max-http2-streams
concurrent streams. pool. (default: 1H )
[Link]-acquisition-timeout
./mvnw quarkus:add-extension Parameter Type Description
Timout for connection adquisation. (default: 1M) -Dextensions="quarkus-mongodb-client"
max-connection-idle- Idle time of a pooled
Duration
[Link]-time-before-connection-test time connection.
Pooled connections idled in the pool for longer than this timeout
@Inject
will be tested before they are used. (default: -1 )
[Link] client; max-connection-life- Life time of pooled
Duration
time connection.
As Neo4j uses SSL communication by default, to create a native
@Inject
executable you need to compile with next options GraalVM options:
[Link] client;
Maximum wait time
-H:EnableURLProtocols=http,https --enable-all-security-services - wait-queue-timeout Duration
for new connection.
H:+JNI
INFO: Reactive client uses exposes Mutiny API.
And Quarkus Maven Plugin with next con guration:
Time period between
maintenance-
[Link]-string=mongodb://localhost:27018 Duration runs of maintenance
<artifactId>quarkus-maven-plugin</artifactId> frequency
[Link]=false job.
<executions>
<execution>
<id>native-image</id> Time to wait before
Multi MongoDB support maintenance-initial-
<goals> Duration running the rst
delay
<goal>native-image</goal>
You can con gure multiple MongoDB clients using same approach maintenance job.
</goals>
as with DataSource . The syntax is [Link].<optional name>.
<configuration>
<property> :
<enableHttpUrlHandler>true Multiplied with max-
</enableHttpUrlHandler> pool-size gives max
[Link]-string = mongodb://mongo2: wait-queue-multiple Int
<enableHttpsUrlHandler>true numer of threads
</enableHttpsUrlHandler> 27017/userdb waiting.
<enableAllSecurityServices>true [Link]-string = mongodb://mon
</enableAllSecurityServices> go3:27017/invdb
<enableJni>true</enableJni> connection-timeout Duration
</configuration>
</execution> Inject the instance using
</executions> socket-timeout Duration
@[Link] annotation:

@Inject tls-insecure boolean [false] Insecure TLS.

Alternatively, and as a not recommended way in production, you @MongoClientName("users")
can disable SSL and Quarkus will disable Bolt SSL as well. MongoClient mongoClient1;
[Link]=false . tls boolean [false] Enable TLS
If you are using Neo4j 4.0, you can use fully reactive. Add the next
[Link] as pre x is skipped in the next table.
extension: quarkus-resteasy-mutiny . Implies hosts given
replica-set-name String
Parameter Type Description are a seed list.
@GET
public Publisher<String> get() {
MongoDB connection
return [Link]().resource(driver::rxSession, connection-string String server-selection- Time to wait for
URI. Duration
session -> [Link](tx -> { timeout server selection.
RxResult result = [Link]("MATCH (f:Fruit) RETUR
N [Link] as name"); Addresses passed as
return [Link]().publisher([Link] hosts List<String> Minimum ping time
host:port .
rds()) local-threshold Duration to make a server
.map(record -> [Link]("name").asStr eligible.
ing()); application-name String Application name.
})
).withFinalizer(session -> { Frequency to
return [Link]().publisher([Link]()); Maximum number of heartbeat-frequency Duration determine the state
});
max-pool-size Int
connections. of servers.
}

Minimum number of
min-pool-size Int
connections.
MongoDB Client
Q k i i hM DB
Parameter Type Description MongoDB con guration comes from MongoDB Client section.
PanacheQuery<Person> livingPersons =
[Link]("status", [Link]);
primary , @MongoEntity(collection="ThePerson") [Link]([Link](25));
primaryPreferred , public class Person extends PanacheMongoEntity {
read-preference secondary , Read preferences. public String name; // get the first page
secondaryPreferred , List<Person> firstPage = [Link]();
nearest @BsonProperty("birth") // get the second page
public LocalDate birthDate; List<Person> secondPage = [Link]().list();

Max number of public Status status;
concurrent }
max-wait-queue-size Int
operations allowed to Range
wait.
PanacheQuery<Person> livingPersons = Person
Possible annotations in elds: @BsonId (for custom ID), .find("status", [Link]);
@BsonProperty and @BsonIgnore .
Ensures are writes List<Person> secondRange = [Link](25, 49).list
[Link] boolean [true]
are ack. ();
@MongoEntity is optional.

write- Journal writing

boolean [true] You cannot mix pagination and range.
[Link] aspect. Multi-tenancy with MongoDB Panache
Queries
@MongoEntity(collection = "TheBook", clientName = "client2"
Value to all write , database = "database2") Native MongoDB queries are supported (if they start with { or
write-concern.w String
commands. [Link] instance) as well as Panache Queries. Panache
Queries equivalence in MongoDB:
[Link]- Retry writes if Methods provided are similar of the ones shown in Persistence
boolean [false] firstname = ?1 and status = ?2 → {'firstname': ?1, 'status': ?
writes network fails. section.
2}

[Link](); amount > ?1 and firstname != ?2 → {'amount': {'$gt': ?1},

write-concern.w- Timeout to all write [Link](); 'firstname': {'$ne': ?2}}
Duration
timeout commands. [Link]();
lastname like ?1 → {'lastname': {'$regex': ?1}}
List<Person> allPersons = [Link]();
[Link] String Username. person = [Link](personId); lastname is not null → {'lastname':{'$exists': true}}
List<Person> livingPersons = [Link]("status", Status.A
live); PanacheQL refers to the Object parameter name but native
[Link] String Password.
List<Person> persons = [Link]([Link]("name").and("bir queries refer to MongoDB eld names.
th"));

[Link]- MONGO-CR , GSSAPI ,

Projection
long updated = [Link]("name", "Mortal").where("statu
mechanism PLAIN , MONGODB-X509
s", [Link]); Projection can be done for both PanacheQL and native queries.

long countAll = [Link]();
Source of the import [Link];
[Link]-
String authentication
source [Link](id);
credentials. @ProjectionFor([Link]) (1)
[Link]("status", [Link]); public class PersonName {
public String name;
Authentication }
[Link]-
Map<String, String> mechanism All list methods have equivalent stream versions.
mechanism-properties
properties. PanacheQuery<PersonName> shortQuery = [Link]("status "
Pagination , [Link]).project([Link]);

MongoDB Panache You can also use pagination:

1 Entity class.
You can also use the Panache framework to write persistence part
when using MongoDB. Testing

./mvnw quarkus:add-extension To mock using active record pattern:

-Dextensions="mongodb-panache"
 MongoDB with Panache allows using reactive implementation too You need to create a DaoProducer:
<dependency>
<groupId>[Link]</groupId>
by using ReactivePanacheMongoEntity or
ReactivePanacheMongoEntityBase or ReactivePanacheMongoRepository @Inject
<artifactId>quarkus-panache-mock</artifactId>
or ReactivePanacheMongoRepositoryBase depending on your style. public FruitDaoProducer(QuarkusCqlSession session) {
<scope>test</scope>
</dependency> FruitMapper mapper = new FruitMapperBuilder(session).buil
public class ReactivePerson extends ReactivePanacheMongoEnt d();
ity { fruitDao = [Link]();
public String name; }
@Test }
public void testPanacheMocking() { @Produces
[Link]([Link]); CompletionStage<Void> cs1 = [Link](); @ApplicationScoped
CompletionStage<List<ReactivePerson>> allPersons = Reactive FruitDao produceFruitDao() {
[Link]([Link]()).thenReturn(23l); [Link](); return fruitDao;
[Link](23, [Link]()); Publisher<ReactivePerson> allPersons = [Link] }
[Link]([Link], [Link](1)).coun mAll();
t();
} Uni<List<PersonName>> persons = [Link](
Cassandra con guration:
"lastname", name).project([Link]).list();

[Link]-points=[Link]:9042
DAO pattern [Link]-datacenter=datacenter1
MongoDB REST Data Panache [Link]=k1
@ApplicationScoped [Link]=john
public class PersonRepository MongoDB REST Data with Panache extension can generate the [Link]=s3cr3t
implements PanacheMongoRepository<Person> { basic CRUD endpoints for your entities and repositories.
}

./mvnw quarkus:add-extension You can con gure other Cassandra Java driver settings using
-Dextensions="mongodb-rest-data-panache" [Link] or [Link] les. They need to be located
Jandex in the classpath of your application. Driver settings reference.

If entities are de ned in external JAR, you need to enable in these If MicroPro le Metrics extension is registered, the Cassandra
You also need to add the JDBC driver extension and a JSON
projects the Jandex plugin in project. extension can provide (if enabled) metrics about the session:
Marshaller (ie resteasy-jackson ).
<plugin> Then you can de ne interfaces for de ning endpoints: [Link]=true
<groupId>[Link]</groupId> [Link]-enabled=connected-nodes,b
<artifactId>jandex-maven-plugin</artifactId> In case of Active Record pattern: ytes-sent
<version>1.0.3</version> [Link]-enabled=[Link]-connection
<executions> public interface DeveloperResource extends PanacheMongoEnti s
<execution> tyResource<Developer, Long> {
<id>make-index</id> }
<goals>
Reactive
<goal>jandex</goal>
</goals> You can also use Mutiny to de ne a reactive DAO:
</execution> In case of Repository:
</executions>
@Dao
<dependencies> public interface DeveloperResource extends PanacheMongoRepo
public interface FruitDaoReactive {
<dependency> sitoryResource<DeveloperRepository, Developer, Long> {

<groupId>[Link]</groupId> }
@Update
<artifactId>jandex</artifactId>
Uni<Void> update(Fruit fruit);
<version>[Link]</version>

</dependency>
</dependencies> Cassandra @Select
MutinyMappedReactiveResultSet<Fruit> findById(String stor
</plugin>
Quarkus integrates with Cassandra and DataStax Object Mapper. eId);
}

<dependency>
Panache includes an annotation processor that enhance your @Mapper
<groupId>[Link]</groupId>
entities. If you disable annotation processors you might need to public interface FruitMapper {
<artifactId>cassandra-quarkus-client</artifactId>
create a marker le on Panache archives at META-INF/panache-
</dependency>
[Link] manually. @DaoFactory
FruitDaoReactive fruitDaoReactive();
Reactive Panache }
Enities and DAOs are generated as you have been doing with
D t St Obj t M
Reactive Programming @GET Uni<Void> uniFromCompletable = [Link]()
@Produces(MediaType.TEXT_PLAIN) .converter(UniRxConvert
Quarkus implements MicroPro le Reactive spec and uses RXJava2 public Uni<String> hello() { [Link](), completable);
to provide reactive programming model. return [Link]().item(() -> "hello"); Uni<String> uniFromSingle = [Link]()
} .converter(UniRxConverters.
./mvnw quarkus:add-extension fromSingle(), single);
-Dextensions="quarkus-smallrye-reactive-streams-operator @GET Uni<String> uniFromObservable = [Link]()
s" @Produces(MediaType.TEXT_PLAIN) .converter(UniRxConverters.
public Multi<String> multi() { fromObservable(), observable);
return [Link]().items("hello", "world"); Uni<String> uniFromFlowable = [Link]()
} .converter(UniRxConverters.
Asynchronous HTTP endpoint is implemented by returning Java fromFlowable(), flowable);
CompletionStage . You can create this class either manually or using
...
MicroPro le Reactive Streams spec:
Mutiny
Multi<Void> multiFromCompletable = [Link]()
@GET .converter(MultiRxC
Quarkus integrates with Mutiny as reactive programming library:
@Path("/reactive") [Link](), completable);
@Produces(MediaType.TEXT_PLAIN) Multi<String> multiFromObservable = [Link]()
./mvnw quarkus:add-extension
public CompletionStage<String> getHello() { .converter(MultiRxC
-Dextensions="mutiny"
return [Link]("h", "e", "l", "l", "o") [Link](), observable);
.map(String::toUpperCase) Multi<String> multiFromFlowable = [Link]()
.toList() .converter(MultiRxC
.run() [Link](), flowable);
@ApplicationScoped
.thenApply(list -> [Link]()); ...
public static class ReactiveHello {
}

public Uni<String> greeting() {
return [Link]().item(() -> "hello") To RxJava2 :
Creating streams is also easy, you just need to return Publisher .emitOn([Link]
object. ()); Completable completable = [Link]().with(UniRxConverter
} [Link]());
@GET Single<Optional<String>> single = [Link]().with(UniRxC
@Path("/stream") public Multi<String> stream() { [Link]());
@Produces(MediaType.SERVER_SENT_EVENTS) return [Link]().items("hello", "world") Observable<String> observable = [Link]().with(UniRxCon
public Publisher<String> publishers() { .emitOn([Link] [Link]());
return Flowable ()); Flowable<String> flowable = [Link]().with(UniRxConvert
.interval(500, [Link]) } [Link]());
.map(s -> [Link]()) } ...
.map(i -> [Link](i));
} Completable completable = [Link]().with(MultiRxConve
Converting from/to RxJava2 or Reactor APIs: [Link]());
Single<Optional<String>> single = [Link]().with(Mult

Mutiny and JAX-RS RxJava 2 [Link]());

Observable<String> observable = [Link]().with(MultiR
Apart from the CompletionStage support, there is also support for <dependency> [Link]());
Mutiny. <groupId>[Link]</groupId> Flowable<String> flowable = [Link]().with(MultiRxCon
<artifactId>mutiny-rxjava</artifactId> [Link]());
</dependency> ...
./mvnw quarkus:add-extension
-Dextensions="quarkus-resteasy-mutiny"

From RxJava2 : Reactor API

<dependency>
<groupId>[Link]</groupId>
<artifactId>mutiny-reactor</artifactId>
</dependency>

From Reactor :
 Uni<String> uniFromMono = [Link]().converter(UniRea
or in Mutiny: @Inject @Stream(“out”)
[Link](), mono); Publisher<String> result;
Uni<String> uniFromFlux = [Link]().converter(UniRea @ApplicationScoped
[Link](), flux); public class ProducerData { @GET
Multi<String> multiFromMono = [Link]().converter @Outgoing("my-in-memory") @Produces(SERVER_SENT_EVENTS)
([Link](), mono); public Multi<Integer> generate() { public Publisher<String> stream() {
Multi<String> multiFromFlux = [Link]().converter return [Link]().ticks().every([Link] return result;
([Link](), flux); Seconds(5)) }
.onItem().apply(n -> [Link](100));
}
}
To Reactor : Message → Business Logic

Mono<String> mono = [Link]().with(UniReactorConverter @ApplicationScoped

[Link]());
If you want to dispatch to all subscribers you can annotate the
public class ReceiverMessages {
Flux<String> flux = [Link]().with(UniReactorConverter
method with @Broadcast .
@Incoming("prices")
[Link]()); public void print(String price) {
Consumes generated data from my-in-memory stream.
}
Mono<String> mono2 = [Link]().with(MultiReactorConve }
[Link]()); @ApplicationScoped
Flux<String> flux2 = [Link]().with(MultiReactorConve public class ConsumerData {
[Link]()); @Incoming("my-in-memory")
public void randomNumber(int randomNumber) { To indicate that the method should be executed on a worker pool
[Link]("Received " + randomNumber); you can use @Blocking :
}
CompletionStages or Publisher } @Outgoing("Y")
@Incoming("X")
CompletableFuture<String> future = Uni @Blocking
.createFrom().completionStage([Link]
You can also inject an stream as a eld:
plyAsync(() -> "hello"));

@Inject To customize:
CompletationStage<String> cs = Uni
.createFrom().subscribeAsCompletionStage(); @Stream("my-in-memory") Publisher<Integer> randomRumbers;
@Blocking(value="my-custom-pool", ordered = false)

Multi implements Publisher . @Inject @Stream("generated-price")

Emitter<String> emitter; [Link]-concurrency=3
Reactive Messaging
Quarkus relies on MicroPro le Reactive Messaging spec to Patterns Possible implementations are:
implement reactive messaging streams.
REST API → Message In-Memory
mvn quarkus:add-extension
-Dextensions=" If the stream is not con gured then it is assumed to be an in-
@Inject @Stream(“in”)
[Link]:quarkus-smallrye-reactive-messaging" memory stream, if not then stream type is de ned by connector
Emitter<String> emitter;
eld.

[Link](message);
Kafka
You can just start using in-memory streams by using @Incoming to
produce data and @Outgoing to consume data. To integrate with Kafka you need to add next extensions:
Message → Message
Produce every 5 seconds one piece of data.
mvn quarkus:add-extension
@Incoming(“in”) -Dextensions="
@ApplicationScoped [Link]:quarkus-smallrye-reactive-messaging-kafka"
@Outgoing(“out”)
public class ProducerData {
public String process(String in) {

}
@Outgoing("my-in-memory")
Then @Outgoing , @Incoming or @Stream can be used.
public Flowable<Integer> generate() {
return [Link](5, [Link])
Message → SSE Kafka con guration schema: [Link].[outgoing|incoming].
.map(tick -> [Link](100));
{stream-name}.<property>=<value> .
}
} The connector type is smallrye-kafka .
 [Link]= amqp-username=quarkus Kafka Streams
smallrye-kafka amqp-password=quarkus
[Link]= # write Create streaming queries with the Kafka Streams API.
prices [Link]=
[Link]= smallrye-amqp ./mvnw quarkus:add-extension
localhost:9092 [Link]= -Dextensions="kafka-streams"
[Link]= prices
[Link] [Link]=
true
[Link]= # read
All we need to do for that is to declare a CDI producer method
smallrye-kafka [Link]=
which returns the Kafka Streams
[Link] :
[Link]= smallrye-amqp
[Link] [Link]=
er true @ApplicationScoped
public class TopologyProducer {
@Produces
public Topology buildTopology() {
A complete list of supported properties are in Kafka site. For the A complete list of supported properties for AMQP.
[Link]
producer and for consumer
der
MQTT
builder = new StreamsBuilder();
JSON-B Serializer/Deserializer
To integrate with MQTT you need to add next extensions: // ...
You can use JSON-B to serialize/deserialize objects. [Link]()
.join()
./mvnw quarkus:add-extension
// ...
./mvnw quarkus:add-extension -Dextensions="vertx, smallrye-reactive-streams-operator
.toStream()
-Dextensions="quarkus-kafka-client" s
.to();
smallrye-reactive-messaging"
return [Link]();
}
To serialize you can use }
[Link] . And add [Link]:smallrye-reactive-messaging-mqtt-
1.0:0.0.10 dependency in your build tool.
To deserialize you need to extend
[Link] and Then @Outgoing , @Incoming or @Stream can be used. Previous example produces content to another stream. If you want
provide a type. to write interactive queries, you can use Kafka streams.
MQTT con guration schema: [Link].[outgoing|incoming].
{stream-name}.<property>=<value> . @Inject
public class BeerDeserializer
extends JsonbDeserializer<Beer> { KafkaStreams streams;
The connector type is smallrye-mqtt .

public BeerDeserializer() { return streams
super([Link]); [Link]= .store("stream", [Link]
} smallrye-mqtt ());
[Link]=
} prices
[Link]=
The Kafka Streams extension is con gured via the Quarkus
localhost
con guration le [Link] .
[Link]=
AMQP 1883
[Link]-servers=localhost:9092
[Link]-generated-client-id=
To integrate with AMQP you need to add next extensions: [Link]-id=temperature-aggregator
true
[Link]-server=${hostname}:8080

./mvnw quarkus:add-extension [Link]=weather-stations,temperature-v
[Link]=
-Dextensions="reactive-messaging-amqp" alues
smallrye-mqtt

[Link]=
[Link]=10240
prices
[Link]=1000
Then @Outgoing , @Incoming or @Stream can be used. [Link]=
localhost
AMQP con guration schema: [Link].[outgoing|incoming]. [Link]=
{stream-name}.<property>=<value> . Special properties amqp-username 1883 IMPORTANT: All the properties within the kafka-streams
and amqp-password are used to con gure AMQP broker credentials. [Link]-generated-client-id= namespace are passed through as-is to the Kafka Streams engine.
true Changing their values requires a rebuild of the application.
The connector type is smallrye-amqp .
Reactive DataSource Properties
Common Reeactive DataSource Client con guration properties Database con guration is the same as shown in Persistence Reactive Transactions
pre xed with [Link] : section, but URL is different as it is not a jdbc.
[Link] is an util class that
[Link]-prepared-statements
[Link]-kind=postgresql allows you to run reactive persisten code within a transaction.
Prepared statements should be cached on the client side. [Link]=postgresql:///your_database
(default: false )
Uni<Void> r = [Link](client, tx -
> {
[Link]
Then you can inject [Link] class. Uni<RowSet<Row>> insertOne = [Link]("INSE
The datasource URL. RT INTO fruits (name) VALUES ($1) RETURNING (id)")
@Inject .execute([Link]([Link]));
[Link]-size });
PgPool client;
The datasource pool maximum size.
Uni<List<Fruit>> fruits =
[Link]-all [Link]("SELECT * FROM fruits")
ActiveMQ Artemis
All server certi cates should be trusted. (default: false ) .onItem().apply(rowSet -> {
JsonArray jsonArray = new JsonArray();
Quarkus uses Reactive Messaging to integrate with messaging
for (Row row : rowSet) {
[Link]-certificate-pem systems, but in case you need deeper control when using Apache
[Link](from(row));
Trust con guration in the PEM format. ActiveMQ Artemis there is also an extension:
}
return jsonArray;
[Link]-certificate-jks ./mvnw quarkus:add-extension
})
Trust con guration in the JKS format. -Dextensions="quarkus-artemis-core"

[Link]-certificate-pfx
Trust con guration in the PFX format.
Reactive MySQL Client And then you can inject
[Link]
You can use Reactive MySQL to execute queries to MySQL instance.
[Link]-certificate-pem
database in a reactive way, instead of using JDBC.
Key/cert con guration in the PEM format.
@ApplicationScoped
./mvnw quarkus:add-extension
[Link]-certificate-jks public class ArtemisConsumerManager {
-Dextensions="quarkus-reactive-mysql-client"

Key/cert con guration in the JKS format.
@Inject
ServerLocator serverLocator;
[Link]-certificate-pfx
Database con guration is the same as shown in Persistence
Key/cert con guration in the PFX format. section, but URL is different as it is not a jdbc. private ClientSessionFactory connection;

[Link]-local @PostConstruct
[Link]-kind=mysql
Use one connection pool per thread. [Link]=mysql:///your_database public void init() throws Exception {
connection = [Link]();
[Link]-attempts }
}
The number of reconnection attempts when a pooled connection Then you can inject [Link] class.
cannot be established on rst try. (default: 0 )
Reactive DB2 Client And con gure ServerLocator in [Link] :
[Link]-interval
The interval between reconnection attempts when a pooled You can use Reactive DB2 to execute queries to DB2 database in a
connection cannot be established on rst try. (default: PT1S ) reactive way, instead of using JDBC. [Link]=tcp://localhost:61616

[Link]-timeout
./mvnw quarkus:add-extension
The maximum time without data written to or read from a -Dextensions="quarkus-reactive-db2-client" You can con gure ActiveMQ Artemis in [Link] le
connection before it is removed from the pool. by using next properties pre xed with quarkus :

Reactive PostgreSQL Client Database con guration is the same as shown in Persistence
[Link]

Connection URL.
section, but URL is different as it is not a jdbc.
You can use Reactive PostgreSQL to execute queries to PostreSQL
database in a reactive way, instead of using JDBC way. [Link]
[Link]-kind=db2
[Link]=vertx-reactiv[Link]//localh
Username for authentication.
./mvnw quarkus:add-extension ost:50005/hreact
-Dextensions="quarkus-reactive-pg-client" [Link]
Password for authentication.
Then you can inject i i db2 li 2 l class
Artemis JMS Example of Vert.X Web Client:
[Link]=apache

If you want to use JMS with Artemis, you can do it by using its
@Inject
extension:
Vertx vertx;
You can go async by using Mutiny:

./mvnw quarkus:add-extension private WebClient client;
-Dextensions="quarkus-artemis-jms" @Inject
@PostConstruct [Link] sqs;
void initialize() {
[Link] = [Link](vertx, ...); [Link]()
And then you can inject [Link] :
} .completionStage(
[Link](m -> [Link](queueUrl).messageBo
@ApplicationScoped dy(message))
public class ArtemisConsumerManager { )
Amazon SQS Client .onItem()...
@Inject
ConnectionFactory connectionFactory; return [Link]()
./mvnw quarkus:add-extension
.completionStage(
private Connection connection; -Dextensions="amazon-sqs"
[Link](m -> [Link](10).q
ueueUrl(queueUrl))
@PostConstruct )
public void init() throws JMSException { Injecting the client: .onItem()
connection = [Link]();
[Link]();
@Inject
}
[Link] sqs; And you need to add the asynchronous Netty client:
}

SendMessageResponse response = [Link](m -> [Link]
<dependency>
Url(queueUrl).messageBody(message));
<groupId>[Link]</groupId>

Con guration options are the same as Artemis core. List<Message> messages = [Link](m -> [Link]
<artifactId>netty-nio-client</artifactId>
</dependency>
rOfMessages(10).queueUrl(queueUrl)).messages();

Vert.X Reactive Clients

And con gure it: Con guration properties are the same as Amazon DynamoDB but
Vert.X Reactive clients in Quarkus, the next clients are supported
changing the pre x from dynamodb to sqs .
and you need to add the dependency to use them:
[Link]-override=[Link]
Vert.X Mail Client [Link]=us-east-1
[Link]:smallrye-mutiny-vertx-mail-client [Link]=static
[Link]-key-id=t
Vert.X MongoDB Client est-key
[Link]:smallrye-mutiny-vertx-mongo-client
[Link]-access-k
ey=test-secret

Vert.X Redis Client

[Link]:smallrye-mutiny-vertx-redis-client
You need to set a HTTP client either URL Connection :
Vert.X Cassandra Client
[Link]:smallrye-mutiny-vertx-cassandra-client <dependency>
<groupId>[Link]</groupId>
Vert.X Consul Client <artifactId>url-connection-client</artifactId>
</dependency>
[Link]:smallrye-mutiny-vertx-consul-client

Vert.X Kafka Client

or Apache HTTP:
[Link]:smallrye-mutiny-vertx-kafka-client

Vert.X AMQP Client <dependency>

<groupId>[Link]</groupId>
[Link]:smallrye-mutiny-vertx-amqp-client
<artifactId>apache-client</artifactId>
</dependency>
Vert.X RabbitMQ Client
[Link]:smallrye-mutiny-vertx-rabbitmq-client
RBAC You need to provide permissions set by using the roles-allowed
@Inject
JsonWebToken jwt;
property or use the built-in ones deny , permit or authenticated .
You can set RBAC using annotations or in [Link] .
You can use enabled property (ie @Inject
Annotations @Claim(standard = Claims.preferred_username)
[Link] ) to enable the entire
permission set. String name;
You can de ne roles by using
[Link] annotation.
Testing @Inject
@Claim("groups")
@RolesAllowed("Subscriber") Quarkus provides explicit support for testing with different users, Set<String> groups;
and with the security subsystem disabled.
@Inject
You can use [Link] as a shortcut of <dependency> JWTParser parser;
@RolesAllowed("*") . <groupId>[Link]</groupId>
<artifactId>quarkus-test-security</artifactId>
To alter RBAC behaviour there are two con guration properties: <scope>test</scope> Set of supported types: String , Set<String> , Long , Boolean,
</dependency> `[Link] , Optional ,
[Link]-unannotated=true [Link] .

And con guration in src/main/resources/[Link] :

@Test
Con guration options: @TestSecurity(authorizationEnabled = false)
[Link]=
void someTestMethod() {
[Link]-uncovered META-INF/resources/[Link]
...
[Link]=
If true denies by default to all JAX-RS endpoints. (default: false ) }
[Link]

[Link]-unannotated @Test
If true denies by default all CDI methods and JAX-RS endpoints. @TestSecurity(user = "testUser", roles = {"admin", "user"})
void someTestMethod() { Con guration options:
(default: false )
...
} [Link]
By default in Quarkus, if an incoming request has a credential the
request will always be authenticated (even if the target page does Public Key text itself to be supplied as a string.
not require authentication).
[Link] Relative path or URL of a public
You can change this behaviour by setting
BouncyCastle key.
[Link] property to false .
Quarkus supports BouncyCastle, you only need to add the [Link]
File Con guration BouncyCastle dependency and con gure the security provider: iss accepted as valid.

De ning RBAC in [Link] instead of using [Link]-providers=BC [Link]

annotations. [Link]-providers=BCJSSE
Sets header such as Cookie is used to pass the token. (default:
Authorization ).
[Link]-allowed=
user,admin
[Link]=
JWT [Link]

/roles-secured/*,/other/*,/api/* Name of the cookie containing a token.

[Link]= Quarkus implements MicroPro le JWT RBAC spec.
role-policy1 [Link]
mvn quarkus:add-extension Comma-separated list containing an alternative single or multiple
[Link]= -Dextensions="[Link]:quarkus-smallrye-jwt" schemes. (default: Bearer ).
/public/*
[Link]= [Link]-principal
permit A token must have a upn or preferred_username or sub claim set
Minimum JWT required claims: typ , alg , kid , iss , sub , exp , iat ,
[Link]= if using [Link] . True makes throw an exception
jti , upn , groups .
GET if not set. (default: false ).
You can inject token by using JsonWebToken or a claim individually by
[Link]= using @Claim . [Link]
/forbidden
[Link]= Path to the claim with subject name.
deny
[Link]
Default sub claim value.
[Link]
@Inject @GET
Path to the claim containing the groups. @Claim(standard = [Link]) @RolesAllowed("admin")
private Instance<Long> providerIAT;
[Link]-separator
Separator for splitting a string which may contain multiple group Con gure application to Keycloak service in [Link]
values. (default. ` `). RBAC le.

[Link] JWT groups claim is directly mapped to roles to be used in security [Link]=quarkus
Default groups claim value. annotations. [Link]-server-url=[Link]
[Link]=backend-service
[Link]-interval @RolesAllowed("Subscriber") [Link]-only=true
JWK cache refresh interval in minutes. (default: 60 ). [Link]=secret

[Link] Generate tokens

Expiration grace in seconds. (default: 60 ). Con guration options with [Link] pre x:
JWT generation API:
enabled
[Link]
Comma separated list of the audiences that a token aud claim
[Link]() The OIDC is enabled. (default: true )
.issuer("[Link]
may contain.
.claim("customClaim", 3) tenant-enabled
.sign(createKey());
[Link] If the tenant con guration is enabled. (default: true )

Signature algorith. (defsult: RS256 ) JwtSignatureBuilder jwtSignatureBuilder = [Link]("/test
application-type
[Link]").jws();
[Link] jwtSignatureBuilder The application type. Possible values: web_app , service . (default:
service )
If set then the veri cation JWK key as well every JWT token must .signatureKeyId("some-key-id")
have a matching kid header. .signatureAlgorithm(SignatureAlgorithm.ES256)
.header("custom-header", "custom-value"); connection-delay
[Link]-to-live .sign(createKey()); The maximum amount of time the adapter will try connecting.

The maximum number of seconds that a JWT may be issued for
[Link]("/[Link]")
use. auth-server-url
.encrypt(createKey());
The base URL of the OpenID Connect (OIDC) server.

[Link]-location
JwtEncryptionBuilder jwtEncryptionBuilder = [Link]("/te
Location of a private key which will be used to sign the claims [Link]").jwe();
introspection-path
when either a no-argument sign() or innerSign() method is jwtEncryptionBuilder Relative path of the RFC7662 introspection service.
called. .keyEncryptionKeyId("some-key-id")
.keyEncryptionAlgorithm(KeyEncryptionAlgorithm.ECDH_E jwks-path
[Link]-location S_A256KW) Relative path of the OIDC service returning a JWK set.
Location of a public key which will be used to encrypt the claims .header("custom-header", "custom-value");
or inner JWT when a no-argument encrypt() method is called. .encrypt(createKey()); public-key

Public key for the local JWT token veri cation
Supported public key formats: [Link]("/[Link]")
.innerSign(createKey());
client-id
PKCS#8 PEM .encrypt(createKey());
The client-id of the application.
JWK
[Link]-claim-path
JWKS OpenId Connect Path to the claim containing an array of groups. ( realm/groups )
JWK Base64 URL Quarkus can use OpenId Connect or OAuth 2.0 authorization
[Link]-claim-separator
servers such as Keycloak to protect resources using bearer token
JWKS Base64 URL issued by Keycloak server. Separator for splitting a string which may contain multiple group
values.
To send a token to server-side you should use Authorization
header: curl -H "Authorization: Bearer eyJraWQiOi… " . mvn quarkus:add-extension
[Link]
-Dextensions="using-openid-connect"
To inject claim values, the bean must be @RequestScoped CDI Issuer claim value.
scoped. If you need to inject claim values in scope with a lifetime
greater than @RequestScoped then you need to use You can also protect resources with security annotations.
[Link]
[Link] interface. Audience claim value.

t k i ti
 Expiration grace period in seconds. You can use [Link] property to enable URL used to validate the token and gather the authentication
consuming form different domain. claims.
[Link]-claim
Name of the claim which contains a principal name. Multi-tenancy [Link]-claim
The claim that is used in the endpoint response to load the roles
Multi-tenancy is supported by adding a sub-category to OIDC ((default: scope )
[Link]-expired
con guration properties (ie [Link].{tenent_id}.property ).
If property is enabled then a refresh token request is performed.
[Link]-server-url=[Link]
Authenticating via HTTP
[Link]
lms/quarkus
The client secret HTTP basic auth is enabled by the [Link]=true
[Link]-id=multi-tenant-client
property.
[Link]-type=web-app
[Link]-path
HTTP form auth is enabled by the
Relative path for calculating a redirect_uri query parameter. [Link]-server-url=[Link]
[Link]=true property.
[Link]
[Link]-path-after-redirect [Link]-type=web-app Then you need to add elytron-security-properties-file or elytron-
[Link]-id=xxxx security-jdbc .
The original request URI used before the authentication will be
[Link]=yyyy
restored after the user has been redirected back to the
application. (default: true )
[Link]=[Link]
Security with Properties File
com
[Link]=email,profile,o
[Link] You can also protect endpoints and store identities (user, roles) in
penid
List of scopes. the le system.

[Link]-params mvn quarkus:add-extension

Additional properties which will be added as the query OAuth2 -Dextensions="elytron-security-properties-file"
parameters .
Quarkus integrates with OAuth2 to be used in case of opaque
tokens (none JWT) and its validation against an introspection
[Link]-path You need to con gure the extension with users and roles les:
endpoint.
Cookie path parameter.
And con guration in src/main/resources/[Link] :
mvn quarkus:add-extension
[Link]
-Dextensions="security-oauth2" [Link]=true
The host (name or IP address) of the Proxy.
[Link]=[Link]
[Link]=[Link]
[Link]
And con guration in src/main/resources/[Link] : [Link]-mechanism=BASIC
The port number of the Proxy. (default: 80 ) [Link]-name=MyRealm
[Link]-text=true
[Link]-id=client_id
[Link]
[Link]-secret=secret
The username to authenticate. [Link]-url=[Link]
pect Then [Link] and [Link] :
[Link]

The password to authenticate. scott=jb0ss

And you can map roles to be used in security annotations. jdoe=p4ssw0rd
end-session-path

Relative path of the OIDC end_session_endpoint . @RolesAllowed("Subscriber")

[Link]
scott=Admin,admin,Tester,user
jdoe=NoRolesUser
The relative path of the logout endpoint at the application. Con guration options:
[Link]-logout-path [Link]
IMPORTANT: If plain-text is set to false (or omitted) then
Relative path of the application endpoint where the user should Determine if the OAuth2 extension is enabled. (default: true ) passwords must be stored in the form MD5
be redirected to after logging out.
( username :`realm`:`password`).
[Link]-id
[Link] Elytron File Properties con guration properties. Pre x
The OAuth2 client id used to validate the token.
Sets the TLs veri cation. Possible values: REQUIRED , NONE . [Link] is skipped.
(default: REQUIRED ). [Link]-secret
[Link]
The OAuth2 client secret used to validate the token.
With Keycloak OIDC server The le realm is enabled. (default: false )
[Link] where {realm} has
[Link]-url
to be replaced by the name of the Keycloak realm file auth-mechanism
 The authentication mechanism. ( default: BASIC ) You can also protect endpoints and store identities in a database. [Link]-encoding
A string referencing the password hash encoding ( BASE64 or HEX ).
[Link]-name mvn quarkus:add-extension (default: BASE64 )
The authentication realm name. (default: Quarkus ) -Dextensions="elytron-security-jdbc"
[Link]-index
[Link]-text The index column containing the Bcrypt salt. (default: 0 )
If passwords are in plain or in MD5. (default: false ) You still need to add the database driver (ie jdbc-h2 ).
[Link]-encoding
[Link] You need to con gure JDBC and Elytron JDBC Realm: A string referencing the salt encoding ( BASE64 or HEX ). (default:
Classpath resource of user/password. (default: BASE64 )
[Link] ) [Link]=
[Link]=[Link] [Link]-count-index
[Link]=sa
[Link] The index column containing the Bcrypt iteration count. (default:
[Link]=sa
Classpath resource of user/role. (default: [Link] ) 0)

[Link]=true
Embedded Realm For multiple datasources you can use the datasource name in the
[Link]=
properties:
SELECT [Link], [Link] FROM test_user u WHERE [Link]
You can embed user/password/role in the same
=?
[Link] :
[Link]-query [Link]=
.[Link]=true [Link]=
[Link]=true [Link]-query
[Link]-text=true .[Link]-index=1 [Link]=
[Link]=jb0ss [Link]-query [Link]=
[Link]=admin,tester,us .[Link]=2
er [Link]-query
[Link]-mechanism=BASIC .[Link]=groups
Security with JPA
You can also protect endpoints and store identities in a database
IMPORTANT: If plain-text is set to false (or omitted) then You need to set the index (1-based) of password and role. using JPA.
passwords must be stored in the form MD5
( username :`realm`:`password`). Elytron JDBC Realm con guration properties. Pre x
mvn quarkus:add-extension
[Link] is skipped.
Pre x [Link] is skipped. -Dextensions="security-jpa"
auth-mechanism
algorithm
The authentication mechanism. (default: BASIC )
Determine which algorithm to use. Possible values: DIGEST_MD5 ,
Also you might require jdbc-postgresql , resteasy ,
DIGEST_SHA , DIGEST_SHA_256 , DIGEST_SHA_384 , DIGEST_SHA_512 ,
realm-name hibernate-orm-panache .
DIGEST_SHA_512_256 . (default: DIGEST_MD5 )
The authentication realm name. (default: Quarkus )
[Link]
enabled
The le realm is enabled. (default: false )
If the properties store is enabled. (default: false )
[Link]-mechanism
[Link]
The authentication mechanism. (default: BASIC )
The sql query to nd the password.
[Link]-name
[Link]
The authentication realm name. (default: Quarkus )
The data source to use.
[Link]-text
[Link]
If passwords are in plain or in MD5. (default: false )
If the clear-password-mapper is enabled. (default: false )
[Link].*
[Link]-index
* is user and value is password.
The index of column containing clear password. (default: 1 )
[Link].*
[Link]
* is user and value is role.
If the bcrypt-password-mapper is enabled. (default: false )
Security with a JDBC Realm [Link]-index
Th i d f l t i i dh h (d f lt )
 The identi er ( baseFilter ) which correlates to the provided user
@[Link] [Link]=true
(default: uid )
@Table(name = "test_user") [Link]=uid=tool,ou=acc
@Entity ounts,o=YourCompany,c=DE
[Link]-base-dn
public class User extends PanacheEntity { [Link]=ldaps://[Link].l
@[Link] ocal The dn where we look for users.
public String name; [Link]=PASSWORD
[Link]-identifier=uid [Link]-mappings.<id>.from
@[Link] [Link]-base-dn=ou=us The roleAttributeId from which is mapped
public String pass; ers,ou=tool,o=YourCompany,c=DE
[Link]-mapping [Link]-mappings.<id>.to
@ManyToMany s."0".from=cn
The identi er whom the attribute is mapped to (default: gropus )
@Roles [Link]-mapping
public List<Role> roles = new ArrayList<>(); s."0".to=groups
[Link]-mappings.<id>.filter
[Link]-mapping
public static void add(String username, String passwor s."0".filter=(member=uid={0}) The lter ( roleFilter )
d) { [Link]-mapping
User user = new User(); s."0".filter-base-dn=ou=roles,ou=tool,o=YourCompany,c=DE [Link]-mappings.<id>.filter-base-dn
[Link] = username; The lter base dn ( rolesContextDn )
[Link] = [Link](password);
[Link]();
}
Testing Vault
} There is a Quarkus Test Resource that starts and stops InMemory
Quarkus integrates with Vault to manage secrets or protecting
LDAP server before and after test suite. It is running in localhost sensitive data.
@Entity with dc=quarkus,dc=io and binding credentials
public class Role extends PanacheEntity { ( "uid=admin,ou=system", "secret" ). Imports LDIF from a le located
at root of the classpath named [Link] . mvn quarkus:add-extension
@ManyToMany(mappedBy = "roles") -Dextensions="vault"
public List<ExternalRolesUserEntity> users; Register dependency [Link]:quarkus-test-ldap:test.

@[Link] And annotate the test:
And con guring Vault in [Link] :
public String role;
} @QuarkusTestResource([Link]
# vault url
[Link])
[Link]=[Link]
public class ElytronLdapExtensionTestResources {

You need to con gure JDBC: }
[Link]=
bob
[Link]=jdbc:postgresql:security_jpa [Link]=
[Link]=[Link] Elytron LDAP Realm con guration properties. Pre x sinclair
[Link]=quarkus [Link] is skipped.
[Link]=quarkus # path within the kv secret engine
enabled [Link]-config-kv-path=
[Link]=drop-and-create Enable the LDAP elytron module (default: false ) myapps/vault-quickstart/config
[Link]=
realm-name multi/singer

Security with LDAP The elytron realm name (default: Quarkus )

direct-verification vault kv put secret/myapps/vault-quickstart/config a-private-

You can also protect endpoints and store identities in a database
key=123456
using LDAP. Provided credentials are veri ed against LDAP (default: true )
vault kv put secret/multi/singer firstname=paul
mvn quarkus:add-extension [Link]
-Dextensions="elytron-security-ldap" The url of the LDAP server.
@ConfigProperty(name = "a-private-key")
String privateKey;
[Link]

User ( bindDn ) which is used to connect to LDAP server. @ConfigProperty(name = "[Link]")
String firstName;
[Link]
The password ( bindCredential ) which belongs to the principal.
You can access the KV engine programmatically:
[Link]-identifier
 Vault con guration properties. Pre x [Link] is skipped.
@Inject @Inject
VaultKVSecretEngine kvSecretEngine; VaultTransitSecretEngine transit;
url

[Link]("myapps/vault-quickstart/" + vaul [Link]("my_encryption", text); Vault server URL
tPath).toString(); [Link]("my_encryption", text).asString();
[Link]("my-sign-key", text); [Link]-token
Map<String, String> secrets; Vault token to access
[Link]("myapps/vault-quickstart/crud",
secrets); [Link]-id
Vault TOTP

Role Id for AppRole auth
[Link]("myapps/vault-quickstart/crud" TOTP secret engine is supported by using
); [Link] class: [Link]-id
Secret Id for AppRole auth
@Inject
Fetching credentials DB VaultTOTPSecretEngine vaultTOTPSecretEngine; [Link]-id-wrapping-token

With the next kv vault kv put secret/myapps/vault-quickstart/db Wrapping token containing a Secret Id. secret-id and secret-id-
CreateKeyParameters createKeyParameters = new CreateKeyPara
password=connor wrapping-token are exclusive.
meters("Google", "test@[Link]");
[Link]("30m");
[Link]
[Link]-path=
myapps/vault-quickstart/db /** Generate Key (QR code) */ Username for userpass auth
final Optional<KeyDefinition> myKey = vaultTOTPSecretEngine
[Link]-kind= .createKey("my_ [Link]
postgresql key_2", createKeyParameters); Password for userpass auth
[Link]=
sarah /** Generate key number to login */ [Link]-wrapping-token
[Link]-provider= final String keyCode = [Link](
Wrapping token containing a password. password and password-
mydatabase "my_key_2");
wrapping-token are exclusive.
[Link]=
jdbc:postgresql://localhost:5432/mydatabase /** Login logic */
[Link]
boolean valid = [Link]("my_key_
2", keyCode); Kubernetes authentication role
No password is set as it is fetched from Vault.
[Link]-token-path

Dynamic credentials are also supported: Vault Provisioning Location of the le containing the Kubernetes JWT token

Running the following dynamic database con g in Vault: Vault extension offers façade classes to Vault provisioning renew-grace-period
functions: Renew grace period duration (default: 1H )
vault write database/config/mydb plugin_name=postgresql-database-
plugin …
..
@Inject secret-config-cache-period
You can con gure as: VaultSystemBackendEngine vaultSystemBackendEngine; Vault con g source cache period (default: 10M )

@Inject
[Link]-provider secret-config-kv-path
VaultKubernetesAuthService vaultKubernetesAuthService;
.[Link]-credentials-role=mydbrole
Vault path in kv store. List of paths is supported in CSV

String rules = "path \"transit/*\" {\n" +
[Link]-kind= log-confidentiality-level
" capabilities = [ \"create\", \"read\", \"updat
postgresql
e\" ]\n" + Used to hide con dential infos. low , medium , high (default:
[Link]-provider=
"}"; medium )
mydatabase
String policyName = "sys-test-policy";
[Link]=
kv-secret-engine-version
jdbc:postgresql://localhost:5432/mydatabase
[Link](policyName, rul Kv secret engine version (default: 1)
es);

kv-secret-engine-mount-path Kv secret engine path (default: secret )
Username and password are fetched from Vault vaultKubernetesAuthService
.createRole(roleName, new VaultKubernetesAuthRole() [Link]-verify
Transit .setBoundServiceAccountNames(boundServiceAccountN
Allows to bypass certi cate validation on TLS communications
ames)
(default: false )
.setBoundServiceAccountNamespaces(boundServiceAcc
ountNamespaces)
[Link]-cert
.setTokenPolicies(tokenPolicies));
Certi cate bundle used to validate TLS communications
[Link]-kubernetes-ca-cert
[Link]=apache @Inject
TLS will be active (default: true ) IamClient client;

connect-timeout @Inject
You can go async by using Mutiny:
Tiemout to establish a connection (default: 5S ) IamAsyncClient async;

@Inject
read-timeout
[Link] kms;
Request timeout (default: 1S ) [Link]-override=${[Link]}
[Link]().completionStage( [Link]=us-east-1
credentials-provider."credentials-provider".database-credentials- [Link](req -> [Link](keyArn).plaintext(SdkByte [Link]=static
role s.fromUtf8String(data)) [Link]-key-id=t
Database credentials role )) est-key
[Link]-access-k
credentials-provider."credentials-provider".kv-path ey=test-secret

A path in vault kv store, where we will nd the kv-key And you need to add the asynchronous Netty client:

credentials-provider."credentials-provider".kv-key <dependency> Con guration properties are the same as Amazon DynamoDB but
Key name to search in vault path kv-path (default: password ) <groupId>[Link]</groupId> changing the pre x from dynamodb to iam .
<artifactId>netty-nio-client</artifactId>

Amazon KMS </dependency>

mvn quarkus:add-extension
Con guration properties are the same as Amazon DynamoDB but
-Dextensions="amazon-kms"
changing the pre x from dynamodb to kms .

Amazon IAM
@Inject
KmsClient kms; mvn quarkus:add-extension
-Dextensions="quarkus-amazon-iam"
[Link](req -> [Link](keyArn).plaintext(
SdkBytes.fromUtf8String(data))).ciphertextBlob();

You need to set a HTTP client either URL Connection :

[Link]-override=[Link] <dependency>
[Link]=us-east-1 <groupId>[Link]</groupId>
[Link]=static <artifactId>url-connection-client</artifactId>
[Link]-key-id=t </dependency>
est-key
[Link]-access-k
ey=test-secret
or Apache HTTP:

<dependency>
You need to set a HTTP client either URL Connection : <groupId>[Link]</groupId>
<artifactId>apache-client</artifactId>
<dependency> </dependency>
<groupId>[Link]</groupId>
<artifactId>url-connection-client</artifactId>
</dependency>
And you need to add the asynchronous Netty client:

<dependency>
or Apache HTTP: <groupId>[Link]</groupId>
<artifactId>netty-nio-client</artifactId>
<dependency> </dependency>
<groupId>[Link]</groupId>
<artifactId>apache-client</artifactId>
</dependency>
HTTP Con guration The le path to a service certi cate or certi cate chain in PEM enable-compression
format. Relative to src/main/resources . If responses should be compressed.
You can con gure HTTP parameters. Using [Link] pre x:
[Link]-file read-timeout
cors The le path to the corresponding certi cate private key in PEM Http connection read timeout for blocking IO. (default: 60s )
Enable CORS. (default: false ) format. Relative to src/main/resources .
[Link]-file-uploads
[Link] [Link]-store-file
If the les sent using multipart/form-data will be stored locally.
CSV of origins allowed. (dedault: Any request valid.) The key store contains the certi cate information. Relative to (default: true )
src/main/resources .
[Link] [Link]-directory
[Link]-store-file-type
CSV of methods valid. (default: Any method valid.) The directory where the les sent using multipart/form-data
The key store type. It is automatically detected based on the le should be stored. (default: file-uploads )
[Link] name or can be set manually. Supported values are: JKS , JCEKS ,
P12 , PKCS12 or PFX .
CSV of valid allowed headers. (default: Any requested header [Link]-from-attributes
valid.) If the form attributes should be added to the request parameters.
[Link]-store-password
(default: true )
[Link]-headers The password to open the key store le.
CSV of valid exposed headers. [Link]-uploaded-files-on-end
[Link]-store-file The trust store location which
If the uploaded les should be removed after serving the request.
contains the certi cate information of the certi cates to trust.
port
Relative to src/main/resources .
The HTTP port. (default: 8080 ) [Link]-body-buffer
[Link]-store-file-type If the body buffer should pre-allocated based on the Content-
test-port The trust store type. It is automatically detected based on the le Length header value. (default: 1K )
The HTTP test port. (default: 8081 ) name or can be set manually.
[Link]-key
host [Link]-store-password The encryption key that is used to store persistent logins.
The HTTP host. (default: [Link] ) The password to open the trust store le.
so-reuse-port
host-enabled [Link]-suites Enable socket reuse port.
Enable listening to host:port. (default: true ) A list of strings of cipher suites to use. If not provided, a
reasonable default is selected. tcp-quick-ack
ssl-port Enable tcp quick ack.
The HTTPS port. (default 8443 ) [Link]

The list of protocols to explicitly enable. (default: TLSv1.3 and tcp-cork

test-ssl-port TLSv1.2 ). Enable tcp cork.
The HTTPS port used to run tests. (default 8444 )
[Link]-auth tcp-fast-open
proxy-address-forwarding Con gures the engine to require/request client authentication. Enable tcp fast open.
The address, scheme etc will be set from headers forwarded by Possible values are: none , request and required . (default: none ).
the proxy server. domain-socket
io-threads
Path to a unix domain socket. (default:
allow-forwarded The number if IO threads used to perform IO. /var/run/[Link] )
Proxy address forwarding is enabled then the standard Forwarded
header will be used, rather than the more common but not [Link]-header-size domain-socket-enabled
standard X-Forwarded-For . The maximum length of all headers. (default: 20k ) Enables domain socket.

insecure-requests [Link]-body-size record-request-start-time

If insecure requests are allowed. Possible values: enabled , The maximum size of a request body. (default: 10M ) If enabled then start time will be recorded to enable logging of
redirect , disable . (default: enabled ) total request time. (default: false )
[Link]-chunk-size
http2 The max HTTP chunk size. [Link]
Enables HTTP/2. (default: true ) If access logging is enabled. (default: false )
[Link]-initial-line-length
[Link] The maximum length of the initial line. (default: 4096 ) [Link]
The HTTPS port. (default: 8443 ) The access log pattern. (default: common )
idle-timeout
ssl certificate file Htt ti idl ti t (d f lt ) l l t fil
 If logging should be done to a separate le. (default: false )
@Path("/book") @Target({[Link]})
public class BookResource { @Retention([Link])
[Link]-file-name
@HttpMethod("LOCK")
The access log le base name. (default: quarkus ) @GET public @interface LOCK {
@Produces(MediaType.APPLICATION_JSON) }
[Link]-directory public List<Book> getAllBooks() {}
The log directory to use when logging access to a le. @LOCK
@POST public void lockIt() {}
[Link]-directory
@Produces(MediaType.APPLICATION_JSON) }
public Response createBook(Book book) {}
The log directory to use when logging access to a le.

@DELETE
[Link]-suffix Injecting
@Path("{isbn}")
The log le su x. (default: .log ) @Produces(MediaType.APPLICATION_JSON) Using @Context annotation to inject JAX-RS and Servlet information.
public Response deleteBook(
[Link] @PathParam("isbn") String isbn) {}
@GET
The log category to use if logging is being done via the standard
public String getBase(@Context UriInfo uriInfo) {
log mechanism. (default: [Link]-log )
return [Link]();
@GET
}
[Link]
@Produces(MediaType.APPLICATION_JSON)
@Path("search")
If the log should be rotated daily. (default: true ) public Response searchBook(
@QueryParam("description") String description) {} Possible injectable objects: SecurityContext , Request , Application ,
same-site-cookie.<name>.case-sensitive Configuration , Providers , ResourceContext , ServletConfig ,
}
If the cookie pattern is case sensitive. ServletContext , HttpServletRequest , HttpServletResponse ,
HttpHeaders , Urinfo , SseEventSink and Sse .
same-site-cookie.<name>.value
To get information from request: HTTP Filters
The value to set in the samesite attribute.
@PathParam
HTTP request and response can be intercepted to manipulate the
same-site-cookie.<name>.enable-client-checker Gets content from request URI. (example: /book/{id} metadata (ie headers, parameters, media type, … ) or abort a
Some User Agents break when sent SameSite=None, this will @PathParam("id") ) request. You only need to implement the next
detect them and avoid sending the value. (default: true ) ContainerRequestFilter and ContainerResponseFilter JAX-RS
@QueryParam interfaces respectively.
same-site-cookie.<name>.add-secure-for-none Gets query parameter. (example: /book?desc=""
If this is true then the 'secure' attribute will automatically be sent @QueryParam("desc) ) @Provider
on cookies with a SameSite attribute of None. (default: true ) public class LoggingFilter
@FormParam implements ContainerRequestFilter {
If metrics extension is registered, you can enable to get HTTP Gets form parameter.
metrics by setting [Link] to true. @Context
@MatrixParam
UriInfo info;
JAX-RS Get URI matrix parameter. (example:

@Context
/book;author=mkyong;country=malaysia )
HttpServletRequest request;
Quarkus uses JAX-RS to de ne REST-ful web APIs. Under the

covers, Rest-EASY is working with Vert.X directly without using any @CookieParam
@Override
Servlet.
Gets cookie param by name. public void filter(ContainerRequestContext context) {
It is important to know that if you want to use any feature that final String method = [Link]();
implies a Servlet (ie Servlet Filters) then you need to add the @HeaderParam final String path = [Link]();
quarkus-undertow extension to switch back to the Servlet Gets header parameter by name. final String address = [Link]();
ecosystem but generally speaking, you don’t need to add it as [Link]("Request %s %s from IP %s",
everything else is well-supported. Valid HTTP method annotations provided by the spec are: @GET ,
method, path, address);
@POST , @PUT , @DELETE , @PATCH , @HEAD and @OPTIONS .
}

You can create new annotations that bind to HTTP methods not }
de ned by the spec.

Exception Mapper

You can map exceptions to produce a custom output by

implementing ExceptionMapper interface:
 @Provider import [Link]; @ApplicationScoped
public class ErrorMapper import [Link]; public class MyDeclarativeRoutes {
implements ExceptionMapper<Exception> { import [Link];
import [Link]; @Route(path = "/hello", methods = [Link])
@Override public void greetings(RoutingContext rc) {
public Response toResponse(Exception exception) { @ApplicationScoped String name = [Link]().getParam("name");
int code = 500; public class MyBean { if (name == null) {
if (exception instanceof WebApplicationException) { name = "world";
code = ((WebApplicationException) exception) public void filters( }
.getResponse().getStatus(); @Observes Filters filters) { [Link]().end("hello " + name);
} filters }
return [Link](code) .register(
.entity( rc -> { @RouteFilter(20)
[Link]() [Link]() void filter(RoutingContext rc) {
.add("error", [Link]()) .putHeader("X-Filter", "filter 1"); [Link]().putHeader("X-Filter", "filter 2");
.add("code", code) [Link](); [Link]();
.build() }, }
) 10);
.build(); } @Route
} String hello(@Param Optional<String> name) {}
} public void routes(
@Observes Router router) { @Route
router String helloFromHeader(@Header("My-Header") String head
.get("/") er) {}
Caching
.handler(rc -> [Link]().end("OK"));
Annotations to set Cache-Control headers: } @Route
} String createPerson(@Body Person person) {}

@Produces(MediaType.APPLICATION_JSON)
}
@[Link]
public User me() {} Declarative

@Produces(MediaType.APPLICATION_JSON) You can use @Route annotation to use reactive routes and GraphQL
@[Link]( @RouteFilter to sue reactive lters in a declarative way:
maxAge = 2000, Quarkus integrates with GraphQL using MicroPro le GraphQL
noStore = false ./mvnw quarkus:add-extension integration.
) -Dextensions="quarkus-vertx-web"
public User you() {}
./mvnw quarkus:add-extension
-Dextensions="graphql"

Vert.X Filters and Routes

@GraphQLApi
Programmatically
public class FilmResource {
You can also register Vert.X Filters and Router programmatically
inside a CDI bean: @Query("allFilms")
public List<String> films() {
}

@Query
public String getFilm(@Name("filmId") int id)) {}

@Query
public List<Hero> getHeroesWithSurname(
@DefaultValue("Skywalker") String surname) {
}

@Mutation
public Greetings load(Greetings greetings) {
}

}
If name not provided, then query name is resolved from method extendig [Link] . [Link]
name. The le path to the corresponding certi cate private key le in
You can see the full schema at /graphql/[Link] . Also
GZip Support PEM format.
GraphiQL UI is enabled at dev and test mode at /graphql-ui/ .
You can con gure Quarkus to use GZip in the [Link]-store

Extension can be con gured with the follwoing paramters pre xed [Link] le using the next properties with An optional key store which holds the certi cate information
with [Link]-graphql . [Link] su x: instead of specifying separate les.

root-path [Link]
[Link]-store-type
The rootPath under which queries will be served. (default: EnableGZip. (default: false ) An optional parameter to specify the type of the key store le.
/graphql )
[Link]-input
[Link]-store-password
root-path-ui Con gure the upper limit on de ated request body. (default: 10M ) A parameter to specify the password of the key store le.
The path where GraphQL UI is available. (default: /graphql-ui ) (default: password )
GRPC
always-include-ui [Link]-store
The path where GraphQL UI is available. (default: /graphql-ui ) Quarkus integrates with gRPC: Trust store which holds the certi cate information of the
certi cates to trust
root-path-ui ./mvnw quarkus:add-extension
Always include the UI. By default this will only be included in dev -Dextensions="quarkus-grpc" [Link]-store-type
and test. (default: false ) Parameter to specify type of the trust store le.

enable-ui Then you need to con gure build tool with gRPC plugins. In the [Link]-store-password
If GraphQL UI should be enabled. (default: false ) case of Maven, the [Link]:os-maven-plugin extension and A parameter to specify the password of the trust store le.
[Link]:protobuf-maven-plugin
[Link] [Link]-suites
Protos les are stored at src/main/proto .
Enable metrics. (default: false ) A list of the cipher suites to use.
When java les are created two service implementations are
Vert.X Verticle provided: one with default gRPC API and other with Mutiny support. [Link]

The list of protocols to explicitly enable. (default:

Vert.X Verticles are also supported: With [Link] pre x, the next con guration properties TLSv1.3,TLSv1.2 )
can be set:
@ApplicationScoped [Link]
port
public class VerticleDeployer { The path to the certi cate le.
The gRPC Server port. (default: 9000 )

@Inject [Link]
host
Vertx vertx;
The path to the private key le.
The gRPC server host. (default: [Link] )
public void init(@Observes StartupEvent ev) {
handshake-timeout
To consume the service:
CountDownLatch latch = new CountDownLatch(1);
[Link](BareVerticle::new, The gRPC handshake timeout.
new DeploymentOptions() @GrpcService("hello")
.setConfig( [Link] client;
max-inbound-message-size
new JsonObject()
The max inbound message size in bytes. @GrpcService("hello")
.put("id", "bare")
) [Link] channel;
plain-text
)
.thenAccept(x -> [Link]()); Use plain text. (default: true )
Some con guration example to set the host and the SSL
[Link](); alpn parameters:
} TWhether ALPN should be used. (default: true )
}
[Link]=localhost
enable-reflection-service [Link]-text=false
Enables the gRPC Re ection Service. (default: false ) [Link]=src/main/resourc
Verticles can be: es/tls/[Link]
[Link] [Link]=src/main/resources/tls/c
bare [Link]
The le path to a server certi cate or certi cate chain in PEM
extending [Link] . format.
[Link]-store=src/main/resourc
es/tls/[Link]
mutiny
Fault Tolerance If 3 (4 x 0.75) failures occur among the rolling window of 4
[Link]/getNow/Retry/enabled=false
consecutive invocations then the circuit is opened for 1000 ms and
# Disable everything except fallback
Quarkus uses MicroPro le Fault Tolerance spec: then be back to half open. If the invocation succeeds then the
MP_Fault_Tolerance_NonFallback_Enabled=false
circuit is back to closed again.
./mvnw quarkus:add-extension You can use bulkahead pattern to limit the number of concurrent
-Dextensions="[Link]:quarkus-smallrye-fault-toleranc access to the same resource. If the operation is synchronous it MicroPro le Fault Tolerance integrates with MicroPro le
e" uses a semaphore approach, if it is asynchronous a thread-pool Metrics spec. You can disable it by setting
one. When a request cannot be processed BulkheadException is MP_Fault_Tolerance_Metrics_Enabled to false.
thrown. It can be used together with any other fault tolerance
annotation.
MicroPro le Fault Tolerance spec uses CDI interceptor and it can Observability
be used in several elements such as CDI bean, JAX-RS resource or
MicroPro le Rest Client. @Bulkhead(5) Health Checks
@Retry(maxRetries = 4,
To do automatic retries on a method: delay = 1000, Quarkus relies on MicroPro le Health spec to provide health
retryOn = [Link]) checks.
@Path("/api") WorldClock getNow(){}
@RegisterRestClient ./mvnw quarkus:add-extension
public interface WorldClockService { -Dextensions="[Link]:quarkus-smallrye-health"
@GET @Path("/json/cet/now")
Fault tolerance annotations:
@Produces(MediaType.APPLICATION_JSON)
@Retry(maxRetries = 2)
Annotation Properties By just adding this extension, an endpoint is registered to /health
WorldClock getNow();
} providing a default health check.
@Timeout unit

{
maxRetries , delay , delayUnit , "status": "UP",
You can set fallback code in case of an error by using @Fallback
maxDuration , durationUnit , "checks": [
annotation: @Retry
jitter , jitterDelayUnit , retryOn , ]
abortOn }
@Retry(maxRetries = 1)
@Fallback(fallbackMethod = "fallbackMethod")
WorldClock getNow(){}

@Fallback fallbackMethod To create a custom health check you need to implement the
public WorldClock fallbackMethod() { HealthCheck interface and annotate either with @Readiness (ready to

return new WorldClock(); process requests) or @Liveness (is running) annotations.

waitingTaskQueue (only valid in
} @Bulkhead
asynchronous)
@Readiness
public class DatabaseHealthCheck implements HealthCheck {
failOn , delay , delayUnit ,
@Override
fallbackMethod must have the same parameters and return type as
requestVolumeThreshold ,
public HealthCheckResponse call() {
the annotated method. @CircuitBreaker
failureRatio , successThreshold
HealthCheckResponseBuilder responseBuilder =
You can also set logic into a class that implements FallbackHandler [Link]("Database conn");
interface:
@Asynchronous try {
checkDatabaseConnection();
public class RecoverFallback
[Link]("connection", true);
implements FallbackHandler<WorldClock> {
You can override annotation parameters via con guration le using [Link]();
@Override
property [classname/methodname/]annotation/parameter : } catch (IOException e) {
public WorldClock handle(ExecutionContext context) {
// cannot access the database
}
[Link]/getNow/Retry/maxDuration=30 [Link]()
}
# Class scope .withData("error", [Link]());
[Link]/Retry/maxDuration=3000 }
# Global return [Link]();
And set it in the annotation as value Retry/maxDuration=3000 }
@Fallback([Link]) . }

In case you want to use circuit breaker pattern:

You can also enable/disable policies using special parameter
enabled .
Builds the next output:
@CircuitBreaker(requestVolumeThreshold = 4,
failureRatio=0.75,
delay = 1000)
WorldClock getNow(){}
 Health groups are supported to provide custom health checks
{ [Link]-path=/hello
groups:
"status": "UP", [Link]-path=/customlive
"checks": [ [Link]-path=/customready
{ @[Link]("mygroup1")
"name": "Database conn", public class SimpleHealthGroupCheck implements HealthCheck
"status": "UP", {
Automatic readiness probes
"data": { }
"connection": true Some default readiness probes are provided by default if any of the
} next features are added:
} You can ping grouped health checks by querying /group/mygroup1 .
] datasource
}
A probe to check database connection status. Group root path can be con gured:

kafka [Link]-path=/customgroup
Since health checks are CDI beans, you can do: A probe to check kafka connection status. In this case you need
to enable manually by setting [Link] to
@ApplicationScoped true . Metrics
public class DatabaseHealthCheck {
mongoDB Quarkus can utilize the MicroPro le Metrics spec to provide metrics
@Liveness
A probe to check MongoDB connection status. support.
HealthCheck check1() {
return [Link]
neo4j ./mvnw quarkus:add-extension
.up("successful-live"); -Dextensions="[Link]:quarkus-smallrye-metrics"
} A probe to check Neo4J connection status.

@Readiness artemis
HealthCheck check2() { A probe to check Artemis JMS connection status. The metrics can be read with JSON or the OpenMetrics format. An
return HealthStatus endpoint is registered automatically at /metrics providing default
metrics.
.state("successful-read", this::isReady) kafka-streams
}
Liveness (for stream state) and Readiness (topics created) MicroPro le Metrics annotations:

probes.
private boolean isReady() {}
@Timed
}
vault Tracks the duration.
A probe to check Vault conection status.
@SimplyTimed
You can ping liveness or readiness health checks individually by gRPC Tracks the duration without mean and distribution calculations.
querying /health/live or /health/ready .
A readiness probe for the gRPC services.
Quarkus comes with some HealthCheck implementations for @Metered
checking service status. Cassandra Tracks the frequency of invocations.
A readiness probe to check Cassandra connection status.
SocketHealthCheck: checks if host is reachable using a @Counted
socket. Redis Counts number of invocations.
UrlHealthCheck: checks if host is reachable using a Http URL A readiness probe to check Redis connection status.
connection. @Gauge
You can disable the automatic generation by setting Samples the value of the annotated object.
InetAddressHealthCheck: checks if host is reachable using <component>.[Link] to false.
[Link] method. @ConcurrentGauge
[Link]=false Gauge to count parallel invocations.
@Liveness [Link]=false
HealthCheck check1() { [Link]=false @Metric
return new UrlHealthCheck("[Link]
Used to inject a metric. Valid types Meter , Timer , Counter ,
.name("Google-Check");
Histogram . Gauge only on producer methods/ elds.
}
In the case of Vault you can pass parameters to modify the call of
the status endpoint in Vault.

If you want to override or set manually readiness/liveness probes, [Link]=true

you can do it by setting health properties: [Link]-by-ok=true
[Link]-stand-by-ok=true
 [Link]
@GET @Stereotype
//... @Retention([Link]) The path for the prometheus metrics endpoint (produces
@Timed(name = "checksTimer", @Target({ [Link], [Link], ElementTyp text/plain). (default: /metrics )
description = "A measure of how long it takes [Link] })
to perform a hello.", @Timed(name = "checksTimer", [Link]
unit = [Link]) description = "A measure of how long it takes Support for export to Azure Monitor.
public String hello() {} to perform a hello.",
unit = [Link]) [Link]-key
@Counted(name = "countWelcome", public @interface TimedMilliseconds {
The path for the azure monitor instrumentationKey.
description = "How many welcome have been performed.") }
public String hello() {}
[Link]

Support for export to StatsD.

There is a tight integration with Micrometer in the form of an
@Gauge annotation returning a measure as a gauge. extension:
[Link]
Micrometer metrics support. (default: true )
@Gauge(name = "hottestSauce", unit = [Link], ./mvnw quarkus:add-extension
description = "Hottest Sauce so far.") -Dextensions="micrometer"
[Link]
public Long hottestSauce() {}
Micrometer metrics support. (default: true )
Add a micrometer dependency for the registry of your choosing:
[Link]
Injecting a histogram using @Metric .
Signalfx URI.
<dependency>
@Inject <groupId>[Link]</groupId>
[Link]-token
@Metric(name = "histogram") <artifactId>micrometer-registry-prometheus</artifactId>
Histogram historgram; </dependency> Access Token.

[Link]-patterns

You can con gure Metrics: You can con gure Micrometer. Pre x is [Link] : Comma-separated case-sensitive list of regular expressions
de ning Paths that should be matched and used as tags
enabled
[Link]=/mymetrics
Micrometer metrics support. (default: true ) [Link]-patterns
Comma-separated case-sensitive list of regular expressions
registry-enabled-default de ning Paths that should be ignored / not measured.
Pre x is [Link]-metrics .
Micrometer MeterRegistry discovery. (default: true )
[Link]
path
The path to the metrics handler. (default: /metrics ) binder-enabled-default Datadog MeterRegistry con guration in Map<String, String>

Micrometer MeterBinder discovery. (default: true ) format.

[Link]
[Link]
Metrics are enabled or not. (default: true ) [Link]

Vert.x metrics support. JMX registry con guration properties in Map<String, String>
format.
[Link]
Apply Micrometer compatibility mode. (default: false ) [Link]
[Link]
Micropro le Metrics support.
Prometheus registry con guration properties in Map<String,
[Link] set to true exposes
String> format.
Hibernate metrics under vendor scope. [Link]

Micrometer JVM metrics support. (default: true )

[Link] set to true exposes MongoDB [Link]
metrics under vendor scope. [Link]
Stackdriver registry con guration properties in Map<String,
String> format.
You can apply metrics annotations via CDI stereotypes: Micrometer System metrics support. (default: true )
Tracing
[Link]
Support for export to Datadog Support for Datadog. Quarkus can utilize the MicroPro le OpenTracing spec.

[Link] ./mvnw quarkus:add-extension

Support for export to JMX Support for JMX. -Dextensions="[Link]:quarkus-smallrye-opentracing"

[Link]
Support for export to Prometheus. Requests sent to any endpoint are traced automatically.
This extension includes OpenTracing support and Jaeger tracer.
<dependency> Native Executable
<groupId>[Link]</groupId>
Jaeger tracer con guration:
<artifactId>opentracing-kafka-client<</artifactId> You can build a native image by using GraalVM. The common use
</dependency> case is creating a Docker image so you can execute the next
[Link]-name=myservice commands:
[Link]-type=const
[Link]-param=1
[Link]=[Link] And con gure it: ./mvnw package -Pnative -[Link]-build=tr
ue
[Link]=true

...
docker build -f src/main/docker/[Link]
[Link]=prices
-t quarkus/getting-started .

@Traced annotation can be set to disable tracing at class or method docker run -i --rm -p 8080:8080 quarkus/getting-started
# For Produces
level.
[Link]=i
Tracer class can be injected into the class.
[Link]
... You can use [Link]-runtime to select the
# For consumers container runtime to use. Now docker (default) and podman are the
@Inject
[Link]=[Link] valid options.
Tracer tracer;
[Link]

[Link]().setBaggageItem("key", "value"); ./mvnw package -Pnative -[Link]-runtime=
podman
AWS XRay
You can disable Jaeger extension by using [Link] If you are building native images, and want to use AWS X-Ray
property. To con gure native application, you can create a config directory at
Tracing with your lambda you will need to include quarkus-amazon- the same place as the native le and place an
lambda-xray as a dependency in your pom.
You can log the traceId , spanId and sampled in normal log: [Link] le inside. config/[Link] .

SSL
[Link]=%d{HH:mm:ss} %-5p traceId=%X{tra
ceId}, To create a native image with SSL you need to copy SunEC library
spanId=%X{spanId}, sampled and certi cates:
=%X{sampled} [%c{2.}] (%t) %s%e%n
Java 8:

Additional tracers FROM [Link]/quarkus/ubi-quarkus-native-image:{graalvm-vers

ion}-java8 as nativebuilder
JDBC Tracer RUN mkdir -p /tmp/ssl-libs/lib \
&& cp /opt/graalvm/jre/lib/security/cacerts /tmp/ssl-libs
Adds a span for each JDBC queries. \
&& cp /opt/graalvm/jre/lib/amd64/[Link] /tmp/ssl-lib
<dependency> s/lib/
<groupId>[Link]</groupId>
<artifactId>opentracing-jdbc</artifactId> FROM [Link]/ubi8/ubi-minimal
</dependency> WORKDIR /work/
COPY --from=nativebuilder /tmp/ssl-libs/ /work/
COPY target/*-runner /work/application
RUN chmod 775 /work /work/application
Con gure JDBC driver apart from tracing properties seen before:
EXPOSE 8080
CMD ["./application", "-[Link]=[Link]", "-Djav
# add ':tracing' to your database URL [Link]=/work/lib", "-[Link]=/wor
[Link]= k/cacerts"]
jdbc:tracing:postgresql://localhost:5432/mydatabase
[Link]=
[Link]
[Link]= Java 11:
[Link]

Kafka Tracer

Adds a span for each message sent to or received from a Kafka

topic.
 password Path to the JVM Docker le. (default:
FROM [Link]/quarkus/ubi-quarkus-native-image:{graalvm-vers
The registry password. ${[Link]}/src/main/docker/[Link] )
ion}-java11 as nativebuilder
RUN mkdir -p /tmp/ssl-libs/lib \
insecure dockerfile-native-path
&& cp /opt/graalvm/lib/security/cacerts /tmp/ssl-libs \
&& cp /opt/graalvm/lib/[Link] /tmp/ssl-libs/lib/ Flag to allow insecure registries. (default: false ) Path to the native Docker le. (default:
${[Link]}/src/main/docker/[Link] )
FROM [Link]/ubi8/ubi-minimal build
WORKDIR /work/ S2I
Boolean to set if image should be built. (default: false )
COPY --from=nativebuilder /tmp/ssl-libs/ /work/
COPY target/*-runner /work/application ./mvnw quarkus:add-extensions
push
RUN chmod 775 /work /work/application -Dextensions="quarkus-container-image-s2i"
EXPOSE 8080 Boolean to set if image should be pushed. (default: false )
CMD ["./application", "-[Link]=[Link]", "-Djav
[Link]=/work/lib", "-[Link]=/wor Jib
k/cacerts"] Pre x is [Link]-image-docker :
./mvnw quarkus:add-extensions base-jvm-image
-Dextensions="quarkus-container-image-jib"
The base image to use for the s2i build. (default: fabric8/java-
Inclusion of resources alpine-openjdk8-jre )

By default, no resources are included in native executable. Quarkus copies any le under src/main/jib into the built container base-native-image
[Link] allows to set glob expressions to
image.
include resources based on src/main/resources path. The base image to use for the native build. (default:
[Link]/ubi8/ubi-minimal )
Pre x is [Link]-image-jib :
Given src/main/resources/foo/[Link] :
base-jvm-image Kubernetes
[Link]=foo/** The base image to use for the jib build. (default: fabric8/java-
alpine-openjdk8-jre ) Quarks can use Dekorate to generate Kubernetes resources.

Container Images Creation base-native-image ./mvnw quarkus:add-extensions

The base image to use for the native build. (default: -Dextensions="quarkus-kubernetes"
You can levarage to Quarkus to generation and release of Docker [Link]/ubi8/ubi-minimal )
containers. It provides several extensions to make it so.
jvm-arguments Running ./mvnw package the Kubernetes resources are created at
mvn clean package The arguments to pass to java. (default: - target/kubernetes/ directory.
-[Link]=true [Link]=[Link],-
-[Link]=true [Link]=[Link] ) Container Images Creation integrates with Kubernetes
-[Link]=[Link] extension, so no need of extra Kubernetes properties.
native-arguments

The arguments to pass to the native application. (default: -

Generated resource is integrated with MicroPro le Health
[Link]=[Link] )
annotations.
Pre x is [Link]-image :
Also, you can customize the generated resource by setting the new
group environment-variables
values in [Link] :
The group/repository of the image. (default: the ${[Link]} ) Map of environment variables.

name jvm-entrypoint
The name of the image. (default: the application name) A custom entry point of the container image in JVM mode.

tag native-entrypoint

The tag of the image. (default: the application version) A custom entry point of the container image in native mode.

additional-tags Docker
Additional tags of the container image.
./mvnw quarkus:add-extensions
registry -Dextensions="quarkus-container-image-docker"

The registry to use for pushing. (default: [Link] )

username Pre x is [Link]-image-s2i :

The registry username.
dockerfile-jvm-path
 [Link]=mynamespace
Or add new labels and/or annotations: To override the name of the generated resource you can use:
[Link] , [Link] and

[Link]=bar [Link] .
[Link]=3
[Link]=bar
Deployment
[Link]=bar
To deploy automatically the generated resources, you need to set
[Link]-seconds=45 metrics [Link] ag to true .

[Link]=/deployment/git When using metrics extension, Prometheus annotations are
mvn clean package -[Link]=true
hub generated:
[Link]-only=true

[Link]/scrape: "true"
[Link]-name=
[Link]/path: /metrics If you set this ag to true , the build and push ags from
github-token
[Link]/port: "8080" container-image are set to true too.
[Link]-name=
greeting-security To deploy the application, the extension uses the
[Link]-mode [Link] All options
=420 Kubernetes Deployment Targets described at Kubernetes Client are valid here.

You can generate different resources setting the property
[Link]-m
[Link]-target .
Minikube
ap-name=my-secret

Possible values are kubernetes , openshift and knative . The default Quarkus has a Minikube extension which creates Kubernetes
[Link]=true
value is kubernetes . manifests that are tailored for Minikube.

[Link]-env-var=foobar
Knative Properties ./mvnw quarkus:add-extension
[Link]=my-config-map,another-con
fig-map -Dextensions="minikube"
Most of the Kubernetes properties are valid in Knative output by
[Link]=my-secret,my-other-secret just changing the kubernetes pre x to knative pre x (ie
[Link]-seconds to
[Link]=64Mi [Link]-seconds ). Remember to execute eval $(minikube -p minikube docker-
[Link]=250m env) to build images directly inside Minkube cluster.
[Link]=512Mi There are also speci c properties for Knative:
[Link]=1000m
OpenShift
[Link]-target=knative
[Link]-name=my-revision Instead of adding Kubernetes extension, set container image s2i
All possible values are explained at [Link]=80 and the target to openshift for working with OpenShift, an
[Link] guration-options. extension grouping all of the is created:
Labels and Annotations
List of con guration options: ./mvnw quarkus:add-extension
The generated manifest use the Kubernetes recommended labels -Dextensions="openshift"
kubernetes
and annotations.
[Link] guration-options
"labels" : {
openshift Kubernetes Con guration Extension
"[Link]/part-of" : "todo-app",
"[Link]/name" : "todo-rest", [Link]
Integration between MicroPro le Con g spec and Con gMaps &
"[Link]/version" : "1.0-rc.1" Secrets:
} Knative
[Link] ./mvnw quarkus:add-extensions
"annotations": {
-Dextensions="quarkus-kubernetes-config"
"[Link]/vcs-url" : "<some url>", Using Existing Resources
"[Link]/commit-id" : "<some git SHA>",
} You an provide your Kubernetes resources in form of yaml/json and
they will provide additional resources or be used as base for the [Link]=true
generation process: [Link]-maps=cmap1,cmap2
You can override the labels by using the next properties:
Resources are added in src/main/kubernetes directory with the
target name ( [Link] , [Link] , [Link] , or the
[Link]-of=todo-app yml equivalents) with one orm ore Kubernetes resources. Any
[Link]=todo-rest resource found will be added in the generated manifests. If one of
[Link]=1.0-rc.1 the provided resources has the same name as one of the generated
ones, then the generated resource will be created on top of the
provided resource respecting existing content
 Client certi cate le.
@ConfigProperty(name = "some.prop1") @Dependent
String someProp1; public class KubernetesClientProducer {
client-cert-data

@ConfigProperty(name = "some.prop2") Client certi cate data. @Produces
String someProp2; public KubernetesClient kubernetesClient() {
client-key-data Config config = new ConfigBuilder()
Client key data. .withMasterUrl("[Link]
.build();
If the con g
key is a Quarkus con guration le
return new DefaultKubernetesClient(config);
[Link] / [Link] , the content is parsed and client-key-algorithm
}
each key of the con guration le is used as con g property. Client key algorithm.
}
List of Kubernetes Con g parameters. client-key-passphrase

[Link]-config as pre x is skipped in the next table. Client key passphrase.

And inject it on code:
enabled username
@Inject
The application will attempt to look up the con guration from the Username. KubernetesClient client;
API server. (default: false )

password
ServiceList myServices = [Link]().list();
fail-on-missing-config Password.
The application will not start if any of the con gured con g Service myservice = [Link]()
sources cannot be located. (default: true ) watch-reconnect-interval .inNamespace("default")
Watch reconnect interval. (default: PT1S ) .withName("myservice")
config-maps .get();
Con gMaps to look for in the namespace that the Kubernetes watch-reconnect-limit

Client has been con gured for. Supports CSV. CustomResourceDefinitionList crds = client
Maximum reconnect attempts. (default: -1 ) .customResourceDefinitions()
namespace
.list();
connection-timeout
Access to Con gMaps from a speci c namespace. Maximum amount of time to wait for a connection. (default: dummyCRD = new CustomResourceDefinitionBuilder()
PT10S ) ...
[Link]
.build()
Whether or not con guration can be read from secrets. (default: request-timeout [Link]()
false ) .create(dummyCRD);
Maximum amount of time to wait for a request. (default: PT10S )

Kubernetes Client rolling-timeout

Maximum amount of time to wait for a rollout. (default: PT15M ) Testing
Quarkus integrates with Fabric8 Kubernetes Client.
Quarkus provides a Kubernetes Mock test resource that starts a
http-proxy
./mvnw quarkus:add-extension
mock of Kubernetes API server and sets the proper environment
HTTP proxy used to access the Kubernetes. variables needed by Kubernetes Client.
-Dextensions="quarkus-kubernetes-client"

https-proxy Register next dependency: [Link]:quarkus-test-kubernetes-

HTTPS proxy used to access the Kubernetes. client:test .
List of Kubernetes client parameters.
proxy-username
[Link]-client as pre x is skipped in the next table.
Proxy username.
trust-certs
proxy-password
Trust self-signed certi cates. (default: false )
Proxy password.
master-url
no-proxy
URL of Kubernetes API server.
IP addresses or hosts to exclude from proxying
namesapce

Default namespace. Or programmatically:

ca-cert-file
CA certi cate data.

client-cert-file
 @QuarkusTestResource([Link] <dependency> public class GreetingFunction {
s) <groupId>[Link]</groupId>
@QuarkusTest <artifactId>quarkus-test-amazon-lambda</artifactId> @Inject
public class KubernetesClientTest { <scope>test</scope> GreetingService service;
</dependency>
@MockServer @[Link]
private KubernetesMockServer mockServer; public String greet(String name) {}

@Test @Test @[Link]("HelloCustomer")
public void test() { public void testLambda() { public String greet(Customer name) {}
final Pod pod1 = ... MyInput in = new MyInput();
mockServer [Link]("Hello"); @Funq
.expect() [Link]("Stu"); public Greeting greet(Friend friend,
.get() MyOutput out = [Link]([Link], in); @[Link] AwsContext ctx) {}
.withPath("/api/v1/namespaces/test/pods") } }
.andReturn(200,
new PodListBuilder()
.withNewMetadata() To scaffold a AWS Lambda run: In case of Amazon Lambda, only one Funqy function can be
.withResourceVersion("1")
exported per Amazon Lambda deployment. If there is only one
.endMetadata()
mvn archetype:generate \ method annotated with @Funq then no prob, if not, you need to set
.withItems(pod1, pod2)
-DarchetypeGroupId=[Link] \ the function name with [Link] property.
.build())
-DarchetypeArtifactId=quarkus-amazon-lambda-archetype \
.always();
}
-DarchetypeVersion={version} Funqy HTTP
}
You can invoke on Funqy functions in a pure HTTP environment
with simple adding the Funqy HTTP extension.
Azure Functions
AWS Lambda <dependency>
Quarkus can make a microservice be deployable to the Azure
<groupId>[Link]</groupId>
Functions.
Quarkus integrates with Amazon Lambda. <artifactId>quarkus-funqy-http</artifactId>
To scaffold a deployable microservice to the Azure Functions run: </dependency>
./mvnw quarkus:add-extension
-Dextensions="[Link]:quarkus-amazon-lambda"
mvn archetype:generate \
-DarchetypeGroupId=[Link] \ Funqy Cloud Events
-DarchetypeArtifactId=quarkus-azure-functions-http-archet
And then implement ype \ Add the extension:
[Link] interface. -DarchetypeVersion={version}

<dependency>
public class TestLambda <groupId>[Link]</groupId>
implements RequestHandler<MyInput, MyOutput> {
Funqy <artifactId>quarkus-funqy-knative-events</artifactId>
@Override </dependency>
public MyInput handleRequest(MyOutput input,
Quarkus Funqy is part of Quarkus’s serverless strategy and aims to
Context context) {
provide a portable Java API to write functions deployable to various
}
FaaS environments like AWS Lambda, Azure Functions, Knative, and
} @Funq
Knative events.
public String defaultChain(String input) {}

The interface
[Link] is also The Cloud Event type that triggers the function is defaultChain . It
supported. generates a response that triggers a new Cloud Event whose type is
[Link] and the event source is defaultChain .
The interface [Link] is also supported.
It can be changed by using the next properties:
You can set the handler name by using [Link]
property or by annotating the Lambda with the CDI @Named
[Link]=c
annotation.
[Link]
Test [Link]-
type=annotated
You can write tests for Amazon lambdas: [Link]-
source=configChain
The properties are of form: [Link]. Apache Camel Possible Swagger UI options with [Link]-ui pre x:
{function name}. .
urls
Apache Camel Quarkus has its own site:
Also can be overriden with The urls that will be included as options. (ie
[Link] [Link]-
@[Link] annotation. [Link]=[Link] )

@Funq
WebSockets
urls-primary-name
@CloudEventMapping(trigger = "annotated", responseSource = If urls option is used, this will be the name of the default
Quarkus can be used to handling web sockets.
"annotated", responseType = "lastChainLink") selection.
public String annotatedChain(String input) {}
./mvnw quarkus:add-extension
title
-Dextensions="[Link]:quarkus-undertow-websockets"
The html title for the page.
responseType chains annotatedChain response to lastChainLink
function. theme
And web sockets classes can be used:
Swagger UI theme to be used.
@Funq
public void lastChainLink(String input, @ServerEndpoint("/chat/{username}")
footer
@Context [Link] @ApplicationScoped
vent event) {} public class ChatSocket { A footer for the html page. Nothing by default.

@OnOpen deep-linking
public void onOpen(Session session, Enables deep linking for tags and operations.
A K-Native Trigger looks like: @PathParam("username") String username) {}
display-operation-id
apiVersion: [Link]/v1alpha1 @OnClose
kind: Trigger
Controls the display of operationId in operations list.
public void onClose(..) {}
metadata:
name: defaultchain default-models-expand-depth
@OnError
spec: public void onError(..., Throwable throwable) {} The default expansion depth for models.
filter:
attributes: @OnMessage default-model-expand-depth
type: defaultChain public void onMessage(...) {} The default expansion depth for the model on the model-example
subscriber: section.
ref: }
apiVersion: [Link]/v1
default-model-rendering
kind: Service
name: funqy-knative-events-quickstart Controls how the model is shown when the API is rst rendered.
OpenAPI
display-request-duration
Quarkus can expose its API description as OpenAPI spec and test it Controls the display of the request duration (in milliseconds) for
And to curl from inside the Kubernetes cluster:
using Swagger UI. "Try it out" requests.
curl -v "[Link]
./mvnw quarkus:add-extension doc-expansion
local" \
-X POST \
-Dextensions="[Link]:quarkus-smallrye-openapi" Controls the default expansion setting for the operations and
-H "Ce-Id: 1234" \ tags.
-H "Ce-Specversion: 1.0" \
-H "Ce-Type: defaultChain" \ Then you only need to access to /openapi to get OpenAPI v3 spec filter
-H "Ce-Source: curl" \ of services. Enables ltering.
-H "Content-Type: application/json" \
-d '"Start"' You can update the OpenApi path by setting [Link]-
max-displayed-tags
[Link] property.
Limits the number of tagged operations displayed to at most this
Also, in case of starting Quarkus application in dev or test mode, many.
Swagger UI is accessible at /swagger-ui . If you want to use it in
production mode you need to set [Link]- operations-sorter
include property to true . Apply a sort to the operation list of each API. ( alpha , method ,
function )
You can update the Swagger UI path by setting [Link]-
[Link] property. show-extensions

Controls the display of vendor extension.

[Link]=/my-custom-path
show-common-extensions
 Controls the display of extensions. presets And then you can use them to send an email:
A list of presets to use in Swagger UI.
tag-sorter [Link](
Apply a sort to the tag list of each API. You can customize the output by using Open API v3 annotations. [Link]("to@[Link]", "Subject", "Body")
);
on-complete @Schema(name="Developers",
Provides a mechanism to be noti ed when Swagger UI has description="POJO that represents a developer.")
nished rendering a newly provided de nition. public class Developer { Reactive Mail client
@Schema(required = true, example = "Alex")
syntax-highlight private String name; @Inject
}
Set to false to deactivate syntax highlighting of payloads and ReactiveMailer reactiveMailer;

cURL command.
@POST CompletionStage<Response> stage =
@Path("/developer") [Link](
oauth2-redirect-url
@Operation(summary = "Create deeloper", [Link]("to@[Link]", "Subject", "Body")
OAuth redirect URL. description = "Only be done by admin.") )
public Response createDeveloper( .subscribeAsCompletionStage()
request-interceptor @RequestBody(description = "Developer object", .thenApply(x -> [Link]().build());
Function to intercept remote de nition, "Try it out", and OAuth 2.0 required = true,
requests. content = @Content(schema =
@Schema(implementation = [Link])))
request-curl-options Developer developer) If you are using quarkus-resteasy-mutiny , you can return
[Link] type.
Array of command line options available to the curl command.
Mail class contains methods to add cc , bcc , headers , bounce
response-interceptor All possible annotations can be seen at
address , reply to , attachments , inline attachments and html body .
Function to intercept remote de nition, "Try it out", and OAuth 2.0 [Link] [Link] package.
responses.
You can also serve OpenAPI Schema from static les instead of [Link]([Link]("to@[Link]", "Subject", body)
dynamically generated from annotation scanning. .addInlineAttachment("[Link]",
show-mutated-request
new File("[Link]"),
Uses the mutated request returned from a requestInterceptor to You need to put OpenAPIdocumentation under META-INF directory "image/png", "<my-image@[Link]>"));
produce the curl command in the UI. (ie: META-INF/[Link] ).

supported-submit-methods A request to /openapi will serve the combined OpenAPI document

from the static le and the generated from annotations. You can If you need deep control you can inject Vert.x mail client
List of HTTP methods that have the "Try it out" feature enabled.
disable the scanning documents by adding the next con guration @Inject MailClient client;
property: [Link]=true .
validator-url You need to con gure SMTP properties to be able to send an email:
Swagger UI attempts to validate specs against [Link]’s Other valid document paths are: META-INF/[Link] , META-
online validator. INF/[Link] , WEB-INF/classes/META-INF/[Link] , WEB- [Link]=test@[Link]
INF/classes/META-INF/[Link] , WEB-INF/classes/META- [Link]=[Link]
with-credentials INF/[Link] . [Link]=465
Enables passing credentials, as de ned in the Fetch standard, in [Link]=true
CORS requests that are sent by the browser. You can store generated OpenAPI schema if [Link]- [Link]=....
[Link]-schema-directory is set. [Link]=....
model-property-macro

Function to set default values to each property in model.

Mail Sender
List of Mailer parameters. quarkus. as a pre x is skipped in the next
You can send emails by using Quarkus Mailer extension:
parameter-macro table.
Function to set default value to parameters.
./mvnw quarkus:add-extension Parameter Default Description
-Dextensions="[Link]:quarkus-mailer"
persist-authorization
[Link] Default address.
It persists authorization data and it would not be lost on browser
close/refresh.
You can inject two possible classes [Link] for
synchronous API or [Link] for Emails not sent, just
false in prod , true in
layout
asynchronous/reactive API. [Link] printed and stored in
dev and test .
The name of a component available via the plugin system to use a MockMailbox .
as the top-level layout for Swagger UI.
@Inject
Mailer mailer; [Link]-
plugins Default address.
address
A list of plugin functions to use in Swagger UI.
Parameter Default Description To start using it you only need to add the next extension:
@Inject
MockMailbox mailbox;
[Link] mandatory SMTP host. ./mvnw quarkus:add-extension
@BeforeEach -Dextensions="kogito"
void init() {
[Link] 25 SMTP port. [Link]();
}

Apache Tika
[Link] The username.
List<Mail> sent = mailbox
.getMessagesSentTo("to@[Link]");
Quarkus integrates with Apache Tika to detect and extract
metadata/text from different le types:
[Link] The password.
./mvnw quarkus:add-extension
Scheduled Tasks -Dextensions="quarkus-tika"
[Link] false Enables SSL.
You can schedule periodic tasks with Quarkus.
[Link]-all false Trust all certi cates.
@ApplicationScoped @Inject
public class CounterBean { [Link] parser;

Max open
[Link]-pool-size 10 @POST
connections . @Scheduled(every="10s", delayed="1s")
void increment() {} @Path("/text")
@Consumes({ "text/plain", "application/pdf",
Hostname for @Scheduled(cron="0 15 10 * * ?") "application/[Link]" })
[Link]-host-name HELO/EHLO and void morningTask() {} @Produces(MediaType.TEXT_PLAIN)
Message-ID } public String extractText(InputStream stream) {
return [Link](stream).getText();
}
Connection pool
[Link]-alive true every and cron
parameters can be surrounded with {} and the
enabled.
value is used as con g property to get the value.
You can con gure Apache Tika in [Link] le by
@Scheduled(cron = "{[Link]}") using next properties pre xed with quarkus :
[Link]-esmtp false Disable ESMTP.
void morningTask() {}
Parameter Default Description
TLS security mode.
And con gure the property into [Link] : Path to the Tika
[Link]-tls OPTIONAL DISABLED , OPTIONAL , [Link]-config-
[Link] con guration
REQUIRED . path
resource.
[Link]=0 15 10 * * ?

Login mode. NONE ,

[Link] NONE CSV of the
OPTIONAL , REQUIRED .
By default Quarkus expresion is used, but you can change that by abbreviated or full
setting [Link]-type property. [Link] parser class to be
loaded by the
[Link]-methods All methods. Space-separated list.
[Link]-type=unix extension.

[Link]-store Path of the key store.

The document may
[Link]
can be injected as any other bean and [Link]-embedded- have other embedded
true
scehdule jobs programmatically. content documents. Set if
[Link]-store-
Key store password. autmatically append.
password
@Inject
[Link] quartz;
if you enable SSL for the mailer and you want to build a
native executable, you will need to enable the SSL support
JGit
[Link](job, trigger);
[Link]=true .
Quarkus integrates with JGit to integrate with Git repositories:
Testing

If [Link] is set to true , which is the default value in

Kogito ./mvnw quarkus:add-extension
-Dextensions="quarkus-jgit"
dev and test mode, you can inject MockMailbox to get the sent
Quarkus integrates with Kogito, a next-generation business
messages.
automation toolkit from Drools and jBPM projects for adding
business automation capabilities. And then you can start using JGit:
 try (Git git = [Link]() import [Link]; @ApplicationScoped
.setDirectory(tmpDir) import [Link]; public class TaskBean {
.setURI(url) import [Link];
.call()) { @Transactional
return [Link](); public class FlightServiceImpl @Scheduled(every = "10s")
} implements FlightService { void schedule() {
@State Task task = new Task();
private int numberOfBookings; [Link]();
}
When running in native mode, make sure to con gure SSL @ReadLock }
access correctly [Link]=true (Native and SSL). public int getNumberOfBookings() {
return numberOfBookings;
Web Resources }
To con gure in clustered mode vida DataSource:

You can serve web resources with Quarkus. You need to place web @WriteLock
[Link]=jdbc:postgresql://localhost/quarkus_
resources at src/main/resources/META-INF/resources and then they public void makeBooking(String details) {
test
are accessible (ie [Link] numberOfBookings += 1;
} [Link]=[Link]
# ...
By default static resources as served under the root context. You }

can change this by using [Link]-path property.
[Link]=true
[Link]-type=db
Transactional Memory Any member is saved/restored automatically ( @State is not
mandatory). You can use @NotState to avoid behaviour.
Quarkus integrates with the Software Transactional Memory (STM)
implementation provided by the Narayana project. Transaction boundaries You need to de ne the datasource used by clustered mode
and also import the database tables following the Quartz
Declarative schema.
./mvnw quarkus:add-extension
-Dextensions="narayana-stm"
@NestedTopLevel : De nes that the container will create a new Quartz can be con gured usinf the following properties with
top-level transaction for each method invocation. [Link] pre x:

Transactional objects must be interfaces and annotated with @Nested : De nes that the container will create a new top-level clustered
[Link] . or nested transaction for each method invocation.
Enable cluster mode or not.
Programmatically
@Transactional store-type
@NestedTopLevel
AtomicAction aa = new AtomicAction(); The type of store to use. Possible values: ram , db (default: ram )
public interface FlightService {

int getNumberOfBookings();
[Link](); datasource
void makeBooking(String details);
}
{ The name of the datasource to use.
try {
[Link]("BA123 ..."); table-prefix
[Link]("East Coast Taxis ...");
The pessimistic strategy is the default one, you can change to The pre x for quartz job store tables. (default: QRTZ_ )

optimistic by using @Optimistic . [Link]();
trigger-listeners.<name>.class
} catch (Exception e) {
Then you need to create the object inside [Link] . [Link](); Class name for the trigger.
}
Container<FlightService> container = new Container<>(); } trigger-listeners.<name>.property-name
FlightServiceImpl instance = new FlightServiceImpl(); The properties passed to the class.
FlightService flightServiceProxy = [Link](instanc
e);
Quartz job-listeners.<name>.class

Class name for the job.

Quarkus integrates with Quartz to schedule periodic clustered
The implementation of the service sets the locking and what needs job-listeners.<name>.property-name
tasks.
to be saved/restored:
The properties passed to the class.
./mvnw quarkus:add-extension
-Dextensions="quartz" plugins.<name>.class

Class name for the plugin.

plugins.<name>.property-name

The properties passed to the class

instance-name To render the template:
{#for i in total}
The name of the Quartz instance. (default: {i}:
QuarkusQuartzScheduler ) public class Item { {/for}
public String name;
thread-count public BigDecimal price;
The size of scheduler thread pool. (default: 25 ) }
The next map methods are supported:

@Inject
thread-priority
[Link] item; {#for key in [Link]}
Thread priority of worker threads in the pool. (default: 5 ) {#for value in [Link]}
@GET {[Link]}
force-start @Path("{id}") {#if [Link]}
The scheduler will be started even if no scheduled business @Produces(MediaType.TEXT_HTML) {map['foo']
methods are found. public TemplateInstance get(@PathParam("id") Integer id) {
return [Link]("item", [Link](id));

Qute } The next list methods are supported:

@TemplateExtension
Qute is a templating engine designed speci cally to meet the {list[0]}
static BigDecimal discountedPrice(Item item) {
Quarkus needs. Templates should be placed by default at
return [Link](new BigDecimal("0.9"));
src/main/resources/templates aand subdirectories.
}
The next number methods are supported:
./mvnw quarkus:add-extension @TemplateExtension(namespace = "str")
-Dextensions="quarkus-resteasy-qute" public static class StringExtensions { {#if [Link](5) == 0}
static String reverse(String val) {
return new StringBuilder(val).reverse().toString();
Templates can be de ned in any format, in case of HTML: }
}
Message Bundling
[Link]

@[Link]
{@[Link] item}
public interface AppMessages {
<!DOCTYPE html> If @ResourcePath is not used in Template then the name of the eld is
@[Link]("Hello {name}!")
<html> used as le name. In this case the le should be
String hello_name(String name);
<head> src/main/resources/templates/item.{} . Extension of the le is not
}
<meta charset="UTF-8"> required to be set.
<title>{[Link]}</title>
</head> discountedPrice is not a eld of the POJO but a method call.
<body> Method de nition must be annotated with @TemplateExtension and There are 3 methods to inject the message:
<h1>{[Link] ?: 'Unknown'}</h1> be static method. First parameter is used to match the base object
<h2>{str:reverse('Hello')}</h2> ( Item ). @TemplateExtension can be used at class level: [Link]([Link]).hello_name("Lucie");
<div>Price: {[Link]}</div>
{#if [Link] > 100} @TemplateExtension
<div>Discounted Price: {[Link]}</div> public class MyExtensions {
or
{/if} static BigDecimal discountedPrice(Item item) {
</body> return [Link](new BigDecimal("0.9"));
</html> } @Inject AppMessages app;
}
app.hello_name("Lucie");

First line is not mandatory but helps on doing property checks at

compilation time. Methods with multiple parameters are supported too:
or
Including templates passing parameters:
{[Link](2)}
<p>{msg:hello_name('Lucie')}</p>
<html>
<head>
<meta charset="UTF-8"> static BigDecimal discountedPrice(Item item, int scale) {
Localization
<title>Simple Include</title> return [Link](scale);
</head> } There are two ways to set localized message:
<body>
{#include foo limit=10 /}
</body>
Qute for syntax supports any instance of Iterable , [Link] ,
</html>
Stream or Integer .
 And the con guration to send all errors occuring in the package
@[Link]("de") @ApplicationScoped
[Link] to Sentrty with DSN [Link] :
public interface GermanAppMessages { public class CachedBean {

@Override [Link]=true @CacheResult(cacheName = "foo")
@[Link]("Hallo {name}!") [Link]=[Link] public Object load(Object key) {}
String hello_name(String name); [Link]=ERROR
} [Link]-app-packages=[Link] @CacheInvalidate(cacheName = "foo")
public void invalidate(Object key) {}

Full list of con guration properties having [Link] as pre x: @CacheInvalidateAll(cacheName = "foo")
or
public void invalidateAll() {}
msg_de.properties [Link] }

hello_name=Hallo {name}! Enable the Sentry logging extension (default: false)

[Link] You can disable the caching system by setting

Where to send events. [Link] property to false .
You can render programmaticaly the templates too:
This extension uses Caffeine as its underlying caching provider.
[Link]
// file located at src/main/resources/templates/reports/v1/
report_01.{}
Log level (default: WARN ) Each cache can be con gured individually:
@ResourcePath("reports/v1/report_01")
Template report; [Link]-app-packages [Link]."foo".initial-capacity=10
Con gure which package pre xes your application uses. [Link]."foo".maximum-size=20
String output = report [Link]."foo".expire-after-write
.data("samples", [Link]()) JSch [Link]."bar".maximum-size=1000
.render();

Quarkus integrates with Jsch for SSH communication.

Full list of con guration properties having [Link].
Reactive and Async [cache-name] as pre x:
./mvnw quarkus:add-extension
-Dextensions="quarkus-jsch"
initial-capacity
CompletionStage<String> async = [Link]();
Multi<String> publisher = [Link](); Minimum total size for the internal data structures.

Uni<String> content = [Link]() JSch jsch = new JSch(); maximum-size
.completionStage(() -> report.r Session session = [Link](null, host, port); Maximum number of entries the cache may contain.
enderAsync()); [Link]("StrictHostKeyChecking", "no");
[Link]();
expire-after-write

Speci es that each entry should be automatically removed from

Qute Mail Integration the cache once a xed duration has elapsed after the entry’s
Cache creation, or last write.
@Inject
MailTemplate hello; Quarkus can cache method calls by using as key the tuple (method expire-after-access
+ arguments). Speci es that each entry should be automatically removed from
CompletionStage<Void> c = [Link]("to@[Link]") the cache once a xed duration has elapsed after the entry’s
.subject("Hello from Qute template") ./mvnw quarkus:add-extension creation, or last write.
.data("name", "John") -Dextensions="cache"
.send();
You can multiple cache annotations on a single method.

@[Link](cacheName = "weather-cache") If you see a [Link] ,

INFO: Template located at src/main/resources/templates/hello.
public String getDailyForecast(LocalDate date, String city) you need to add the quarkus-smallrye-context-propagation
[html|txt] .
{} extension.
Sentry
Banner
Quarkus integrates with Sentry for logging errors into an error @CacheInvalidate removes the element represented by the
monitoring system. calculated cache key from cache. @CacheInvalidateAll removes all Banner is printed by default. It is not an extension but placed in the
entries from the cache. @CacheKey to speci cally set the arguments core.
to be used as key instead of all.
./mvnw quarkus:add-extension
[Link]
-Dextensions="quarkus-logging-sentry"
Path is relative to root of the classpath. (default:
)
[Link] Keys whose value is a raw string. The keys that end up in the user
./mvnw quarkus:add-extension
Enables banner. (default : true ) con guration are the keys speci ed her with '/' replaced by '.'
-Dextensions="quarkus-smallrye-context-propagation"

OptaPlanner properties-value-keys
Keys whose value represents a properties-like le conttent.
If using mutiny extension together you already get context
Quarkus integrates with OptaPlanner. propagation for ArC, RESTEasy and transactions. With
fail-on-missing-key
CompletionStage you need to:
./mvnw quarkus:add-extension If the application will not start if any of the con gured con g
-Dextensions="quarkus-optaplanner, quarkus-optaplanner-ja sources cannot be located. (default: true )
@Inject ThreadContext threadContext;
ckson" @Inject ManagedExecutor managedExecutor;
trust-store

[Link](..) TrustStore to be used containing the SSL certi cate used by
.thenApplyAsync(r -> {}, managedExecutor); Consul agent.
@PlanningSolution
public class TimeTable { trust-store-password
}
If you are going to use security in a reactive environment you will Password of TrustStore to be used containing the SSL certi cate

likely need Smallrye Content Propagation to propagate the identity used by Consul agent.
@Inject
private SolverManager<TimeTable, UUID> solverManager; throughout the reactive callback.
key-password

UUID problemId = [Link](); Con guration from HasiCorp Consul Password to recover key from KeyStore for SSL client
SolverJob<TimeTable, UUID> solverJob = [Link] authentication with Consul agent.
(problemId, problem); You can read runtime con guration from HashiCorp Consul.
TimeTable solution = [Link](); [Link]-port

./mvnw quarkus:add-extension Consul agent host. (default: localhost:8500 )

-Dextensions="consul-config"
Possible con guration options pre xed with [Link] : [Link]-https

Use HTTPS when communicating with the agent. (default: false )

solver-config-xml
You need to con gure Consul:
A classpath resource to read the solver con guration XML. Not [Link]
mandatory. [Link]=true Consul token to be provided when authentication is enabled.
[Link]-port=localhost:8500
[Link]-mode
[Link]-value-keys=config/consul-t [Link]-store
Enable runtime assertions to detect common bugs in your est KeyStore (classpath or lesystem) to be used containing the SSL
implementation during development. Possible values: certi cate used by Consul agent.
FAST_ASSERT , FULL_ASSERT , NON_INTRUSIVE_FULL_ASSERT ,
NON_REPRODUCIBLE , REPRODUCIBLE . (default: REPRODUCIBLE )
[Link]-store-password
@ConfigProperty(name = "[Link]")
[Link]-thread-count String message; Password of KeyStore.
Enable multithreaded solving for a single problem. Possible
[Link]-certs
values: MOVE_THREAD_COUNT_NONE , MOVE_THREAD_COUNT_AUTO , a number
or formula based on the available processors. (default: In Consul: To trust all certi cates or not.
MOVE_THREAD_COUNT_NONE )
[Link]-timeout
"Key": "config/consul-test",
[Link]-limit "Value": "[Link]=Hello from Consul" Connection timeout. (default: 10S )
How long the solver can run. (ie 5s )
[Link]-timeout

[Link]-spent-limit Possible con guration parameters, pre xed with [Link]- Reading timeout. (default: 60S )
How long the solver can run without nding a new best solution config :
after nding a new best solution. (ie 2h ) Amazon Alexa
enabled
[Link]-score-limit The application will attempt to look up the con guration from You can use Amazon Alexa by adding the extension:
Terminates the solver when a speci c or higher score has been Consul. (default: false )
reached. (ie 0hard/-1000soft ) ./mvnw quarkus:add-extension
prefix -Dextensions="quarkus-amazon-alexa"
[Link]-solver-count Common pre x that all keys share when looking up the keys from
The number of solvers that run in parallel. (default: Consul. The pre x is not included in the keys of the user
PARALLEL_SOLVER_COUNT_AUTO ) con guration
WebJar Locator
raw-value-keys
Context Propagation
To change how you can refer to webjars skipping the version part
<dependency> Spring DI
you can use WebJars locator extension. <groupId>[Link]</groupId>
<artifactId>netty-nio-client</artifactId> Quarkus provides a compatibility layer for Spring dependency
./mvnw quarkus:add-extension </dependency> injection.
-Dextensions="webjars-locator"

./mvnw quarkus:add-extension
Con guration properties are the same as Amazon DynamoDB but -Dextensions="quarkus-spring-di"
Then the JavaScript location is changed from changing the pre x from dynamodb to ses .
/webjars/jquery/3.1.1/[Link] to
/webjars/jquery/[Link] in your HTML les. Jbang Some examples of what you can do. Notice that annotations are
the Spring original ones.
Amazon SES Creating an initial script:
@Configuration
public class AppConfiguration {
mvn quarkus:add-extension jbang scripting/[Link]

-Dextensions="amazon-ses"
@Bean(name = "capitalizeFunction")
public StringFunction capitalizer() {
Adding Quarkus dependencies in script: return String::toUpperCase;
@Inject }
[Link] sesClient; //DEPS [Link]:quarkus-resteasy:{quarkus-version} }

@Inject
[Link] sesClien Put some Quarkus CLI code: Or as a component:
t;
@Component("noopFunction")
@Path("/hello")
public class NoOpSingleStringFunction
@ApplicationScoped
implements StringFunction {
[Link]-override=[Link] public class quarkusapp {
}
[Link]=us-east-1 @GET
[Link]=static public String sayHello() {
[Link]-key-id=t return "hello";
est-key } Also as a service and injection properties from
[Link]-access-k public static void main(String[] args) { [Link] .
ey=test-secret [Link](args);
} @Service
} public class MessageProducer {

You need to set a HTTP client either URL Connection :
@Value("${[Link]}")
To run the script: String message;
<dependency>
<groupId>[Link]</groupId> }
<artifactId>url-connection-client</artifactId> jbang [Link]
</dependency>

And you can inject using Autowired or constructor in a component

and in a JAX-RS resource too.
or Apache HTTP:
@Component
<dependency> public class GreeterBean {
<groupId>[Link]</groupId>
<artifactId>apache-client</artifactId> private final MessageProducer messageProducer;
</dependency>
@Autowired @Qualifier("noopFunction")
StringFunction noopStringFunction;

[Link]=apache
public GreeterBean(MessageProducer messageProducer) {
[Link] = messageProducer;
}
Or async: }
Spring Boot Con guration enabled dependency).
Enables read con guration from Spring Cloud Con g Server.
Quarkus provides a compatibility layer for Spring Boot (default: false ) Spring Data JPA
ConfigurationProperties .
fail-fast While users are encouraged to use Hibernate ORM with Panache
./mvnw quarkus:add-extension True to not start application if cannot access to the server. for Relational Database access, Quarkus provides a compatibility
-Dextensions="quarkus-spring-boot-properties" (default: false ) layer for Spring Data JPA repositories.

connection-timeout ./mvnw quarkus:add-extension

-Dextensions="quarkus-spring-data-jpa"
The amount of time to wait when initially establishing a
@ConfigurationProperties("example")
connection before giving up and timing out. (default: 10S )
public final class ClassProperties {

read-timeout INFO: Of course you still need to add the JDBC driver, and con gure
private String value;
The amount of time to wait for a read on a socket before an it in [Link] .
private AnotherClass anotherClass;
exception is thrown. (default: 60S )
// getters/setters public interface FruitRepository
} Spring Web extends CrudRepository<Fruit, Long> {
List<Fruit> findByColor(String color);
}
Quarkus provides a compatibility layer for Spring Web.
[Link]=class-value
[Link]=true ./mvnw quarkus:add-extension
-Dextensions="quarkus-spring-web" And then you can inject it either as shown in Spring DI or in Spring
Web.

Interfaces supported:
Spring Cloud Con g Client Speci cally supports the REST related features. Notice that
infrastructure things like BeanPostProcessor will not be executed. [Link]
Quarkus integrates Spring Cloud Con g Client and MicroPro le
Con g spec. [Link]
@RestController
@RequestMapping("/greeting")
./mvnw quarkus:add-extension [Link]
public class GreetingController {
-Dextensions="quarkus-spring-cloud-config-client" ry

private final GreetingBean greetingBean; [Link] .

You need to con gure the extension: public GreetingController(GreetingBean greetingBean) { INFO: Generated repositories are automatically annotated with
[Link] = greetingBean; @Transactional .
}
[Link]=[Link]
Repository fragments is also supported:
[Link]=user
@GetMapping("/{name}")
[Link]=pass
public Greeting hello(@PathVariable(name = "name") public interface PersonRepository
[Link]=true
String name) { extends JpaRepository<Person, Long>, PersonFragment {
return new Greeting([Link](name));
} void makeNameUpperCase(Person person);
@ConfigProperty(name = "[Link]") } }
String greeting;

Supported annotations are: RestController , RequestMapping , User de ned queries:

Pre x is [Link]-cloud-config . GetMapping , PostMapping , PutMapping , DeleteMapping , PatchMapping ,
RequestParam , RequestHeader , MatrixVariable , PathVariable ,
uri CookieValue , RequestBody , ResponseStatus , ExceptionHandler and
RestControllerAdvice .
Base URI where the Spring Cloud Con g Server is available.
(default: localhost:8888 )
If you scaffold the project with spring-web extension, then
username
Spring Web annotations are sed in the generated project.
mvn [Link]:quarkus-maven-plugin:[Link]:create …
-
Username to be used if the Con g Server has BASIC Auth Dextensions="spring-web" .
enabled.
The next return types are supported:
password [Link] and [Link] .
Password to be used if the Con g Server has BASIC Auth
enabled. The next parameter types are supported: An Exception argument
d / ( ddi
 @PreAuthorize("hasRole(@[Link])") where roles is a bean
@Query("select m from Movie m where [Link] = ?1") @[Link]("someCache"
de ned with @Component annotation and USER is a public eld
Iterator<Movie> findByRating(String rating); )
of the class.
public Greeting greet(String name) {}
@Modifying
hasAnyRole
@Query("delete from Movie where rating = :rating")
void deleteByRating(@Param("rating") String rating); @PreAuthorize("hasAnyRole(@[Link], 'view')") Quarkus provides compatibility with the following Spring Cache

annotations:
@Query(value = "SELECT COUNT(*), publicationYear FROM Book Permit and Deny All
GROUP BY publicationYear") @Cacheable
List<BookCountByYear> findAllByPublicationYear2(); @PreAuthorize("permitAll()")
@CachePut
interface BookCountByYear { @PreAuthorize("denyAll()")
int getPublicationYear(); @CacheEvict
Anonymous and Authenticated
Long getCount();
@PreAuthorize("isAnonymous()")
Spring Schedule
}

@PreAuthorize("isAuthenticated()") Quarkus provides a compatibility layer for Spring Scheduled

annotation.
What is currently unsupported: Expressions
./mvnw quarkus:add-extension
Methods of Checks if the current logged in user is the same as the -Dextensions="spring-scheduled"
[Link] username method parameter:
utor
@PreAuthorize("#[Link] == [Link]
QueryDSL support rname") @[Link](cron=
public void doSomethingElse(Person person){} "*/5 * * * * ?")
Customizing the base repository void cronJob() {
[Link]("Cron expression hardcoded");
[Link] as return type
}
Checks if calling a method if user can access:
Native and named queries when using @Query
@Scheduled(fixedRate = 1000)
@PreAuthorize("@[Link](#person, authenticatio
Spring Security [Link])")
@Scheduled(cron = "{[Link]}")

public void doSomething(Person person){}

Quarkus provides a compatibility layer for Spring Security.
@Component
./mvnw quarkus:add-extension public class PersonChecker {
-Dextensions="spring-security" public boolean check(Person person, String username) {
return [Link]().equals(username);
}
}
You need to choose a security extension to de ne user, roles, …
such as openid-connect , oauth2 , properties-file or security-jdbc
as seen at RBAC.
Combining expressions:
Then you can use Spring Security annotations to protect the
methods: @PreAuthorize("hasAnyRole('user', 'admin') AND #user == pri
[Link]")
@Secured("admin") public void allowedForUser(String user) {}
@GetMapping
public String hello() {
return "hello";
} Spring Cache
Quarkus provides a compatibility layer for Spring dependency
injection.
Quarkus provides support for some of the most used features of
Spring Security’s @PreAuthorize annotation.
./mvnw quarkus:add-extension
Some examples: -Dextensions="spring-cache"

hasRole

@PreAuthorize("hasRole('admin')")
Resources Authors : [Link]

[Link] @alexsotob
Java Champion and Director of DevExp at Red Hat
[Link]