What you will learn in Quarkus in Action
Chapter by chapter
Concepts explained in this book
- Quarkus platformA Quarkus application is an application built with Quarkus, a Kubernetes-native Java framework optimized for fast startup and low memory use.
- application propertiesapplication.properties is a Java application configuration file containing key-value property settings.
- Quarkus extensionA Quarkus extension is an integration component that adds framework-aware build-time and runtime support for a capability or library.
- PanachePanache is a Quarkus framework that simplifies object-relational and database access development through concise APIs and entity-oriented abstractions.
- dev serviceDev Services is a Quarkus feature that automatically starts and manages disposable supporting service instances during development and testing.
- Qutequarkus-qute is a Quarkus extension that integrates the Qute templating engine into Quarkus applications.
- performanceA specification for exposing numerical measurements of application and system behavior.
- Dev UIDev UI is Quarkus’s browser-based development interface for inspecting and interacting with an application and its extensions during development.
- reactive messagingMicroProfile Reactive Messaging is a MicroProfile specification for defining asynchronous message-based communication between application components and external messaging systems.
- OpenShiftOpenShift is a Kubernetes-based container application platform that provides managed development, deployment, and operations capabilities.
- Kubernetes manifestAn OpenShift manifest is a declarative configuration file that specifies OpenShift or Kubernetes resources and their desired state.
- Quarkus dev modeQuarkus dev mode is a Quarkus development mode that provides rapid code-change feedback without restarting the application.
- active record patternThe active record pattern is a persistence pattern in which a data record object encapsulates the operations for storing, updating, deleting, and querying itself.
- Quarkus testing frameworkQuarkusTest is a Quarkus testing annotation that starts the application and enables Quarkus-managed testing facilities for a test class.
- trajectoryTracing data is telemetry describing the operations and timing of requests as they pass through application components and services.
- MultiMulti is a Mutiny asynchronous type that emits zero or more items followed by a completion or failure event.
- HTMXHTMX is a client-side web library that enables HTML-driven interaction with servers and dynamic page updates without requiring custom JavaScript for many use cases.
- code reloadingA development-time process that applies code or configuration changes by reloading an application without a full manual restart.
- build-time processingBuild-time initialization is the evaluation of application or framework initialization logic during the build so its result can be embedded in the produced application.
- ococ is the OpenShift command-line client for authenticating to clusters and managing OpenShift resources.
- s2iSource-to-image is a build technique that assembles application source or binaries into a runnable container image using a builder image.
- resilienceFault tolerance is the ability of a system to continue providing acceptable service despite failures in its components or dependencies.
- quarkus-oidcquarkus-oidc is a Quarkus extension that integrates OpenID Connect authentication into Quarkus applications.
- Hibernate ReactiveHibernate Reactive is a Hibernate library for nonblocking, asynchronous object-relational persistence using reactive database drivers.
- native compilationNative compilation is the ahead-of-time compilation of application code into a platform-specific executable rather than JVM bytecode executed by a JVM.
- health checkA health check is an evaluation that reports whether an application or one of its dependencies is functioning correctly, typically with a binary outcome.
- configuration profileA test config profile is a named configuration set applied when an application runs for testing.
- micrometerMicrometer is a metrics instrumentation library that provides a vendor-neutral API for recording application measurements and exporting them to monitoring systems.
- UniUni is a Mutiny type representing an asynchronous computation that emits one item or a failure.
- reactive programmingReactive programming is a programming paradigm centered on asynchronous data streams and the propagation of changes over time.
- asynchronous programmingAsynchronous execution is computation in which an operation completes independently of the caller and reports its result or failure later.
- RouteA Route is an OpenShift resource that exposes a service to external clients through a hostname and network route.
- repository patternThe repository pattern encapsulates data-access operations behind an abstraction that manages persistence and retrieval for domain objects.
- channelA channel is a virtual messaging address through which messages are propagated between application components or external services.
- KeycloakKeycloak is an open-source identity and access management platform that provides authentication, authorization, and OpenID Connect services.
- @Blocking@Blocking is an annotation that marks an operation as potentially blocking so a reactive framework can schedule it on a worker thread.
- OpenShift SandboxOpenShift Sandbox is a hosted OpenShift environment that provides temporary access to an OpenShift cluster for experimentation and testing.
- schemaA schema definition is a formal specification of a data structure's fields, types, names, and ordering.
- native executableA native executable is a standalone machine-code program that runs directly on a target operating system and processor architecture without requiring a managed runtime.
- green threadA virtual thread is a lightweight JVM-managed thread designed to support large numbers of concurrent tasks with lower resource overhead than traditional platform threads.
- quarkus-grpcquarkus-grpc is a Quarkus extension that provides gRPC support and Protocol Buffers integration, including generated Java gRPC bindings.
- MySQLMySQL is an open-source relational database management system that stores and queries structured data with SQL.
- checked templateA checked template is a Qute template whose usage and parameter types are validated during the application build.
- HTMX attributeAn HTMX attribute is a declarative HTML attribute that specifies client-side requests, events, targets, or updates handled by HTMX.
- hx-get attributeThe hx-get attribute configures HTMX to submit an HTTP GET request to a specified endpoint.
- hx-target attributeThe hx-target attribute identifies the HTML element whose contents HTMX replaces with a response.
- HX-Trigger-After-Swap HTTP headerThe HX-Trigger-After-Swap HTTP header instructs HTMX to dispatch named events after replacing the target content.
- hx-trigger attributeThe hx-trigger attribute declares the events that cause HTMX to issue a request or refresh an element.
- templateA Qute template is a structured document containing markup and Qute expressions that can be rendered with supplied parameters.
- continuous testingContinuous testing is a development technique that automatically executes tests in the background when source code changes.
- REST clientA REST client is a software component that invokes REST endpoints over HTTP.
- SmallRye Reactive MessagingSmallRye Reactive Messaging is an implementation of reactive messaging APIs for connecting application channels with message brokers and other messaging providers.
- configuration keyA configuration key is the named identifier associated with a configuration value.
- spanA span is a recorded unit of work within a trace, such as a method invocation, database invocation, or remote request.
- Transactional annotation@Transactional is an annotation that defines a transaction boundary for an operation executed within a conventional transaction context.
- EmitterEmitter is a MicroProfile Reactive Messaging API element for programmatically sending messages to a channel.
- authenticationAuthentication is the process of verifying the identity of a user or other communicating principal.
- resource tagA tag is a key-value label attached to a metric to identify a particular dimension of the measured data.
- GrafanaGrafana is an open-source observability and visualization platform for querying, displaying, and alerting on data such as time-series metrics.
- production modeProduction mode is the Quarkus execution mode for running a packaged application without development-only features.
- Panache entityPanacheEntity is a Panache base class that provides active record persistence operations and convention-based identity support to entity classes.
- event loop threadAn event loop thread is a thread that runs an event loop to process asynchronous application events and callbacks.
- endpointA REST endpoint is a network-accessible resource interface that handles HTTP interactions according to REST conventions.
- MutinyMutiny, also known as SmallRye Mutiny, is a Java reactive programming library providing asynchronous types and APIs for composing event-driven operations.
- Quarkus GraphQL UIGraphQL UI is a browser-based interface for composing and executing GraphQL operations against a GraphQL endpoint.
- application startup timeStartup time is the elapsed time required for an application or service to become ready to handle requests after launch.
- REST resourceA REST resource is a conceptual or addressable entity exposed through RESTful web-service operations.
- REST AssuredREST Assured is a Java library for testing RESTful web services through programmatic HTTP requests and response assertions.
- entityA persistence entity is a Java object whose state is mapped to and managed as records in a database through object-relational mapping.
- OpenTelemetryOpenTelemetry is a vendor-neutral, language-agnostic collection of APIs, tools, and protocols for generating, collecting, and exporting application telemetry.
- quarkus-container-image-openshiftThe quarkus-openshift extension integrates Quarkus applications with OpenShift build, image, and deployment capabilities.
- database transactionA transaction is a logical unit of work whose operations are coordinated to satisfy defined consistency and completion guarantees.
- build processorA Quarkus build processor is a deployment-module class that declares build steps for augmenting an application during the build.
- smallrye-rabbitmqsmallrye-rabbitmq is a SmallRye Reactive Messaging connector for sending and consuming messages through RabbitMQ.
- QuarkusIntegrationTestQuarkusIntegrationTest is a Quarkus testing annotation that runs a test against a separately built application artifact such as a JAR, container, or native binary.
- MicroProfileA coordinated release of a defined group of MicroProfile specifications under a single platform version.
- environment variableAn environment variable is a named configuration value supplied through a process or container execution environment.
- project object modelA pom.xml file is the XML build descriptor that defines a Maven project's dependencies, plugins, profiles, and other build settings.
- configurationA configuration specification defines APIs and rules for supplying and accessing application configuration values.
- imperative programmingImperative code is code that expresses computation as an ordered sequence of commands that directly change program state.
- mockingMocking is the practice of substituting controlled test doubles for components that are unsuitable or undesirable to run during a test.
- quarkus-kubernetesquarkus-kubernetes is a Quarkus extension that generates Kubernetes manifests for deploying applications.
- reactive streamReactive Streams is a specification defining interfaces and signaling rules for asynchronous stream processing with nonblocking flow control between producers and consumers.
- import.sqlimport.sql is a conventional SQL script that initializes relational database contents when a persistence connection is established.
- securitySecurity is the protection of software systems, data, and communications against unauthorized access, misuse, or disruption.
- serviceA Kubernetes Service is an API resource that provides stable network access to a set of Kubernetes workloads.
- readiness checkA readiness probe is a Kubernetes health check that determines whether a container is ready to receive traffic.
- GraphQLGraphQL is a query language and runtime for APIs that lets clients request precisely the data they need.
- security contextA security context is information describing the authenticated principal and associated security state for a request or interaction.
- Kubernetes DeploymentA Kubernetes deployment is a declarative resource that manages the desired replicas and rollout state of a workload.
- messageMessage is a reactive-messaging API abstraction that wraps a produced payload and exposes operations for acknowledging or negatively acknowledging the received message.
- thread pool threadA worker thread is a thread assigned blocking or computational work outside an event loop.
- openid connectOpenID Connect is an identity layer built on OAuth 2.0 that enables clients to verify user identity and obtain authentication claims.
- @Counted@Counted is a Micrometer annotation that declares counting of invocations of an annotated method.
- MeterRegistryMeterRegistry is Micrometer's central registry for managing the meters and metrics in an application.
- code generationGenerated code is source code produced automatically by a software tool from project settings, templates, or other inputs.
- native imageNative image compilation is the process of compiling an application ahead of time into a platform-specific native executable or image.
- Quarkus CLIThe Quarkus CLI is a command-line tool for creating, managing, developing, and updating Quarkus projects.
- quarkus-openshiftOpenShift integration is a Quarkus extension capability that supports deploying applications and generated resources to OpenShift.
- @Incoming@Incoming is a MicroProfile Reactive Messaging annotation that declares a method as a consumer of messages from a channel.
- quarkus-messaging-kafka extensionA Quarkus extension that integrates Quarkus applications with Kafka messaging.
- GraalVMGraalVM is a high-performance runtime and development platform for running and compiling applications in multiple programming languages, including Java.
- domain-specific languageA domain-specific language is a language designed to express operations within a particular problem domain.
- Docker ComposeDocker Compose is a tool for defining and running multi-container applications from a declarative configuration file.
- StrimziStrimzi is an operator and set of Kubernetes resources for running and managing Apache Kafka clusters.
- ZooKeeperApache ZooKeeper is a distributed coordination service that provides shared configuration, naming, synchronization, and metadata-management primitives.
- build stageA build step is a Quarkus extension processing unit that consumes and produces build items during the application build.
- MockitoMockito is a Java mocking framework for creating test doubles and specifying their behavior dynamically.
- blockingA blocking operation is an operation that prevents its executing thread from performing other work until the operation completes.
- fallbackA fallback is a fault-tolerance pattern that supplies an alternate result or behavior when an operation fails.
- testA test is an automated or manual evaluation of software behavior against expected results.
- GraphQL clientA GraphQL client is software that constructs and sends GraphQL requests to a GraphQL server and processes its responses.
- Quarkus Maven pluginThe Quarkus Maven plugin is a Maven plugin that integrates Quarkus project generation and build operations with Maven.
- pipelineA reactive pipeline is a composition of asynchronous processing stages connected so that results, completion, and failures flow between them.
- BuildConfigA BuildConfig is an OpenShift resource that defines how a build is triggered and how its output is produced.
- ImageStreamAn ImageStream is an OpenShift resource that provides an abstraction over container images and tracks image updates.
- OpenShift deployment manifestAn OpenShift deployment manifest is a YAML or JSON resource definition file containing the OpenShift objects required to deploy an application.
- GraphQL mutationA GraphQL mutation is a GraphQL operation that can add or modify data and may return data with the update.
- GraphQL operationA GraphQL operation is an executable request that specifies a query, mutation, or other interaction with a GraphQL schema.
- gRPCgRPC is a high-performance, open-source remote procedure call framework for communication between distributed services with support for multiple programming languages.
- quarkus-container-image-dockerquarkus-container-image-docker is a Quarkus extension that builds container images using generated Dockerfiles and Docker.
- wellness checkA wellness check reports broader application or dependency health conditions that may indicate problems without necessarily showing that the process is dead or unable to serve requests.
- SmallRye Kafka connectorThe SmallRye Kafka connector is a Reactive Messaging connector that publishes and consumes messages through Apache Kafka.
- dynamic GraphQL clientA dynamic GraphQL client is a GraphQL client that constructs GraphQL documents programmatically rather than deriving them from model classes.
- GraphQLClientApi annotationThe GraphQLClientApi annotation declares a Java interface as a client-side view of a GraphQL API and assigns its client configuration key.
- typesafe GraphQL clientA typesafe GraphQL client is a GraphQL client that derives requests from statically typed application model classes and client interfaces.
- CDI beanA CDI bean is a Java object managed by a CDI container according to contextual dependency-injection rules.
- MicroProfile HealthMicroProfile Health is a MicroProfile specification for exposing application health information through standardized health checks and endpoints.
- MongoDBMongoDB is an open-source document-oriented NoSQL database system that stores data in flexible, JSON-like documents.
- OpenTelemetry extensionThe OpenTelemetry extension is a Quarkus extension that integrates application instrumentation with OpenTelemetry telemetry generation and export.
- protocol bufferProtocol Buffers is a language-neutral serialization format that represents structured data using schemas and generated types.
- quarkus-restquarkus-rest is a Quarkus extension that integrates RESTful web-service support into a Quarkus application.
- RabbitMQRabbitMQ is an open-source message broker that routes and delivers messages between applications.
- kubectlkubectl is the command-line client for interacting with Kubernetes clusters and their resources.
- container imageA container image is a packaged filesystem and metadata bundle from which a container can be created and run.
- authentication policyAn authentication policy is a rule that determines whether requests to a resource collection must be associated with an authenticated identity.
- authorization code flowThe authorization code flow is an OAuth-based authentication pattern in which a client redirects an unauthenticated user to an identity provider and exchanges a returned authorization code for tokens.
- recorderA Quarkus recorder is an extension class whose methods define runtime logic that can be recorded as bytecode during the build.
- build-time propertyA build-time property is a configuration value whose effect is fixed or incorporated while an application is being built.
- quarkus-run.jarquarkus-run.jar is the executable JAR produced by a Quarkus JVM-mode package and used to launch the packaged application.
- multidimensional metricA multidimensional metric is a metric represented by separate data series for combinations of labeled dimensions.
- quarkus-micrometer-registry-prometheusquarkus-micrometer-registry-prometheus is a Quarkus extension that integrates Micrometer metrics with Prometheus exposition.
- system propertyA system property is a named configuration value supplied to a Java process and accessible through its runtime environment.
- database driverThe MySQL JDBC driver is a Java database-connectivity implementation that enables applications to connect to MySQL and execute database operations.
- reactive systemA reactive system is a distributed software system designed to remain responsive through resiliency, elasticity, and asynchronous message-driven communication.
- carrier threadA carrier thread is a platform thread that runs a virtual thread when the virtual thread is mounted for execution.
- liveness checkA Kubernetes liveness probe periodically determines whether a container should be restarted because its application is no longer recoverable.
- @Retry@Retry is a MicroProfile Fault Tolerance annotation that configures repeated execution of a failed method invocation.
- quarkus-test-hibernate-reactive-panachequarkus-test-hibernate-reactive-panache is a Quarkus test extension that provides helpers for testing Hibernate Reactive Panache code.
- @RunOnVertxContext@RunOnVertxContext is an annotation that runs a test method on a Vert.x event-loop context.
- TransactionalUniAsserterTransactionalUniAsserter is a testing API that performs assertions on Uni results while wrapping each operation in a new transaction.
- @WithTransaction@WithTransaction is an annotation that defines a transaction boundary for an asynchronous Hibernate Reactive operation.
- counterA counter is a metric that records a value intended to increase monotonically as occurrences are counted.
- QuarkusTransactionQuarkusTransaction is a Quarkus API for programmatic transaction management with static operations and transactional code wrappers.
- synchronous callSynchronous communication is an interaction in which the requesting application waits for a response from another system before continuing.
- service discoveryA service discovery mechanism dynamically locates the network address of a service in a distributed system.
- proto fileA proto file is a Protocol Buffers definition file that declares messages and service contracts for generated code.
- AMQPAMQP is a messaging protocol standard for exchanging messages between producers, brokers, and consumers.
- CRUDA CRUD operation is an operation that creates, reads, updates, or deletes a persistent entity.
- configuration editorA configuration editor is an interface for viewing and modifying an application's configuration settings.
- dependency graphA bean dependency graph is a visual graph representing dependency relationships among managed beans.
- microprofile config apiMicroProfile Config is a MicroProfile specification for supplying and accessing application configuration values from external and contextual sources.
- @Outgoing@Outgoing is a MicroProfile Reactive Messaging annotation that declares a method as a producer of messages to a channel.
- @Nonblocking@NonBlocking is an annotation indicating that an operation should be executed without blocking the reactive event-loop execution model.
- gRPC streamingA gRPC stream is a protocol-level sequence through which a gRPC call exchanges multiple messages over time.
- DockerfileA Dockerfile is a text-based build specification containing instructions for creating a Docker container image.
- connectorA connector is a MicroProfile Reactive Messaging service-provider interface implementation that bridges a messaging channel to an external messaging provider.
- REST Data extensionREST Data is a Quarkus capability that generates customizable REST CRUD resources for Panache entities.
- serverless computingA serverless platform is a cloud execution platform that automatically provisions, starts, scales, and stops application instances in response to requests.
- @RunOnVirtualThread@RunOnVirtualThread is a Quarkus annotation that directs an annotated method or class's methods to execute on virtual threads.
- QuarkusApplicationQuarkusApplication is a Quarkus interface for defining the application entry point of a command-line application.
- QuarkusMain annotationThe QuarkusMain annotation identifies the main entry point of a Quarkus command-mode application.
- containerA software container encapsulates an application together with its operating-system environment and dependencies for portable execution.
- build itemA build item is a typed object exchanged between Quarkus build steps to communicate build-time data and actions.
- runtime propertyA runtime property is a configuration value that can be supplied or overridden when an application executes.
- @Entity@Entity is a Jakarta Persistence annotation that declares a Java class to be a persistent entity.
- quarkus-hibernate-orm-panachequarkus-hibernate-orm-panache is the Quarkus extension artifact that integrates Panache with blocking Hibernate ORM.
- quarkus-jdbc-postgresqlquarkus-jdbc-postgresql is a Quarkus extension that provides PostgreSQL JDBC connectivity for applications.
- Panache MongoDBquarkus-mongodb-panache is a Quarkus extension that integrates Panache with MongoDB persistence.
- FunqyFunqy is a Quarkus programming model and library for defining portable functions that can run across multiple function-as-a-service platforms.
- reflectionReflection is the runtime inspection and manipulation of program elements such as classes and methods through metadata rather than only statically referenced code.
- Hibernate Reactive Panachequarkus-hibernate-reactive-panache is a Quarkus extension integrating Hibernate Reactive with Panache for reactive persistence.
- MicroProfile Fault ToleranceMicroProfile Fault Tolerance is a MicroProfile specification and annotation-based Java API for defining resilience policies in microservices.
- quarkus-smallrye-openapiA Quarkus extension that integrates SmallRye OpenAPI to generate OpenAPI descriptions for application APIs and support development-time API exploration.
- exchangeA RabbitMQ exchange is a message-routing entity that directs published messages to one or more queues.
- quarkus-messaging-rabbitmqquarkus-messaging-rabbitmq is a Quarkus extension that integrates SmallRye Reactive Messaging with RabbitMQ.
- queueA queue is an ordered messaging destination that stores messages until consumers receive them.
- OpenAPI specificationOpenAPI is a standard machine-readable description of an HTTP API's operations, parameters, and responses.
- KnativeKnative is a Kubernetes-based platform that provides components for serving and running serverless workloads.
- PanacheEntityResourcePanacheEntityResource is a Quarkus REST Data interface for exposing CRUD operations on an entity using the active record model.
- PanacheRepositoryResourcePanacheRepositoryResource is a Quarkus REST Data interface for exposing CRUD operations through a Panache repository.
- quarkus-hibernate-orm-rest-data-panachequarkus-hibernate-orm-rest-data-panache is a Quarkus extension that generates REST resources for Panache entities backed by Hibernate ORM and JDBC.
- @ResourceProperties@ResourceProperties is a REST Data annotation that configures properties of a generated resource, such as its REST path or pagination behavior.
- convention over configurationConvention over configuration is a software design pattern in which framework conventions provide defaults so applications need to specify only deviations.
- GraphQL fieldA GraphQL field is a named element of a GraphQL type that specifies a fetchable value and its type.
- database connection health checkA database connection health check determines whether an application's configured database connection is working.
- Health UIHealth UI is a Quarkus development interface that displays the statuses and details of application health checks.
- JibJib is a container-image building tool that constructs images for Java applications without requiring a Docker daemon.
- MutinyEmitterMutinyEmitter is a reactive-messaging emitter API that sends messages and represents the result as a Mutiny Uni.
- integration testAn integration test evaluates an application or component together with externally packaged or connected components.
- TestHTTPEndpoint annotationA Quarkus test annotation that provides the URL of a specified REST endpoint during a test run.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.