microservices-patterns/ftgo-application
Ftgo Application
This project is a Java microservices reference implementation that demonstrates the application of structural design patterns for distributed systems. It consists of a suite of containerized services and infrastructure dependencies designed to showcase how to coordinate multiple independent services into a functional system.
The implementation focuses on several advanced architectural patterns, including a centralized API gateway for routing and aggregating responses, Command Query Responsibility Segregation to separate read and write operations, and event sourcing to persist the state of business entities as a sequence of immutable events. It also demonstrates the Saga pattern for coordinating distributed transactions to ensure eventual consistency across services.
The system covers a broad range of capabilities including asynchronous event-driven communication, transactional outbox messaging, and the management of domain-specific workflows for order and account lifecycles. It utilizes container orchestration for the deployment and scaling of services.
The suite is provided as a collection of Dockerized and Kubernetes-ready services to facilitate local development and cluster deployment.
Features
- Architectural Pattern Implementations - Serves as a reference implementation for structural distributed system design patterns in Java.
- Microservice Architectures - Implements a reference architecture consisting of loosely coupled, independently deployable microservices using distributed design patterns.
- CQRS Patterns - Implements the CQRS pattern to separate read and write operations, optimizing query performance and scalability.
- Interface-Level Read-Write Separations - Separates read and write paths at the application layer to optimize query performance and scalability.
- Order Lifecycle Management - Manages the complete end-to-end flow of orders, including approval, rejection, and state transition validation.
- CQRS Read Views - Builds dedicated read views for complex data queries to separate them from write operations.
- Asynchronous Data Streaming - Facilitates decoupled communication between microservices using asynchronous data streaming and event brokers.
- Centralized API Gateways - Provides a centralized API gateway that routes external requests to the appropriate internal microservices.
- Asynchronous Message Passing - Utilizes non-blocking asynchronous message passing for decoupled communication between distributed services.
- Decoupled Communication Services - Exchanges data between decoupled services using distributed event streams and message brokers.
- Gateway-Based Request Routings - Provides a single gateway entry point for external clients to access a variety of internal microservices.
- API Gateways - Implements a centralized API gateway to route external requests and aggregate responses from multiple microservices.
- Command Query Responsibility Segregation - Implements Command Query Responsibility Segregation to separate data modification logic from retrieval operations.
- CQRS Patterns - Separates read and write operations into distinct models to optimize query performance and system scalability.
- Saga Coordinators - Coordinates distributed transactions across services using the Saga pattern to ensure eventual consistency.
- Distributed Transaction Patterns - Manages complex business processes across multiple services using the Saga pattern to ensure eventual data consistency.
- Event Driven Messaging - Implements an asynchronous event-driven architecture to decouple microservices via message brokers.
- Event Sourcing - Persists business entity state as a sequence of immutable events combined with CQRS for read-write separation.
- Event Sourcing Persistence - Persists the state of business entities as a sequence of immutable events rather than current snapshots.
- Event Sourcing - Persists the state of business entities as an immutable sequence of events instead of snapshots.
- Backend Domain Events - Triggers event notifications when business entity states change to enable asynchronous communication between services.
- API Gateways - Implements an API gateway as a central entry point to route and aggregate microservice data.
- RESTful Endpoints - Implements synchronous REST endpoints to allow clients to interact with microservices via standard request-response cycles.
- API Response Optimizations - Optimizes API responses by aggregating data from multiple downstream services to reduce client round-trips.
- Transactional Message Deliveries - Ensures atomic data exchange and persistence across services using transactional messaging patterns.
- Domain Aggregates - Organizes business logic into cohesive domain aggregates to maintain internal consistency and define state boundaries.
- Container Orchestration - Automates the deployment and lifecycle management of essential infrastructure containers like databases and message brokers.
- Kubernetes Cluster Deployments - Packages services into containers and manages their deployment and scaling using Kubernetes orchestration tools.
- Containerized Service Deployment - Orchestrates the build and deployment of containerized services and backing infrastructure into a cluster.
- Kubernetes Cluster Orchestration - Implements automated deployment and scaling of microservices within a containerized Kubernetes cluster.
- Microservices Orchestration - Manages the lifecycle, discovery, and routing of a suite of containerized microservices within a cluster.
- Multi-Service Container Orchestration - Orchestrates a suite of inter-dependent containerized services and infrastructure dependencies for a functional system.
- Distributed Service Communications - Manages a mix of synchronous REST calls and asynchronous messaging for distributed service communication.
- API Aggregators - Uses an API aggregator within the gateway to merge data from multiple microservices into single responses.
- Asynchronous Command Processing - Processes domain commands asynchronously by subscribing to event streams and mapping payloads to business logic.
- Microservice Orchestration - Orchestrates the lifecycle and communication of a distributed microservice cluster.
- Service Orchestration - Provides a set of configuration files to coordinate and launch multiple microservices as a unified system.
- Data Model Decoupling - Separates data retrieval views from update logic to optimize query performance and reduce contention.
- Business Logic Encapsulations - Organizes domain logic into reusable encapsulates to maintain data integrity and encapsulate business rules.
- Transactional Outbox Patterns - Implements the transactional outbox pattern to atomically couple database updates with message publishing.
- Microservice Reference Implementations - Restaurant management system using the Saga pattern.
