Edition 0 Updated to asp. Net core 0

Why consider API Gateways instead of direct client-to-microservice 
communication 
In a microservices architecture, the client apps usually need to consume functionality from more than 
one microservice. If that consumption is performed directly, the client needs to handle multiple calls 
to microservice endpoints. What happens when the application evolves and new microservices are 
introduced or existing microservices are updated? If your application has many microservices, 
handling so many endpoints from the client apps can be a nightmare. Since the client app would be 
coupled to those internal endpoints, evolving the microservices in the future can cause high impact 
for the client apps. 
Therefore, having an intermediate level or tier of indirection (Gateway) can be convenient for 
microservice-
based applications. If you don’t have API Gatew
ays, the client apps must send requests 
directly to the microservices and that raises problems, such as the following issues: 
•
Coupling
: Without the API Gateway pattern, the client apps are coupled to the internal 
microservices. The client apps need to know how the multiple areas of the application are 
decomposed in microservices. When evolving and refactoring the internal microservices, those 

---

42 
CHAPTER 3 | Architecting container and microservice-based applications 
actions impact maintenance because they cause breaking changes to the client apps due to the 
direct reference to the internal microservices from the client apps. Client apps need to be 
updated frequently, making the solution harder to evolve. 
•
Too many round trips
: A single page/screen in the client app might require several calls to 
multiple services. That approach can result in multiple network round trips between the client 
and the server, adding significant latency. Aggregation handled in an intermediate level could 
improve the performance and user experience for the client app. 
•
Security issues
: Without a gateway, all 
the microservices must be exposed to the “external 
world”, making the attack surface larger than if you hide internal microservices that aren’t 
directly used by the client apps. The smaller the attack surface is, the more secure your 
application can be. 
•