CODEWITHSUNDEEP
azureexceptionarchitectureazureservicebusdead-letter
Demoric
Demoric

Reputation: 296

Architecture issue - Azure servicebus and message order guarantee

Ok so i'm relatively new to the servicebus. Working on a project where we use Azure servicebus for queueing messages. Our architecture roughly looks like the following:

Architecture

So the idea is that in our SourceSystem all kinds of stuff happens, which leads to messages being put on the servicebustopics. Now our responsibility is syncing these events to the external client so they are aware of what we are doing.

Now the issue is that currently we dont use servicebus sessions so message order isnt guaranteed. Also consider the following scenario:

OrderCreated OrderUpdate 1 OrderUpdate 2 OrderClosed

What happens now is if the externalclients API is down for say OrderUpdate 1 and OrderUpdate 2, we could potentially send the messages in order: OrderCreated, OrderClosed, OrderUpdate 1, OrderUpdate 2.

Currently we just retry a message a few times and then it moves into the deadletter queue for manual reprocessing.

What steps should we take to better guarantee message order? I feel like in the scope of an order, message order needs to be guaranteed.

Should we force the sourcesystem to put all messages for a order in a servicebus session? But how can we handle this with multiple topics? And what do we do if message 1 from a session ends up in the deadletter?

There are a lot of considerations here, should we use a single topic so its easier to manage the sessions? But this opens up other problems with different message structures being in a single topic?

Id love to hear your opinions on this

Upvotes: 0

Views: 240

Answers (2)

Kaptein Babbalas
Kaptein Babbalas

Reputation: 1108

Have a look at Durable Functions in Azure. You can use the 'Async Http API' or one of the other patterns to achieve the orchestration you need to do. NServicebus' Sagas might also be a good option, here is an article that does a very good comparison between NServicebus and Durable Functions.

Upvotes: 1

Sean Feldman
Sean Feldman

Reputation: 26067

If the external client has to receive all those events and order matters, sending those messages to multiple topics where a topic is per message type will make your mission extremely hard to accomplish. For ordered messaging first you need to use a single entity (queue or topic) with Sessions enabled. That way you can guarantee ordered message processing. In case you have multiple external clients, you'd need to have a session-enabled entity (topic) per external client.

Another option is to implement a pattern known as Process Manager. The process manager would be responsible to make the decisions about the incoming messages and conclude when the work for a given order is completed or not.

There are also libraries (MassTransit, NServiceBus, etc) that can help you. NServiceBus implements Process Manager via a feature called Saga (tutorial) and MassTransit has it as well (documentation).

Upvotes: 1

Related Questions