舉報 
會員
Microservice Patterns and Best Practices
Thisbookisforarchitectsandseniordeveloperswhowouldlikeimplementmicroservicedesignpatternsintheirenterpriseapplicationdevelopment.Thebookassumessomepriorprogrammingknowledge.
最新章節(jié)
- Leave a review - let other readers know what you think
- Other Books You May Enjoy
- Summary
- Service instance per container
- Service instance per VM
- Service instance per host
品牌：中圖公司
上架時間：2021-06-30 18:29:41
出版社：Packt Publishing
本書數(shù)字版權(quán)由中圖公司提供，并由其授權(quán)上海閱文信息技術(shù)有限公司制作發(fā)行
- Leave a review - let other readers know what you think 更新時間：2021-06-30 19:03:36
- Other Books You May Enjoy
- Summary
- Service instance per container
- Service instance per VM
- Service instance per host
- Multiple service instances per host
- The blue/green deployment pattern and Canary releases
- Continuous integration/continuous delivery/continuous deploy
- Deployment
- The API gateway
- Web container
- Explaining the interceptor
- Defense for malicious requests – Identifying attacks
- Security of data
- Single Sign-On
- Understanding JWT
- Security
- The metrics – Understanding the numbers
- Learning from the errors in the application
- Looking at the logs
- Monitoring multiple services
- Monitoring a single service
- Monitoring microservices
- Monitoring Security and Deployment
- Summary
- Chaos Monkey
- Monkey tests
- Signature tests
- Release pipelines
- End-to-end tests
- Integration tests
- Preparing the containers for the integration test
- Unit tests
- Testing Microservices
- Summary
- API integration
- Fail strategies
- Pattern distribution
- Applying binary communication
- Understanding the data contract between services
- Communication layer and accreditation between services
- Understanding general tools
- The internal layer
- The public facing layer
- Understanding the current application status
- Microservices Working Together
- Summary
- Pros and cons of the asynchronous messaging design pattern
- Keep it simple
- Don’t try to create responses
- Application definition
- Best practices
- Process sequence anti-pattern
- Pattern scalability
- Preparing the pub/sub structure
- Applying the message broker and queues
- Microservice communication
- Coding the microservice
- Data definition – RecommendationService
- Domain definition – RecommendationService
- Understanding the pattern
- Asynchronous Messaging Microservice
- Summary
- Pros and cons of the branch design pattern
- Keep it simple
- Attention to physical components
- Respect the rules
- Domain definition
- Best practices
- Pattern scalability
- Microservice communication
- Data orchestration and response consolidation
- Understanding the pattern
- Branch Microservice Design Pattern
- Summary
- Understanding the pros and cons of chained design pattern
- Paying attention to the communication layer
- Understanding chain in depth
- Requesting consistent data
- Purest microservices
- Best practices
- Big Ball of Mud anti-pattern
- Pattern scalability
- Microservice communication
- Data orchestration and response consolidation
- Understanding the pattern
- Chained Microservice Design Pattern
- Summary
- Pros and cons of proxy design pattern
- Simple response
- Caching in the proxy
- Looking at the bottleneck
- Purest pattern
- Best practices
- Pattern scalability
- Microservice communication
- Proxy strategy to orchestrator
- Understanding our proxy
- Smart proxy
- Dumb proxy
- The proxy approach
- Proxy Microservice Design Pattern
- Summary
- Cons of aggregator design pattern
- Pros of aggregator design pattern
- Pros and cons of aggregator design pattern
- Writing the integration tests
- Integration test
- Writing the functional test
- Functional test
- Applying tests
- Best practices
- Bottleneck anti-pattern
- Pattern scalability
- Updating the proxy/load balancer
- Making the containers work together
- Applying the message broker
- Creating the orchestration controller
- Writing the server access
- Writing the configuration file
- Writing the dependencies
- Preparing the microservice container
- Building the orchestrator
- Microservice communication
- Preparing the database containers to work together
- Creating the service
- Writing the models
- Configuring the container
- Configuring the framework
- Selecting our requirements
- Refactoring the microservices
- Writing the QueryStack container
- Creating the news databases
- Writing the CommandStack container
- Separating the database
- Applying CQRS and event sourcing
- Understanding the pattern
- Aggregator Microservice Design Pattern
- Summary
- Pros and cons of the shared data pattern
- Testing
- Best practices
- Storage sharing anti-pattern
- Microservice communication
- Consolidating responses
- Data orchestration
- Dependencies with requirements.txt
- Creating the Dockerfile
- Preparing the app to run
- Exposing the microservice data
- Creating our model
- Writing the microservice configuration file
- Developing new microservices
- Sending to production
- Creating a prototype
- Defining standards
- Making experiments
- Defining the domain
- Setting deadlines
- Defining priorities
- Breaking a monolithic application into microservices
- Understanding the pattern
- Shared Data Microservice Design Pattern
- Summary
- Circuit breaker
- Fail fast
- Designing with isolation
- Partitioning by criticality
- Designing for redundancy
- Bulkheads – using the ecosystem against failures
- Regionalizing data
- Depreciating data
- Storage distribution
- Using the containers
- Creating Dockerfile
- Separating UsersService
- Layered services architecture
- Separating containers
- Microservice Ecosystem
- Summary
- Understanding event sourcing
- State mutation
- Event sourcing – data integrity
- Advantages and disvantages of implementing CQRS
- Understanding CQRS
- What is CQRS?
- CQRS – query strategy
- Asynchronism and workers
- Enqueuing tasks
- Caching first
- Applying cache
- Caching strategies
- The main.go file
- The app.go file
- The models.go file
- Project structure
- Programming language and tools
- Database
- Developing the structure
- Internal Patterns
- Summary
- Locust
- WRK
- Apache Benchmark
- Locale proof performance
- The databases
- Implementation gaps
- Components
- Build
- Performance
- Fail alert tools
- Redis
- Memcached
- Caching tools
- Kafka
- RabbitMQ
- ActiveMQ
- Message broker – Async communication between services
- Direct communication alerts
- Apache Thrift
- Apache Avro
- gRPC
- MessagePack
- Tools for synchronous communication
- Understanding the aspect
- Binary communication – direct communication between services
- Golang ORMs
- Package manager
- Tests
- Middleware
- Handlers
- Logs
- Go
- Python
- Microservice frameworks
- Go
- JavaScript
- Python
- C#
- Java
- Making choices for our application
- Scalability cost
- Ecosystem
- Development of practicality
- Performance
- Proficiency
- Programming languages
- The Microservice Tools
- Summary
- From domain to entity
- Identifying microservice domains for the business
- Identifying the fat domains
- Identifying anemic domains
- Throttling for your client
- Caching at the client level
- Endpoints for mobile applications
- Endpoints for web applications
- Documentation of communication
- Potentially heterogeneous/polyglot
- Asynchronous
- Synchronous
- Light weight communication
- Replace
- The z-axis
- The y-axis
- The x-axis
- Scale
- Upgrade
- Independent deployment
- Independently deploy upgrade scale and replace
- Explicitly published interface
- Single responsibility principle
- Domain-driven design
- Knowing the application
- Understanding the Microservices Concepts
- Reviews
- Get in touch
- Conventions used
- Download the color images
- Download the example code files
- To get the most out of this book
- What this book covers
- Who this book is for
- Preface
- Packt is searching for authors like you
- About the reviewer
- About the author
- Contributors
- PacktPub.com
- Why subscribe?
- Packt Upsell
- Dedication
- Title Page
- coverpage
- coverpage
- 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
