WunderGraph API-Mesh: Integrate all your APIs, Services and Databases into a single unified Interface

Published: 2022-05-23

One of the biggest problems when building web applications is that you need data from multiple services, databases and probably 3rd parties. Additionally, you usually have to mutate state in different services. Each of them uses different access patterns, protocols and formats, making it hard to build a coherent developer experience.

It's 2021, and the most common solution to the problem is to let developers waste their time and talent on this time-consuming and boring task.

Enter our unique API-Mesh technology, turning boring into awesome. Instead of wasting days and weeks of time to build custom integrations, you're able to integrate systems in minutes.

But that's not all! Those integrations are re-usable. Once integrated, you can re-use them for another project or make them available to other teams, allowing you to save even more resources over time.

WunderGraph API-Mesh Overview#

With WunderGraph API-Mesh, you can take service descriptions like OpenAPI Specification or GraphQL Introspection to analyze existing services and merge them into a single unified API-Mesh.

The resulting API Mesh is protected by our advanced approach on API Security, allowing you to securely expose your API-Mesh to insecure clients like Browsers.

Our API-Mesh is unique in that it doesn't only expose your APIs securely, but it's also extremely performant. We achieve this performance advantage through our unique Query Compiler.

Let's talk about the benefits of using an API-Mesh, compared to the traditional process of manually integrating APIs.

Unified Schema across all Services and APIs#

Without API-Mesh, you and your developers have to deal with services with different protocols, message formats and access patterns. Just finding documentation and a service description can already be a complicated task.

With our API-Mesh technology, you're able to access all services and APIs through a single unified Interface, using one single widely adopted language, GraphQL.

Our API-Mesh Technology takes all services descriptions, e.g. OpenAPI Specifications, and merges them into a single "virtual" GraphQL API. You can then use GraphQL to query and mutate the API or subscribe to changes.

No more dealing with multiple formats, just one language. But it's not any language, it's the most widely adopted Query Language.

No Point-to-Point integrations#

Let's take WunderGraph out of the Equation and re-visit the architecture from above. The result is the opposite of a Service-Mesh, it's a Service-Mess.

If your Architecture looks like this, you have to deal with a problems like these:

How do you implement Logging and Analytics across different protocols?
How do you manage API consumers that rely on different API Styles and Access patterns? (e.g. PostgreSQL vs REST API vs Kafka)
How do you centralize Access and Permission Management across a heterogenous set of API consumers?
How do you implement centralized Governance across different API styles? (e.g. who accessed PII from a specific user across multiple REST & GraphQL APIs)

Centralized Analytics and Logging across all DataSources#

With a unified API-Mesh, all clients talk the same language, GraphQL. This allows us to implement Logging and Analytics exactly once. It works across all DataSources and Systems, one single pane of glass to get the full picture.

Every System added to your API-Mesh makes it more powerful and gives your more visibility into your systems.

Using this unified API-Mesh, you're able to answer questions like:

What are the dependencies between services?
How are services being used and what are the access patterns?
Which applications rely on which internal and external services?
In case of a data-leak, who had access to which service during a specific period in time?
Additionally, what exact Queries were made by a specific API client across all systems?
Which API clients had access to PII of a specific user?
and many more...

Piping all your API traffic through a single layer is good, but making this layer speak a single language allows you to also understand what's happening.

Layer 4 API Gateways are a good start. With WunderGraphs unique API-Mesh Technology, you'll get insights on Layer 7.

Manage all API consumers across all Services and APIs through a single Control Plane#

How do you manage API consumers that speak different languages and protocols? It's not possible to create an API Key that grants access to a PostgreSQL Database, a specific Kafka topic and a REST API.

With API-Mesh, it is! Through the use of an AsyncAPI description, PostgreSQL introspection and an OpenAPI Specification for the REST API, we're able to merge all services into a unified API-Mesh, talking a single language, GraphQL.

We then expose this API securely over HTTP. This way, we're able to manage API consumers and producers across all sorts of services.

Centralised Access- and Permission Management#

Talking about management of API consumers. Thanks to this single layer, a single unified API talking HTTP, it's now possible to manage API keys across all sorts of systems.

Define fine-grained permissions across all systems, throttle access via rate-limits to protect services and define quotas to limit resource consumption.

Centralized Governance#

With all that in place, you'll get a single unified view of all your APIs, Services and Systems. You can understand all your API consumers, and their access patterns, allowing you to continuously improve your API products.

In case of a data-leak, you immediately know which API consumers had access to specific systems and data.

You can identify problems within your Service landscape and immediately identify bottlenecks.

Is WunderGraph for you?#

Do you have Questions? Want a demonstration? Let's chat and figure out how we can help you!