What is API composition in microservices architecture?

API Composition is a fundamental pattern in microservices architecture used to aggregate data and operations from multiple underlying microservices to fulfill a single client request. It addresses the challenge of presenting a unified and simplified API to clients when functionality is distributed across many granular services.

Understanding API Composition in Microservices

In a microservices architecture, a single business capability is often broken down into several smaller, independent services. While this design offers benefits like scalability and independent deployment, it can complicate client interactions. A client application might need to call multiple services, combine their responses, and transform the data to display a single logical view or perform a complex operation. API Composition addresses this by providing a layer that orchestrates these calls.

The Problem API Composition Solves

Without API composition, clients would need to directly interact with many microservices. For example, to display a product detail page, a client might need to fetch product information from a 'Product Service', reviews from a 'Review Service', and pricing from a 'Pricing Service'. This leads to:

• Increased network latency due to multiple round-trips from the client to various services.
• Complex client-side logic to aggregate and transform data.
• Tight coupling between clients and individual microservices, making service refactoring difficult.
• Security concerns as clients need access to multiple service endpoints.

How API Composition Works

API composition involves creating an aggregating service (often an API Gateway or a Backend for Frontend) that acts as an intermediary between client applications and the individual microservices. When a client sends a request, the compositor service performs the following steps:

• Receives the client request.
• Breaks down the request into sub-requests for relevant microservices.
• Invokes multiple microservices concurrently or sequentially.
• Aggregates the responses from these microservices.
• Transforms and combines the data into a unified response format suitable for the client.
• Returns the consolidated response to the client.

Common API Composition Patterns

API Gateway

An API Gateway is a single entry point for all client requests. It can handle routing, authentication, authorization, rate limiting, and also API composition. It acts as a reverse proxy, routing requests to appropriate microservices and composing responses when necessary. It provides a generalized composition layer for all types of clients.

Backend for Frontend (BFF)

The BFF pattern suggests creating a separate API composition service for each type of client (e.g., one for web, one for mobile iOS, one for Android). This allows each client to have an optimized API tailored to its specific needs, reducing the need for client-side data transformation and ensuring that only relevant data is transferred. BFFs can also perform composition logic specific to their client's view.

Benefits of API Composition

• Simplified Client Interactions: Clients interact with a single, simplified API endpoint, reducing their complexity.
• Reduced Network Latency: Fewer round-trips from the client to the server as multiple service calls are aggregated server-side.
• Decoupling: Clients are decoupled from the internal microservice structure, allowing services to evolve independently.
• Improved Performance: Server-side aggregation can often be more efficient than client-side aggregation, especially over high-latency networks.
• Enhanced Security: Clients don't need direct access to all internal services.
• Client-Specific APIs: With BFFs, APIs can be tailored to specific client needs, avoiding over-fetching or under-fetching of data.

Challenges

• Increased Complexity: The composition layer itself adds another component to manage and operate.
• Performance Overhead: The composition service adds a hop and processing overhead. This needs to be managed carefully.
• Single Point of Failure: If the API compositor fails, it can impact multiple client functionalities (mitigated by high availability).
• Distributed Transactions: Handling complex transactions across multiple services and rolling back changes on failure can be challenging.
• Latency for Internal Calls: While it reduces client-side latency, the composition service still makes multiple internal calls, which might become a bottleneck if not optimized (e.g., using parallel calls).