1

As a part of our DDD design, we are working on a bounded context and have identified two microservices A and B.

Service A needs to make calls to Service B via REST API. Service B already provides open API spec on how to get any data. We use openapi generator to auto generate client side DTOs. There is exactly a one-to-one mapping between B DTO to A's domain object.

As far as I understand, we should use anti corruption layer (using hexagonal architecture) if our service is communicating with an untrusted third party service. But what should we do, if the communication is between internal services, like in the case above ?

  1. Should microservice B API DTOs directly used as domain objects in microservice A ? This would mean that we will not create separate domain class/object in service A. We treat B's DTO as domain object in service A.
  2. Should we create an adapter layer to convert B's DTO to domain objects in microservice A ?
  3. Should I create domain objects in service A which would also be manual output DTO for service B ?. This is opposite of point 1, where DTOs are treated as domain objects, where as in this case, we are treating domain objects as DTOs
Mohit K.
  • 71
  • 8
  • None of these points are ideal (see my comments on https://stackoverflow.com/a/74966287/64348). #2 is the worst possible solution because it adds more "accidental" complexity on top of existing accidental complexity. – Kit Jan 01 '23 at 03:22

2 Answers2

1

In my opinion, you are mixing two separate concepts:

  1. The "anticorruption layer", which is a strategic DDD pattern
  2. The layers in a layered or onion architecture, which are tactical patterns to separate concerns within an application

The goal of the anticorruption layer is to translate the ubiquitous language from another Bounded Context into your ubiquitous language so that your code doesn't get polluted with concepts not belonging to your Bounded Context.

The goal of the layers in a layered or onion architecture and specifically the contracts between them (the DTOs you are talking about) is to avoid changes in one part of the code (for example, adding or removing a property in a domain object in the Core) to cause issues somewhere else (like accidentally modifying the public API contract).

If I understand it correctly, your two microservices belong to the same Bounded Context. If that is the case, you shouldn't need any anticorruption layer because both microservices share the same ubiquitous language.

Now regarding the options that you propose, I'm not sure I fully understand options 2 and 3, but what I'll say is that if you are doing real microservices, you can't use option 1, as these microservices wouldn't be autonomous, and independently deployable as a change in microservice B's API would require a change and coordinated deployment of microservice A.

So, design your microservices so that you have control over how their parts evolve (be able to make non-breaking changes in their APIs, change storage strategies without having to change the Core, change the core without having to change the API, etc). Of course, if a microservice is very simple, don't over-engineer it.

Francesc Castells
  • 2,692
  • 21
  • 25
  • Agreed that services within a BC should be able to "talk to" each other without an anticorruption layer. If they are, it smells like a design flaw. That said, pragmatically, they may be implemented at different times, and so you have this accidental complexity to deal with. Accidental complexity is a form of technical debt. I would suggest do the minimum you can to make these "talk", but record the technical debt to your backlog for a potential future refactoring where they share the model, or even become the same service... highly dependent on the architecture of course. – Kit Jan 01 '23 at 03:19
0

The answer here is simple - There is no magic to make breaking changes non-breaking. So treat internal dependencies like you would external. That requires a high discipline on versioning of the APIs and moving versions ahead. The Service A needs to publish new API version specifications ahead of time and Service B needs to be given time to implement those. Depending on the size of your organization it can be useful to support multiple API versions concurrently (for a while that is). You may also want Team A to be monitoring usage of their API versions (e.g. how many customers are still using an old version of the API etc.).

I would not put a high focus on how exactly your API specification is documented or which technology is used to generate client bindings (if at all). This should be up to the service A owners and service B should be able to adopt whatever being offered. In general I would put the focus on simplicity and avoid too many additional layers if they don't provide clear benefit. And team B should be free to design their internals as they see best fit (even with respect to data that comes from Service A). The whole point of microservices architecture is to be able to move forward independently.

Oswin Noetzelmann
  • 9,166
  • 1
  • 33
  • 46