Description
This intensive 4-day training enables participants to master the development of high-performance, reactive, and cloud-native microservices with Quarkus. Combining theory and hands-on practice, it covers the entire lifecycle of a microservice: design, security, resilience, asynchronous communication, deployment, and production monitoring.
Objectifs pédagogiques
- Understand the fundamental concepts of the Quarkus Java framework and the principles of microservices architectures
- Develop secure RESTful and GraphQL microservices with Quarkus, and test them effectively
- Implement resilience patterns (Circuit Breaker, Bulkhead, etc.) to ensure fault tolerance
- Implement asynchronous communication with Azure Service Bus, including transaction management and Saga-like patterns
- Leverage reactive programming with Mutiny and understand the differences compared to virtual threads
- Build, deploy, and monitor a Quarkus application in a production environment using Docker, Kubernetes, Prometheus, Grafana, and OpenTelemetry
Public concerné
Java developers looking to adopt Quarkus in their projects
Backend engineers working on microservices architectures
Software or technical architects aiming to modernize their stack towards cloud-native environments
Technical teams responsible for transformation or migration projects to Kubernetes or managed cloud services
Prérequis
Proficiency in the Java language (intermediate to advanced level)
Basic knowledge of REST API development
Familiarity with Java development tools (IDE, Maven)
Initial experience with Docker or microservices is a plus, but not required
Déroulé du programme
1
9:00 AM – 10:30 AM: Introduction to Quarkus and Microservices
- Introduction to Quarkus: philosophy, cloud-native approach, startup time, memory usage
- Quarkus vs Spring Boot, Java EE, Jakarta EE
- Why choose Quarkus in a cloud environment (Kubernetes, serverless, etc.)
- Microservices: architectural principles, decoupling, independent deployment
- Introduction to MicroProfile: standardization of features for microservices (Config, Health, Metrics...)
2
10:45 AM – 12:30 PM: Hands-on Lab 1: Exploring the Environment
- Setting up the development environment (JDK, Quarkus CLI, IDE, Docker, extensions)
- Using the Dev UI, Live Reload, and hot replacement
- Generating and running a blank project (quarkus create app)
- Exploring key files: application.properties, pom.xml, and the Quarkus project structure
3
1:15 PM – 2:45 PM: Getting Started with Quarkus
- Creating a Hello World project (basic endpoint)
- Docker integration: building a standard Quarkus container
- Overview of Quarkus extensions: RESTEasy, Hibernate ORM, OpenAPI, SmallRye, etc.
- Exploring tools for development, debugging, and testing with Quarkus: Introduction to the testing environment (Dev Services, mocking)
4
3:00 PM – 4:00 PM: Hands-on Lab 2: Deploying a Microservice
- Creating a REST microservice (GET /hello)
- Adding dynamic configuration
- Debugging with breakpoints and Quarkus logs
- Implementing unit tests (@QuarkusTest) and continuous testing
5
9:00 AM – 10:30 AM: REST with Jakarta RESTful & Documentation
- Jakarta RESTful: annotations, injection, paths, media types
- Documenting your API with OpenAPI / Swagger UI
- Introduction to GraphQL with SmallRye GraphQL
- Structure of schemas and resolvers
6
10:45 AM – 12:30 PM: Hands-on Lab 3: REST Microservice Exposing an API
- Microservice A: exposes a REST API (/products)
- Microservice B: queries A via GraphQL (getProductsByType)
- Testing Swagger documentation and GraphQL Playground
- Testing with Postman / curl / Swagger UI
7
1:15 PM – 2:45 PM: REST Clients + OIDC & JWT Security
- Creating a typed MicroProfile REST Client
- Dynamic client injection
- Concepts of OIDC, Identity Provider, Keycloak, OAuth2
- JWT token validation with SmallRye JWT
8
3:00 PM – 4:00 PM: Hands-on Lab 4: Securing and Consuming a Protected API
- Setting up a local Keycloak instance
- Securing the /products API with @RolesAllowed
- OAuth2 authentication, token generation & validation
- Testing secure access with and without a JWT token
9
9:00 AM – 10:30 AM: Theory – Resilience
- What is resilience? Why is it critical?
- Overview of SmallRye Fault Tolerance
- Fault tolerance patterns: Circuit Breaker, Timeout, Retry, Bulkhead, Fallback
10
10:45 AM – 12:30 PM: Hands-on Lab 5: Applied Resilience
- Integrating Fault Tolerance into the /products microservice
- Implementing @CircuitBreaker and @Timeout
- Testing a slow or failed call
- Implementing @Bulkhead for resource isolation
11
1:15 PM – 2:15 PM: Introduction to Message-Oriented Communication
- Event-Driven Architecture
- Reactive programming (non-blocking, data streams)
- Messaging transactions
- Introduction to the Saga Pattern (orchestration, compensation)
- Overview of Azure Service Bus: Queue, Topic, SenderClient, ReceiverClient
- Azure SDK for Java
12
2:15 PM – 4:00 PM: Hands-on Lab 6: Asynchronous Sender with Azure Service Bus
- Configuring Azure Service Bus and the SDK
- Development: Creating a ServiceBusSenderClient ; Sending a JSON message with product ID and timestamp ; Wrapping the operation in a Mutiny Uni
- Local testing (using Azure Explorer and console logs)
13
9:00 AM – 10:30 AM: Receiving Messages from Azure
- Creating a LoggerService or AuditService microservice
- Integrating a ServiceBusProcessorClient to listen for messages
- Processing with Mutiny
- Adding transactional logic: simulated cancellation, settlement handling
- Implementing a mini Saga pattern: chaining processing steps with simulated rollback on failure
14
10:45 AM – 12:45 PM: Reactive Programming vs Virtual Threads
- Traditional threads vs virtual threads (Project Loom)
- Examples: parallel requests with Uni.combine().all().unis(...); equivalent execution using virtual threads
- Comparative demo: performance & readability
- Discussion on use cases for each model
15
1:15 PM – 2:30 PM: Production Deployment – AOT Compilation & Containerization
- Build strategies for production: classic JVM vs GraalVM Native
- Overview of HotSpot vs GraalVM: startup time, memory usage, Ahead-Of-Time compilation
- Docker build strategies: Dockerfile for JVM (OpenJDK) and Dockerfile for GraalVM native-image
- Introduction to Kubernetes: pod, service, ingress
- Hands-on lab: Build two Docker images: JVM & native (OCI compliant); Push to a local registry ; Deploy on a local orchestrator (minikube, kind, or Docker Desktop) using kubectl apply with a YAML manifest ; Expose the service using Ingress or NodePort
16
2:45 PM – 4:00 PM: Production Monitoring
- Advanced Health Checks: @Readiness, @Liveness; creating a /health/products endpoint; adding conditional business logic (e.g., database or memory check)
- Log management: JSON format + contextual enrichment (correlationId, traceId); best practices for centralization
- OpenTelemetry & Application Insights: automatic trace export; adding custom spans for specific processing
- Prometheus & Grafana: enabling the quarkus-micrometer-registry-prometheus extension; exporting metrics on /metrics port; creating a simple Grafana dashboard with request count, response time, and error rate
- Hands-on lab: Create and test a custom Health Check endpoint ; Live visualization of enriched JSON logs ; Display metrics in Grafana ;Check traces in Application Insights
Informations
Durée
3 jour(s)
24h
Tarif
Sur demande
