CQRS and Event Sourcing
•Transferir como PPTX, PDF•
6 gostaram•991 visualizações
CQRS and Event Sourcing are popular architectural patterns that allow you to build effective event-driven micro-services. The basic idea of these patterns is to record each event that changes the state of the domain model into the event-storage. This approach allows you to reduce service latency for any data scale, as well as be able to restore the system without losing any data.
Recomendados
Recomendados
Mais conteúdo relacionado
Mais procurados
Mais procurados (20)
Semelhante a CQRS and Event Sourcing
Semelhante a CQRS and Event Sourcing (20)
Mais de Sergey Seletsky
Mais de Sergey Seletsky (13)
Último
Último (20)
CQRS and Event Sourcing
- 1. CQRS and Event Sourcing in .NET .NET Excellence Center at Intellias Sergiy Seletsky Senior Solutions Architect MEETUP
- 2. .NET Excellence Center – what is it? Community development Presales support Consulting Interview support and preparation Mentorship Employee Assessment And more… Intellias CoEs is a virtual organization of proactive people, who go beyond their regular duties and employ their expertise where this is crucial for the company to succeed. Join our team of proactive experts if you are senior+, of course ;) For details contact: Tetiana Kulbatska
- 3. Agenda Pain points of traditional architecture CQS and CQRS theory Event Sourcing in .NET DDD and Event-driven microservices Reference implementation for .NET Q&A
- 4. • Scalability of System is by larger and larger RDBMS • Surprise, surprise! • Persistence means ‘save the Current State’ of the domain model • Query concerns are at odds with Transactional concerns • System audit adds extra complexity • Issues with complex data schema versioning • more… Application Design Pain Points
- 5. Domain Modeling Pain Points Business Rules only exist in user’s heads Converting Domain Objects to DTOs (and back again!) Domain Object Persistence Lazy vs. Eager Fetching Optimizing Domain for efficient Queries Setter/Getter Anti-Pattern Tests are (often) brittle more…
- 6. Business Pain Points Must know what business questions we want to ask up front Optimizing for Queries and Optimizing for Transactions are tied together (and very expensive) Evolving Requirements is hard/expensive more…
- 7. What is CQS & CQRS?
- 8. Command-Query Separation • Command-Query Separation (CQS) states that every method should either be a command that performs an action, or a query that returns data to the caller, but not both. • In other words, asking a question should not change the answer. • More formally, methods should return a value only if they are referentially transparent and hence possess no side effects. Query - returns data and not apply any changes Command - apply changes and not returns data, only result of execution
- 10. From CRUD to CQS
- 12. Command-Query Responsibility Segregation • The CQS principles applied to your domain modeling and system architecture • Enable each element of your architecture to be optimized for a single responsibility • Decomposition for your architecture rather than just for your objects
- 14. LAN/WAN Slicing and Dicing our Architecture Application Services Domain Object Domain Object Domain Object Domain Object Client Remote Services Request DTO ReturnDTO Command ACK Returned RDBMS Client Server WriteRead
- 15. LAN/WAN Refactoring our Architecture Application Services Domain Object Domain Object Client Remote Services Request DTO ReturnDTO Application Services Command ACK Returned WriteRead Light-Weight Query Services RDBMS Domain Object Domain Object Persistence Persistence Remote ServicesRemote Services Eventually
- 16. Command Query Responsibility Segregation Read StorageEvents Storage APIs Write Model Read ModelEvents Command Query
- 17. Write Model Write Model Events Command Handler Event Handler EventBus/EventStore Domain Model Repository REST commandBus.Send( CreateJobProfile(jobProfile) ); [CommandHandler] public Task Handle(CreateJobProfileCommand command) { //check if exist repository.FindEntity(); event = new JobProfileCreated(command.entity); RaiseEvent(event); [EventHandler] public void HandleCreated(JobProfileCreated event) { entity = new JobProfileQueryModel( event.Entity ); repository.Save( entity ); } CmdBu s
- 18. Read Model Write Model EventBus/EventStore Event Handler Domain Model Events Repository REST [EventHandler] public void Handle(JobProfileCreated event) { entity = new CareerMatrixQueryModel( event.Entity ); //extra projections happened here repository.Save(entity);
- 19. As many read models as you want With No performance degradation UI Write Model Events Command Query Read ModelRead ModelRead Model
- 20. C PA CAP Theorem: onsistency, vailability, artition-Tolerance; pick any two! Write Read Scaling of Distributed Systems C A P
- 23. Event Sourcing advantages Events are immutable and can be stored using an append-only operation. Events are simple objects that describe some action that occurred Events typically have meaning for a domain expert Event sourcing can help prevent concurrent updates from causing conflicts because it avoids the requirement to directly update objects in the data store The append-only storage of events provides an audit trail that can be used to monitor actions taken against a data store The event store raises events, and tasks perform operations in response to those events.
- 24. ASP.NET Core – APIs Controller public class InventoryController: Controller { private readonly ICommandBus commandBus; private readonly IReadModelFacade queryModel; public InventoryController(ICommandBus bus, IReadModelFacade facade) { queryModel = facade; commandBus = bus; } [HttpGet] public async Task<IActionResult<IQuerable<InventoryQueryItem>>> Query() { return await queryModel.GetInventoryItemsQueryAsync(); } [HttpGet("{id}")] public async Task<IActionResult<InventoryQueryItem>> QueryById(string id) { return await queryModel.GetInventoryItemAsync(id); } [HttpPost] public async Task<IActionResult<IExecutionResult>> Add(CreateInventoryItem command) { return await commandBus.SendAsync(command); } [HttpPut("/change-name")] public async Task<IActionResult<IExecutionResult>> ChangeName(RenameInventoryItem command) { return await commandBus.SendAsync(command); } [HttpPut("/check-in")] public async Task<IActionResult<IExecutionResult>> CheckIn(CheckInItemsToInventory command) { return await commandBus.SendAsync(command); } [HttpPut("/remove")] public async Task<IActionResult<IExecutionResult>> Remove(RemoveItemsFromInventory command) { return await commandBus.SendAsync(command); } [HttpDelete] public async Task<IActionResult<IExecutionResult>> Deactivate(DeactivateInventoryItem command) { return await commandBus.SendAsync(command); } } NoCRUD–generalupdatenotallowed Allupdatesseparatedbycommands ExecutionresultmayreturncorrelationID APIs Gateway
- 25. ASP.NET Core – Command Handler public class InventoryCommandHandlers : ICommandHandler<CreateInventoryItem>, ICommandHandler<DeactivateInventoryItem>, ICommandHandler<RemoveItemsFromInventory>, ICommandHandler<CheckInItemsToInventory>, ICommandHandler<RenameInventoryItem> { private readonly ISession _session; public InventoryCommandHandlers(ISession session) { _session = session; } public async Task Handle(CreateInventoryItem command) { var item = new InventoryItem(command.Id, command.Name); await _session.Add(item); await _session.Commit(); } public async Task Handle(DeactivateInventoryItem command) { var item = await _session.Get<InventoryItem>(command.Id, command.ExpectedVersion); item.Deactivate(); await _session.Commit(); } public async Task Handle(RemoveItemsFromInventory command) { var item = await _session.Get<InventoryItem>(command.Id, command.ExpectedVersion); item.Remove(command.Count); await _session.Commit(); } public async Task Handle(CheckInItemsToInventory command) { var item = await _session.Get<InventoryItem>(command.Id, command.ExpectedVersion); item.CheckIn(command.Count); await _session.Commit(); } public async Task Handle(RenameInventoryItem command) { var item = await _session.Get<InventoryItem>(command.Id, command.ExpectedVersion); item.ChangeName(command.NewName); Execution of commands on domain object
- 26. ASP.NET Core – Event Handler public class InventoryListView : IEventHandler<InventoryItemCreated>, IEventHandler<InventoryItemRenamed>, IEventHandler<InventoryItemDeactivated> { public Task Handle(InventoryItemCreated message) { InMemoryDatabase.List.Add(new InventoryItemListDto(message.Id, message.Name)); return Task.CompletedTask; } public Task Handle(InventoryItemRenamed message) { var item = InMemoryDatabase.List.Find(x => x.Id == message.Id); item.Name = message.NewName; return Task.CompletedTask; } public Task Handle(InventoryItemDeactivated message) { InMemoryDatabase.List.RemoveAll(x => x.Id == message.Id); return Task.CompletedTask; } } Building denormalized/materialized query views
- 27. ASP.NET Core – Aggregate Rootpublic class InventoryItem : AggregateRoot { private bool _activated; private InventoryItem(){} public InventoryItem(string id, string name) { Id = id; ApplyChange(new InventoryItemCreated(id, name)); } private void Apply(InventoryItemCreated e) { _activated = true; } private void Apply(InventoryItemDeactivated e) { _activated = false; } public void ChangeName(string newName) { if (string.IsNullOrEmpty(newName)) throw new ArgumentException("newName"); ApplyChange(new InventoryItemRenamed(Id, newName)); } public void Remove(int count) { if (count <= 0) throw new InvalidOperationException("cant remove negative count from inventory"); ApplyChange(new ItemsRemovedFromInventory(Id, count)); } public void CheckIn(int count) { if(count <= 0) throw new InvalidOperationException("must have a count greater than 0 to add to inventory"); ApplyChange(new ItemsCheckedInToInventory(Id, count)); } public void Deactivate() { if(!_activated) throw new InvalidOperationException("already deactivated"); ApplyChange(new InventoryItemDeactivated(Id)); } } Clean & centralized domain-driven business logic
- 29. Domain boundaries is a key to success
- 30. Define cross-boundary domain events Event storming
- 31. The Art of Scalability CQRS & ES Infinite Scale Unlimited scalability
- 32. Power of Azure via Event Grid Production ready event sourcing platform
- 33. Event is a single source of truth No data losing and easy recovery and audit
- 35. IntelliGrowth - Inner Sourcing Initiative
- 36. IntelliGrowth – Serverless Cloud Architecture
- 38. Reading Domain Driven Design Eric Evans Building Microservices Sam Newman Exploring CQRS and Event Sourcing Dominic Betts
- 39. Resources Greg Young - Building an Event Storage Microsoft - Exploring CQRS and Event Sourcing Greg Young - CQRS & Event Sourcing Lorenzo Nicora - A visual introduction to event sourcing and cqrs Greg Young - A Decade of DDD, CQRS, Event Sourcing Martin Fowler - Event Sourcing Eric Evans - DDD and Microservices: At Last, Some Boudaries! Martin Kleppmann — Event Sourcing and Stream Processing at Scale Julie Lerman - Data Points - CQRS and EF Data Models Vaughn Vernon - Reactive DDD: Modeling Uncertainty Mark Seemann - CQS versus server generated IDs Udi Dahan - If (domain logic) then CQRS, or Saga? Event Store - The open-source, functional database with Complex Event Processing in JavaScript Pedro Costa - Migrating to Microservices and Event-Sourcing: the Dos and Dont’s David Boike - Putting your events on a diet DDD Quickly Dennis Doomen - The Good, The Bad and the Ugly of Event Sourcing Liquid Projections - A set of highly efficient building blocks to build fast autonomous synchronous and asynchronous projector