GraphQL federation hufanyaje kazi kwa microservices?

Question

IT Interview Practice · Accepted Answer

**Federation** huruhusu huduma nyingi zilizosambazwa kivyake kila moja kumiliki sehemu ya graph moja, ambayo **gateway** huitunga kuwa schema moja ambayo clients hu-query. Ni mbadala wa kisasa wa **schema stitching**, ambapo gateway iliunganisha remote schemas kwa mikono — federation husogeza kanuni za muunganisho ndani ya subgraphs zenyewe.

## Muundo (architecture)

```text
                 ┌────────────────────────┐
   Client ─────▶ │  Gateway / Router      │  (composed supergraph)
                 └───────┬────────┬───────┘
                         │        │  plans + fans out sub-queries
              ┌──────────▼──┐  ┌──▼──────────┐  ┌──────────────┐
              │ Users svc    │  │ Reviews svc │  │ Products svc │
              │  type User   │  │  extends    │  │  type Product│
              │  @key(id)    │  │  User/Prod  │  │  @key(id)    │
              └──────────────┘  └─────────────┘  └──────────────┘
```

Kila huduma ni **subgraph**. Type humilikiwa na huduma moja na **inaenezwa (extended)** na nyingine. `@key` directive hutaja field(s) zinazotambua entity kuvuka huduma.

```graphql
# Users subgraph OWNS User
type User @key(fields: "id") {
  id: ID!
  name: String!
}

# Reviews subgraph EXTENDS User with fields it owns
type User @key(fields: "id") {
  id: ID! @external          # declared elsewhere; referenced here by key
  reviews: [Review!]!        # this subgraph contributes this field
}
```

Wakati query inavuka huduma, gateway **huipanga**: pata `User` kutoka Users, kisha uite **entity resolver** ya Reviews subgraph (`__resolveReference`) ikiwa na `{ id }` ili kujaza `reviews`.

```js
// Reviews subgraph resolves the User reference the gateway hands it
const resolvers = {
  User: {
    __resolveReference: (ref, ctx) => ctx.reviewLoader.load(ref.id),
  },
};
```

## Federation dhidi ya stitching

Stitching huweka mantiki ya muunganisho katikati katika gateway (dhaifu, gateway lazima ijue kila mtu). Federation **husambaza (decentralizes)** umiliki: timu hubadilisha subgraph yao kivyake, na muunganisho huthibitishwa katika CI. Maafikiano ni gateway/router yenye utata zaidi na upangaji wa query wa kuvuka-huduma.

## Kwa nini ni muhimu

Kwa kiwango kikubwa, timu moja haiwezi kumiliki schema ya monolithic. Wahoji wanataka kuona unaelewa **umiliki wa entity kupitia `@key`, reference resolvers, na upangaji wa query** — na kwa nini federation inashinda stitching kwa upanuzi wa kiutawala, si tu uzuri wa kiufundi.

Muundo (architecture)

Federation dhidi ya stitching

Kwa nini ni muhimu

Maswali yanayohusiana