Cloud-native Microservices with Quarkus

Build an application skeleton for a Quarkus microservice using Maven or Gradle, create a module in IntelliJ, and expose a RestEasy endpoint.

Set up a Quarkus application using free tools, choose rest service extensions, and run with the maven wrapper via Quarkus dev on localhost:8080.

Explore the generated project skeleton, including the parent module and the Quarkus bom, and review RestEasy with Jackson, Arc CDI, development mode, and application.properties guidance.

Explore Quarkus as a cloud-native runtime designed for containerized environments like Kubernetes, delivering fast startup and minimal resource use in serverless contexts.

Contrast design-first and code-first approaches for an HTTP API in the Smart Bar Backoffice, focusing on categories, articles and tables, with OpenAPI guiding collaboration and iteration.

Adopt a design-first approach to build the smart bar back-office API with an OpenAPI specification, defining CRUD operations for categories, articles, and tables using reusable schemas and 201 responses.

Quarkus extensions are extendable project dependencies that autoconfigure libraries for easy use, enable native compilation with GraalVM, and provide extensive options via quarkus.io/extensions.

Generate server api stubs from an OpenAPI spec using the OpenAPI Generator Maven plugin to produce a JAX-RS RestEasy API in a Quarkus project, with generated API and model classes.

Implement REST endpoints in Quarkus with JAX-RS classic, converting stubs to interfaces via the openapi generator. Validate with rest-assured and use response class to return HTTP 201 with location header.

Switch to rest easy reactive in Quarkus to build reactive non-blocking rest APIs, replacing classic rest easy extensions, resolve dependency gaps, and annotate resources as non-blocking to enable reactive behavior.

Explore migrating to Quarkus rest, where rest easy classic and rest easy reactive merge into Quarkus rest, and upgrade to a current Quarkus version to rebuild the app.

Compare blocking and non-blocking request handling in Quarkus, showing how worker threads, io threads, and the non-blocking annotation affect memory use and throughput.

Explore implementing a service layer behind the api using dependency injection with quarkus arc, applying constructor-based injection, and injecting an article service to replace dummy data.

Learn how to test a quarkus application in dev mode using junit, rest assured, jsonpath, and test containers, with 8080/8081 ports, quarkus test annotation, and continuous testing.

Explore how to mock the service layer in Quarkus tests using the Quarkus mock annotation or Mockito, enabling isolated testing of a JAX-RS API before moving to persistence.

Explore persistence options in Quarkus using JPA with Hibernate for the smart bar back office, covering relational and non-relational stores and both reactive and blocking approaches.

Learn how to set up hibernate ORM in a Quarkus cloud-native microservices project, including choosing Postgres, adding the JDBC driver, and leveraging dev services for auto docker containers.

Implement persistence with Hibernate by creating a base entity and a table entity with a generic CRUD service. Configure Quarkus to connect to a Postgres database and enable schema generation.

Explore a complete CRUD solution for categories, articles, and tables in a Quarkus microservices setup. The lesson covers API data models, header-based category linking, entity manager operations, and mapping strategies.

Learn to map between API and persistent data models in a Quarkus app using map struct, configure maven dependencies, and implement a CDI bean mapper that handles id fields appropriately.

Explore enforcing data quality in Quarkus through database constraints and hibernate validator, using unique and not-null rules at both persistence and api levels.

Explore Quarkus profiles to activate environment-specific properties for dev, test, and prod, using percentage prefixes. See how profiles affect database schemas and multi-environment deployments.

Learn how to manage configuration in quarkus with profile aware property files, creating dedicated application-<profile> properties for dev or prod, and activating profiles via quarkus.profile for fine-grained control.

Explore how Quarkus configuration sources determine property precedence, using profile aware file, system properties, and environment variables; inject config values with the config property and provide defaults.

Switch to yaml configuration in Quarkus by adding the yaml configuration extension and renaming all property files to yaml for a tighter, clearer overview.

Discover how Quarkus distinguishes runtime properties from build-time properties and their overridable intersection. Spot build-time only properties with a lock symbol and overridable data source passwords.

examine quarkus prod vs dev mode, highlighting production's fast startup and low memory footprint, and dev mode's hot reload, dev ui, configuration hot reloading, and swagger/openapi tooling.

Configure DevServices in DevMode with DevService properties to tailor a Postgres dev service, controlling port, database name, and image while DevService startup and shutdown are managed.

Explore Panache, a Quarkus extension that simplifies JPA persistence with active record and repository patterns, reducing boilerplate and removing direct entity manager interaction.

Implement active record through panache in Quarkus to let entities manage their own persistence with static methods, transactions, and minimal boilerplate, while comparing with the repository pattern.

Switch to the repository pattern in quarkus panache to manage a single JPA entity with a dedicated repository class, replacing the active record approach.

Master custom Panache queries by extending repository methods to filter articles by category, using list and find with HQL or syntactic sugar, and applying paging and sorting for scalable results.

Discover how Panache rest resources automatically expose repository methods as rest endpoints, reducing boilerplate in Quarkus apps. Compare repository versus active record patterns for CRUD.

Customize Quarkus rest endpoints using resource properties to control exposure, path, paging, and hal formats, and switch to the ActiveRecord pattern for custom behavior with Panache.

Explore auto generation of rest resources with Quarkus, compare design-first and code-first approaches, and use Swagger UI to view and test endpoints and OpenAPI specs.

Evaluate the limitations of code-first API design and the design-first philosophy in practice. See how panache rest resources enable rapid prototyping while keeping domain and api models loosely coupled.

Explore Quarkus hibernate reactive extensions, currently experimental, to enable true reactive database access, switch to reactive panache and rest data, and configure the reactive Postgres client for i/o thread operations.

Explore Quarkus security architecture for http authentication and identity providers, then enforce admin role-based access via security identity and authorization checks.

activate http basic authentication in Quarkus and configure a JPA reactive identity provider to manage database users with an admin role for protected endpoints.

Switch from basic to form-based authentication using an HTML login form, with credentials stored in a Quarkus credentials cookie and admin role gating access.

Combine authentication mechanisms with mutual TLS to protect machine-to-machine communications in Quarkus. Learn how to enable TLS, generate keystores, configure server and client authentication, and mix MTLS with basic auth.

Learn to configure mutual TLS and basic and form-based authentication across dev, test, and prod profiles in Quarkus, and use Quarkus Test Security to selectively disable security in tests.

Explore OpenID Connect authorization code flow in a quarkus web app with keycloak, detailing login redirects, code exchange for tokens, and role-based access control.

Learn to integrate OpenID Connect with a Quarkus backend in a single-page Vue.js app, using Keycloak JS, bearer tokens, and the authorization code flow.

Assess your http API's security needs and choose authentication and authorization strategies, with Keycloak as a reliable identity provider; for stronger protection, consider mutual TLS despite added complexity.

Build production-ready Quarkus applications with the prod profile and reactive jdbc, then prepare production schemas and OpenID Connect setup for deployment.

Learn to build a jvm docker image for a Quarkus app, configure environment variables, and run containers in a cloud native setup with Postgres, Keycloak, and nginx.

Build native images with Quarkus using GraalVM, enabling fast startup and low memory in cloud native deployments. Use multi-stage Docker builds to package native executables for Linux containers.

Develop the second microservice for user orders in the cloud-native Quarkus app’s order client. It handles high load, guest authentication, and protected waiter access, prioritizing performance and security.

Learn to use the Quarkus CLI to create an application, configure group id, artifact id, name, and package, choose Java and Maven, add extensions, and run in dev mode.

Outline the smartbar orderclient requirements: QR-based table login, fetch menus and tables, place orders with a login token, and protected REST endpoints for waiter management.

Explore how to manage extensions with the Quarkus CLI, including listing, adding, and removing extensions, and viewing extensions within a project.

Learn how to choose and implement reliable HTTP clients in Quarkus, comparing built-in Java, Jakarta EE, Apache HTTP client, and MicroProfile HTTP client for declarative access to external services.

Implement a pure Java HTTP client in a Quarkus microservice, using Jackson for JSON mapping and OpenAPI generated models to fetch the back-office menu API non-blockingly.

learn to use the apache http client via the camel http extension, perform a get request, and map the response with a json mapper to Appmenu.

Explore using the jakarta REST client to access a back-office API, enable JSON deserialization with the Rest Client Jackson extension, and manage blocking versus reactive patterns for higher workloads.

Switch to a declarative microprofile http client for the back office api using a rest client interface annotated with path and get and configure its base url under quarkus.rest.client.

Discover how Quarkus rest extension routes calls to worker or io threads based on synchronous and asynchronous method signatures, enabling fully reactive back office communication.

Explore fault tolerance for synchronous microservices communication by applying MicroProfile patterns such as retries, fallbacks, and circuit breakers with Quarkus and SmallRye.

Explore fault tolerance in Quarkus by using the samurai extension and the retry annotation to automatically retry back office API calls with a customizable delay and three attempts.

Explore implementing timeouts to prevent slow requests, configure the microprofile timeout annotation, and combine timeouts with retries for fast, reliable menu access in cloud-native microservices.

Configure fallbacks to ensure a result by annotating methods, with a value provider or handler, returning a completion stage even when retries and timeouts fail.

Learn the circuit breaker pattern in Quarkus for cloud-native microservices, tracking request volume and failure ratio to prevent cascading failures, with half open and open states, thresholds, and fallbacks.