Microservice Patterns and Best Practices

Cover
Copyright and Credits
Dedication
Packt Upsell
Contributors
Table of Contents
Preface
Chapter 1: Understanding the Microservices Concepts
	Knowing the application
		Domain-driven design
		Single responsibility principle
		Explicitly published interface
	Independently deploy, upgrade, scale, and replace
		Independent deployment
		Upgrade
		Scale
			The x-axis
			The y-axis
			The z-axis
			Replace
	Light weight communication
		Synchronous
		Asynchronous
	Potentially heterogeneous/polyglot
	Documentation of communication
	Endpoints for web applications
	Endpoints for mobile applications
	Caching at the client level
	Throttling for your client
	Identifying anemic domains
	Identifying the fat domains
	Identifying microservice domains for the business
	From domain to entity
	Summary
Chapter 2: The Microservice Tools
	Programming languages
		Proficiency
		Performance
		Development of practicality
		Ecosystem
		Scalability cost
		Making choices for our application
			Java
			C#
			Python
			JavaScript
			Go
	Microservice frameworks
		Python
		Go
			Logs
			Handlers
			Middleware
			Tests
			Package manager
			Golang ORMs
	Binary communication – direct communication between services
		Understanding the aspect
			Tools for synchronous communication
			MessagePack
			gRPC
			Apache Avro
			Apache Thrift
		Direct communication alerts
	Message broker – Async communication between services
		ActiveMQ
		RabbitMQ
		Kafka
	Caching tools
		Memcached
		Redis
	Fail alert tools
		Performance
		Build
		Components
		Implementation gaps
	The databases
	Locale proof performance
		Apache Benchmark
		WRK
		Locust
	Summary
Chapter 3: Internal Patterns
	Developing the structure
		Database
		Programming language and tools
		Project structure
			The models.go file
			The app.go file
			The main.go file
	Caching strategies
		Applying cache
		Caching first
		Enqueuing tasks
		Asynchronism and workers
	CQRS – query strategy
		What is CQRS?
		Understanding CQRS
		Advantages and disvantages of implementing CQRS
	Event sourcing – data integrity
		State mutation
			Understanding event sourcing
	Summary
Chapter 4: Microservice Ecosystem
	Separating containers
		Layered services architecture
		Separating UsersService
			Creating Dockerfile
			Using the containers
	Storage distribution
		Depreciating data
		Regionalizing data
	Bulkheads – using the ecosystem against failures
		Designing for redundancy
		Partitioning by criticality
		Designing with isolation
		Fail fast
	Circuit breaker
	Summary
Chapter 5: Shared Data Microservice Design Pattern
	Understanding the pattern
	Breaking a monolithic application into microservices
		Defining priorities
		Setting deadlines
		Defining the domain
		Making experiments
		Defining standards
		Creating a prototype
		Sending to production
		Developing new microservices
			Writing the microservice configuration file
			Creating our model
			Exposing the microservice data
			Preparing the app to run
			Creating the Dockerfile
			Dependencies with requirements.txt
	Data orchestration
	Consolidating responses
	Microservice communication
	Storage sharing anti-pattern
	Best practices
	Testing
	Pros and cons of the shared data pattern
	Summary
Chapter 6: Aggregator Microservice Design Pattern
	Understanding the pattern
	Applying CQRS and event sourcing
		Separating the database
			Writing the CommandStack container
			Creating the news databases
			Writing the QueryStack container
		Refactoring the microservices
			Selecting our requirements
			Configuring the framework
			Configuring the container
			Writing the models
			Creating the service
			Preparing the database containers to work together
	Microservice communication
		Building the orchestrator
			Preparing the microservice container
			Writing the dependencies
			Writing the configuration file
			Writing the server access
			Creating the orchestration controller
		Applying the message broker
			Making the containers work together
			Updating the proxy/load balancer
	Pattern scalability
	Bottleneck anti-pattern
	Best practices
	Applying tests
		Functional test
			Writing the functional test
		Integration test
			Writing the integration tests
	Pros and cons of aggregator design pattern
		Pros of aggregator design pattern
		Cons of aggregator design pattern
	Summary
Chapter 7: Proxy Microservice Design Pattern
	The proxy approach
		Dumb proxy
		Smart proxy
		Understanding our proxy
	Proxy strategy to orchestrator
	Microservice communication
	Pattern scalability
	Best practices
		Purest pattern
		Looking at the bottleneck
		Caching in the proxy
		Simple response
	Pros and cons of proxy design pattern
	Summary
Chapter 8: Chained Microservice Design Pattern
	Understanding the pattern
	Data orchestration and response consolidation
	Microservice communication
	Pattern scalability
	Big Ball of Mud anti-pattern
	Best practices
		Purest microservices
		Requesting consistent data
		Understanding chain in depth
		Paying attention to the communication layer
	Understanding the pros and cons of chained design pattern
	Summary
Chapter 9: Branch Microservice Design Pattern
	Understanding the pattern
	Data orchestration and response consolidation
	Microservice communication
	Pattern scalability
	Best practices
		Domain definition
		Respect the rules
		Attention to physical components
		Keep it simple
	Pros and cons of the branch design pattern
	Summary
Chapter 10: Asynchronous Messaging Microservice
	Understanding the pattern
	Domain definition – RecommendationService
	Data definition – RecommendationService
	Coding the microservice
	Microservice communication
		Applying the message broker and queues
		Preparing the pub/sub structure
	Pattern scalability
	Process sequence anti-pattern
	Best practices
		Application definition
		Don’t try to create responses
		Keep it simple
	Pros and cons of the asynchronous messaging design pattern
	Summary
Chapter 11: Microservices Working Together
	Understanding the current application status
		The public facing layer
		The internal layer
		Understanding general tools
	Communication layer and accreditation between services
		Understanding the data contract between services
		Applying binary communication 
	Pattern distribution
	Fail strategies
	API integration
	Summary
Chapter 12: Testing Microservices
	Unit tests
	Preparing the containers for the integration test
	Integration tests
	End-to-end tests
	Release pipelines
	Signature tests
	Monkey tests
	Chaos Monkey
	Summary
Chapter 13: Monitoring Security and Deployment
	Monitoring microservices
		Monitoring a single service
		Monitoring multiple services
		Looking at the logs
		Learning from the errors in the application
		The metrics – Understanding the numbers
	Security
		Understanding JWT
		Single Sign-On
		Security of data
		Defense for malicious requests – Identifying attacks
		Explaining the interceptor
		Web container
		The API gateway
	Deployment
		Continuous integration/continuous delivery/continuous deploy
		The blue/green deployment pattern and Canary releases
		Multiple service instances per host
		Service instance per host
			Service instance per VM
			Service instance per container
	Summary
Other Books You May Enjoy
	Leave a review - let other readers know what you think
Index