Microservice Patterns and Best Practices
更新时间：2021-06-30 19:03:36
最新章节：Leave a review - let other readers know what you thinkcoverpage
Title Page
Dedication
Packt Upsell
Why subscribe?
PacktPub.com
Contributors
About the author
About the reviewer
Packt is searching for authors like you
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Reviews
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
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
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
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
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
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
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
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
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
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
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
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
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
更新时间：2021-06-30 19:03:36