GraphQL Federation으로 여러 GraphQL 서비스 통합하기

GraphQL Federation의 목적

GraphQL Federation이란?

GraphQL 기본 개념

Object type과 field

type Product {
	id: ID!
	name: String!
	price(in: Currency = KRW): Float!
}

enum Currency {
	KRW
	USD
}

Object type간의 관계

type Review {
	id: ID!
	rating: Float!
  body: String!
	product: Product!
}

type Product {
	...
	reviews: [Review!]!
}

Query object type과 GraphQL query문

type Query {
	products: [Product!]!
}

query AllProductsAndTheirReviews {
	products {
		id
		name
		price
		reviews {
			id
			rating
			body
		}
	}
}

Field Resolver

const resolvers = {
	Query: {
		products: async (parent, arguments, context, info) => {
			return await context.fetchAllProducts();
		}
	},
	Product: {
		reviews: async (parent, arguments, context, info) => {
			return await context.fetchReviewsByProductId(parent.id);
		}
  }
}

Apollo Federation의 개념

모놀리틱에서 MSA로의 전환

type Product {
	id: ID!
  name: String!
  price(in: Currency = KRW): Float!
}

type Query {
	products: [Product!]!
}

Schema의 종류

1. Subgraph schema: Subgraph는 각 GraphQL (마이크로)서비스를 의미하며, 각 서비스가 제공하는 GraphQL schema를 subgraph schema라고 합니다.

2. Supergraph schema: 모든 subgraph schema와, 거기에 어떤 subgraph가 어떤 field를 resolve할 수 있는지에 대한 정보를 포함하는 schema입니다.

3. API schema: Supergraph schema에서 routing 정보를 제외한 schema로, 클라이언트에게 노출 되는 schema입니다.

type Query {
  me: User
}

type User @key(fields: "id") {
  id: ID!
  username: String! @shareable
}

# (Subgraph schemas include this to opt in to Federation 2 features.)
extend schema
  @link(url: "https://specs.apollo.dev/federation/v2.0",
        import: ["@key", "@shareable"])

type Query {
  topProducts(first: Int = 5): [Product]
}

type Product @key(fields: "upc") {
  upc: String!
  name: String!
  price: Int
}

extend schema
  @link(url: "https://specs.apollo.dev/federation/v2.0",
        import: ["@key", "@shareable"])

type Review {
  body: String
  author: User @provides(fields: "username")
  product: Product
}

type User @key(fields: "id") {
  id: ID!
  username: String! @external
  reviews: [Review]
}

type Product @key(fields: "upc") {
  upc: String!
  reviews: [Review]
}

# (This subgraph uses additional federated directives)
extend schema
  @link(url: "https://specs.apollo.dev/federation/v2.0",
        import: ["@key", "@shareable", "@provides", "@external"])

schema
  @link(url: "https://specs.apollo.dev/link/v1.0")
  @link(url: "https://specs.apollo.dev/join/v0.2", for: EXECUTION)
{
  query: Query
}

directive @join__field(graph: join__Graph!, requires: join__FieldSet, provides: join__FieldSet, type: String, external: Boolean, override: String, usedOverridden: Boolean) repeatable on FIELD_DEFINITION | INPUT_FIELD_DEFINITION

directive @join__graph(name: String!, url: String!) on ENUM_VALUE

directive @join__implements(graph: join__Graph!, interface: String!) repeatable on OBJECT | INTERFACE

directive @join__type(graph: join__Graph!, key: join__FieldSet, extension: Boolean! = false, resolvable: Boolean! = true) repeatable on OBJECT | INTERFACE | UNION | ENUM | INPUT_OBJECT | SCALAR

directive @link(url: String, as: String, for: link__Purpose, import: [link__Import]) repeatable on SCHEMA

scalar join__FieldSet

enum join__Graph {
  PRODUCTS @join__graph(name: "products", url: "http://localhost:4003/graphql")
  REVIEWS @join__graph(name: "reviews", url: "http://localhost:4002/graphql")
  USERS @join__graph(name: "users", url: "http://localhost:4001/graphql")
}

scalar link__Import

enum link__Purpose {
  """
  `SECURITY` features provide metadata necessary to securely resolve fields.
  """
  SECURITY

  """
  `EXECUTION` features provide metadata necessary for operation execution.
  """
  EXECUTION
}

type Product
  @join__type(graph: PRODUCTS, key: "upc")
  @join__type(graph: REVIEWS, key: "upc")
{
  upc: String!
  name: String! @join__field(graph: PRODUCTS)
  price: Int @join__field(graph: PRODUCTS)
  reviews: [Review] @join__field(graph: REVIEWS)
}

type Query
  @join__type(graph: PRODUCTS)
  @join__type(graph: REVIEWS)
  @join__type(graph: USERS)
{
  topProducts(first: Int = 5): [Product] @join__field(graph: PRODUCTS)
  me: User @join__field(graph: USERS)
}

type Review
  @join__type(graph: REVIEWS)
{
  body: String
  author: User @join__field(graph: REVIEWS, provides: "username")
  product: Product
}

type User
  @join__type(graph: REVIEWS, key: "id")
  @join__type(graph: USERS, key: "id")
{
  id: ID!
  username: String! @join__field(graph: REVIEWS, external: true) @join__field(graph: USERS)
  reviews: [Review] @join__field(graph: REVIEWS)
}

type Product {
  name: String!
  price: Int
  reviews: [Review]
  upc: String!
}

type Query {
  me: User
  topProducts(first: Int = 5): [Product]
}

type Review {
  author: User
  body: String
  product: Product
}

type User {
  id: ID!
  reviews: [Review]
  username: String!
}

Entity

@key directive

type Product @key(fields: "id") {
	id: ID!
	price: Int!
	...
}

Reference resolver

const resolvers = {
	Product: {
		__resolveReference(productRepresentation) {
			return fetchProductById(productRepresentation.id)
		}
	}
}

다른 subgraph의 entity를 참조하기

type Review {
	id: ID!
	rating: Float!
  body: String!
	product: Product!
}

type Product @key(fields: "id", resolvable: false) {
  id: ID!
}

Query flow 예제

query GetReviewsWithProducts {
	latestReviews { # 리뷰 subgraph에 정의됨.
    rate
    product {
			id
			price # 리뷰 subgraph에 정의되지 않음.
    }
  }
}

Query plan

query {
  latestReviews {
    score
    product {
      __typename
      id
    }
  }
}

query {
  _entities(representations: [...]) {
    ... on Product {
      price
    }
  }
}

[
  {
    "__typename": "Product",
    "id": "1"
  },
  {
    "__typename": "Product",
    "id": "2"
  }
	//...
]

@key 더 잘 사용하기

복수 @key

type Product @key(fields: "id") @key(fields: "sku") {
  id: ID!
  sku: String!
  name: String!
  price: Int
}

복합(Compound) @key

type User @key(fields: "id organization { id }") {
  id: ID!
  organization: Organization!
}

type Organization {
  id: ID!
}

다른 field를 참조해 계산되는 field 정의하기

type Product @key(fields: "id") {
  id: ID!
  shippingEstimate: String
}

type Product @key(fields: "id") {
  id: ID!
  size: Int @external
  weight: Int @external
  shippingEstimate: String @requires(fields: "size weight")
}

1. 상품 subgraph에서 상품의 size와 weight field를 쿼리하고,

2. 배송 subgraph에 상품의 size와 weight 값을 전달하여 shippingEstimate field를 쿼리합니다.

type Product @key(fields: "id") {
  id: ID!
  dimensions: ProductDimensions @external
  shippingEstimate: String @requires(fields: "dimensions { size weight }")
}

type ProductDimensions {
	size: Int!
  weight: Int!
}

다른 subgraph의 field를 resolve하기

• @shareable directive는 해당 field를 이 subgraph가 항상 resolve할 수 있는 경우,

• @provides directive는 해당 field가 특정 query path를 통해 요청된 경우에만 resolve할 수 있는 경우 사용합니다.

@shareable directive

# 상품 subgraph
type Product @key(fields: "id") {
  id: ID!
  name: String! @shareable
  price: Int
}

@provides directive

type InStockCount {
  product: Product! @provides(fields: "name")
  quantity: Int!
}

type Product @key(fields: "id") {
  id: ID!
  name: String! @external
  inStock: Boolean!
}

GraphQL Federation의 한계

Apollo Federation외의 대안이 없음

N+1 문제

type Query {
	products: [Product!]!
}

type Product {
	...
  reviews: [Review!]!
}

type Review {
	...
	users: [User!]!
}

type User {
	id: ID!
	...
}

1. 많은 수의 object type을 반환할 가능성이 있는 field에는 pagination을 적용하고,

2. DataLoader 패턴을 적용하여 동일한 여러개의 요청을 한 번에 처리하도록 해야 합니다.

마치며

References

Introduction to GraphQL

A query language for your API - GraphQL provides a complete description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools.

https://graphql.org/learn/

Introduction to Apollo Federation

Apollo Federation is a powerful, open architecture for creating a supergraph that combines multiple GraphQL APIs: With federation, you can responsibly share ownership of your supergraph across any number of teams. And even if you currently only have one GraphQL API, Apollo Federation is essential for scaling that API as you grow your features, user base, and organization.

https://www.apollographql.com/docs/federation/

How Netflix Scales Its API with GraphQL Federation

https://www.youtube.com/watch?v=QrEOvHdH2Cg

The GraphQL Dataloader Pattern: Visualized

Understanding data loading challenges in GraphQL This post is an early preview of Production Ready GraphQL, a book I recently released on building GraphQL servers that goes into great detail on building GraphQL servers at scale: https://book.productionreadygraphql.com Check it out if you enjoy this kind of content!

https://xuorig.medium.com/the-graphql-dataloader-pattern-visualized-3064a00f319f