Quarkus Cookbook

Spis treści książki

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

pokaż cały spis treści

ukryj recenzje