Playing with Java Microservices on Kubernetes and OpenShift

Table of Contents
Acknowledgements
Preface
	What this book covers
Part One: The Monolithics Era
	Chapter 1: Introduction to the Monolithic architecture
		Introduction to an actual situation
		Presenting the context
		How to solve these issues ?
	Chapter 2: Coding the Monolithic application
		Presenting our domain
			Use Case Diagram
			Class Diagram
			Sequence Diagram
		Coding the application
			Presenting the technology stack
				Java 8
				Maven
				Spring Boot
				NetBeans IDE
			Implementing the Boutique
				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
					Maven Dependencies
					Java Configuration
					Hello World Swagger !
	Chapter 3 : Upgrading the Monolithic application
		Refactoring the database
	Chapter 4: Building & Deploying the Monolithic application
		Building the monolith
			Which package type: WAR vs JAR
			Build a JAR
			Build WAR if you
				Step 1: Adding the Servlet Initializer Class
				Step 2: Exclude the embedded container from the WAR
				Step 3: Change the package type to war in pom.xml
				Step 4: Package your application
		Deploying the monolith
			Deploying the JAR
			Deploying the WAR
Part Two: The Microservices Era
	Chapter 5: Microservices Architecture Pattern
		The Monolithic Architecture
			What is a Monolithic Architecture ?
		Microservices Architecture
			What is a Microservices Architecture ?
			What is really a Microservice?
		Making the Switch
	Chapter 6: Splitting the Monolith: Bombarding the domain
		What is Domain-Driven Design ?
			Context
			Domain
			Model
			Ubiquitous Language
			Strategic Design
				Bounded context
		Bombarding La Boutique
			Codebase
		Dependencies and Commons
		Entities
			Example: Breaking Foreign Key Relationships
		Refactoring Databases
			Staging the Break
		Transactional Boundaries
			Try Again Later
			Abort the Entire Operation
			Distributed Transactions
			So What to Do?
		Summary
	Chapter 7: Applying DDD to the code
		Introduction
		Applying Bounded Contexts to Java Packages
			The birth of the commons package
			The birth of the configuration package
		Locating & breaking the BC Relationships
			Locating the BC Relationships
			Breaking the BC Relationships
	Chapter 8: Meeting the microservices concerns and patterns
		Introduction
		Cloud Patterns
			Service discovery and registration
			Externalized configuration
			Circuit Breaker
			Database per service
			API gateway
			CQRS
			Event sourcing
			Log aggregation
			Distributed tracing
			Audit logging
			Application metrics
			Health check API
			Security between services: Access Token
		What's next?
	Chapter 9: Implementing the patterns
		Introduction
		Externalized configuration
			Step 1: Generating the Config Server project skull
			Step 2: Defining the properties of the Config Server
			Step 3: Creating a centralized configuration
			Step 4: Enabling the Config Server engine
			Step 5: Run it !
			Step 6: Spring Cloud Config Client
		Service Discovery and Registration
			Step 1: Generating the Eureka Server project skull
			Step 2: Defining the properties of the Eureka Server
			Step 3: Creating the main configuration of the Eureka Server
			Step 4: Enabling the Eureka Server engine
			Step 5: Update the global application.yml of the Config Server
			Step 6: Run it !
			Step 7: Client Side Load Balancer with Ribbon
		Distributed tracing
			Step 1: Getting the Zipkin Server
			Step 2: Listing the dependencies to add to our microservices
				Sleuth
				Zipkin Client
		Health check API
		Circuit Breaker
			Step 1: Add the Maven dependency to your project
			Step 2: Enable the circuit beaker
			Step 3: Apply timeout and fallback method
			Step 4: Enable the Hystrix Stream in the Actuator Endpoint
			Step 5: Monitoring Circuit Breakers using Hystrix Dashboard
		API Gateway
			Step 1: Generating the API Gateway project skull
			Step 2: Enable the Zuul Capabilities
			Step 3: Defining the route rules
			Step 4: Enabling API specification on gateway using Swagger2
			Step 5: Run it!
		Log aggregation and analysis
			Step 1: Installing Elasticsearch
			Step 2: Installing Kibana
			Step 3: Installing & Configuring Logstash
				Installing Logstash
				Configuring Logstash
				Run it !
			Step 4: Enabling the Logback features
				Adding Logback libraries to our microservices
				Adding Logback configuration file to our microservices
			Step 5: Adding the Logstash properties to the Config Server
			Step 6: Attending the Kibana party
		Conclusion
	Chapter 10: Building the standalone microservices
		Introduction
		Global Architecture Big Picture
		Implementing the µServices
			Before starting
				Step 1: Generating the Commons project skull
				Step 2: Moving Code from our monolith
				Step 3: Moving Code from our monolith
				Step 4: Building the project
			The Product Service
				Step 1: Generating the Product Service project skull
				Step 2: Swagger 2
				Step 3: Application Configuration
				Step 4: Logback
				Step 5: Activating the Circuit Beaker capability
				Step 6: Moving Code from our monolith
			The Order Service
				Step 1: Generating the Order Service project skull
				Step 2: Swagger 2
				Step 3: Application Configuration
				Step 4: Logback
				Step 5: Activating the Circuit Beaker capability
				Step 6: Moving Code from our monolith
			The Customer Service
				Step 1: Generating the Customer Service project skull
				Step 2: Swagger 2
				Step 3: Application Configuration
				Step 4: Logback
				Step 5: Activating the Circuit Beaker capability
				Step 6: Moving Code from our monolith
		Conclusion
Part Three: Containers & Cloud Era
	Chapter 11. Getting started with Docker
		Introduction to containerization
		Introducing Docker
			What is Docker ?
			Images and containers
		Installation and first hands-on
			Installation
			Run your first container
		Docker Architecture
			The Docker daemon
			The Docker client
			Docker registries
			Docker objects
				Images
				Containers
			Docker Machine
			Why should I use it?
				Using Docker on older machines
				Provision remote Docker instances
		Diving into Docker Containers
			Introduction
			Your new development environment
			Define a container with Dockerfile
				Create sample application
					Run the app
					Share your image
				Log in with your Docker ID
					Tag the image
					Publish the image
					Pull and run the image from the remote repository
					Automating the Docker image build
					Spotify Maven plugin
					GoogleContainerTools Jib Maven plugin
		Meeting the Docker Services
			Your first docker-compose.yml file
			Run your new load-balanced app
			Scale the app
			Remove the app and the swarm
		Containerizing our microservices
	Chapter 12. Getting started with Kubernetes
		What is Kubernetes ?
			Kubernetes Architecture
			Kubernetes Core Concepts
				Kubectl
				Cluster
				Namespace
				Label
				Annotation
				Selector
				Pod
				ReplicationController
				ReplicaSet
				Deployment
				StatefulSet
				DaemonSet
				Service
				Ingress
				Volume
				PersistentVolume
				PersistentVolumeClaim
				StorageClass
				Job
				CronJob
				ConfigMap
				Secret
		Run Kubernetes locally
	Chapter 13: The Kubernetes style
		Discovering the Kubernetes style
			Create the ConfigMap
			Create the Secret
			Deploy PostgreSQL to Kubernetes
			What is Spring Cloud Kubernetes
			Deploy it to Kubernetes
			It works ! Hakuna Matata !
		Revisiting our Cloud Patterns after meeting Kubernetes
			Service Discovery and Registration
				Engaging the Kubernetes-enabled Discovery library
					Step 1: Remove the Eureka Client dependency
					Step 2: Add the Kubernetes-enabled Discovery library
					Step 3: Defining the Kubernetes Service name:
			Load Balancing
				Server Side Load Balancing
				Client Side Load Balancing
			Externalized Configuration
				Replacing the Config Server by ConfigMaps
					Step 1: Removing the Spring Cloud Config footprints
					Step 2: Adding the Maven Dependencies
					Step 3: Creating ConfigMaps based on the Application properties files
					Step 4: Authorizing the ServiceAccount access to ConfigMaps
					Step 5: Boosting Spring Cloud Kubernetes Config
			Log aggregation
				Step 1: Prepare the Minikube
				Step 2: Install EFK using Helm
					Step 2.1: Prepare Helm
					Step 2.2: Add the Chart repository
				Step 3: Installing the Elasticsearch Operator
				Step 4: Installing the EFK Stack using Helm
				Step 5: Remove the broadcasting appenders
			Health check API
			API Gateway
				Step 1: Delete the old ApiGateway microservice
				Step 2: Create the ApiGateway Ingress
			Distributed Tracing
				Step 1: Deploy Zipkin to Kubernetes
				Step 2: Forward Sleth traces to Zipkin
	Chapter 14: Getting started with OpenShift
		Introduction
		What is really OpenShift ?
			Run OpenShift locally
			Free OpenShift cluster
		What is the difference between OpenShift & Kubernetes
			The OpenShift Web Console
			Integrated Container Registry & ImageStreams
			Native CI/CD factory
			Logging and monitoring
			Version Control Integration
			Security
		What is changing in OpenShift?
			Common Kubernetes and OpenShift resources
			OpenShift specific resources
	Chapter 15: The Openshift style
		Introduction
		What is the OpenShift style?
			Route instead of Ingress
			Building applications
			Continuous Integration & Deployment
				OpenShift Pipelines
					OpenShift Jenkins Client Plug-in
					OpenShift DSL
					Jenkins Pipeline Strategy
					Jenkinsfile
				Jenkins
					Using the Jenkins Kubernetes Plug-in to Run Jobs
					OpenShift Container Platform Pipeline Plug-in
					OpenShift Container Platform Client Plug-in
					OpenShift Container Platform Sync Plug-in
		Conclusion
			Does it worth to move from OpenShift ?
			When do I need OpenShift ?
			Is OpenShift really matters ?
			Can I do the job using Kubernetes ?
Part four: Conclusion
	Chapter 16: Conclusion
		Development
		Fabric8 Maven Plugin
		Deployment
		End of the End
Part five: Bonus Chapters
	Service Mesh
		Introduction
		What is a Service Mesh ?
		Why do we need Service Mesh ?
		Conclusion
	Bonus 1: Service Mesh: Istio
		What is Istio?
			Istio Architecture
			Istio Components
				Envoy
				Mixer
				Pilot
				Citadel
				Galley
		Getting started with Istio
			Requirements
			Get & Install Istio
			Envoy Sidecar Injection
				Automatic Sidecar Injection
				Manual Sidecar Injection
		Traffic Management
			Istio Gateway & VirtualService
			Destination Rules
		Observability
			Distributed Tracing
				Hello Jaeger
				Trace sampling
			Grafana
			Prometheus
			Service Graph
		Conclusion
	Bonus 2: Service Mesh: Linkerd