Quarkus Cookbook

Book Description

Optimized for Kubernetes, Quarkus is designed to help you create Java applications that are cloud first, container native, and serverless capable. With this cookbook, authors Alex Soto Bueno and Jason Porter from Red Hat provide detailed solutions for installing, interacting with, and using Quarkus in the development and production of microservices.

The recipes in this book show midlevel to senior developers familiar with Java enterprise application development how to get started with Quarkus quickly. You’ll become familiar with how Quarkus works within the wider Java ecosystem and discover ways to adapt this framework to your particular needs.

You’ll learn how to:

  • Shorten the development cycle by enabling live reloading in dev mode
  • Connect to and communicate with Kafka
  • Develop with the reactive programming model
  • Easily add fault tolerance to your services
  • Build your application as a Kubernetes-ready container
  • Ease development with OpenAPI and test a native Quarkus application

Publisher Resources

View/Submit Errata

Table of Contents

  1. Foreword
  2. Preface
    1. Who Should Read This Book
    2. Why We Wrote This Book
    3. Navigating This Book
    4. Conventions Used in This Book
    5. Using Code Examples
    6. O’Reilly Online Learning
    7. How to Contact Us
    8. Acknowledgments
  3. 1. Quarkus Overview
    1. Developer-Friendly
    2. Integration with Kubernetes
    3. Memory and First Response Time
    4. A Basic Quarkus Workflow
  4. 2. Scaffolding
    1. 2.1. Scaffolding a Quarkus Project with Maven
    2. 2.2. Scaffolding a Quarkus Project with Gradle
    3. 2.3. Scaffolding a Quarkus Project with the Quarkus Start Coding Website
    4. 2.4. Scaffolding a Quarkus Project with Visual Studio Code
    5. 2.5. Live Reloading with Dev Mode
    6. 2.6. Serving Static Resources
  5. 3. Developing RESTful Services
    1. 3.1. Creating a Simple REST API Endpoint
    2. 3.2. Extracting Request Parameters
    3. 3.3. Using Semantic HTTP Response Status Codes
    4. 3.4. Binding HTTP Methods
    5. 3.5. Enabling Cross-Origin Resource Sharing (CORS)
    6. 3.6. Using Reactive Routes
    7. 3.7. Intercepting HTTP Requests
    8. 3.8. Secure Connections with SSL
  6. 4. Configuration
    1. 4.1. Configuring the Application with Custom Properties
    2. 4.2. Accessing Configuration Properties Programmatically
    3. 4.3. Overwriting Configuration Values Externally
    4. 4.4. Configuring with Profiles
    5. 4.5. Changing Logger Configuration
    6. 4.6. Adding Application Logs
    7. 4.7. Advanced Logging
    8. 4.8. Configuring with Custom Profiles
    9. 4.9. Creating Custom Sources
    10. 4.10. Creating Custom Converters
    11. 4.11. Grouping Configuration Values
    12. 4.12. Validating Configuration Values
  7. 5. Programming Model
    1. 5.1. Marshalling/Unmarshalling JSON
    2. 5.2. Marshalling/Unmarshalling XML
    3. 5.3. Validating Input and Output Values
    4. 5.4. Creating Custom Validations
    5. 5.5. Validating Objects Programmatically
    6. 5.6. Injecting Dependencies
    7. 5.7. Creating Factories
    8. 5.8. Executing Object Life Cycle Events
    9. 5.9. Executing Application Life Cycle Events
    10. 5.10. Using a Named Qualifier
    11. 5.11. Using Custom Qualifiers
    12. 5.12. Qualifying and Configuring Annotations
    13. 5.13. Creating Interceptors
    14. 5.14. Writing Behavioral Tests
    15. 5.15. Writing Unit Tests
    16. 5.16. Creating Mock Objects
    17. 5.17. Creating Mock Objects with Mockito
    18. 5.18. Grouping Several Annotations into One with a Meta-Annotation
    19. 5.19. Executing Code Before or After a Test
    20. 5.20. Testing the Native Executable
  8. 6. Packaging Quarkus Applications
    1. 6.1. Running in Command Mode
    2. 6.2. Creating a Runnable JAR File
    3. 6.3. Über-JAR Packaging
    4. 6.4. Building a Native Executable
    5. 6.5. Building a Docker Container for JAR File
    6. 6.6. Building a Docker Container for Native File
    7. 6.7. Build and Dockerize a Native SSL Application
  9. 7. Persistence
    1. 7.1. Defining a Datasource
    2. 7.2. Using Multiple Datasources
    3. 7.3. Adding Datasource Health Check
    4. 7.4. Defining Transaction Boundaries Declaratively
    5. 7.5. Setting a Transaction Context
    6. 7.6. Programmatic Transaction Control
    7. 7.7. Setting and Modifying a Transaction Timeout
    8. 7.8. Setup with Persistence.xml
    9. 7.9. Setup Without persistence.xml
    10. 7.10. Using Entities from a Different JAR
    11. 7.11. Persisting Data with Panache
    12. 7.12. Finding All Entity Instances with Panache listAll Method
    13. 7.13. Finding Individual Entities with Panache findById Method
    14. 7.14. Finding Entities Using Panache Find and List Methods
    15. 7.15. Obtaining a Count of Entities Using the Panache count Method
    16. 7.16. Paginating Through Entity Lists Using the Panache page Method
    17. 7.17. Streaming Results via the Panache Stream Method
    18. 7.18. Testing Panache Entities
    19. 7.19. Using a Data Access Object (DAO) or Repository Pattern
    20. 7.20. Using Amazon DynamoDB
    21. 7.21. Working with MongoDB
    22. 7.22. Using Panache with MongoDB
    23. 7.23. Using Neo4j with Quarkus
    24. 7.24. Flyway at Startup
    25. 7.25. Using Flyway Programmatically
  10. 8. Fault Tolerance
    1. 8.1. Implementing Automatic Retries
    2. 8.2. Implementing Timeouts
    3. 8.3. Avoiding Overloads with the Bulkhead Pattern
    4. 8.4. Avoiding Unnecessary Calls with the Circuit Breaker Pattern
    5. 8.5. Disabling Fault Tolerance
  11. 9. Observability
    1. 9.1. Using Automatic Health Checks
    2. 9.2. Creating Custom Health Checks
    3. 9.3. Exposing Metrics
    4. 9.4. Creating Metrics
    5. 9.5. Using Distributed Tracing
    6. 9.6. Custom Distributed Tracing
  12. 10. Integrating with Kubernetes
    1. 10.1. Building and Pushing Container Images
    2. 10.2. Generating Kubernetes Resources
    3. 10.3. Generating Kubernetes Resources with Health Checks
    4. 10.4. Deploying Services on Kubernetes
    5. 10.5. Deploying Services on OpenShift
    6. 10.6. Building and Deploying a Container Image Automatically
    7. 10.7. Configuring an Application from Kubernetes
    8. 10.8. Configuring an Application from Kubernetes with Config Extension
    9. 10.9. Interacting with a Kubernetes Cluster Programmatically
    10. 10.10. Testing Kubernetes Client Interactions
    11. 10.11. Implementing a Kubernetes Operator
    12. 10.12. Deploying and Managing Serverless Workloads with Knative
  13. 11. Authentication and Authorization
    1. Quarkus Security Basics
    2. 11.1. Authentication and Authorization with Elytron Properties File Config
    3. 11.2. Authentication and Authorization with Elytron Security JDBC Config
    4. 11.3. Authorization with MicroProfile JWT
    5. 11.4. Authorization and Authentication with OpenId Connect
    6. 11.5. Protecting Web Resources with OpenId Connect
  14. 12. Application Secrets Management
    1. 12.1. Storing Data Using Kubernetes Secrets
    2. 12.2. Store Configuration Secrets Securely with Vault
    3. 12.3. Cryptography as a Service
    4. 12.4. Generate Database Password as Secret
    5. 12.5. Authenticating Services Using Vault Kubernetes Auth
  15. 13. Quarkus REST Clients
    1. 13.1. Using the JAX-RS Web Client
    2. 13.2. Using the MicroProfile REST Client
    3. 13.3. Implementing a CRUD Client
    4. 13.4. Manipulating Headers
    5. 13.5. Using REST Client for Multipart Messages
    6. 13.6. Using REST Client to Configure SSL
  16. 14. Developing Quarkus Applications Using Spring APIs
    1. 14.1. Using Spring Dependency Injection
    2. 14.2. Using Spring Web
    3. 14.3. Using Spring Data JPA
    4. 14.4. Using Spring Security
    5. 14.5. Using Spring Boot Properties
  17. 15. Working with a Reactive Programming Model
    1. 15.1. Creating Async HTTP Endpoints
    2. 15.2. Streaming Data Asynchronously
    3. 15.3. Using Messaging to Decouple Components
    4. 15.4. Reacting to Apache Kafka Messages
    5. 15.5. Sending Messages to Apache Kafka
    6. 15.6. Marshalling POJOs into/out of Kafka
    7. 15.7. Using Kafka Streams API
    8. 15.8. Using AMQP with Quarkus
    9. 15.9. Using MQTT
    10. 15.10. Query Using Reactive SQL
    11. 15.11. Insert Using Reactive SQL Client
    12. 15.12. Using the Reactive MongoDB Client
    13. 15.13. Using the Reactive Neo4j Client
  18. 16. Additional Quarkus Features
    1. 16.1. Creating Templates with the Qute Template Engine
    2. 16.2. Rending HTML Using Qute
    3. 16.3. Changing the Location of Qute Templates
    4. 16.4. Extending Qute Data Classes
    5. 16.5. Describing Endpoints with OpenAPI
    6. 16.6. Customizing OpenAPI Spec
    7. 16.7. Sending Email Synchronously
    8. 16.8. Sending Email Reactively
    9. 16.9. Creating Scheduled Jobs
    10. 16.10. Using Application Data Caching
  19. Minikube
  20. Keycloak
  21. Knative
  22. Index

Product Information

  • Title: Quarkus Cookbook
  • Author(s): Alex Soto Bueno, Jason Porter
  • Release date: July 2020
  • Publisher(s): O'Reilly Media, Inc.
  • ISBN: 9781492062653