3

I'm working on a project where DynamoDB is being used as database and every use case of the application is triggered by a message published after an item has been created/updated in DB. Currently the code follows this approach:

repository.save(entity);
messagePublisher.publish(event);

Udi Dahan has a video called Reliable Messaging Without Distributed Transactions where he talks about a solution to situations where a system can fail right after saving to DB but before publishing the message as messages are not part of a transaction. But in his solution I think he assumes using a SQL database as the process involves saving, as part of the transaction, the correlationId of the message being processed, the entity modification and the messages that are to be published. Using a NoSQL DB I cannot think of a clean way to store the information about the messages.

A solution would be using DynamoDB streams and subscribe to the events published either using a Lambda or another service to transformed them into domain-specific events. My problem with this is that I wouldn't be able to send the messages from the domain logic, the logic would be spread across the service processing the message and the Lambda/service reacting over changes and the solution would be platform-specific.

Is there any other way to handle this?

sajadre
  • 1,141
  • 2
  • 15
  • 30
Juan Vega
  • 1,030
  • 1
  • 16
  • 32

1 Answers1

2

I can't say a specific solution based on DynamoDB since I've not used this engine ever. But I've built an event driven system on top of MongoDB so I can share my learnings you might find useful for your case.

You can have different approaches:

1) Based on an event sourcing approach you can just save the events/messages your use case produce within a transaction. In Mongo when you are just inserting/appending new items to the same collection you can ensure atomicity. Anyway, if the engine does not provide that capability the query operation is so centralized that you are reducing the possibility of an error at minimum.

Once all the events are stored, you can then consume them and project them to a given state and then persist the updated state in another transaction.

Here you have to deal with eventual consistency as data will be stale in your read model until you have projected the events.

2) Another approach is applying the UnitOfWork pattern where you cache all the query operations (insert/update/delete) to save both events and the state. Once your use case finishes, you execute all the cached queries against the database (flush). This way although the operations are not atomic you are again centralizing them quite enough to minimize errors.

Of course the best is to use an ACID database if you require that capability and any other approach will be a workaround to get close to it.

About publishing the events I don't know if you mean they are published to a messaging transportation mechanism such as rabbitmq, Kafka, etc. But that must be a background process where you fetch the events from the DB and publishes them in order to break the 2 phase commit within the same transaction.

mgonzalezbaile
  • 1,056
  • 8
  • 10
  • In your first example, the flow would be: 1) Get the event (new order) and store it in the store 2) Consume the event and update the read state (new Order(1)) 3) Publish an event that the previous one was consumed (order created). If that's the approach, how do I handle transition from 2) to 3)? DynamoDB provides a stream for this so any modification to a document would publish an event.But you have to handle retries somehow. If I create a document and the system crashes right after, the event would be retried.Even if the action is idempotent, that would still publish orderCreated/Updated. – Juan Vega Mar 12 '18 at 10:02
  • And given this approach, I understand any frontend would need to use something like WebSockets to be able to wait for a message saying the request was processed successfully. Or at least be optimistic and say that the message was processed in the reply but listen to any updates that may arrive when there are issues. – Juan Vega Mar 12 '18 at 10:04