Event-Driven Microservice Flows With Loose-Coupled Service Discovery
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing technologies face challenges in managing complex mobile and computer applications due to tight coupling of functions, leading to increased complexity, bugs, and reduced flexibility and code reusability, with conventional methods lacking effective decoupling and configuration management.
Innovation Solution
A system and method for managing flow configurable event-driven microservices using a processor to provide memory space addresses, automatic service discovery, and configuration files to connect functions in a sequence or parallel mode, with data mapping and event envelopes to ensure loose coupling and immutability, allowing for decoupled data models and statelessness.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If conventional tight coupling approach is used to write application code, then code execution is straightforward and simple, but code complexity increases and flexibility is reduced as the application grows
Solution Approach 1:
The patent divides the monolithic application into independent microservices that can be developed, deployed, and scaled separately. Each microservice encapsulates specific business logic and communicates through standardized interfaces, reducing overall system complexity while maintaining execution simplicity through modular architecture.
Solution Approach 2:
The patent introduces an event bus as an intermediary layer between microservices, enabling asynchronous communication and decoupling service interactions. This mediator allows services to publish and subscribe to events without direct dependencies, simplifying execution flow while managing complexity through standardized event-driven patterns.
2Device complexity
If microservices architecture is used with conventional direct method invocation, then application size is reduced into smaller modules, but tight coupling between functions is created
Solution Approach 1:
The event bus serves as a mediator that replaces direct method invocations between microservices. Services publish events to the bus rather than calling each other directly, achieving loose coupling while maintaining small module sizes. This allows independent deployment and easier adaptation of individual services.
Solution Approach 2:
The patent implements dynamic service discovery and routing where microservices can be added, removed, or modified at runtime without affecting the entire system. The event-driven architecture allows flexible configuration and adaptation of service interactions, enhancing code versatility while maintaining modular structure.
3Ease of operation
If Flow-Based Programming is used to separate business logic from connectivity, then data processing follows clear input/process/output steps, but transaction data model remains coupled with business logic
Solution Approach 1:
The patent extracts the data model layer from business logic by implementing separate data transfer objects (DTOs) and event schemas. Business logic operates on abstract event structures while connectivity and data persistence handle concrete model implementations, achieving clear input/process/output separation while decoupling data models through interface-based interactions.
4Ease of manufacture
If conventional configuration management is used in tightly coupled applications, then setup is straightforward, but patches are required multiple times during development and documentation is inadequate
Solution Approach 1:
The patent implements configuration files and service registries that are established beforehand, allowing services to automatically discover and configure their dependencies during startup. This preliminary setup eliminates the need for repeated manual configuration and patching during development, reducing development time while maintaining straightforward initial setup through standardized templates.
Data Source
AI summary
Systems and methods for managing flow configurable event-driven microservices are disclosed. A system provides, for each function in sequence of steps corresponding to transaction flow associated with model of event-driven microservices, an address of associated memory space using route name. The system connects each function with another function in memory space and/or different application instances with automatic service discovery. The system transports, for event-driven microservices, an input and/or output comprising message and/or an event comprising object corresponding to payload, in an event envelope, based on a configuration file/a configuration file-like handle. Additionally, the system executes a sequence of steps connecting each function in sequential mode or parallel mode, based on a configuration file/a configuration file-like handle. The system performs data mapping between transaction data states (‘stateful data model’) in a transaction and input/output of each function that is connected in two or more steps in single transaction.