Home > Mobile >  How do you name API paths of the same microservice but w/ different consumers
How do you name API paths of the same microservice but w/ different consumers

Time:09-17

Context

Let's imagine a simple microservices architecture (e.g. 2-3 microservices). Microservices are domain-based, API gateway in place and everything is how it should be. At the same time, microservices APIs are consumed by public mobile applications, admin UI, and other services for S2S communication, hence, we have three possible APIs consumers. Depends on the consumer, response DTOs are different but the business process might be the same (e.g. response for GET /users endpoint has different DTOs for a consumer application and admin UI but technically the data is taken from the same DB).

Question

How do you segment APIs in that case? Do you use namespaces like external, internal and etc?

Also, feel free to share your experience of how you segment APIs.

Thanks in advance!

CodePudding user response:

From my point of view, the APIs should be different depending on the type of consumer that is going to use them.

For example, talking about your use case, It couldn't be the same API one that is intended to provide simple user information that the one used by an administrator. You should define two different APIs in this case, with different paths like internal/users/ and external/users as you said, and internally these two endpoints can use the same logic.

This separation is not only good in order to return different dtos in each endpoint but also to define different security (authentication/authorization) mechanisms for each API because I suppose that these requirements will be different for an admin API that for a general user one

CodePudding user response:

It depends a bit on the philosophy you want to adopt.

The one suggested by @JArgente is good, in that you'd get good separation, and the role of each is (or at least should be) very clear.

The other approach is layering, which (for the OO programmers out there) is a bit like developing overloads for a method. It assumes that the data required by the derived API's is provided by the base API. So:

  1. Develop a base API that provides all the data this API family needs to provide. This API might be the one that internal users use (e.g. Admin User), and it could require authentication.
  2. Develop a public facing API that consumes the base API. This one would be your public-facing one.

enter image description here

  • Each API has a separate API Spec; depending in how you do this you can leverage inheritance at the Spec level.
  • Each API also has an actual endpoint which triggers some sort of processing - e.g. logic within the API Gateway itself, or logic handled within a downstream component like a microservice.
  • The public-facing one can be anonymous, as long as something (e.g. the API Gateway) can make an authenticated call against the base API, using some kind of 'service account'.

The advantage here is that you still get good separation between different API's and their consumers, but you also get the advantages of inheritance, so that code duplication is reduced (testing effort isn't so diffuse, etc).

This approach also allows you to run the endpoints on the same API Gateway, or deployed on separate ones (internal vs external).

  • Related