Librería Portfolio Librería Portfolio

Búsqueda avanzada


0 productos

en total 0,00 €

Año de edición:
67,50 €



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

Table of contents

Who Should Read This Book
Why We Wrote This Book
Navigating This Book
Conventions Used in This Book
Using Code Examples
O'Reilly Online Learning
How to Contact Us
1. Quarkus Overview
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