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

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