Event-Driven

Building Event-Driven Microservices - Chapter 16 Deploying Event-Driven Microservices

Building Event-Driven Microservices - Chapter 16 Deploying Event-Driven Microservices

Translations: RU
Principles of Microservice Deployment Differentes between Continuous integration (CI), Continuous delivery and Continuous deployment. Deployment patterns: The Basic Full-Stop Deployment Pattern The Rolling Update Pattern The Breaking Schema Change Pattern: two options here - Eventual Migration and Synchronized Migration The Blue-Green Deployment Pattern All of these is disclosed in the Chapter 16 of the book: “Building Event-Driven Microservices: Leveraging Organizational Data at Scale” by Adam Bellemare Sharing my mind map with all the details as usual:
Building Event-Driven Microservices - Chapter 15 - Testing Event Driven Microservices.

Building Event-Driven Microservices - Chapter 15 - Testing Event Driven Microservices.

Translations: RU
Testing event-driven solutions is a challenging task. It includes: Common principles Unit testing: stateless and stateful Testing the Topology (I bet you didn’t do it! ;) Testing Schema Evolution and Compatibility Integration testing: Local, Remote and Hybrid - a set of common sense considerations not to forgot about Choosing the testing strategy All of these is disclosed in the Chapter 15 of the book: “Building Event-Driven Microservices: Leveraging Organizational Data at Scale” by Adam Bellemare
Building Event-Driven Microservices - Chapter 14 - Supportive Tooling

Building Event-Driven Microservices - Chapter 14 - Supportive Tooling

Translations: RU
Quite often the tooling is a forgotten area during the beginning of development. This chapter overlooks the tooling that can help build and maintain event-driven microservices. Useful checklist! This topic includes: Org rules Documentation, tagging Quotas Schema registry Offset management ACL State management and app reset Consumer offset lag monitoring Container Management Controls Cluster Creation and Management Dependency Tracking All of these is disclosed in the Chapter 14 of the book:
Building Event-Driven Microservices - Chapter 13 - Integrating Event-Driven and Request-Response Microservices

Building Event-Driven Microservices - Chapter 13 - Integrating Event-Driven and Request-Response Microservices

Translations: RU
How to integrate event-driven microservices with request-response APIs? There are two types of external events: Autonomously Generated Events (analytical events) Reactively Generated Events (events from request-reply) There are two approaches of processing and serving requests using stateful services: using internal state stores (with silly or with smart routing) using external state stores (with regular or with composite microservice) Ways of handling requests within an event-driven workflow:
Building Event-Driven Microservices - Chapter 12 - Lightweight Framework Microservices

Building Event-Driven Microservices - Chapter 12 - Lightweight Framework Microservices

Translations: RU
The 4th pattern to build microservices is to use Lightweight Frameworks. Lightweight Frameworks provide similar functionality to Heavyweight Frameworks, but they heavily rely on: the event broker the container management system (CMS) In many cases they exceed Heavyweight Frameworks. Different apps can use any/different resources from the cluster which are better fit their needs. While still provide Scaling and Recovering from Failures (again by heavily relying on event broker and CMS).
Building Event-Driven Microservices - Chapter 11 - Heavyweight Framework Microservices

Building Event-Driven Microservices - Chapter 11 - Heavyweight Framework Microservices

Translations: RU
Heavyweight Stream Processing Frameworks are another foundation/pattern to build your microservices. These frameworks are highly scalable and allow you to efficiently solve many analytical tasks. But they are not always good for stateful event-driven microservice application patterns. Heavyweight frameworks operate using centralized resource clusters, which may require additional operational overhead, monitoring, and coordination to integrate successfully into a microservice framework. However, recent innovations move these frameworks toward container management solutions (CMS) such as Kubernetes that should reduce your efforts.
Building Event-Driven Microservices - Chapter 10 - Basic Producer and Consumer Microservices

Building Event-Driven Microservices - Chapter 10 - Basic Producer and Consumer Microservices

Translations: RU
Basic Producer and Consumer (BPC) is a simple pattern for creating microservices. It forms the foundation of stateless and stateful services. You can use it for: interfacing layer between event streams and legacy systems leverage external stream processing systems to augment capabilities. But it requires your extra effort for: simple state materialization event scheduling timestamp-based decision making All of these is disclosed in the Chapter 10 of the book we are currently studying:
Building Event-Driven Microservices - Chapter 9 - Microservices Using Function as a Service

Building Event-Driven Microservices - Chapter 9 - Microservices Using Function as a Service

Translations: RU
Function-as-a-Service (FaaS) is an area of cloud computing that is growing rapidly. There are following issues to conside here: Principles of FaaS Open source and 3rd party FaaS providers 4 components to consider when building microservices as functions Cold Start vs Warm Start Different Triggers that can start FaaS: Triggering Based on New Events, Triggering Based on Consumer Group Lag, Triggering on a Schedule, Triggering Using Webhooks, Triggering on Resource Events Maintaining State Two patterns of functions calling other functions: Event-driven and Direct-call Termination and Shutdown Tuning and Scaling All of these is disclosed in the Chapter 9 of the book we are currently studying:
Building Event-Driven Microservices - Chapter 8 - Building Workflows with Microservices

Building Event-Driven Microservices - Chapter 8 - Building Workflows with Microservices

Translations: RU
There are two patterns of building event-driven microservices: Choreography (without centralized coordination) Orchestration (with centralized coordination) Both have pros and cons (however what I’ve learnt is that Orchestration is a better pattern) How to implement Distributed Transactions with Choreography and with Orchestration. How to AVOID implementing Distributed Transactions - a Compensation Workflows approach. All of these is disclosed in the Chapter 8 of the book we are currently studying:
Building Event-Driven Microservices - Chapter 7 - Stateful-Streaming

Building Event-Driven Microservices - Chapter 7 - Stateful-Streaming

Translations: RU
Event-Driven Microservices need to materialize states. And it comes with the important things to think about. Two approaches to choose from: Internal state store or External state store Both have pros and cons. Both have important scalability and recovery considerations. Two approaches for changing data structures: Bebuilding and Migration Transactions and how to emulate them in order to implement Effectively Once processing. All of these is disclosed in the Chapter 7 of the book we are currently studying: