Cargando…
Microservice Patterns and Best Practices : Explore patterns like CQRS and event sourcing to create scalable, maintainable, and testable microservices.
Microservices are a hot trend in the development world right now. Many enterprises have adopted this approach to achieve agility and the continuous delivery of applications to gain a competitive advantage. This book will take you through the different design patterns at different stages of the micro...
| Clasificación: | Libro Electrónico |
|---|---|
| Autor principal: | |
| Formato: | Electrónico eBook |
| Idioma: | Inglés |
| Publicado: |
Birmingham :
Packt Publishing,
2018.
|
| Temas: | |
| Acceso en línea: | Texto completo |
Tabla de Contenidos:
- 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.