Docs
Launch GraphOS Studio

The Apollo GraphOS platform

Unify your infrastructure with GraphQL


is the platform for building, managing, and scaling a supergraph: a unified network of your organization's microservices and their —all composed into a single distributed API.

With one to your 's router, an application client can fetch data from any combination of your services:

Your infrastructure
GraphOS
Sub-query
Sub-query
Query
Users
API
Products
API
Graph
Router
Clients

Clients your with a powerful language called GraphQL, which enables them to retrieve exactly the data they need, with no overfetching. Your 's architecture is not exposed—clients send queries to a single endpoint (your ), no matter what data they need.

The is not a replacement for your existing infrastructure. Instead, it's a methodology for interconnecting your existing infrastructure, to make it more accessible and useful for everyone who interacts with your data.

What's in GraphOS?

The platform provides an ever-growing collection of tools and services to help you build your and scale it safely alongside your organization.

These features are core to :

  • Cloud routing
    • automatically provisions and hosts a for each of your . Clients your router instead of your individual services (also called ). This enables the router to automatically collect metrics that you can then visualize in .
  • The schema registry
    • tracks the schemas for all your APIs, and it also handles composing those schemas into one for your .
  • Safe
    • The schema checks feature of enables you to verify whether proposed changes to one of your services will cause an issue with other services, or with any of your existing clients.
    • Whenever you update a service's schema, composes a new for your . If succeeds, your router automatically begins using its new schema.
    • You can view the results of each launch that takes place whenever you update a service's schema, helping you resolve any issues that might occur.
  • An interface for every use case
    • GraphOS Studio is the primary web interface for . Among other capabilities, you use Studio to create your organization and its , view schemas and metrics, and test out in the Explorer.
    • The Rover CLI is the primary command-line interface for . Among other capabilities, you use to publish schemas to the registry, run from CI, and test out your within your development environment.
    • If you want to automate your own workflows outside of Studio or , you can use the official GraphOS Platform API to do so. We'll expose more capabilities through the Platform API over time.

To learn more about these and many more features, see the complete GraphOS documentation.

What's in a supergraph?

If is the platform for building and managing , it's important to understand what's in a supergraph.

Every uses an open architecture called Apollo Federation, which consists of the following parts:

Your infrastructure
GraphOS
GraphQL API
A
GraphQL API
B
Graph
Router
Clients

  • The
    • The serves as the client-accessible entry point to your . It receives all incoming queries.
    • As its name suggests, the "routes" each incoming to the appropriate combination of (see the next item). It's also responsible for combining multiple subgraph responses into a single response for the client.
    • can take care of provisioning and hosting your 's for you.
  • One or more s
    • Your APIs each contribute a subset of your 's available data, so we call them subgraphs Clients don't your directly—only your does.
    • Usually, each of your existing microservices acts as a different .
  • Backing (databases, REST APIs, etc.)
    • Your use these to populate data for incoming queries.

The diagram above shows a basic with a -managed , two , and two corresponding .

The following video provides a helpful visualization of how the architecture helps organizations scale with their data:

Why adopt a supergraph?

Adopting a significantly improves the developer experience for every team (both internal and external) that interacts with your organization's data. These improvements enable developers to ship products and features more quickly, with greater confidence in their reliability and performance.

How do I implement a supergraph?

To implement a , you set up its individual parts: the and your . Apollo provides libraries and tools for setting up each part. And more importantly, we provide tutorials to help you.

Tutorials

  • If you're new to , we recommend starting your journey with the Lift-off tutorial series.
    • Familiarizing yourself with fundamental concepts is an important prerequisite to getting the most out of your .
  • If you're already using , we recommend jumping in with your first . See the quickstart.

Implementing the router

If you create a cloud supergraph with , Apollo provisions and hosts your 's for you.

For enterprise organizations that need to run their in their own infrastructure, Apollo provides two libraries that can act as a router:

  • The Apollo Router (strongly recommended)
    • This is a high-performance binary written in Rust that adds minimal latency to request processing, even with extremely high traffic.
    • Because the is a precompiled binary, you don't need to write any boilerplate code around it to deploy it to your backend. All it needs is a configuration file for any behavior you want to customize.
    • Cloud use the under the hood.
  • Apollo Server with @apollo/gateway
    • This is Apollo's open-source Node.js library, which you can configure to act as a gateway.

If you get started with one of these libraries and later decide to switch to the other, you can do so without making any changes to the rest of your .

Implementing subgraphs

Each is itself a API. Therefore, it uses a library to handle queries forwarded along by your graph .

To act as a , a library needs to support the subgraph specification. Fortunately, many popular libraries do. See Federation-compatible subgraph implementations.

Feel free to use whichever server library best suits your organization. Different can even use completely different libraries, which is helpful if your various microservices use different languages.

How do clients query my supergraph?

To client applications, your appears the same as any other API. Therefore, they it with the same client libraries.

Apollo provides libraries for the following platforms:

These are all customizable, open-source libraries with powerful caching and state management features. Client-side caching enables an application to locally replicate the parts of your that it cares about. The application can then itself for data if it's already present, which dramatically improves performance by eliminating redundant network requests.

Where do I start?

We have loads of helpful resources to help you start your journey:

Looking for additional guidance? Share a question in our community forums and we'll help point you in the right direction.

Previous
Home
Next
Why adopt GraphQL?
Edit on GitHubEditForumsDiscord

© 2024 Apollo Graph Inc.

Privacy Policy

Company