Quarkus - Guides

View Category:

  • Core

    • Configuring Your Application

      Hardcoded values in your code is a no go (even if we all did it at some point ;-)). In this guide, we learn how to configure your application.

    • All Configuration Properties

      List all the configuration properties per extensions

    • Application Initialization and Termination

      You often need to execute custom actions when the application starts and clean up everything when the application stops. This guide explains how to be notified when an application stops or starts.

    • Introduction to CDI

      Quarkus DI solution is based on the Contexts and Dependency Injection for Java 2.0 specification. This guide explains the basics of CDI.

    • CDI Reference

      Go more in depth into the Quarkus implementation of CDI.

    • Testing Your Application

      This guide covers:

      • Testing in JVM mode
      • Testing in native mode
      • Injection of resources into tests
    • Configuring Logging

      This guide explains logging and how to configure it.

    • Command Mode Reference

      This reference guide explains how to develop command line applications with Quarkus.

    • Using SSL With Native Images

      In this guide, we will discuss how you can get your native images to support SSL, as native images don’t support it out of the box.

    • Context Propagation

      Learn more about how you can pass contextual information with our implementation of MicroProfile Context Propagation.

    • Writing Native Applications

      This guide is a collection of tips to help you solve the problems you encounter when compiling applications to native executable.

  • Web

    • Writing REST JSON Services

      JSON is now the lingua franca between microservices. In this guide, we see how you can get your REST services to consume and produce JSON payloads.

    • Writing Simple REST CRUD Services

      Hibernate ORM REST Data with Panache simplifies the creation of CRUD applications based on JAX-RS and Hibernate ORM.

    • Validation with Hibernate Validator

      This guide covers how to use Hibernate Validator/Bean Validation in your REST services.

    • Using the REST Client (including JSON)

      This guide explains how to use the MicroProfile REST Client in order to interact with REST APIs (JSON and other) with very little effort.

    • Using the REST Client with Multipart

      This guide explains how to use the MicroProfile REST Client to send multipart REST requests, typically to upload documents.

    • Using JWT RBAC

      This guide explains how your application can utilize MicroProfile JWT RBAC to provide secured access to the JAX-RS endpoints.

    • Using WebSockets

      This guide explains how your Quarkus application can utilize web sockets to create interactive web applications. Because it’s the canonical web socket application, we are going to create a simple chat application.

    • Using OpenAPI and Swagger UI

      This guide explains how to use the OpenAPI extension to generate an OpenAPI descriptor and get a Swagger UI frontend to test your REST endpoints.

    • HTTP Reference Documentation

      Learn more about configuring Quarkus’ Vert.x based HTTP layer - and Undertow if you are using servlets.

    • Using Fault Tolerance

      This guide demonstrates how your Quarkus application can utilize the MicroProfile Fault Tolerance specification through the SmallRye Fault Tolerance extension.

    • Using Reactive Routes

      This guide demonstrates how to use reactive routes.

    • Consuming and Implementing GraphQL Services

      This guide explains how to leverage Eclipse MicroProfile GraphQL to consume and implement GraphQL services.

  • Data

    • Configuring your datasources

      With Quarkus, you can easily configure a datasource, or several if need be.

    • Using Hibernate ORM and JPA

      Hibernate ORM is the de facto JPA implementation and offers you the full breath of an Object Relational Mapper. It works beautifully in Quarkus.

    • Simplified Hibernate ORM with Panache

      Hibernate ORM is the de facto JPA implementation and offers you the full breadth of an Object Relational Mapper.

      It makes complex mappings possible, but it does not make simple and common mappings trivial.

      Panache focuses on making your entities trivial and fun to write.

    • Simplified Hibernate ORM with Panache and Kotlin

      This explain the specifics of using Hibernate ORM with Panache in a Kotlin project.

    • Hibernate Search + Elasticsearch

      Hibernate Search allows you to index your entities in an Elasticsearch cluster and easily offer full text search in all your Hibernate ORM-based applications.

    • Using Transactions

      Quarkus comes with a Transaction Manager and uses it to coordinate and expose transactions to your applications. Each extension dealing with persistence will integrate with it for you. And you will explicitly interact with transactions via CDI. This guide will walk you through all that.

    • Using Blaze-Persistence

      This guide explains how to use Blaze-Persistence to simplify your data and DTO layers.

    • Validation with Hibernate Validator

      This guide covers how to use Hibernate Validator/Bean Validation in your REST services.

    • Cache your application data

      This guide explains how to cache expensive method calls of your CDI beans using simple annotations.

    • Schema Migration with Flyway

      This guide covers how to use the Flyway extension to manage your schema migrations.

    • Schema Migration with Liquibase

      This guide covers how to use the Liquibase extension to manage your schema migrations.

    • Using Infinispan Client

      Infinispan is an in memory data grid that allows running in a server outside of application processes. This extension provides functionality to allow the client that can connect to said server when running in Quarkus.

    • Reactive SQL Clients

      This guide covers how to use the Reactive SQL Clients for MySQL and PostgreSQL in Quarkus.

    • Elasticsearch Clients

      This guide covers how to use an Elasticsearch cluster using the low level or high level REST clients.

    • MongoDB Client

      This guide covers how to use MongoDB in Quarkus.

    • MongoDB with Panache

      This guide covers the usage of MongoDB using active records and repositories.

    • Redis Client

      This guide covers how to use a Redis datastore in Quarkus.

    • Neo4j Client

      This guide covers how to use the Neo4j graph database in Quarkus.

    • Apache Cassandra Client

      This guide covers how to use the Apache Cassandra NoSQL database in Quarkus.

    • Amazon DynamoDB

      This guide covers how to use the Amazon DynamoDB database in Quarkus.

    • Amazon S3

      This guide covers how to use the Amazon S3 cloud storage in Quarkus.

    • Using Software Transactional Memory

      This guides covers the usage of Software Transactional Memory (STM)

  • Messaging

    • Using Apache Kafka

      This guide demonstrates how your Quarkus application can utilize MicroProfile Reactive Messaging to interact with Apache Kafka.

    • Using AMQP with Reactive Messaging

      This guide demonstrates how your Quarkus application can utilize MicroProfile Reactive Messaging to interact with AMQP.

    • Using Apache Kafka Streams

      This guide demonstrates how your Quarkus application can utilize the Apache Kafka Streams API to implement stream processing applications based on Apache Kafka.

    • Using the event bus

      This guide explains how different beans can interact using the event bus.

    • Using JMS

      This guide demonstrates how your Quarkus application can use JMS messaging with AMQP 1.0 using Apache Qpid JMS, or using Apache ActiveMQ Artemis JMS.

  • Security

    • Security Architecture and Guides

      This guide is the entry point for everything security in Quarkus.

  • Business Automation

    • Using Kogito to add business automation capabilities to an application

      This guide demonstrates how your Quarkus application can use Kogito to add business automation to power it up with business processes and rules.

    • Using AI to optimize a schedule with OptaPlanner

      This guide walks you through the process of creating a Quarkus application with OptaPlanner’s constraint solving Artificial Intelligence (AI).

  • Integration

    • Apache Camel

      This guide covers the systems integration with Apache Camel

  • Command Line Applications

    • Command Mode Reference

      This reference guide explains how to develop command line applications with Quarkus.

    • Picocli

      Simplify command line applications creation with the Picocli extension.

    • jbang Integration

      Easy Quarkus-based scripting with jbang.

  • Cloud

    • Build Container Images

      Learn how to build and push container images with Jib, S2I or Docker as part of the Quarkus build.

    • Deploying Quarkus Applications on Kubernetes

      This guide covers how to deploy a native application on Kubernetes.

    • Deploying Quarkus Applications on OpenShift

      This guide covers how to deploy a native application on OpenShift.

    • Consuming Kubernetes ConfigMaps

      Use ConfigMaps as a configuration source for your Quarkus applications.

    • Using the Kubernetes Client to Interact with a Kubernetes Cluster

      This guide demonstrates how to use the Fabric8 Kubernetes client to interact with your Kubernetes cluster.

    • Deploying to Microsoft Azure Cloud

      This guide explains how to deploy a Quarkus application to Microsoft Azure Cloud.

    • Azure Functions (Serverless) with Vert.x Web, Servlet, or RESTEasy

      This guide explains how you can deploy Vert.x Web, Servlet, or RESTEasy microservices as an Azure Function.

    • Amazon Lambda

      This guide explains how you can deploy Quarkus-based Amazon Lambdas.

    • Amazon Lambda with Vert.x Web, Servlet, or RESTEasy

      This guide explains how you can deploy Vert.x Web, Servlet, or RESTEasy microservices as an Amazon Lambda.

    • Google Cloud Functions

      This guide explains how you can deploy Quarkus-based Google Cloud Functions.

    • Google Cloud Functions with Vert.x Web, Servlet, or RESTEasy

      This guide explains how you can deploy Vert.x Web, Servlet, or RESTEasy microservices as a Google Cloud Function.

    • Quarkus Funqy

      This guide explains basics of the Funqy framework, a simple portable cross-provider cloud function API.

    • Quarkus Funqy HTTP

      This guide explains Funqy’s HTTP binding.

    • Quarkus Funqy Amazon Lambdas

      This guide explains Funqy’s Amazon Lambda binding.

    • Quarkus Funqy Amazon Lambdas HTTP

      This guide explains Funqy’s Amazon Lambda HTTP binding.

    • Quarkus Funqy Knative Events

      This guide explains Funqy’s Knative Events binding.

    • Quarkus Funqy Azure Functions HTTP

      This guide explains Funqy’s Azure Functions HTTP binding.

    • Quarkus Funqy Google Cloud Platform

      This guide explains Funqy’s Google Cloud Platform Functions binding.

    • Quarkus Funqy Google Cloud Platform HTTP

      This guide explains Funqy’s Google Cloud Platform Functions HTTP binding.

    • Amazon DynamoDB

      This guide covers how to use the Amazon DynamoDB database in Quarkus.

    • Amazon KMS

      This guide covers how to use the Amazon Key Management Service in Quarkus.

    • Amazon S3

      This guide covers how to use the Amazon S3 cloud storage in Quarkus.

    • Amazon SES

      This guide covers how to use the Amazon Simple Email Service in Quarkus.

    • Amazon SNS

      This guide covers how to use the Amazon Simple Notification Service in Quarkus.

    • Amazon SQS

      This guide covers how to use the Amazon Simple Queue Service in Quarkus.

  • Observability

    • Using Health Check

      This guide demonstrates how your Quarkus application can utilize the MicroProfile Health specification through the SmallRye Health extension.

    • Using OpenTracing

      This guide explains how your Quarkus application can utilize OpenTracing to provide distributed tracing for interactive web applications.

    • Collecting Metrics with Micrometer

      This guide demonstrates how your Quarkus application can collect metrics using the Micrometer extension.

    • Collecting Metrics with Microprofile Metrics

      This guide demonstrates how your Quarkus application can utilize the MicroProfile Metrics specification through the SmallRye Metrics extension.

    • Using Fault Tolerance

      This guide demonstrates how your Quarkus application can utilize the MicroProfile Fault Tolerance specification through the SmallRye Fault Tolerance extension.

    • Using Sentry to Monitor your Logs

      This guide explains how to use Sentry to monitor your application and be notified when exceptions occur.

    • Centralized Log Management

      This guide explains how to centralize your logs with Logstash or Fluentd using the Graylog Extended Log Format (GELF).

  • Serialization

    • Writing REST JSON Services

      JSON is now the lingua franca between microservices. In this guide, we see how you can get your REST services to consume and produce JSON payloads.

    • Getting Started with gRPC

      This guide explains how to start using gRPC in your Quarkus application.

    • Implementing gRPC Services

      This guide explains how to implement gRPC services in your Quarkus application.

    • Consuming gRPC Services

      This guide explains how to consume gRPC services in your Quarkus application.

  • Tooling

    • Building Applications with Maven

      This guide covers:

      • Maven configuration
      • Creating a new project
      • Dealing with extensions
      • Development mode
      • Debugging
      • Import in your IDE
      • Building a native image
      • Build a container friendly executable
    • Building Applications with Gradle

      This guide covers:

      • Gradle configuration
      • Creating a new project
      • Dealing with extensions
      • Development mode
      • Debugging
      • Import in your IDE
      • Building a native image
      • Build a container friendly executable
    • Measuring the coverage of your tests

      This guide explains how to measure the test coverage of your Quarkus application.

  • Compatibility

    • Using the Quarkus Extension for Spring DI API

      While you are encouraged to use CDI annotations for injection, Quarkus provides a compatibility layer for Spring dependency injection in the form of the spring-di extension.

    • Using the Quarkus Extension for Spring Web API

      While you are encouraged to use JAX-RS annotations for defining REST endpoints, Quarkus provides a compatibility layer for Spring Web in the form of the spring-web extension.

    • Using the Quarkus Extension for Spring Data JPA API

      While you are encouraged to use Hibernate ORM with Panache for your data layer, Quarkus provides a compatibility layer for Spring Data JPA in the form of the spring-data-jpa extension.

    • Using the Quarkus Extension for Spring Security API

      While you are encouraged to use the Quarkus security layer to secure your applications, Quarkus provides a compatibility layer for Spring Security in the form of the spring-security extension.

    • Using the Quarkus Extension for Spring Cache

      While you are encouraged to use the Cache extension for your application-level caching, Quarkus provides a compatibility layer for Spring Cache in the form of the spring-cache extension.

    • Using the Quarkus Extension for Spring Scheduled

      While you are encouraged to use the Scheduler or Quartz extensions to schedule tasks, Quarkus provides a compatibility layer for Spring Scheduled in the form of the spring-scheduled extension.

    • Using Spring Boot's ConfigurationProperties

      Use Spring Boot’s @ConfigurationProperties in place of MicroProfile Config annotations

    • Using the Quarkus Extension for Spring Cloud Config

      Quarkus provides a compatibility layer for Spring Cloud Config in the form of the spring-cloud-config-client extension.

  • Miscellaneous

    • Scheduling Periodic Tasks

      Modern applications often need to run specific tasks periodically. In this guide, you learn how to schedule periodic tasks.

    • Scheduler Reference

      Learn more about the Scheduler extension.

    • Scheduling Clustered Tasks with Quartz

      You need clustering support for your scheduled tasks? This guide explains how to use the Quartz extension for that.

    • Sending Emails

      Learn more about how you can send email from a Quarkus application with our reactive email client.

    • Templating with Qute

      Learn more about how you can use templating in your applications with the Qute template engine.

    • Qute Reference Guide

      Learn everything you need to know about the Qute template engine.

    • Extracting Content with Apache Tika

      Learn more about how you extract content from documents using the Apache Tika toolkit.

    • Using Vert.x

      This guide explains how to use Vert.x in Quarkus to build reactive applications.

    • Access Git repositories with JGit

      This guide explains how you can access Git repositories with JGit.

    • Consume Configuration from Consul

      This guide explains how your Quarkus application can read configuration properties at runtime from Consul.

    • Measuring Performance

      This guide explains how to best measure the footprint of a Quarkus application.

  • Alternative Languages

    • Using Kotlin

      This guide explains how to use Kotlin.

    • Simplified Hibernate ORM with Panache and Kotlin

      This explain the specifics of using Hibernate ORM with Panache in a Kotlin project.

  • Writing Extensions

    • Building My First Extension

      Learn step by step how to build a simple extension.

    • Writing Your Own Extension

      Quarkus extensions optimize your applications by pushing as much work as possible to the build operation. This guide explains the rationale of Quarkus extensions and guides you through authoring your own extensions.

    • Writing Native Applications

      This guide is a collection of tips to help you solve the problems you encounter when compiling applications to native executable.

    • Class Loading Reference

      Learn more about Quarkus class loading infrastructure.

Sorry, no guides matched your search. Please try again.