Pro Java Microservices with Quarkus and Kubernetes: A Hands-on Guide

✍ Scribed by Nebrass Lamouchi

• Publisher: Apress
• Year: 2021
• Tongue: English
• Leaves: 413
• Edition: 1
• Category: Library

✦ Synopsis

Build and design microservices using Java and the Red Hat Quarkus Framework. This book will help you quickly get started with the features and concerns of a microservices architecture. It will introduce Docker and Kubernetes to help you deploy your microservices.

You will be guided on how to install the appropriate tools to work properly. For those who are new to enterprise development using Quarkus, you will be introduced to its core principles and main features through a deep step-by-step tutorial. For experts, this book offers some recipes that illustrate how to split monoliths and implement microservices and deploy them as containers to Kubernetes.

By the end of reading this book, you will have practical hands-on experience of building microservices using Quarkus and you will master deploying them to Kubernetes.

What You Will Learn

• Work with Quarkus and GraalVM
• Split a monolith using the domain-driven design approach
• Implement the cloud and microservices patterns
• Rethink the deployment process
• Introduce containerization, Docker, and Kubernetes to your toolkit
• Boost microservices efficiency and performance with Azure
• Play with Quarkus and distributed application runtimes

Who This Book Is For

Java developers who want to build microservices using Red Hat Quarkus and who want to deploy them in Kubernetes.

✦ Table of Contents

Table of Contents
About the Author
About the Technical Reviewer
Acknowledgments
Preface
Introduction
Chapter 1: Getting Started with Containerization
Introducing Containerization
Introducing Docker
The Dockerfile
Images and Containers
Installing Docker
Running Your First Container
Understanding the Docker Architecture
Docker Objects
Images
Containers
Docker Machine
Diving Into Docker Containers
Docker Containers in Development Environments
Define a Container with Dockerfile
Create a Sample Application
Run the App
Publish Your Image
Log In with Your Docker ID
Tag the Image
Publish the Image
Pull and Run the Image from Docker Hub
Play with Google Jib
Build with Google Jib
Meeting the Docker Services
Create the First docker-compose.yml File
Achieving More with Docker
Get the Needed Tools Quickly
Get a Dockerized PostgreSQL Instance
Get a Dockerized SonarQube Instance
Unleash the Requirements Chains
Containerization Is Not Docker Only
What Are Docker’s Limitations?
Meet Podman and Buildah
Conclusion
Chapter 2: Introduction to the  Monolithic Architecture
Introduction to an Actual Situation
Presenting the Context
Solving These Issues
Chapter 3: Coding a Monolithic Application
Presenting the Domain
Use Case Diagram
Class Diagram
Sequence Diagram
Coding the Application
Presenting the Technology Stack
The PostgreSQL Database
Java 11
Maven
The Quarkus Framework
JetBrains IntelliJ IDEA
Implementing the QuarkuShop
Generating the Project Skull
Creating the Persistence Layer
Cart
CartStatus
Address
Category
Customer
Order
OrderItem
Payment
Product
ProductStatus
Review
Creating the Service Layer
Typical Service: CartService
AddressService
CategoryService
CustomerService
OrderItemService
OrderService
PaymentService
Product Service
ReviewService
Creating the Web Layer
Typical RestController: CartResource
CategoryResource
CustomerResource
OrderItemResource
OrderResource
PaymentResource
ProductResource
ReviewResource
Automated API Documentation
Hello World Swagger!
Customize the Quarkus Banner
Conclusion
Chapter 4: Upgrading a Monolithic Application
Implementing QuarkuShop Tests
Introducing Tests Libraries in Quarkus
Writing the First Tests
Discovering SonarQube
Building and Running QuarkuShop
Building the QuarkuShop
Packaging Modes in Quarkus
Meeting the Quarkus Native
Running the Tests in Native Mode
Packaging and Running the Native QuarkuShop
Differences Between the JVM and Native Modes
The Magic Behind GraalVM’s Power
Conclusion
Chapter 5: Building and Deploying a Monolithic Application
Introduction
Importing the Project into Azure DevOps
Creating the CI/CD Pipelines
Creating the Continuous Integration Pipeline
Creating a Maven-Based CI Pipeline
Creating a Docker Multistage Based CI Pipeline
Making the Continuous Deployment Pipeline
Create the Virtual Machine
Create the Continuous Deployment Pipeline
Conclusion
Chapter 6: Adding Anti-Disaster Layers
Introduction
Implementing the Security Layer
Analyzing Security Requirements and Needs
Defining Authorization Matrices for REST APIs
Implementing the Security Layer
Preparing and Configuring Keycloak
Implementing the auth2 Java Components in QuarkuShop
Java Configuration Side
Java Source Code Side
Update the Integration Tests to Support auth2
Adding Keycloak to the Production Environment
Implementing the Monitoring Layer
Implementing Health Checks
Implementing the Metrics Service
Conclusion
Chapter 7: Microservices Architecture Pattern
Introduction
Microservices Architecture
Benefits of a Microservices Architecture
What Really Is a Microservice?
Conclusion: Making the Switch
Chapter 8: Splitting the Monolith: Bombarding the Domain
Introduction
What Is Domain-Driven Design?
Context
Domain
Model
Ubiquitous Language
Strategic Design
Bounded Context
Bombarding QuarkuShop
Codebase
Dependencies and Commons
Entities
Example: Breaking Foreign Key Relationships
Conclusion
Chapter 9: Applying DDD to the Code
Applying Bounded Contexts to Java Packages
The Birth of the Commons Package
Locating the Bounded Contexts Relationships
Breaking the BC Relationships
Conclusion
Chapter 10: Meeting the Microservices Concerns and Patterns
Cloud Patterns
Service Discovery and Registration
Context and Problem
Solution
Externalized Configuration
Context and Problem
Solution
Circuit Breaker
Context and Problem
Solution
Database Per Service
Context and Problem
Solution
API Gateway
Context and Problem
Solution
CQRS
Context and Problem
Solution
Event Sourcing
Context and Problem
Solution
Log Aggregation
Context and Problem
Solution
Distributed Tracing
Context and Problem
Solution
Audit Logging
Context and Problem
Solution
Application Metrics
Context and Problem
Solution
Health Check API
Context and Problem
Solution
Security Between Services: Access Token
Context and Problem
Solution
Conclusion
Chapter 11: Getting Started with Kubernetes
Introduction
What Is Kubernetes?
The Kubernetes Architecture
Kubernetes Core Concepts
Kubectl
Cluster
Namespace
Label
Pod
ReplicaSet
Deployment
StatefulSet
DaemonSet
Service
Ingress
Volume
PersistentVolume
PersistentVolumeClaim
StorageClass
Job
CronJob
ConfigMap
Secret
Run Kubernetes Locally
Practical Summary and Conclusion
Additional Reading
Chapter 12: Implementing the Cloud Patterns
Introduction
Bringing the Monolithic Universe to Kubernetes
Deploying PostgreSQL to Kubernetes
Deploying Keycloak to Kubernetes
Deploying the Monolithic QuarkuShop to Kubernetes
Conclusion
Chapter 13: Building the Kubernetized Microservices
Introduction
Creating the Commons Library
Implementing the Product Microservice
Implementing the Order Microservice
Implementing the Customer Microservice
Implementing the User Microservice
Conclusion
Chapter 14: Flying All Over the Sky with Quarkus and Kubernetes
Introduction
Implementing the Circuit Breaker Pattern
Implementing the Log Aggregation Pattern
Step 1: Deploying the ELK Stack to Kubernetes
Step 2: Configuring the Microservices to Log Into the ELK Stack
Step 3: Collecting Logs
Implementing the Distributed Tracing Pattern
Step 1: Deploying the Jaeger All-in-One to Kubernetes
Step 2: Enabling Jaeger Support in Our Microservices
Step 3: Collecting Traces
Implementing the API Gateway Pattern
Step 1: Enabling Ingress Support in Minikube
Step 2: Creating the API Gateway Ingress
Step 3: Testing Ingress
Conclusion
Afterword:
Final Words and Thoughts
Index