Declarative Database Virtualization in Federated API Gateways
Solution Overview
Problem
Configuring applications to access multiple APIs with different authentication settings and handling varying response times leads to inefficiencies and latency due to the complexity of integrating databases into federated APIs, where databases do not have a fixed data shape and require complex schema mapping.
Innovation Solution
The integration of databases into federated APIs is facilitated through declarative annotations that map database tables and columns to API schema elements, allowing a federation management service to generate a unified API schema and process data access queries, eliminating the need for dedicated services and network API wrapping.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If applications access multiple APIs with different authentication settings, then service functionality is improved, but configuration complexity and latency increase
Solution Approach 1:
The patent introduces an API gateway as an intermediary component that sits between applications and multiple backend APIs. The gateway handles authentication, authorization, and request routing centrally, allowing applications to access multiple APIs through a single standardized interface without needing to configure each API's authentication settings individually.
Solution Approach 2:
The API gateway provides universal access to multiple different APIs through a single unified interface. It performs multiple functions including authentication, authorization, request transformation, and routing, allowing diverse backend services to be accessed through a common entry point that simplifies application configuration.
2Adaptability or versatility
If applications ping multiple APIs to perform services, then service capability is improved, but latency increases due to varying response times
Solution Approach 1:
The API gateway performs preliminary actions by pre-establishing connections to backend APIs, caching authentication tokens, and pre-processing requests where possible. It also implements connection pooling to maintain persistent connections to backend services, reducing the time needed to establish new connections for each API call.
Solution Approach 2:
The gateway maintains continuous connections to backend APIs through connection pooling and keep-alive mechanisms, eliminating the need to repeatedly establish and tear down connections. This continuous state of readiness reduces latency for subsequent API calls while maintaining the ability to access multiple services.
3Adaptability or versatility
If databases are integrated into federated APIs, then data access capability is improved, but integration complexity increases due to varying data shapes and schema mapping requirements
Solution Approach 1:
The API gateway acts as a mediator between applications and databases, translating database-specific data models and query languages into standardized API responses. It handles schema mapping, data transformation, and result formatting, allowing applications to access diverse database structures through a uniform interface without dealing with the underlying complexity.
Solution Approach 2:
The gateway dynamically changes parameters such as data format, query structure, and response schema based on the specific database being accessed. It transforms database-specific parameters into standardized API parameters and vice versa, allowing the same API interface to work with multiple database types having different data shapes and structures.
Data Source
AI summary
A federation management service may receive an indication of multiple data sources to integrate into a federated application programming interface (API). One of the data sources is a database that is associated with an API schema that includes annotations that map elements of the API schema to the features of the database. The federation management services processes the API schema to generate the federated API. The federated API may receive a request for an element that is mapped to the feature of the database, generate a query based on the annotations of the API schema, and return a result based on the generated query.